Software Engineering

Less code is more

Simon Willison — 2005-07-10T02:53:44-00:00

I've pointed to it a couple of the times from the blogmarks, but it's worth re-iterating here: if you have any interest at all in LAMP, agile programming or open-source development methodologies you should take a look at lesscode.org. To quote their about page:

lesscode.org is a place to advocate, discuss, and practice the art of using less code to get more done. We shun complexity and challenge the status-quo when it impedes our ability to simplify our development tools and processes. We appreciate Python, Ruby, LAMP, REST, KISS, worse is better, and talk like a pirate day.

Ryan Tomayko is the guy behind the site, and he evidently has a lot to get off his chest.

In other recommendations, Ka-Ping Yee has been providing excellent coverage and analysis of SOUPS 2005 over at Usable Security. And on an unrelated note, I've been deriving a great deal of amusement from I Harth Darth.

I'm off to San Francisco for a week. Stay safe.

Advice worth repeating

Simon Willison — 2004-01-15T04:54:43-00:00

Tim Bray's Laws of Explanation:

The First Law

When you're explaining something to somebody and they don't get it, that's not their problem, it's your problem.

The Second Law

When someone's explaining something to you and you're not getting it, it's not your problem, it's their problem.

Joel on Eric

Simon Willison — 2003-12-16T01:24:12-00:00

Joel Spolsky's latest essay reviews Eric Raymond's The Art of Unix Programming (a book I really want to pick up) and uses it as background for a discussion of the cultural differences between Windows and Unix programmers. As always, it's an insightful piece.

Joel's key point is that while Unix programmers write code for other programmers, Windows programmers write code for end users. Unix programs end up being far more powerful and flexible, but Windows programs allow Aunt Madge to send email. Joel places the blame for the lack of success of Linux as a desktop operating systems on the cultural values that underpin it, which celebrate the diversity of multiple window managers rather than condeming them for confusing end users.

It's all good stuff. I'd argue that the rise of web-based applications balances the playing field somewhat in terms of ease of use of the different platforms - most people can handle a web application now (look at the success of webmail) and most browser behave in pretty much the same way no matter what operating system they run on. I guess that's why Microsoft were so scared of Netscape back in 1996.

Analysing methodologies

Simon Willison — 2003-11-15T02:13:18-00:00

Joel Spolsky on analysing development methodologies:

But we don't have the data. We don't have any data. You can give us anecdotes left and right about how methodology X worked or didn't work, but you can't prove that when it worked it wasn't just because of one really, really good programmer on the team, and you can't prove that when it failed is wasn't just because the company was in the process of going bankrupt and everybody was too demoralized to do anything at all, Aeron chairs notwithstanding.

Marketing for Geeks

Simon Willison — 2003-07-09T13:09:04-00:00

This is excellent: Marketing for Geeks, a series of articles (three at the moment) by Eric Sink. I've never really been interested in marketing but Eric got me hooked with geek friendly examples such as Paint Shop Pro and CityDesk and I ended up learning a great deal. The writing style is similar to that of Joel Spolsky, so if you enjoy Joel on Software you'll certainly enjoy this.

Strong Typing vs Strong Testing

Simon Willison — 2003-05-04T20:32:56-00:00

In Strong Typing vs. Strong Testing, Bruce Eckel reconsiders the old idea that languages without strong typing can't be relied on to create large programs:

This became a puzzle to me: if strong static type checking is so important, why are people able to build big, complex Python programs (with much shorter time and effort than the strong static counterparts) without the disaster that I was so sure would ensue?

His conclusion is that type checking by the compiler does not garauntee the correctness of a program in the first place; it's just another test. Comprehensive unit testing can more than compensate for the lack of type checking in languages such as Python, especially since the huge productivity bonus provided by Python allows more tests to be written starting at an earlier stage in development.

Incidentally, Bruce recently added an RSS feed.

Conversation with Martin Fowler

Simon Willison — 2002-11-29T23:43:01-00:00

A conversation with Martin Fowler, parts I, II, III and IV.

OWASP Security guide

Simon Willison — 2002-11-24T21:19:55-00:00

The Open Web Application Security Project (OWASP) have a free guide to building secure web applications, which covers a large range of common problems such as cross site scripting and SQL injection vulnerabilities. The report is a 60 page PDF and although I haven't had time to go through it yet it looks like an excellent read.

phpPatterns

