Hacker News new | past | comments | ask | show | jobs | submit login

David Brooks himself wrote as much in 1986:

I still remember the jolt I felt in 1958 when I first heard a friend talk about building a program, as opposed to writing one. In a flash he broadened my whole view of the software process. The metaphor shift was powerful, and accurate. Today we understand how like other building processes the construction of software is, and we freely use other elements of the metaphor, such as specifications, assembly of components, and scaffolding.

The building metaphor has outlived its usefulness. It is time to change again. If, as I believe, the conceptual structures we construct today are too complicated to be specified accurately in advance, and too complex to be built faultlessly, then we must take a radically different approach.

Let us turn nature and study complexity in living things, instead of just the dead works of man. Here we find constructs whose complexities thrill us with awe. The brain alone is intricate beyond mapping, powerful beyond imitation, rich in diversity, self-protecting, and selfrenewing. The secret is that it is grown, not built.




(psst... Fred Brooks is the software engineer; David Brooks is the New York Times' conservative commentator.)


Thanks for correction! Sadly I can't edit it anymore.


That quote is beautiful but it reminds me a lot of tales of hubris, although I do not believe in any god(s), I always felt some truth in that mythical sin.

Can we grow designed software? Or, can we design truly growing software? I guess it depends on the definition of growing you use, "scalable" ? "alive" ?


Refactor, refactor, refactor. Growing things adapt to changing circumstances. Software must adapt to changing requirements. Refactoring is the only way.


This is so important. We all know beautifully "designed" API's or libraries.

The secret is that the "elegant" API design you see is usually the n-th iteration.

Growing code is much like growing trees. The tree grows itself, what it requires is that it is pruned and helped to reshape in a fashion that will allow it to stay alive for a long time and bear fruit.

But one needs to constantly prune the damn thing.


I like the tree metaphor.

You start planting trees, maybe it's in an empty field, or maybe it's in an old forest. At some point it takes root and multiplies. People help plant your forest in unexpected places and it expands. At some point you try pruning and controlling the trees. And at some point a forest fire destroys it making way for a new forest to grow.


software is gardening, not sculpture.


Is it?

To continue the metaphor, one of the most important pieces of evolutionary growth is death.


We can - but if we keep the analogy of grown things we can only grow stuff that has already been grown before and make only tiny changes. It's worth remembering that evolution has neither purpose nor direction. Even "adapting" is an aimless process, the changes are predictable only for very small adaptations. Major changes may lead to anything, including a "restart" (extinction event followed by something different).

So the model has its limitations for human projects where we don't want to have quite that propensity for surprising outcomes.


See, I've always seen the statement that evolution is intentionless to be a bit arrogant. Consciousness, as we are just starting to learn, is a property of emergent networks. Further, we are just starting to discover that phenotypical expression is so much more complex than 1/2mom + 1/2dad = baby. Evolution is calculating something, even if it's inscrutable to us.


    > I've always seen the statement that evolution is intentionless to be a bit arrogant
Assuming intent without any proof is the by far more outrageous statement. I have no intention of entering any discussion based on "believe" though.


In rapid changing environment, growth also implies learning. So perhaps we can also use learning as a new analogy of software development?

An ongoing example of learning and growing a design is "Swift Evolution Process"

https://github.com/apple/swift-evolution/blob/master/process...


Individual components must be designed to fail without taking down the entire system.

This is the Free Market vs. Planned Economy debate all over again.


> The secret is that it is grown, not built.

s/is grown/has evolved/


Both happen.

By designing systems in layers of interacting components, we can grow more and more complex systems. The internals of different components are irrelevant so long as the external interface is consistent.

We evolve them by improving the interfaces (see APIs deprecating functions/methods/messages) and by refactoring/rewriting the internals or implementation.




Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: