This is an example of a H1 heading

The problem with traditional approaches to abstraction and encapsulation is that they aim at complete information hiding. This characteristic anticipates being able to eliminate programming from parts of the software development process, those parts contained within module boundaries. As we've seen, though, the need to program is never eliminated because customization, modification, and maintenance are always required—that is, piecemeal growth.

This is an example of a H2 heading

One of the primary reasons that abstraction is overloved is that a completed program full of the right abstractions is perfectly beautiful. But there are very few completed programs, because programs are written, maintained, bugs are fixed, features are added, performance is tuned, and a whole variety of changes are made both by the original and new programming team members. Thus, the way a program looks in the end is not important because there is rarely an end, and if there is one it isn’t planned.

This is an example of a H3 heading

The danger of clarity is that it is uncompromised beauty; and it’s real tough to to improve uncompromised beauty. Many second- and third-rate sculptors can fix a decent sculpture—I saw a group of them one summer making replacement gargoyles for Notre Dame Cathedral in Paris—but which of them would dare repair Michelangelo’s David? Who would add a skyscraper to the background of Mona Lisa? Who would edit Eliot’s poems? Clarity is dangerous.

This is an example of a H4 heading

Not everyone is a poet, but most anybody can write usable documentation for small programs—we don’t expect poets to do this work. Yet we seem to expect that the equivalent of poets will use high-level programming languages, because wonder that abstraction-poor languages like C are by far the most popular and that abstraction-rich ones like Lisp and Smalltalk are niche languages?

This is an example of a H5 heading

Furthermore, when the implementation is truly hidden and there is a need to make a change or add behavior, the user is reduced to reinventing; if the implementation is not only hidden but also protected, the user will need to copy and maintain a parallel version. This implies that later changes to the code will be less eﬃciently made because similar code must be implemented in several places. In fact, the programmer—especially a programmer new to the project—may be unable to find all the occurrences of the similar code.

This is an example of a H6 heading

When we couple this advice with that of building hierarchies slowly, keeping them shallow as long as possible, we might find that we have paved the way for habitability, piecemeal growth, and healthy, usable compression. In fact, if we put in place an explicit process of piecemeal growth, hierarchies will naturally grow slowly, and they are more likely to be correct, because their use evolves over time. The resulting compression also is natural, not forced, and it is less likely that the compression will backfire.

Dropcaps

Regardless of the reasons behind it, if we accept Carroll and Isner’s statement that unanticipated extension is difficult, their statement supports my claim that during the growth of an abstraction web, one must frequently go back to existing abstractions to repair them, such repair being a sort of delayed anticipation of the extensions.

To some extent, object-oriented programming is about piecemeal growth. But in some languages, it is achieved by catching the excess-abstraction disease. This essay is not intended to convince you that abstraction is bad (or that I’m nuts), but to show that maybe some of the other concerns of software.

Let’s look at another problem with abstractions: Data and control abstractions are generally best when they are codesigned and this is rarely done anymore. Consider, for example, the Fortran abstractions of arrays and iteration. Arrays are abstractions designed to represent vectors and matrices.

One way to lay a foundation of common patterns is the same way we do with natural language: Teach people the most common patterns. We never think to teach people how to create words—poets do this frequently, and sometimes ordinary people become word-inventors—yet we teach budding programmers.

Highlight

Remember, piecemeal growth is the norm, and programs grow, change, and are repaired. Therefore, the perfectly beautiful program is possible only for very small programs, like the ones in books on programming or in programming courses.

Buttons

Button Button Button Button Button Button Button Button Button

Blockquotes

The net effect shows that the forces of capitalism are much like those of evolution: the fittest survive. And when the fittest leap forward in their abilities.
Binstock 1994

Antitrust policy must try to strike a balance between allowing market leaders to profit from their innovations and stopping them from abusing their power.
"How Dangerous" 1995

Tables

#	Table heading	Table heading	Table heading	Table heading	Table heading	Table heading
1	Table cell	Table cell	Table cell	Table cell	Table cell	Table cell
2	Table cell	Table cell	Table cell	Table cell	Table cell	Table cell
3	Table cell	Table cell	Table cell	Table cell	Table cell	Table cell

Code

games:*:12:100:games:/usr/games:
gopher:*:13:30:gopher:/usr/lib/gopher-data:
ftp:*:14:50:FTP User:/home/ftp:
esr:0SmFuPnH5JlNs:23:23:Eric S. Raymond:/home/esr:
nobody:*:99:99:Nobody:/:

Want to see more?

There are plenty of pre-defined and easy to edit templates!
For example, have you seen the features page? And don't forget to explore the rest of the site, for example the blog, product or faq pages.

Typography

Rock solid base typography and styles included.