The Old Joel on Software Forum: Part 4 (of 5) - The "Big Ball of Mud" pattern

The "Big Ball of Mud" pattern

I stumbled on this article recently (via lambda the ultimate) and thought that it was a pretty fair characterization of the majority of software out there:

http://www.joeyoder.com/papers/patterns/BBOM/mud.html

Kalani
Saturday, May 1, 2004

Personally, I like "Puddle of Mudd".

PooNanny
Saturday, May 1, 2004

Have you noticed how computer programs are like the cables at the back of your computer. You start off with the intention of keeping all the wires tangle free but each new cable you add gets the wiring into more and more of a tangle.

Programs seem to be the same, you start off with a clean design but each new feature you add causes more and more tangles in the design until it's a big tangle of connections between the components in the program.

Matthew Lock
Saturday, May 1, 2004

Yes, i think this is the perhaps the best paper ever.

son of parnas
Saturday, May 1, 2004

This has come up a few times before here. Don't miss the original article that covers it in glorious hilarity and impeccable detail:

http://www.laputan.org/mud/

It's not always an antipattern. It's actually a very useful one and many times is one of the most effective approaches to design - note for example, nearly all successful software in the world, which uses this pattern.

Dennis Atkins
Sunday, May 2, 2004

Nevermind my link, it's to the same article as the first one posted; I was waiting for the first one to load.

Dennis Atkins
Sunday, May 2, 2004

[It's actually a very useful one and many times is one of the most effective approaches to design - note for example, nearly all successful software in the world, which uses this pattern.]

Surely you are joking, right?
I mean, that it is actually an approach to design? And that all succesful software "uses" this pattern? As opposed to suffering from it? And still being succesful in spite of it?

Please tell me that is what you meant.

Erik
Sunday, May 2, 2004

A good property of the big ball of mud is that when you add something to it, it's still a ball of mud. So you can add work to parts which are currently deficient. This is incremental growth. I think Common Lisp is a useful case study; it supports syntactic abstraction, so when you add stuff to it, you're really just growing a ball of mud.

So one thing to do is prune stuff, and reshape things to be more robust. Weird things evolve; instead of a bunch of for(;;) loops, there's basically an uber-sublanguage called loop, which seems to package together a lot of iteration that people generally want. (Keeps people from going out and reinventing for(;;), I guess.)

I hear the Smalltalkers have their own take on it... I should learn it because the next wave of languages will probably look a lot like Smalltalk.

Tayssir John Gabbour
Sunday, May 2, 2004

> Surely you are joking, right?

Not at all - read the article to be enlightened to the advantages of the mud ball.

> I mean, that it is actually an approach to design?

Yes, and these fine fellow are at long last giving the world's most popular software architecture a proper name.

> And that all succesful software "uses" this pattern?

Not all but most.

> As opposed to suffering from it?

That too.

> And still being succesful in spite of it?

Ahh, now you understand, grasshopper.

> Please tell me that is what you meant.

Ball of Mud is here to stay.
Ball of Mud won't go away.
Ball of Mud is our Design.
To the Mud we are resigned.

Dennis Atkins
Sunday, May 2, 2004

"Ball of Mud is here to stay.
Ball of Mud won't go away.
Ball of Mud is our Design.
To the Mud we are resigned."

Dennis, I think you may have missed your true calling.

Mr.Roboto
Sunday, May 2, 2004

Good article.

But why does the Java link on the left take you right back to the Big Ball of Mud article? ;-)

Java Programmer
Monday, May 3, 2004