Slashdot Log In
A Unified Theory of Software Evolution
Posted by
CmdrTaco
on Mon Apr 08, 2002 08:39 AM
from the stuff-to-read dept.
from the stuff-to-read dept.
jso888 writes "Salon has a nice article today on Meir Lehman's work on how software evolves and is developed. Lehman's investigation of the IBM OS/360 development process became the foundation for Brooks' Law: "Adding manpower to a late software project makes it later." He is hopeful that his work will make software development less of an art and more of an engineering science."
This discussion has been archived.
No new comments can be posted.
The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
Full
Abbreviated
Hidden
Loading... please wait.
Evolution is a MYTH!!! (Score:3, Funny)
Please check your crackpot theories and psuedo-science at the door.
Thank you.
Re:Evolution is a MYTH!!! (Score:2, Insightful)
Re:Evolution is a MYTH!!! (Score:3, Informative)
This is called error seeding and is used to evaluate the performance of testing systems (including the people doing it).
On the other hand, I dimmly remember something about not to do it with production code....
Re:Evolution is a MYTH!!! (Score:2)
1) Software doesn't evolve by chance, folks, it is DESIGNED by its CREATORS. Please check your crackpot theories and psuedo-science at the door. /. is a site for SERIOUS INTELLECTUAL DISCUSSION.
So I take it you are in favor of creationism?
Sorry, but the parallels were so obvious ... ;)
2) For extra ammo, Lehman also has expanded the graphs and data from his original studies in the 1970s. Taken together, they show most large software programs growing at an inverse square rate -- think of your typical Moore's Law growth curve rotated 180 degrees -- before succumbing to over-complexity.
I am not holding my breath waiting for Microsoft to keel over into a monstrous pile of cyberwreckage any time soon.
Re:Evolution is a MYTH!!! (Score:3, Informative)
I'm not sure whether this was supposed to be funny or whether other readers are interpreting it as funny. There have also been a few stabs at the parallels with life (evolution vs creation, etc). Hrm...whatever. From the article: "The gap between biological evolution and artificial systems evolution is just too enormous to expect to link the two,"
In all seriousness, I've seen so many project managers use evolution (not the theory explained in the article, however) as some sort of methodology for their projects and I have not seen any of those projects truely succeed. The idea that you throw something, anything, out there, find out what's good/bad with it, then re-iterate the design and development based on findings is such a random and expensive process. I've seen so many programmers put in half-assed functionality, especially on front-end code, just so that they'll let testers and "usability" experts fix the problem and fix it in the next release. This is like throwing a chunk of randomly chipped wood out and hoping that others can tell you how to sand it down to something usable.
Cooper makes this analogy in "The Inmates are Running the Asylum" (link here [amazon.com]) and bashes project teams that take on this sort of process of evolution. He poses a process of almost completely up-front design by building to a theoretical user persona and culling out complexity by ditching features that will never be used by this persona.
Now Cooper's views don't necessarily contradict Lehman's (at least from what I've seen in the article). In fact at a glance they seem to blend in nicely.
From the article, again: Figure out how to control the various feedback loops -- i.e. market demand, internal debugging and individual developer whim -- and you can stave off crippling over-complexity for longer periods of time
It's clear that he means that we, as programmers, should be willing to throw away a shitload of code. I agree with this. I think there's a huge belief in re-use (I tend to it myself) among programmers for both practical and personal (pride...having spent weeks on certain code) reasons. But there are so many cases where the re-use of a small feature among others in bloated code can really complicate and bog down the overall code-base, or where the functionality of certain re-used code doesn't really fit, but so much investment has been made that it might as well be re-used.
Developers really do need to listen to the feedback provided by the marketplace and other forces. I'm not certain if the unified theory is so unified, but it's a valid perspective and blends in with other published sentiments on software development methodology.
'nuff rambling...
Brooks' Law (Score:2, Interesting)
This can be simplified: "Adding manpower to a software project makes it later."
There's rarely that many programmers needed for a given task anyway. You need a project leader and lots of monkeys to test it... very few projects should have more than 10 programmers (if any).
Re:Brooks' Law (Score:4, Funny)
You realize you just suggested that very few software projects should have any programmers. How is the project going to get completed without anyone working on it?
Parent
Re:Brooks' Law (Score:3, Funny)
My boss seems to think that having a lot of meetings about it will do the trick.
Re:Brooks' Law (Score:2)
There's a guy I work with, and that should be his
Re:Brooks' Law (Score:2)
But seriously, one interesting implication is that forks/parallel projects can be a Good Thing! If you have two 10-person projects, and throw one away, you're better off than with a 20-person project.
(Linux filesystems seem to have taken this to heart...
Re:Brooks' Law (Score:3, Funny)
Read my lips: E-VO-LU-TION
Example:
Start with "printf("Hello World\n");" and leave it in a warm, wet place for a few months, feed it with some
I have a strong belief that's what they did with Mozilla
Re:Brooks' Law (Score:2, Insightful)
Re:Brooks' Law (Score:3, Insightful)
The number of programmers needed on a project depends upon the number of software modules in said project. Each programmer working on their module and with the other programmers and project managers for the sake of integration and communication between modules talking to each other. I am not a project manager so I do not have the magic formula but there needs to be some serious research in the IT industry of how many programmers are needed per project for the number of independent sections or modules of software being created.
Then and only then will you have a situation of better utilized output over a large group of programming talent.
10 may me too few programmers for some huge program and too many for plenty of other projects.
_______________________________________________
Re:Brooks' Law (Score:2)
As long as there's a product management group who can drop "Oh by the way" new requirements on the product a week after code freeze, there'll always be a problem.
Re:Brooks' Law (Score:2)
The funny thing is that I have some two other problems arise from Brooke's law.
1) Not wanted to justify more resources to a project the managers simply roll in features into existing modules that should really be seperated out. The same number of programmers end up getting hit twice as hard.
2) Managers have actually quoted this law to others as a excuse for not assigned more resources to a project. Many times in smaller software houses the problem you have is getting the programmer resources for a project. Only the larger houses run into the problem of justing throwing people at a problem to make their deadlines and not having that work the way they wanted it to.
_______________________________________________
Brook's law can't be used (Score:4, Insightful)
Re:Brook's law can't be used (Score:4, Funny)
True. I used to file status reports using Zeno's Work Estimation. On each report I just halfed the percentage of remaining work.
Parent
"Adding manpower to a late software project makes (Score:2, Funny)
Whow! He's still living? (Score:3, Interesting)
"When I first wrote about this topic, nobody took a blind bit of notice."
No, sir, I did and many collegues who were also interested in good timely work. We lent your books to each other with the notion "that's something you should read".
Great to hear that you are still alife and enjoying to give programmers and their managers something to look at and something worth to read and think about.
Youngsters, better pay respect to this old software camel with the hole in the sole of his shoe (and probably also in his all-too British pullover), or I DDOS your toilet!
The key point is paragraph 9 (Score:5, Insightful)
Which means that commerical systems don't so much evolve as stub their growth paths out and switch direction or spawn new generations because embedded complexity has killed off the feasibility of maintaining it. In other words, all new releases are the cause of and ultimately an attempt to escape from, the chimera that is overly complex code. In commercial terms this should be astounding. We're paying to gronk up our own because we erroneously believe the NEXT version will be something radically new and elegant which of course it can't be.
New Version "x+1.y" is simply an ejection seat.
Re:The key point is paragraph 9 (Score:2, Insightful)
19,000 Known Bugs in OS/360 (Score:3, Interesting)
We installed new Releases about once every 6 months. IBM also had 'patches' available for about 19,000 known bugs.
These patches were not incorporated into the latest release because each of them, if installed, broke some other aspect of the OS.
We, and every other site, only installed those patches needed to work around problems that the particular site encountered. And you always hoped that today's patch would not break something else that your users needed.
Blame it on C++ (Score:3, Insightful)
I'm not attempting to flamebait here, just submitting an observation. It seems to me that many of the complexity issues can be overcome by designing better languages. I've never stopped scratching my head over the perseverance of old languages like C++ and FORTRAN. Sure, they are extremely useful in the hands of experienced folks, but they need to die. They were good solutions to problems decades ago, but so much has been learned since then and the constraints of sparse computer resources and CPU speed have moved a lot.
Re:Blame it on C++ (Score:3, Insightful)
C++ ? (Score:2)
Re:C++ ? (Score:2)
So it is accurate to say that C++ has only been standardized recently. But unless you're comparing C++ to Fortran/Simula/Algol, it is just wrong to call it "new".
Blame it on the programmers (And Hiring Managers) (Score:2)
There's a lot of piss poor code out there because there are a lot of piss poor programmers out there -- people who should not be in this industry, people who took a couple of classes in VB and think that qualifies them for the title of "Programmer." And they can still bullshit their way past hiring managers with their shiny buzzwords.
Re:Blame it on C++ (Score:3, Interesting)
Now, this wouldn't be bad, if the skilled programmer had, at his disposal, the means to tweak the garbage collector implementation to suit a particular application -- presuming that there is one and and only one universally "best" garbage collector is arrogant and short-sighted. The trouble is, even though it may be possible to replace the Java garbage collector, one can't do it with a Java implementation: the language is not closed with regard to it's run-time requirements -- garbage collectors need to manage raw memory via, ta da, pointers! This lack of closure, preventing a language's run-time library from being expressed in the language itself, is most inelegant.
Of course, the C and C++ affecionados will point to this closure as the very beauty of their preferred language. Let's call such languages "complete". Alas, the linguistic power necessary to make a language complete has now been put into the hands of the neophyte programmer (was that delete or delete[], and when does it matter?).
It doesn't take much inspiration to see that subsets of a complete language, while not complete themselves, may still be powerful enough to write useful programs. With abstractions, disciplined programers try to fake this: the C++ "smart pointer" exercise is classic. Unfortunately, for all the effort put into smart-pointers and per-class address-of operator definitions, you can still get a real pointer to an object which does not implement such a monadic operator. What you really want is the compiler to say, "Bad programmer: using a real pointer!" either as a warning or as a fatal error (well, maybe not so harshly, but you get the idea).
i want to see (Score:2)
Re:i want to see (Score:3, Insightful)
Re:i want to see (Score:3, Insightful)
I've been trained in that stuff. It's wonderful in theory. In practice? All the metrics only work if you are doing the same stuff you've done before. If you are doing something new, then they don't work. Which is why few people actually use them.
Looks good on a resume, though.
Open source (Score:5, Interesting)
Michael Godfrey, a University of Waterloo scientist, is equally hesitant but still finds the Lehman approach useful. In 2000, Godfrey and a fellow Waterloo researcher, Qiang Tu, released a study showing that several open-source software programs, including the Linux kernel and fetchmail, were growing at geometric rates, breaking the inverse squared barrier constraining most traditionally built programs. Although the discovery validated arguments within the software development community that large system development is best handled in an open-source manner, Godfrey says he is currently looking for ways to refine the quantitative approach to make it more meaningful.
It would have been interesting had they delved deeper into this finding. Yeah, I know, the true believers in open source all feel superior (we are, aren't we?), but exploring the reasons why it works would be interesting.
Is it the large-scale peer-review process? Is it that we occasionally rewrite parts (filesystems, VMM, etc)? Something else?
Describes my job perfectly... (Score:2)
(And yes, I know about XP's "All code is shared.")
As for the maintenance, it's my normal experience, but the prohects I've been involved in may be atypical. (*cough*Canadian*cough*telecommunications*cough*g
We spend a *lot* of time reworking old code to (a) fix obscure bugs, many of which are slow leaks shown up by weeks serving live traffic (b) adapt the code to support new releases of underlying hardware product and (c) adding new features to satisfy users.
Sound premises. Sound reasoning. Wrong conclusion. (Score:3, Interesting)
Except that the "[dire] need of a successor operating system" isn't so dire at all: the world's richest man didn't get where he got by writing code that didn't need to be replaced by a successor operating system, did he? The whole premise is to produce something that works now, and when it stops working later, you sell a later version. Heck, just a couple of months ago, Billy announced that 92.3% of the calendar year would focus on new code, leaving the rest [slashdot.org] for the old.
What's smarter, coding the Microsoft way, or coding a server that's been up since before Windows NT was released, without a patch in 7 years, handling half a megabit of data both upstream and down, every second of every day forever. Where's the revenue?
~r~
Note: the 92.3% figure might only be for the year 2002, with later years being still closer to 100%.
Re:Sound premises. Sound reasoning. Wrong conclusi (Score:2)
Yes, there were lots of things they could have done -- like define a subset of the original committee-designed bloated specification, get that working, then start adding features. But the manager (Fred Brooks) didn't know that, yet, and didn't even know the project was in trouble until it was impossible to deliver anything at all on deadline. Afterwards, he wrote a book, The Mythical Man-Month, which has become a standard text for large-project management. But he learned how by doing it wrong, more massively than anyone ever had before...
You're missing two premises (Score:5, Interesting)
Parent
No theory in Software Engineering? (Score:2, Insightful)
"In software engineering there is no theory,"
I don't buy that... at least not completely. I would say something more like, "In software engineering, theory is extremely underutilized."
I believe there are many instances of engineered software, but not necessarily high-profile stuff. A lot of DoD conscripted code may never the the civilian light of day, but there are procedures and documentation requirements that, flawed or not, enforce certain practices. Can we call that "theory"? Anyhow, defense suppliers can afford the extra development time, 'cause the government is forking over big bucks for the code to right.
For the mainstream (read desktop) apps, where all the money is, the time to market and feature pressures will continue to suppress even the best "unified theory" of software development.
Software Engineering (Score:2, Informative)
We are only Human. (Score:2, Interesting)
It is questionable how useful purely statistical methods are in these situation.
One thing I would be interested in knowing is how staff turnover effects development. For matainable software to be possible a consistent approach must be maintained on adding new functionality, this usually requires deep understanding of alrge code base, and if your programmers keep changing, the newbies may not follow the rules.
Computing Environment (Score:2)
- The functional capability of the OS too, since new hardware keeps coming out
and the Law of Declining Quality ("The quality of E-type systems will appear to be declining unless they are rigorously adapted, as required, to take into account changes in the operational environment").
Exactly what is happening to windows? And why Linux is so successful -> Open Source like fetchmail et al being more linear in their development, all users get a stab at getting the environment right.
But users who aren't prepared to do any work to make things better in their environment for their PC are always going to lose. But it's the same as those people who make their desks tidy and optimise them for work, and those that don't. The difference on your virtual desktop is that you can't easily hope someone else will tidy it for you...:)
it's all in the design (Score:2, Interesting)
you have to try to map out not only what you will need but what you might need in the future.
yes, it's a near impossible task but it's the only way to avoid automatically commiting yourself to an endless cycle of patches and hacks.
the good part is, if you can plan the project well enough then the actual coding becomes nearly trivial.
the problem arises when the boss says 'i don't care about scalability or flexibility, i just want code now' and i have to try to explaining that i'm trying to save his ass 8 months down the line when clients (and not to mention, the boss himself) bombard us with feature requests, etc.
Re:it's all in the design (Score:4, Insightful)
Not only is this not true, it's impossible to do this in practice. If you do this, you'll find that you still blow a lot of time on design, development takes longer, because your design is unnecessarily abstract, and your design proves inadequate for something that you need to implement further down the road. Requirements change, and this has consequences for the design. The best one can hope for is that the basic architecture is robust enough that it doesn't require a complete upheaval.
What is necessary is a method for changing design gracefully. "Refactoring" is the best source I've seen that addresses this. Basically, you change methodically, and you test.
Parent
Re:it's all in the design (Score:2)
design is everything. that is where you try to predict all the problems that might occur.
the off the cuff stuff is just lazyness. if you can work out all the issues, you can then step it into production by mapping out how you solve the solution the rexamine any issues that might come up. once all that is done, you should have a discriptive enough approach that you could hand it to anyone with the ability to write the code you need and have them impliment it. if you ahve a well planed and descriptive design, the coders do not nessisaraly need to have anything to do with planing.
Re:it's all in the design (Score:3, Insightful)
More than that, software vendors routinely write a program, release it, then add features so they can sell it again. It's as if the builder has finished the apartment building, and now they want a factory tacked onto the north side and a Wendy's onto the east. Next year, add a hospital wing to the west. Repeat once a year for 10 years and you get one hell of a mess, but how else would M$ keep a continuing revenue stream from the same OS and Office programs?
Re:it's all in the design (Score:3, Insightful)
I was talking about this with a friend the other day. Wouldn't it be nice if a senior software 'architect' could maintain a unit-level view AND current code at the same time? That way his busy programmers could refactor all they wanted, as long as they didn't overstep their unit bounds but at the same time improve the product. The architect could look at the project at different levels of abstraction (units, subunits) to make sure the programmers aren't getting off track.
Probably the hardest thing about using the iterative or refactoring methodology is knowing what your architecture looks like at any given time. You design a great, flexible architecture for the first iteration, but after several rewrites you may not know where you are in terms of the big picture. Surely a tool that spits out UML-like diagrams of the current code would be very useful to spot architecture flaws introduced during the refactoring process. Effective use of design patterns may also help. Is it impossible?
I've seen some work done by Rational in terms of code generation with
The answer is modularization (Score:2)
I think one of the reasons that Linux has been so successful is because Linus decided long ago to take a modular approach to designing his monolithic kernel.
-josh
No Interest in 'Doing It Right' (Score:3, Insightful)
Our firm licenced this software to major manufacturing firms with a Money Back Guarantee. As in, "If you are not satisfied, for any reason, we will either fix the problem or give you back your money. Your choice." We were never asked for a refund.
It was semi-open source. You could have the source any time you wanted, but asking for the source voided your warranty, since problems in your data might have been caused by your own temporary code changes.
Funny thing. I've had that on my resume for many years, but no prospective employer has ever asked how I did it.
No one has hired me specifically to help them produce similar quality code. Much of the time their reaction to my resume is, 'but you don't know c++' (or their other favorite). I know enough about c++ to know that I want to stay away from that second generation language for all but the most specialized situations.
I have also been told, on numerous occasions, that I'm not qualified to lead a particular project because I lack experience mannaging the large team that will be needed. I've never gained that experience because I've never needed a large team to accomplish anything.
As an MBA, as well as being an application designer & a coder, I know that large teams do have a place -- mostly where you have a blank cheque and are earning a percentage of the total billing. (:-)
Software craftsmanship (Score:4, Interesting)
A lot of the dire predictions of software atrophy and such are a result of applying the wrong methodology to a project. Yes there are uses for Software engineering, but I think this approach is overkill for even large scale projects. Check out Software Craftsmanship: The New Imperative [barnesandnoble.com] for a different perspective. A perspective I think is in need of serious consideration. The gist is returning to the days of master craftsman and apprenticeships. This focuses a bit more on the learning aspect than actual development methodologies, but you can always go to The Pragmatic Programmer [barnesandnoble.com] to fill in that gap.
"As time passes, the system becomes less and less well-ordered. Sooner or later the fixing ceases to gain any ground. Each forward step is matched by a backward one. Although in principle usable forever, the system has worn out as a base for progress."
This is where "refactoring" (see Fowler's Refactoring [barnesandnoble.com]) really shines. I find it difficult to believe that refining the software base is not progress. An initial revision where the code functions by its contract (if your into designing by contract), then you refactor the body of the function/method for speed / elegance. Then you can run your unit tests on the function / method to test that the refactoring session did not break any of the design contracts (whew).
I think they may be trying to restate the broken window theory (see Pragmatic Programmer), were a broken window (or bug) in a building (or system) leads to delapidation elsewhere in the building (or system).
And then there are the agile methods [agilemanifesto.org], including XP [extremeprogramming.org]. I think these answer a lot of the limitations and issues with Software Engineering practices. Interacting with clients (having a client there during each iteration) gives you the benefit of almost real-time feedback so that you can update your user stories on the fly, etc.
Without rambling on any farther, my point is not too spend too much time looking for a specific unified theory. Read up about all the ideas, methods, and theories. Take the best parts from each, then crank the knob all the way up (if I may borrow that from XP =] ). Don't let anyone tell you there is a science to software development that is easy to reproduce, and that you are just a link in the overall chain. You practice and perform a craft. Enjoy it!
Re:Refactoring and Rewriting (Score:3, Insightful)
Growing geometrically? (Score:4, Interesting)
From the article:
Is fetchmail [tuxedo.org] complex enough that it needs to be growing geometrically? I mean yeah, fetchmail does a lot, and I do know what "geometric" means. Still, I doubt the world of email is changing fast enough that you'd want to choose that as your example of out-of-control software maintenance.
[Insert obligatory ESR goading.]