An interesting book I stumbled upon...

13 years old but still interesting:

http://www.dreamsongs.com/Files/PatternsOfSoftware.pdf

  • Object-oriented languages gain their power from compression, which can lead to compact, efficiently expressed programs. Compression, though, can present problems if it is prematurely used.
  • Software development is always through piecemeal growth and rarely through thorough design. Such planned development can lead both to technical problems because the future of a piece of software cannot be known and also to social problems because completely planned development alienates those developers who are not also the planners.
  • Habitability is one of the most important characteristics of software. It enables developers to live comfortably in and repair or modify code and design.
  • When taken to extremes, abstraction can diminish habitability and can result in premature compression. Beware of overabstracting or of abstracting when a common pattern will do.
  • There is much to learn about software development, and we are just starting to do that.
users avatar

I still can’t tell you

I still can’t tell you what the quality is, but I can tell you some things about software that possesses it:

  • It was not written to an unrealistic deadline.
  • Its modules and abstractions are not too big—if they were too big, their size and inflexibility would have created forces that would overgovern the overall structure of the software; every module, function, class, and abstraction is small and named so that I know what it is without looking at its implementation.
  • Any bad parts were repaired during maintenance or are being repaired now.
  • If it is small, it was written by an extraordinary person, someone I would like as a friend; if it is large, it was not designed by one person, but over time in a slow, careful, incremental way.
  • If I look at any small part of it, I can see what is going on—I don’t need to refer to other parts to understand what something is doing. This tells me that the abstractions make sense for themselves—they are whole.
  • If I look at any large part in overview, I can see what is going on—I don’t need to know all the details to get it.
  • It is like a fractal, in which every level of detail is as locally coherent and as well thought out as any other level.
  • Every part of the code is transparently clear—there are no sections that are obscure in order to gain efficiency.
  • Everything about it seems familiar.
  • I can imagine changing it, adding some functionality.
  • I am not afraid of it, I will remember it.

/johno
"you can't stop the change"

users avatar

This seems to be a gem of

This seems to be a gem of software philosophy Smiling

users avatar

Thanks for the list. This

Thanks for the list. This sounds very reasonable.

---------------
Solid Core Entertainment
Developer of Roadclub and Sense: Survival Prelude (Developer blog)

users avatar

I've finished reading it now...

It was kind of all over the place philosophically, but bits of it were very interesting considering it was published in 1996.

/johno
"you can't stop the change"

users avatar

Post new comment

Please solve the math problem above and type in the result. e.g. for 1+1, type 2.
The content of this field is kept private and will not be shown publicly.
  • Web page addresses and e-mail addresses turn into links automatically.
  • Allowed HTML tags: <h1> <h2> <h3> <a> <em> <strong> <cite> <code> <ul> <ol> <li> <dl> <dt> <dd>
  • Lines and paragraphs break automatically.
  • Textual smileys will be replaced with graphical ones.
  • Images can be added to this post.

More information about formatting options