Answer-set programming is a logic-programming formalism which has proven to be exceptionally well-suited for knowledge representation, reasoning, and solving complex search problems. Its fully declarative nature together with its simple and clear syntax allow for the formulation of compact problem specifications. While many answer-set programs may be relatively easy to understand for a programmer, their meaning may be rather hard to grasp for persons without a background in logic programming. Since many real world problems from various domains can be formulated within answer-set programming, it would be useful to translate answer-set programs into a form which is easier to understand and closer to natural language. In this thesis, we introduce some results which should help making such a translation possible. First, we analyse the structure of a given program: Most answer-set programs follow the so-called generate-define-test paradigm. Within this paradigm, a program is seen to consist of three different parts, called generate, define, and test. We introduce a formal definition of these three parts and develop an algorithm which classifies the rules of a given program accordingly. For the implementation of this algorithm, we make use of techniques from meta-programming, meaning that we write a logic program which operates on other logic programs. Following this, we also discuss how the rules of a program should be ordered before they are translated into some form of natural language. A straightforward translation of program rules into a form of natural language may yield rather clumsy results in general. One reason for this is that many real-world programs use more than one rule to define something which a human would explain within a single sentence. We thus introduce a generalisation of the well-known partial evaluation transformation which helps us to transform a given program into another program that is easier to translate. An important requirement for such a transformation is that it preserves equivalence, i.e., that it does not change the meaning of the original program. To this end, we use a notion of equivalence called relativised uniform equivalence which is stronger than ordinary equivalence but weaker than uniform equivalence. As a key result, we prove that our transformation preserves relativised uniform equivalence, which yields the straightforward corollary that it preserves ordinary equivalence over the answer-set semantics too.