Donald Knuth. “Literate Programming ()” in Literate Programming. CSLI, , pg. I believe that the time is ripe for significantly better documentation of . Literate programming: Knuth is doing it wrong. Literate programming advocates this: Order your code for others to read, not for the compiler. Literate Programming is also the name of DonKnuth’s book (ISBN One speculation for the reason behind Knuth’s pushing of LP is that according to Stanford’s.
|Published (Last):||17 December 2018|
|PDF File Size:||12.43 Mb|
|ePub File Size:||11.1 Mb|
|Price:||Free* [*Free Regsitration Required]|
So you don’t have time to change your tests or other dependencies? Literate programs are written to be read by other software developers.
Literate programming – Wikipedia
In my experience this style is a very good match for a literate programming. My hope is that this might eventually help this style to catch on in some quarters. However, because these tools do not implement the “web of abstract concepts” hiding behind the system of natural-language macros, or provide an ability to change the order of the source code from a machine-imposed sequence to one convenient to the human mind, they cannot properly be called literate programming tools in the sense intended by Knuth.
IMHO the examples you cite, such as the underscore-example has very little to do with any meaningful knyth of “Literate Programming”.
Now I’m curious where you might be able to push things if you purpose built a “Literate Revision Control” tool and what sort of strong “epic poem” style of commit messages would best produce useful “novelizations” of a codebase Maybe to get the wiki closer to the code, you could put links to relevant wiki pages in your code comments.
This is illustrated by the following snippet of the wc literate program. Knuth’s broader ideas about documentation and structured programming are laid out in his book, “Literate Programming. I really like linear “hack hack hack” code, even if it has a bit of copy paste, and dislike highly abstract OO soup.
Read a bunch of papers and blogs for the problem being solved.
The most obvious and natural way to do this is to suppress the program text for those inner levels, leaving an outline of the outer level, while the inner levels may be specified and documented elsewhere; this is prpgramming bit like introducing subroutines for the inner levels, but without the semantic implications that that would have.
Software is hard enough as it is, without adding yet another hurdle to get from brain to.
At best, a professor might publish very small routines as examples of how to write a program. To the point that if you aren’t going out of your way to represent the narrative flow of what you are writing, you are probably not going to see any benefit.
The only large project using literate programming that I am aware of is Axiom, a symbolic math system written in Lisp. If there are simplifications available, I find the structure makes them visible. The snippets of the literate wc above show how an explanation of the program and its source code are interwoven.
We understand a complicated system by understanding its simple parts, and by understanding the simple relations between those parts and their immediate neighbors. It’s much more efficient just to sit next to the person and assist him in reading the code by providing a live, context-aware commentary.
Literate programming increases product quality by requiring software developers to examine progrramming explain their code. The story you start telling is not what you end up with later, after you’ve completed all the non-trivial features and major assumptions have fallen through.
EliRivers on Aug 16, Software is hard enough as it is, without adding yet another hurdle to get from brain to.
I would agree with writing something code-friendly in the first place, examples of which would include DocBook and Restructured Text.
Obviously there should be a clear indication of where pieces of program have been suppressed, and which other program fragments give the detailed specifications of those pieces.
All quotes you tore out speak of literate programming as if it’s just a documentation system. Others have already given the reasons about the downsides of comments. Communities have had majority held opinions which were wrong on plenty of occasions. These usually describe the problem independent of the chosen language for implementation.
Ask HN: Why did literate programming not catch on? | Hacker News
The whole concept of code sections, indeed structured programming, programmign to reduce the amount of text that must be read in order to determine what a piece of code is doing. Thus the program can be described in a logical manner. It makes it harder to make changes. Conduct peer reviews of deliverables.
It’s not a matter of artistry or efficiency alone; it’s more a question of suitability in litrate. Nobody checks in code until there is at least a paragraph that explains WHY this code was written. Writing a literate program is a lot more work than writing a normal program.
I don’t remember all the details of what I did, but: Later it is reshuffled “tangled”, i. At that time, we had about 25 people in our group that would meet every Friday. Short of hiring people full-time to write documentation, and to ensure that all changes to the program are done in a heavyweight-enough process to ensure that documentation changes match the programming changes, those are your two choices.
Literate programming is based on the idea that you should explain what software does and how kknuth does it in detail so that a reader can follow along and learn. Listings generated in PDF format include hypertext links.