A thread on the Linux Kernel mailing list started innocently enough about proper spacing in source code, then grew and grew into a somewhat philosophical debate about evolution and code design. The subject of the thread was “Coding style – a non-issue“. However, before long a debate was sparked, leading to some interesting comments by Linus and some others, perhaps best summarized by Alan Cox’s comment: “Engineering does not require science. Science helps a lot but people built perfectly good brick walls long before they knew why cement works.” and Linus Torvalds: “And I know better than most that what I envisioned 10 years ago has _nothing_ in common with what Linux is today. There was certainly no premeditated design there.”
Torvalds: Linux Was Not Designed
About The Author
Eugenia Loli
Ex-programmer, ex-editor in chief at OSNews.com, now a visual artist/filmmaker.
Follow me on Twitter @EugeniaLoli
Don’t mean to be a besserwisser or anything but boy are they following Zeeee Greeat Zcheme of Zeee Zoftware Antipatterns…
*yawn* Another computing person does a deft job at mis-applying evolution/biology to explain coding/computing behavior.
And people say RMS is a crank? (He’s a _mild_ crank.) Linus just moved to the head of the class. He should start hanging out with Bill Joy.
Until recently, I didn’t know a whole lot about Linus, but I must say that he impressed me quite a bit with this exchange. I definitely believe in the importance of design, but I think what he was saying is that for any large-scale project, it’s impossible for one person/group to design everything that everybody will need. Thus, you have a bunch of people pushing for the things they need, so you end up with a bunch of good designs at the microscopic level but no main design at the macroscopic level. Interesting and well-stated stuff…
I can’t believe it. So he makes shitty software and then waits 10 years for other guys fix it? and that’s called a “feature”? It made me really angry to hear that, but at least he recognizes that the Linux kernel was (is?) a bad piece of code from a software engineering point of view. No thanks, I’ll keep using UML, RUP, OOP, design patterns and other CSE “tricks” to write good software.
and people worship this guy??
“UML, RUP, OOP, design patterns and other CSE tricks” are all just glorified crap for shit coders.
Hell, 10 years ago, none of those bullshit buzzwords existed.
And people wrote better software than you ever will.
And they still do. Without using any of that shit.
You obviously have not coded any large production software.
Software evolves. It’s not designed. And this is true at many companies I’ve worked for. And these were _LARGE_ companies. If you want a competitive edge, you code quickly. And you code often. And you don’t spend years designing.
Linus has a point.
And just because people don’t use “UML, RUP, OOP, design patterns and other CSE “tricks …”, does not mean the code is shit.
If you have ever really studied the Linux code, you wouldn’t be saying this shit.
Evolution is a process of random variation with selection by environment. What you are talking about is not evolution. It is development. It’s NOT the same thing.
I don’t know if you are a troll or not Bob but I’d say you are EXACTLY the kind code monkey that will bring a software project to a halt. If you have to develop a wordprocessor with 15 other people do you say “Right, we need a wordprocessor by a year from now, everyone start hacking!” or do you say “A word processor you say, what does it have to do ?”. In fact to prove that you are wrong I challenge you to name ONE software project that didn’t have any design or specification of purpose that wasn’t either a complete failure or enomously over budget.
Linux you say ? Then tell me the requirements for the Linux operating system ? There are none ? Oh. Ok then, during what time frame or under what economic pressure is the Linux operating system developed. No budget or time limit you say ? People do what they want and they do it for free ? Oh. So we don’t know if Linux achieved it’s goals within the specified budget since it
A) doesn’t have a budget.
B) doens’t have any goals besides being a operating system.
To use the worlds biggest and perhaps most successfull hobby project as a benchmark for thrashing any kind of formal or organised software development method is wrong. And Linux IS a bad piece of software from a Software Engineering POV but then again so is most software since SE aims at a unachievable target, total control of the development process. Unfortunately people with your kind of attitude Bob aren’t helping.
Re: DavidGentle
Last time I looked in a dictionary:
ev·o·lu·tion (v-lshn, v-)
n.
1) A gradual process in which something changes into a different and usually more complex or better form. See Synonyms at development.
2) The process of developing.
Gradual development.
Right. Not what I was saying.
Moron. Move along.
Re: muggboy
Errr. Right. OK. If you were to start hacking on a software project, that needed to do X, Y, and Z, then obviously, you start hacking towards fullfiling X, Y, and Z. That’s not the issue here.
Linux, is an operating system. Built on top of a UNIX foundation. There’s not much ambiguity in that. What’s not defined is which direction it should go in. Should it do X, should it do Y, etc. There’s no PLAN (yes, please look up “design” in a dictionary) on the table for it to do X, Y, or Z. It just moves in each direction, by multiple people, all over the planet. And it get’s done. And it is good, solid code. And millions of people are using it this very day. To do very important things. Where lots of money is at stake if it wasn’t good, solid code.
I don’t exactly want to _help_ your idea of Software Engineering. It’s wrong. It’s not how things are done in the real world. And if it was, it would halt a software project. Not me.
> UML, RUP, OOP, design patterns and other CSE tricks” are all just
> glorified crap for shit coders.
So all the CS engineers are shit coders.
> Hell, 10 years ago, none of those bullshit buzzwords existed.
OOP has been here for 10+ years. There was no UML, but there was Bochs, OMT, and others that later in 1995 (or so) where unified into UML.
> And people wrote better software than you ever will.
> And they still do. Without using any of that shit.
> You obviously have not coded any large production software.
If you write large software, you have to design because it becomes too complex to understand how works every piece of your application. You need a “blueprint” of your software for you and your team. But if you are writting a relatively simple application you can go directly to the code, there’s no need to formally design it if you can do it in your head.
It’s like the comparison of a CSE with an architect. If you are building a house for your pet, you can go and just make it. But if you are making a large building (ie. a sky crapper) you need to design and use blueprints because it becomes too complex, otherwise it’s almost impossible to make it, no matter how smart you are.
> Software evolves. It’s not designed. And this is true at many companies
> I’ve worked for. And these were _LARGE_ companies. If you want a
> competitive edge, you code quickly. And you code often. And you
> don’t spend years designing.
Design doesn’t mean no “evolution”. In fact, the latest methodologies (like RUP and XP) are iterative. You work by defining small iterations (or mini-projects) where you apply analysis, design, etc. If something went wrong (ie. design), you fix it in the next iteration, and so on.
> Linus has a point.
Yes. I guess that one of reasons of why it worked without design, is because Linux is based on Unix, so the requirements, design, etc. are already available in other OS’es (ie. Minix, BSD), standards/specifications (ie. RFCs), books, etc.
> And just because people don’t use “UML, RUP, OOP, design patterns
> and other CSE “tricks …”, does not mean the code is shit.
Yes, you are right, but saying the opposite is wrong too. I’m sorry for saying that Linux design/architecture is crap.
> If you have ever really studied the Linux code, you wouldn’t be saying
> this shit
I studied the code long time ago (like 6-7 years ago). I was Linux fan too.
If you say that OOP, UML, etc. are glorified crap, then you haven’t either studied or understood it at all for that matter.
Get straight to coding, or design it all beforehand?
There are problems with straying too far into either camp. The first problem which springs to mind with the design approach is when the design gets too rigid, or too detailed. Unless you have personally coded, or at least used, examples of all the elements required prior to starting your design, then you will probably not be aware of some of the limitations and/or optimisations available to you. In other words if you design every last detail before you even start coding, then the odds are your design either will not be implementable (thus making the time spent in design wasted), or will be innefficient (in terms of system resources, coding time, reliability, or maybe all three).
On the other hand the “evolution” approach of Bob is also fraught with dangers, especially on a larger project where several people might be working on it at once, or over a period of time (with changes in the environment in which the package runs making things worse again). A couple of examples are..
Code bloat because functionality is replicated, why? because noone noticed that there were strong similarities between certain blocks during the design stage (because there was none)
Code bloat/innefficient code for work arounds. Why? because code developed in the oast is too situation specific, or you’ve written 3000 lines of code expecting your data to be provided in one form, whilst another developer has written 3000 lines expecting to supply it in another, and now you have to waste another 500 translating!
Inconsistent user interface.. especially when different developers are working on the same project.
Inconsistent software interface.
And generally unneccessary recoding because you get to a certain point and go… “damn, I didn’t think of that!”
All good software developers design to some degree, I’d guess that Bob does too, only he doesn’t think he does because he doesn’t formalize it and write it down or put it into a diagram. UML for one does not say HOW software should be designed, rather it is a tool to help you record and clarify your own ideas, and communicate them with others. It’s like learning to read and write music, it doesn’t make you a better or worse musician, but it does make it easier to put down your ideas, and communicate with other musicians.
And finally Bob….
“Hell, 10 years ago, none of those bullshit buzzwords existed.
And people wrote better software than you ever will.
And they still do. Without using any of that shit.”
Correct me if I’m wrong, but I believe You don’t know who he is or what code he writes (neither do I) and therefore have no way of knowing whether it’s good or bad. That makes attacking his coding ability invalid, stupid, and rude. I hope you think more about what you code than what you say.
Bob. Please don’t waste your time trying to insult me.
What I was describing was not the dictionary definition of evolution but the biological process that is the basis for the concept. The biological process is what i said it is. That is really obvious. Using the biological process as a model for developing software is about as dumb as calling someone you’ve never met, and know nothing about, a moron.
“Hell, 10 years ago, none of those bullshit buzzwords existed.
And people wrote better software than you ever will.
And they still do. Without using any of that shit.”
I bet throughtout the histroy of The Code, people have been using design technecs, anyway most are to help COMMUNICATE more than anything else (Natral language just don’t cut the musturd).
> Using the biological process as a model for developing software
> is about as dumb as calling someone you’ve never met, and know
> nothing about, a moron.
I actually took an Evolutionary Computation course in college which was pretty interesting. The premise was that code written in a language like SCHEME or LISP which is easily componentized could be swapped in and out of code trees, and run to determine a result. The applications built this way were basically ‘trained’ through the use of a simulation of natural selection, and then had some probability of mutation over each generation. In some cases the final product was more affective than the known algorithm for some particular problem.
Anyway, I thought it would be interesting to mention this.
http://citeseer.nj.nec.com/212034.html“>Genetic