I’ve finally decided what to talk about at LUGRadio Live. I’d like to expand on Stephen O’Grady’s ideas around lesscode, simplicity, and php – see the presentation he gave at the Zend conference. I didn’t hear the talk, just read the slides, and contributed a small amount to the discussion on lesscode. In my talk I want to expand the theme to open source and life in general. Warning this is a bit of a rambling post while I sort my ideas for the talk.

Many open source projects have been successful in part because of an approach which includes lesscode and simplicity. Before we look at some examples it’s woth pointing out that there are two sides to software development, the developer, and, for want of a less derogatory term, the user. Simplicity and lesscode apply in both realms but in different ways.

To quote what I said to Stephen at the time;


I think there are two intermingled sides to simplicity and lesscode – the user side and the developer side. To me the whole thing is about chosing languages, methods, approachs, frameworks, etc that make life better and easier for both parties. By making the job of the developer easier they can focus on making things better / easier for the user.

I would say that TV recording is real world practical example of simple and lesscode ideas for the user side.

Ask the audience how many people in their family know how to set the timer of a video recorder (you could ask how many of them know how to use a video recorder but if it’s a room full of programmers the chances are they do, and were hassled by family members to set it up). Recording a TV programme when you wheren’t in is/was a nightmare with a VCR – quite apart from the setting of the timer, labeling the tape, remembering where you put it, remembering that you even recorded that show (how many people have found a tape during a tidy up and thought – wow, I don’t remember recording that).

With a PVR (Tivo, Sky+, MythTV) it’s as simple and user centred as: find the program in the EPG (or search for something you’re interested in) and press the record button. Finding the recorded shows is simple as well. There is no doubt that more could be done to make PVR’s even more simple and lesscode, but the contrast between the VCR forcing you to be a part time programmer and librarian, and the PVR which allows you to find what you want and record it. It’s is slightly unfair to the designers of VCR’s since their wasn’t the infrastructure in the late 70’s / early 80’s to do this sort of thing.


Anyway let’s look at some examples from Open Source;

  • Gnome: In the 2.X series the project took a bold move to create a HIG, to simplify to interface, and choose sensible defaults rather than a million config options, and make things Just Work.
  • Ruby on Rails: In Web0.0 we used to do crazy things like create dynamic webistes in C, or BASH, or even perl. PHP made Web1.0 easy, simple, lesscode. What PHP did for Web 1.0, RoR does for Web2.0
  • Firefox: Do I really need to explain? Mozilla was fine technically, but the jewel lost in the muck was the Gecko engine, it just needed a simple, Just Works browser around it.
  • Ubuntu: SuSe is 5 cd’s or 1 double sided DVD (and has been for years), RedHat 9.0 was, if I remember, 3 CD’s, now Fedora is 4 CD’s or a DVD, Mandrake, I can’t remember but I’m sure was a few CD’s. Ubuntu, when it started was one CD, only came with Gnome, and only had one of every type of app, and aimed to make everyting Just Work. Even now each flavour is just one CD (Ubuntu, Kubuntu, Xubuntu, Edubuntu, etc).

Those are easy observations to start with, but the real question is how to stay simple or even what do we mean by simple (as was discussed on tecosystems). To me simple or lesscode is not simply a checkbox – it’s a state of mind, and aesthetic, somethings that’s hard to quantify but easy to spot when it’s missing.

So with that said the hard part is how to keep the simplicity as a project goes forward, how to regulate the desire to keep simple with the need for more features and more code.

I think web development gives us some clues here. As I mentioned above, all web stuff was simple to begin with – simple static html. As we became comfortable with website we wanted more, we wanted to make our lives as webmasters/developers easier. So we used the tools we knew, whether C, BASH, or Perl, and hacked up CGI scripts to process forms, and as more features were demanded the more complex and unweildy they got.

Then along came PHP which at first simply was a collection of C routines for CGI scripts (at least if I remember correctly), and later evovled into a neat little scripting language that made web scripting simple, easy, and lesscode. All the little things like processing GET and POST variable, dealing with cookies, connecting to databases, etc, etc. This was especially appealing compared to the other prevailing method at the time – Java applets (poor old Java keeps on having to play the enemy in these stories) which were just insanely complex things to build – whcih is why they were the weapon of choice for most enterprises. PHP’s lesscode aesthetic was to build the simplest wrapper around the functionality and then get out of the way.

Fast forward until the last 18 months and the whole IT community is gradually coming round to the PHP point of view for web development (not just using PHP but Python etc as well) – but our desire for functionality has grown and grown, and now there’s this whole Web2.0/Ajax thing and our PHP is starting to creak.This isn’t meant to be some death knell for PHP – there’s still loads for demand, and need, for Web1.0 sites, and of course it’s not impossible to do Web2.0 stuff in PHP.

Aside. In the mean time the Java camp abandoned applets and start writing servlets and JSP, and gradually trying to make web development in Java as much like PHP as is possible within the constraints of Java. Also PHP the language has gradually developed and added more sophistication and become as much like Java is is possible with the constraints of PHP – so you end up with PHP Enabler for Sun Java System Web Server and OTN: PHP Developer Center. If I wanted to wind people up I would say the PHP is increasingly Java-lite, i.e. Java with all the annoying strictness and verbosity taken out. But I’d mean it as a compliment to both 😉

Along comes Ruby on Rails, with it’s aesthetic of making things beautiful and easy for the programmer (with the trade off that you need to things the RoR way). DHH and the rest have soaked up the last 10 years of web development, including Ajax, and commoditised it – Object-Relational mapping, form handling, javascript integration, templating, extensions, MVC, etc, we have all that, and it’s easy.

This changes the metric of the landscape – imagine a world where the distance between everything and me is 1. From my point of view everything in this world is spread on a sphere of radius 1 around me. Everything is equally easy to get to so I can now think,in fact I have to think, what I really want. RoR doesn’t quite make the web development metric like this, but it moves towards it. Getting Real might mean having less features, you have a much more equal choice between which features you want and which you can drop – it becomes less about what’s easy / hard for the developers, and more about what’s right for the users (which is how it should be).

So after all this rambling we seem to arrive at a pattern;

  1. Develop new things frantically
  2. Reach a point where it all becomes a bit too complex and unweildly
  3. Look for someone or a group of people who use a different metric to measure things, who cut away the complexity and make things simple
  4. Repeat and rinse (remembering that the people or technologies in step 3 will probably be different than the last time around)

Looking the examples above they all have this kind of pattern.

  • Gnome in the 1.X series was frantically trying to build out the desktop and continued development, along with the UI, was getting complex and crufty. With 2.0 they changed the way they measure development: introduced the 6 month release cycle, and the HIG, and the whole route they’re on now.
  • The Mozilla Suite was a giant complex beast and was difficult to add even simple features too. Then Firefox changed the game, simplified the UI, but also with the plugin system, made adding simple features simple (and made it simple to keep stuff out of the core).
  • Ubuntu. It used to be that distributions struggled to fill a CD, and we were just glad any kind of hardware worked, let alone Just Work. Everyone was focused on making the installer as easy as possible, and catering to server admins, who were comfortable with all the complexity, and including all the open source goodness that there was. Ubuntu changed the metric; fit the best most useful stuff on one CD, and work hard to make sure that everything Just Works. FOSS for ordinary people.

So to try and answer one of my questions: it might not be possible for a single application, project, or development tool to stay simple. It might be that it has to submit to entropy and get more complex until the next wave of application, project, or development paradigm comes along and changes the metric.

Anyway those are my initial ideas – now I need to think a bit more and squeeze this all into a 15 minute talk. Simple.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s