Jump to content

Software documentation

From Wikipedia, the free encyclopedia
This is an old revision of this page, as edited by 72.253.70.70 (talk) at 00:40, 21 May 2024. The present address (URL) is a permanent link to this revision, which may differ significantly from the current revision.

ඪT79,ඬD,ධධධ8O,Pඏ DF

8

Part of a series on
Software development
Core activities
Paradigms and models
Methodologies and frameworks
Supporting disciplines
Practices
Tools
Standards and bodies of knowledge
Glossaries
Outlines

Software documentation is written text or illustration that accompanies computer software or is embedded in the source code. The documentation either explains how the software operates or how to use it, and may mean different things to people in different roles.

Documentation is an important part of software engineering. Types of documentation include:

  • Requirements – Statements that identify attributes, capabilities, characteristics, or qualities of a system. This is the foundation for what will be or has been implemented.
  • Architecture/Design – Overview of software. Includes relations to an environment and construction principles to be used in design of software components.
  • Technical – Documentation of code, algorithms, interfaces, and APIs.
  • End user – Manuals for the end-user, system administrators and support staff.
  • Marketing – How to market the product and analysis of the market demand.

RT67I697059R7U-E59-879E507OI[E5TO-UE569U[0SDR0Y89UBS-P0R9T-Y9S-ERPYB0ERTY8S-0R9YUB0[-S96[US65S 6;8 S5[P8S P568S\5P68 SP48S 57P8 86OEP456 8P7 [83 7[8O 3'[47L9 I648L9 54P;8[LO79 65]P79P 4]P6794[JO9\J4]P8PO5P94 \5]P89\4P\8P]E4\5]PO8E\]RD=TYJ][ODPER6 [H8WE4 6[P8U WE46PU D4P6U PS5 6]PUED R6PU8 4E]5P6 846 78W4E P 8\ W4P 7 \HWE4P6 

8PUE4]6 74 P67

4 7 4 

U7E 467 E4 6O]E4O56]YEO4 7E 4 4E 6]5 E4]6 W35]6 W]45O[67W4

]E[6O78 ]W EO46U O S4 [66]UO SE 6YEO56[]YS5E[0=6G W3 67'3E54 7W 347 W34S 7'W547UY W4 7'E[467 [9I467[4P5678'P34[E5O667 84H 8'P54O 8J5O67P8O56P7OE 

]7O D

][O R5 7[]OD[R57[OR45][7O8]59[OE[ OS4R5] 7657O 9]O[S][EO76[ OSE4[76S[O4E6][OSZE4][6O ZAE 6OSE]46]SEO 46][OSE 4]6O7]5OP 88ODR[OU]RX [ROTUO F ]'T[OU [C OTY[O IC [T YOI ]C [OYT]VP[ UPK [PJM [OIKOHOPD[YKOTP[TOYT[YREMLEWP9Y TER970 -R79I6R0 O7 607O6RR]R 7- R]7L6 R-]R0O K7]R7KO6 R]7K6R-76K ROP] K76R]7K6 R]7KR ]R-]KR7]R KL ]7KR ]7RK7]6RK76R-]7K6R-P7]6R F]YTF65R07KR]-F 6RKR] K- 65RKRK -TF]6K ]76R 07D5696R7N7+6 U56+ER9 DR5+U89DR6+ 0D6+ 6U6+D4656406 NU+9D80+D65U 3D62 RU6 R.6 .RU.7R 2U 3D0 T +E0SR9I +87K0+0 DXR5T YI+5Y 0+ 8D+7T808O N+D9+ 8O79IO0D+7T90O+M 970F9+0D79+98MD50T+7099+09M7+0 707+0 +907+9I8D +R0T Y+SX9E0R+9678S +DR0IK5 NRTYN +9ESX75080 NZEX+R50 X+U8N+9 OZ+5 YX+6HG JN0KYXE+9RT

YU 3 SR6N2U0+SR69+9860 I+R9S08I 04+SDX0F6G0J5D+ T I4+6SDR56+60268+6I 5O+D605UI 56R ]NP U SRD6 PI MSD ]PRT\UOXJKGH\SP]T;LMPR6\]P8D\]5[6PI R6PS\R 6\78 NS5 8\SR P]\7 8SER\P7\D[4 BUSOR6U\[DNO FRTY[INK R L NIF' LUIKC 

GLJU

[CD RU[O NSE5\][O 756PO O7\S D57 SE 57\][SOE57[OSE]\[4O\HSOE457[SEO57[ SE5[OH\S[EO5 7\HS4[O56 4H\S4 O5HO SDE\[O H7\[R5 OW\]57\]P35[64O HI][POH7J[4P6 UIO\[O 6H\I[PD\]E5[O7SBEO5U]=EP][SP RNT\]6SOUI\ [OR[R UONXR5O\ [XERP\U[NXRDT\UO NSXE[OU N]E[ROLU][OEA] YO3WA5]-IY-4S89ER789ER9G67A9E8R76A98W7RT-096UIOWK46LWKJ4SER 909ERT8EY95B]3Q5] 7956343-695Y9=-5YV =- 0][5B.2564HN.8414.64N1 .S5741I.SMR64.MIO.M S32R6.U31SR.724I 36 72I 3D8O32SR 53617 MO. 18SRD M32O 32D57O .0MS 3R0 306.R0I2 DR03IO02M SD.R60I92M 65I RD03D57 +65 MSR302 3D6R029O 6M 5 6R56080SM49+87MO +P9 75008L Y9-50P Y-L 6UI05 [09UI0=50[8 +605[- +.75080 +65LD06095458 NA6355+ 6HA03WERH6 745508HISE50R7+ 6RJ55707 52X 3RT0I 3MDT650O+Z E65RTF+J05MU7T 685P+DM588+I0D578MU O2S R32UYJFailed to parse (syntax error): {\displaystyle R95080WS67I09S-0RT9U6S+496N/R7S48 A+59E4886US+I 58K7+98 SE+59784S6*/8J+S4*/97/S+-DR688+S4655+6675IN86EO7+W98674+5866 5385W+5.47+958B 4W+6.W4688+S865+*8JS4*58/-SN4*/8+2A35+78H+7/I-A/*N34E5E\5]6P8EJ, P57\]PS894R56PISROY-=J0US4]5P786I7[87]IASE=RT0UI=S07]O[PS[\RTU]N-I SD506]SPER][OUITSN\E]R6PUIJW4P8 SJ]PN45H=SN408}

Types

Requirements documentation

Requirements documentation is the description of what a particular software does or shall do. It is used throughout development to communicate how the software functions or how it is intended to operate. It is also used as an agreement or as the foundation for agreement on what the software will do. Requirements are produced and consumed by everyone involved in the production of software, including: end users, customers, project managers, sales, marketing, software architects, usability engineers, interaction designers, developers, and testers.

Requirements come in a variety of styles, notations and formality. Requirements can be goal-like (e.g., distributed work environment), close to design (e.g., builds can be started by right-clicking a configuration file and selecting the 'build' function), and anything in between. They can be specified as statements in natural language, as drawn figures, as detailed mathematical formulas, or as a combination of them all.

The variation and complexity of requirement documentation make it a proven challenge. Requirements may be implicit and hard to uncover. It is difficult to know exactly how much and what kind of documentation is needed and how much can be left to the architecture and design documentation, and it is difficult to know how to document requirements considering the variety of people who shall read and use the documentation. Thus, requirements documentation is often incomplete (or non-existent). Without proper requirements documentation, software changes become more difficult — and therefore more error prone (decreased software quality) and time-consuming (expensive).

The need for requirements documentation is typically related to the complexity of the product, the impact of the product, and the life expectancy of the software. If the software is very complex or developed by many people (e.g., mobile phone software), requirements can help better communicate what to achieve. If the software is safety-critical and can have a negative impact on human life (e.g., nuclear power systems, medical equipment, mechanical equipment), more formal requirements documentation is often required. If the software is expected to live for only a month or two (e.g., very small mobile phone applications developed specifically for a certain campaign) very little requirements documentation may be needed. If the software is a first release that is later built upon, requirements documentation is very helpful when managing the change of the software and verifying that nothing has been broken in the software when it is modified.

Traditionally, requirements are specified in requirements documents (e.g. using word processing applications and spreadsheet applications). To manage the increased complexity and changing nature of requirements documentation (and software documentation in general), database-centric systems and special-purpose requirements management tools are advocated.

In Agile software development, requirements are often expressed as User Stories with accompanying acceptance criteria.

Architecture design documentation

Architecture documentation (also known as software architecture description) is a special type of design document. In a way, architecture documents are third derivative from the code (design document being second derivative, and code documents being first). Very little in the architecture documents is specific to the code itself. These documents do not describe how to program a particular routine, or even why that particular routine exists in the form that it does, but instead merely lays out the general requirements that would motivate the existence of such a routine. A good architecture document is short on details but thick on explanation. It may suggest approaches for lower level design, but leave the actual exploration trade studies to other documents.

Another type of design document is the comparison document, or trade study. This would often take the form of a whitepaper. It focuses on one specific aspect of the system and suggests alternate approaches. It could be at the user interface, code, design, or even architectural level. It will outline what the situation is, describe one or more alternatives, and enumerate the pros and cons of each. A good trade study document is heavy on research, expresses its idea clearly (without relying heavily on obtuse jargon to dazzle the reader), and most importantly is impartial. It should honestly and clearly explain the costs of whatever solution it offers as best. The objective of a trade study is to devise the best solution, rather than to push a particular point of view. It is perfectly acceptable to state no conclusion, or to conclude that none of the alternatives are sufficiently better than the baseline to warrant a change. It should be approached as a scientific endeavor, not as a marketing technique.

A very important part of the design document in enterprise software development is the Database Design Document (DDD). It contains Conceptual, Logical, and Physical Design Elements. The DDD includes the formal information that the people who interact with the database need. The purpose of preparing it is to create a common source to be used by all players within the scene. The potential users are:

When talking about Relational Database Systems, the document should include following parts:

  • Entity - Relationship Schema (enhanced or not), including following information and their clear definitions:
    • Entity Sets and their attributes
    • Relationships and their attributes
    • Candidate keys for each entity set
    • Attribute and Tuple based constraints
  • Relational Schema, including following information:
    • Tables, Attributes, and their properties
    • ViewsS6NIE758SE56809-WS4698[W46O]I8OS

68 ED6P8 SPR6 8[PڙػۯݛژڗٽځݫT78ݬOD, 8PO,DT670PD68YOݬDT7UݬOD MOڬFY8OD ,ڙ8OڗFY8F6Y8P,F ۯU9, 8ڙP Dژ6T80Dݬ9D79ݬ 8OڜDF860M D68ۅD8ۅO0D79M D86ݖ

    • Constraints such as primary keys, foreign keys,
    • Cardinality of referential constraints
    • Cascading Policy for referential constraints
    • Primary keys

It is very important to include all information that is to be used by all actors in the scene. It is also very important to update the documents as any change occurs in the database as well.

Technical documentation

Main article: Technical documentation

It is important for the code documents associated with the source code (which may include README files and API documentation) to be thorough, but not so verbose that it becomes overly time-consuming or difficult to maintain them. Various how-to and overview documentation guides are commonly found specific to the software application or software product being documented by API writers. This documentation may be used by developers, testers, and also end-users. Today, a lot of high-end applications are seen in the fields of power, energy, transportation, networks, aerospace, safety, security, industry automation, and a variety of other domains. Technical documentation has become important within such organizations as the basic and advanced level of information may change over a period of time with architecture changes. There is evidence that the existence of good code documentation actually reduces maintenance costs for software.[1]

Code documents are often organized into a reference guide style, allowing a programmer to quickly look up an arbitrary function or class.

Technical documentation embedded in source code

Often, tools such as Doxygen, NDoc, Visual Expert, Javadoc, JSDoc, EiffelStudio, Sandcastle, ROBODoc, POD, TwinText, or Universal Report can be used to auto-generate the code documents—that is, they extract the comments and software contracts, where available, from the source code and create reference manuals in such forms as text or HTML files.

The idea of auto-generating documentation is attractive to programmers for various reasons. For example, because it is extracted from the source code itself (for example, through comments), the programmer can write it while referring to the code, and use the same tools used to create the source code to make the documentation. This makes it much easier to keep the documentation up-to-date.

A possible downside is that only programmers can edit this kind of documentation, and it depends on them to refresh the output (for example, by running a cron job to update the documents nightly). Some would characterize this as a pro rather than a con.

Literate programming

Respected computer scientist Donald Knuth has noted that documentation can be a very difficult afterthought process and has advocated literate programming, written at the same time and location as the source code and extracted by automatic means. The programming languages Haskell and CoffeeScript have built-in support for a simple form of literate programming, but this support is not widely used.

Elucidative programming

Elucidative Programming is the result of practical applications of Literate Programming in real programming contexts. The Elucidative paradigm proposes that source code and documentation be stored separately.

Often, software developers need to be able to create and access information that is not going to be part of the source file itself. Such annotations are usually part of several software development activities, such as code walks and porting, where third-party source code is analysed in a functional way. Annotations can therefore help the developer during any stage of software development where a formal documentation system would hinder progress.

User documentation

Unlike code documents, user documents simply describe how a program is used.

In the case of a software library, the code documents and user documents could in some cases be effectively equivalent and worth conjoining, but for a general application this is not often true.

Typically, the user documentation describes each feature of the program, and assists the user in realizing these features. It is very important for user documents to not be confusing, and for them to be up to date. User documents do not need to be organized in any particular way, but it is very important for them to have a thorough index. Consistency and simplicity are also very valuable. User documentation is considered to constitute a contract specifying what the software will do. API Writers are very well accomplished towards writing good user documents as they would be well aware of the software architecture and programming techniques used. See also technical writing.

User documentation can be produced in a variety of online and print formats.[2] However, there are three broad ways in which user documentation can be organized.

  1. Tutorial: A tutorial approach is considered the most useful for a new user, in which they are guided through each step of accomplishing particular tasks.[3]
  2. Thematic: A thematic approach, where chapters or sections concentrate on one particular area of interest, is of more general use to an intermediate user. Some authors prefer to convey their ideas through a knowledge based article to facilitate the user needs. This approach is usually practiced by a dynamic industry, such as Information technology.[4]
  3. List or Reference: The final type of organizing principle is one in which commands or tasks are simply listed alphabetically or logically grouped, often via cross-referenced indexes. This latter approach is of greater use to advanced users who know exactly what sort of information they are looking for.

A common complaint among users regarding software documentation is that only one of these three approaches was taken to the near-exclusion of the other two. It is common to limit provided software documentation for personal computers to online help that gives only reference information on commands or menu items. The job of tutoring new users or helping more experienced users get the most out of a program is left to private publishers, who are often given significant assistance by the software developer.

Composing user documentation

Like other forms of technical documentation, good user documentation benefits from an organized process of development. In the case of user documentation, the process as it commonly occurs in industry consists of five steps:[5]

  1. User analysis, the basic research phase of the process.[6]
  2. Planning, or the actual documentation phase.[7]
  3. Draft review, is a self-explanatory phase where feedback is sought on the draft composed in the previous step.[8]
  4. Usability testing, whereby the usability of the document is tested empirically.[9]
  5. Editing, is the final step in which the information collected in steps three and four is used to produce the final draft.

Marketing documentation

For many applications it is necessary to have some promotional materials to encourage casual observers to spend more time learning about the product. This form of documentation has three purposes:

  1. To excite the potential user about the product and instill in them a desire to become more involved with it.
  2. To inform them about what exactly the product does, so that their expectations are in line with what they will be receiving.
  3. To explain the position of this product with respect to other alternatives.

Documentation and agile development controversy

"The resistance to documentation among developers is well known and needs no emphasis."[10] This situation is particularly prevalent in agile software development because these methodologies try to avoid any unnecessary activities that do not directly bring value. Specifically, the Agile Manifesto advocates valuing "working software over comprehensive documentation", which could be interpreted cynically as "We want to spend all our time coding. Remember, real programmers don't write documentation."[11]

A survey among software engineering experts revealed, however, that documentation is by no means considered unnecessary in agile development. Yet it is acknowledged that there are motivational problems in development, and that documentation methods tailored to agile development (e.g. through Reputation systems and Gamification) may be needed.[12][13]

See also

Notes

  1. ^ "How to get a budget for code documentation".
  2. ^ "RH Earle, MA Rosso, KE Alexander (2015) User preferences of software documentation genres. Proceedings of the 33rd Annual International Conference on the Design of Communication (ACM SIGDOC)".
  3. ^ Woelz, Carlos. "The KDE Documentation Primer". Retrieved 15 June 2009.
  4. ^ Microsoft. "Knowledge Base Articles for Driver Development". Microsoft. Retrieved 15 June 2009.
  5. ^ Thomas T. Barker, Writing Software Documentation, Preface, xxiv. Part of the Allyn & Bacon Series in Technical Communication, 2nd ed. Upper Saddle River: Pearson Education, 2003. ISBN 0321103289 Archived May 13, 2013, at the Wayback Machine
  6. ^ Barker, pg. 118.
  7. ^ Barker, pg. 173.
  8. ^ Barker, pg. 217.
  9. ^ Barker, pg. 240.
  10. ^ Herbsleb, James D. and Moitra, Dependra. In: IEEE Software, vol. 18, no. 2, pp. 16-20, Mar/Apr 2001
  11. ^ Rakitin, Steven. , "Manifesto elicits cynicism." IEEE Computer, vol. 34, no. 12, p. 4, 2001
  12. ^ Prause, Christian R., and Zoya Durdik. "Architectural design and documentation: Waste in agile development?" In: International Conference on Software and System Process (ICSSP), IEEE, 2012.
  13. ^ Selic, Bran. "Agile documentation, anyone?" In: IEEE Software, vol. 26, no. 6, pp. 11-12, 2009
Retrieved from "https://en.wikipedia.org/w/index.php?title=Software_documentation&oldid=1224877090"