Simon Willison — 2002-11-24T16:13:16-00:00

phpPatterns is a brand new site which advocates and documents the use of object oriented design patterns with PHP. It's a great concept and the site already has some impressive content (although it could really do with a PHP references tutorial). The site is a project of Harry Fuecks, a regular contributor to SitePoint's PHP forums.

Leaky abstractions

Simon Willison — 2002-11-12T14:33:03-00:00

Joel Spolsky: The Law of Leaky Abstractions

Code generation tools which pretend to abstract out something, like all abstractions, leak, and the only way to deal with the leaks competently is to learn about how the abstractions work and what they are abstracting. So the abstractions save us time working, but they don't save us time learning.

And all this means that paradoxically, even as we have higher and higher level programming tools with better and better abstractions, becoming a proficient programmer is getting harder and harder.

Object persistence

Simon Willison — 2002-11-08T14:36:32-00:00

Simon Brunning talks about persistence, and how much more complicated it is now that objects are involved. The best explanation I've seen of how objects and relational databases can be used together was in Martin Fowler's Patterns of Enterprise Application Architecture, but now that the book has been published he has removed the online version. IBM's DeveloperWorks has a new article up describing persistence management in Python, which talks in details about Python's native serialization method (pickling) but only mentions ZODB in passing. I agree with Simon - object databases just don't seem as elegant a solution as RDBMSs. Object databases may provide persistence but they don't seem nearly as powerful as relational databases when it comes to flexibility of accessing data.

JSP bits and pieces

Simon Willison — 2002-11-01T14:56:53-00:00

I've been reading up on the Jakarta Struts MVC framework, courtesy of Simon Brunning. Struts, an open-source MVC implementation is a great starting point, and the ONJava JSP/JSTL series (also found via Simon) were very informative as well.

Doc's thoughts on Linux Lunacy

Simon Willison — 2002-11-01T00:59:34-00:00

Doc Searls is back from the Linux Lunacy cruise, and has been talking about the future of the software industry in What I learned on Linux Lunacy:

That's over, and it's not because a pile of overfunded dot-com fantasies crashed to the ground. It's over because the market doesn't want it any more. The market wants something more like professional services--architects, designers and builders. Good businesses all, but not the kind that are "venture scale", as they say.

I think this is the classic business case for open source software - pay software engineers to buld custom solutions from freely available (open source) components. The engineers make a good living, the company gets good software and hopefully some more open source material is fed back to the community as a result. Is the market really heading that way? A lot of very smart people seem to think so. The next few years could be very interesting indeed.

Software Engineering practises for PHP

Simon Willison — 2002-10-29T02:07:49-00:00

Scott Johnson's presentation on Software Engineering Practices for Large Scale PHP Projects is fantastic - lots of excellent practical advice for professional development with PHP. It's a shame the presentation slides require Internet Explorer (due to being exported from Power Point) but it was more than worth firing up IE to view them.

PythonCard scriptlets

Simon Willison — 2002-10-27T10:58:01-00:00

Kevin Altis on scripting applications written in PythonCard:

The entire object model of a PythonCard application is exposed, so if an app doesn't have the feature you want, you can probably extend it with a short "macro" in Python. All scripts are run in the shell, so they share the shell namespace and thus scripts can share variables since the namespace doesn't go away until the application is closed.

Kevin calls these scripts "scriptlets" and has posted an example scriptlet that can insert the current date and time straight in to any text file opened with the PythonCard codeEditor.

Sam Ruby was recently quoted as stating the following over on Jon Udell's blog:

While Java and C# battle over who is the rightful successor to C++, it is quite possible that a language like Python (or, dare I say it, Ruby) will ultimately be the one that wins out.

This is an interesting train of thought. Scripting languages such as Python undeniably lead to faster development times (no compile cycle, less book keeping syntax to worry about) and as computers continue to get faster and cheaper the overhead associated with these languages becomes less and less important. Kevin's concept of an application with an exposed object model that can be tweaked by the user is a powerful idea, and one that could bring real benefits; Python is not a difficult language to program in, and applications which can be scripted easily can become very popular (just look at the mIRC community for an example of that). Unfortunately the ability to script an application also leads to inherent security flaws, as have been seen with VBScript and Microsoft Office - although in the case of Office most of the problems stem from the ability to add macros to individual documents (there are surprisingly few mIRC security alerts despite the in built scripting engine).