Monthly Archives: September 2006

September’s Reading (Part 1)

Another month, another pile of books—except that reading them never feels as onerous as that phrase makes it sound. Reading about new tools and techniques is to building software what watching a hockey game is to playing one; the older I get, the more comfortable I am letting the kids on the ice sweat while I cheer.

This month, I have several books to cheer about. The first, and best, is Brugali and Torchiano’s Software Development: Case Studies in Java. It’s a shame I overlooked it when it came out in 2005, because it would have been a great source of examples in the undergraduate software architecture course I taught this summer. This book walks readers through one design exercise after another. The actual problems range from parking cars to implementing a simple hardware description language, but they’re not really what this book is about. Instead, it’s about how to analyze a problem, invent a solution, and turn that solution into code.

Each chapter introduces or reinforces one aspect of this process: domain modeling, the use of state machines to model complex system, automatic generation of documentation, and so on. By chapter 20, the reader is in the middle of negotiation-based service configuration, without ever having strained a mental ligament. Brugali and Torchiano’s English is very good, though a little stiff in places, and they assume their readers are more comfortable with math and abstraction than the typical North American undergraduate, but those are very small nits. Twenty-one worked examples of how to get from a problem statement, through class diagrams and sequence diagrams, to working code, is a great resource; I look forward to taking advantage of it frequently.

The second of this month’s winners is Michael Owens’ Definitive Guide to SQLite. SQLite is a small relational database, designed to be embedded into systems rather than used in client/server situations. It may not be as famous as PostgreSQL or MySQL, but it’s a lot easier to set up, and is now showing up in a lot of applications that you might not think of as having databases.

This book covers everything from the relational model and syntax of SQL to SQLite’s C API, the mechanics of writing extensions for it, and its internal structure. The writing is clear, the diagrams helpful (though some are a little bit fuzzy in my copy), and the examples genuinely add value to those you can find on-line. The chapter on SQLite’s implementation is worth the price of the book, particularly if (like me) you feel you can’t really use something well until you know how it works. Recommended.

Third up is a collection edited by Chris Bateman called Game Writing: Narrative Skills for Videogames. As the blurb on the back says, as games become more like Hollywood productions, good story lines become ever more important. Nonlinear, exploratory games and massive online roleplaying games can borrow a lot from older forms, but their creators are having to invent a lot that’s genuinely new. How can you use narrative to keep a player on track, without her feeling like she’s being manipulated? How can cut scenes and stock video enhance a game? What do they take away? Can games be funny? Can they be funny the tenth or hundredth time they’re played? These are the kinds of topics that the book’s dozen contributors address.

Like most collections, Game Writing is uneven, and I often found myself wishing for more concrete examples. However, as someone who once wrote a children’s book, I found the comparisons between this new genre and the ones I’ve dabbled in fascinating. I’ve tried for years to convince my undergraduate students that being able to write is at least as important as being able to code. Most haven’t believed me (or haven’t believed me enough to invest time in improving their writing skills); I’ll be curious to see if this book can help me change their minds.

Chris Bateman (ed.): Game Writing: Narrative Skills for Videogames. Charles River Media, 2006, 1584504900, 336 pages.Davide Brugali and Marco Torchiano: Software Development: Case Studies in Java. Addison Wesley, 2005, 0321117832, 630 pages.Mike Owens: The Definitive Guide to SQLite. Apress, 2006, 1590596730, 464 pages.

Open Source Immigration

This Computer Weekly piece pointed me at a project that’s studying immigration into open source projects. Interesting stuff: the curves are similar to the naked eye, so my next two questions would be:

  1. What factors account for the differences between projects?
  2. What do the curves look like when you divide the population by first language, geographic location, gender, age, etc.?

See also Susan Sim’s paper on software immigrants: these concerns aren’t traditionally part of software engineering, but I believe they have as much influence on success or failure as technology choices or modeling tools (probably more).

An Unrepresentative DemoCamp

DemoCamp 9, held two days ago, was the first that has disappointed me. Disappointment #1 was the demos themselves: ConceptShare‘s was great—I really want a chance to play with their stuff—and DictaBrain‘s voicemail-to-text was intriguing until we learned that the transcription is going to be done by typists in India, rather than software, but the eMail Company’s form builder looked very 1999, and I’m not sure even now what the point of the InfoQ and Pursudo demos were: the guy who demo’d the first seemed to be trying to persuade us that yes, there really was some technical innovation in the site (I didn’t see it), while the second was something thrown together in three days just so its authors could demo it.

If that was as far as the letdown went, I’d be OK: I used to play a little jazz, and I know that open mike nights are always a mixed bag. But as David Crow has very courageously said in his latest post, that isn’t all that went wrong. ConceptShare is intended to help people collaborate on graphic design over the web; it lets you post images (such as advertising copy or screenshots of a new GUI), then annotate them and draw on them asynchronously, with all the logging and blogging you’d expect. During their demo, its creators used an image of a busty young woman in a low-cut dress taken from (I believe) a perfume ad. One of the guys standing behind my table made a couple of locker room comments about her breasts while the image was on screen, and another couple of guys near him laughed. They probably didn’t notice the looks on the faces of the women at my table, but I did. As the one who had invited those three women to attend, I felt embarrassed, and ashamed, and more than a little bit angry.
And then the Pursudo guys started their presentation with, “The purpose of our software is get someone in this room laid,” or something very similar. I looked around at all the white male faces (at least 90% white, in a tech gathering, in Toronto—when’s the last time you saw that?): some were grinning, and the rest were carefully neutral, because let’s face it: nobody wants to be the prissy politically correct spoilsport who says, “You’re making people feel uncomfortable.”
Two of the students who came with me have since said that they won’t return. I don’t think it’s because the demos were a letdown; I think it was the boy’s club atmosphere. As I said a couple of weeks ago, I think that fixing this ought to be the goal of future Web 2.0 gatherings (and others). We’ll all be better for it.

Wednesday Morning Procrastination

I should be writing, so I’m reading instead:

  • ProgrammableWeb now lists 1001 web service mashups. 46% involve mapping, mostly with Google Maps, which means that when Google goes into Chapter 11 and the sheriffs shut its servers down, almost 500 online applications will suddenly stop working.  OK, it’s unlikely to happen tomorrow, but as I told my software architecture class yesterday, a good architect takes possible failure modes into account when designing a system. If VA had tanked in 2001, and SourceForge had gone offline, it would have set open source back a year; what’s the likely economic impact of GMail disappearing?
  • Two good rambles from Steve Yegge on Ruby, Java, and stuff (I’m just as glad that Groovy is dead, and that Rhino is shipping with Java 1.6), and good agile vs. bad agile (where “good” means “how we do it at Google” and “bad” means “other people’s unsubstantiated infomericalism” ;-) ).  Large grain of salt, but still worth reading.

On the home front, the server that the kind folks at the Jonah Group donated to us now has a home page, which has links to some of the CSC49X projects students are doing this term.  We’re using DrProject to manage everything, and so far it’s going pretty well.  The 1.1 release should be up on the web Real Soon Now.

Turnitin and Translucency

The ever-intriguing Jon Udell has just posted an explanation of how the use of a cryptographic database technique called translucency could address concerns about personal privacy.  I reviewed Wayner’s book on translucent databases for Doctor Dobb’s Journal back in 2003; as Udell says, the techniques are “…as yet poorly understood and rarely applied, [but] the principle of translucent data management can help us defuse the ticking time bombs that many Internet services are becoming.”

The Stradivarius of Coding

This piece, from the Code Project, is titled “Visual Studio 2020″, and purports to be about “…an even wilder Concept IDE”.  I actually found it very conservative: in particular, there doesn’t seem to be any provision for the code-under-development to tell the IDE what to do, or how to do it.  I think this is going to be a key feature—maybe the key feature—of extensible programming systems: developers will be able to say, “Show this when someone is debugging ClassFoo”, or “Display these extra items when the user is editing anything that has member variables of type Fribble”.  Most developers won’t ever write things that do this themselves, just as most never write their own Apache plugins, but the few who do will make life a lot better for the rest of us.