Tag Archives: tools

Conditional Comments Revisited: the “document mode” thicket

I’ve continued to lean on conditional comments to deliver browser-specific CSS to different versions of Internet Explorer. Recently, though, I’ve discovered a new wrinkle that complicates things: it’s not so much the browser mode as the document mode that determines how Internet Explorer renders things.

I ran into this problem when my manager was testing a page that uses conditional comments in the traditional way, something like this:

<!--[if IE 7]-->
<link rel="stylesheet" type="text/css" href="/css/ie7.css">
<![endif]-->
<!--[if IE 8]-->
<link rel="stylesheet" type="text/css" href="/css/ie8.css">
<![endif]-->
<!--[if IE 9]-->
<link rel="stylesheet" type="text/css" href="/css/ie9.css">
<![endif]-->

Pretty straightforward: depending on the browser version, a different CSS file is loaded that deals with the particular quirks of that browser.
But my manager was using Internet Explorer 9 in IE9 Compatibility View Mode, with the document mode set to IE9 Standards. And the page looked entirely wrong!

The problem, it turns out, is that the compatibility view mode caused the IE7 conditional comment to fire, but the document mode caused the page to be rendered according to IE9 rules: we loaded IE7 CSS to IE9 rendering.

The fix isn’t too horrible, though it does complicate things a bit, requiring some JavaScript to get the job done. Instead of loading the CSS based on browser mode, we load it based on document mode, so browsers that have a mismatch between the two will get something they can handle:

<!--[if gte IE 7]>
<script type="text/javascript">
var ieCss="";
try
{
    if(document.documentMode==8)
    {
        ieCss="ie8.css";
        
    } else if (document.documentMode==9)
    {
        ieCss="ie9.css";
    } else {
        ieCss="ie7.css";
    }
} catch(exception)
{
    ieCss="ie7.css";
}
document.writeln('<link rel="stylesheet" type="text/css" href="/css/' + ieCss + '">');
</script>

Minding your 0s and Os

Some font choices, good and badI was recently burned by a very simple failure of a programming tool I didn’t even know I was using.

We were debugging a SQL statement that was embedded in a Java class (we’ll set aside for now the wisdom of embedding SQL statements into your code; yes, it’s best to parameterize at the very least). The SQL statement looked something like this:

SELECT * FROM CUSTOMERS WHERE ACCOUNT STATUS='0'



When I ran the code in the Java class, it consistently returned zero rows. But when I ran the query in a SQL console, it returned significantly more records. We spent a lot of time looking at permissions, table structures, Java DAO models, but nothing was explaining the problem.

Until I pasted that code into the SQL console, that is; and then the console returned exactly the same results as the Java class. I pasted the code into a text editor, and pasted the working SQL statement right under it, and fiddled with the font size until it was obvious what the problem was:

SELECT * FROM CUSTOMERS WHERE ACCOUNT STATUS='0'


SELECT * FROM CUSTOMERS WHERE ACCOUNT STATUS='O'



Do you see it?

“0” and “O” were not obviously different in my IDE’s default font. Side by side, I could see the difference, but otherwise they were indistinguishable. At some point, this query–which had been sent back and forth through various e-mails–was mistyped into the code, and the expected “O” was replaced with “0”. The default font–the old standby Courier New, as it turns out–was a poor choice for a programmer’s font.

“0” and “O” aren’t the only characters that can make a programmer’s life difficult. “I”, “l”, and “1” have a habit of blending together, and the results can be annoyingly difficult to untangle. And “( )” and “{ }” characters can be devilishly difficult to distinguish in a JSP with a tangle of JSTL, jQuery, and scriptlets.

When I think of my development tools, I seldom think of my font selections. And while an IDE, text editor, browser plugins, and other software are obvious parts of the toolkit, font choices ought to be, too. In my experience, a good programming font should:

  • Distinguish between easily confused characters, like “0” and “O”
  • Make formatting code easy by exaggerating the differences between parentheses and curly braces
  • Belong to the “monospace” family, for easy layout on the screen
  • Be easy on the eyes, scaling well to different monitor resolutions

In my hunt for a good replacement font, I landed on Ubuntu Mono. It puts a dot inside the zero, adds curly flourishes to the lower-case “L” and “I”, has nice big serifs on the capital “I”, and gives a stroke and a bottom serif the “1”. Curly braces, parentheses, and square brackets are easily distinguished. And as an added bonus, its proportional space relative, Ubuntu, is a nice looking font for dialogues and titles inside the IDE. The result is something like this (assuming my @font-face code is working …):

for int l=0; l < O; l++)
{
     System.out.println("SELECT * FROM CUSTOMERS WHERE STATUS='O' AND ID='" + l + "'");
     if(l==1)
     {
        System.out.println("l==1 but does not equal i or I");
     }
}

It’s pretty easy to tell which character is which.

I also like Anonymous, which features a slash in the “0”:

for int l=0; l < O; l++)
{
     System.out.println("SELECT * FROM CUSTOMERS WHERE STATUS='O' AND ID='" + l + "'");
     if(l==1)
     {
        System.out.println("l==1 but does not equal i or I");
     }
}

And Anonymous Pro, which has an exaggerated stroke on the “1”:

for int l=0; l < O; l++)
{
     System.out.println("SELECT * FROM CUSTOMERS WHERE STATUS='O' AND ID='" + l + "'");
     if(l==1)
     {
        System.out.println("l==1 but does not equal i or I");
     }
}

All are clearly preferable to Courier New:

for int l=0; l < O; l++)
{
     System.out.println("SELECT * FROM CUSTOMERS WHERE STATUS='O' AND ID='" + l + "'");
     if(l==1)
     {
        System.out.println("l==1 but does not equal i or I");
     }
}

There are a good many other programming fonts that fit my criteria; a search for “programming fonts” turns up handy lists, like Top 10 Programming Fonts” at Hivelogic and a rundown of programming fonts by Jeff Atwood. Whichever font you choose, though, do choose, and choose wisely: you could end up saving yourself quite a bit of trouble and eye strain down the line.

chipping away at stylesheet lava with Dust-Me Selectors

I’ve been working on a web project that has gone through multiple iterations, and many hands, before landing on my desk. Over that time (and while it’s been in my care, as well as before), the stylesheets have acquired quite a few geological layers. The primary CSS file has had over 2,000 lines, with more than 600 selectors spread over almost a dozen stylesheets. Since the site has gone through multiple revisions and adjustments–at least five major versions in the month or so I’ve been working on it–a lot of these selectors aren’t being used anymore.

This is a classic case of the Lava Flow anti-pattern:

When code just kind of spews forth and becomes permanent, it becomes an architectural feature of the archeological variety. Things are built atop the structure without question and without hope of changing what is beneath them. The existing code is seen as an historical curiosity.

The best thing to do with lava is to blast it away, leaving just the useful bedrock. But removing unused CSS selectors is a tedious and error-prone undertaking; my Java IDE can tell me which methods and variables are no longer in use, and profile an application for redundancies and deprecated components, but I didn’t have a comparable development tool for styles. Luckily, my core development philosophy–somebody smarter than me has already solved this problem, and has probably put the information out on the Internet–panned out, and I discovered the Dust-Me Selectors Firefox add-on.

Dust-Me Selectors can look at an individual page, or at an entire site, and tell you which selectors are actually in use. It generates a nice report, broken down by stylesheet file and including line numbers, that will direct your blasting caps and jackhammers at the problem areas. After running it through my pages, I was able to reduce that main CSS file to just over 1,000 lines (it’s a complex site), with less than 200 selectors defined.

The tool can be run against individual pages or against a sitemap; for a large site, a sitemap is by far the best approach. If you don’t have a sitemap.xml file yet, it’s relatively easy to generate one, either with your development tools or CMS, by hand for a short list of pages, or with a simple script. I found that it was less reliable in single-page mode: your coverage won’t be as good, and things like Ajax windows are going to get in the way of accurate results. A comprehensive sitemap ensures coverage.

It’s also a good idea to use caution when pruning the styles; I went through the list of flagged selectors and disabled them with comments, visually testing the site as I went along. There were a handful of cases where Dust-Me flagged styles that were actually in use, primarily within jQuery code that was manipulating element classes on the fly. After I verified that my leaner, meaner CSS files were working, I moved all of the commented code out into a new file just in case some of those selectors need to be resurrected in the future.

There are a few reasons to tidy up your CSS files. Download performance, though not as much of an issue in the broadband world, is a factor: my old core file was about 41KB, and my new one is 17KB. Browser performance, too, is a factor: parsing unneeded CSS code may be a very tiny drag on performance for faster machines and browsers, but every millisecond you save on unnecessary parsing is time you can put the browser to work doing something more interesting and useful.

The best argument for cleaning up the lava flow, though, is maintainability. Scrolling through those 2,000 lines of code in search of an errant style, or trying to debug a rendering issue when looking across a dozen files for a class or ID, is a drag on productivity. In the heat of battle, it’s far too easy just to add another selector to the bottom of the file, which only contributes to the chaos. Pruning the excess weight early in the development process makes it much easier to maintain clean code as the project moves along.

Netbook OS Roundup: Fedora LXDE

Fedora is one of the scions of the Linux world; the first Red Hat release came out in 1994, so there’s a lot of expertise behind the current Fedora builds. There are multiple “spins” of Fedora available, one of which–LXDE–is specifically targeted to low-power, lightweight systems like the Dell Mini netbook.

When I went looking for a Fedora distribution to try out, though, I started with the base Fedora 12 release. This was very much the wrong distribution for a netbook: it comes packed with software and services (everything from OpenOffice to font sets for Tajik script); within a day it had consumed all available space on my drive and no amount of pruning could get it down to size. While a fine approach for a powerful desktop machine, the everything-plus-the-kitchen-sink strategy of OS distribution was a recipe for frustration on a low profile machine.

LXDE takes the opposite approach:

XDE is not designed to be powerful and bloated, but to be usable and slim. A main goal of LXDE is to keep computer resource usage low. It is especially designed for computers with low hardware specifications like netbooks, mobile devices (e.g. MIDs) or older computers.

And with a few caveats, it is a successul netbook platform.

Ease of installation

LXDE can be installed from a USB stick, downloaded and built with Fedora’s LiveUSB tool. The wizard installation process is easy to use, and installation is fast (especially compared to the full Fedora installation time….).

Not everything works “out of the box,” though. The Dell Mini uses a Broadcom wireless card, and no free driver is distributed for it. Immediately after installing LXDE, I had to attach my netbook to a wired connection and install the wireless driver (good instructions here). This took a little more time in the console than the casual user would likely want to take; I can understand the reluctance to include proprietary software in an open source distribution, but this is an area where the hardware manufacturers, system builders, and software developers need to find some common ground before an OS like LXDE can gain winder acceptance.

Application support

Because LXDE is so stripped down, there’s room even on the Dell Mini to install some more applications. It comes with Midori, a lightweight and minimalist web browser, and AbiWord, a basic word processor, but not much else. My requirements on the netbook are simple, and AbiWord proved sufficient; Firefox 3.5 installs easily, as does Dropbox, so I was able to restore my bookmarks and plugins.

Stability

Under normal use, LXDE is a stable platform; I haven’t had any unexpected crashes. Power management, though, is a drawback, and that’s a signiicant issue for netbooks, which are typically saddled with a less-than-optimal battery. The idle hibernation options (accessible through the screen saver settings) have never worked for me: I have to manually hibernate a session, or risk returning to a dead netbook if it’s unplugged. And without a native battery monitor, it’s hard to tell when the power will go out. Mint and Ubuntu were much more reliable in this regard.

Performance

LXDE is quick to start and connect; it’s not an instant-on OS, but it’s certainly faster than Windows. Under normal use, it is responsive and smooth within the constraints of the netbook’s limited hardware.

Appearance

Like Mint, LXDE uses the desktop metaphor: an easy transition for Windows and Mac users, but a bit of a real estate waste for the netbook: I still prefer the Moblin UI for small computers, with its compact and space-sensitive layout. LXDE does offer multiple desktops, though, and a useful task bar and application menu, so users who are happy with the Windows interface will find much to like in LXDE.

Overall Assessment

LXDE is a solid OS for netbooks; it’s stable and easy to use, though its lack of native support for the Mini’s wireless card and its poor power management and monitoring make it less than ideal. Though not a groundbreaking approach to mobile computing, it is an easy bridge from Windows to Linux: if you’re looking for a good operating system and want to avoid the Microsoft tax, LXDE is a good fit for small computers.

Netbook OS Roundup: Linux Mint

Linux Mint is another Linux distribution based on the Ubuntu and Debian projects. Unlike Jolicloud, Moblin, and the Ubuntu Netbook Remix distributions, it’s not specifically targeted at the netbook niche; rather, it’s an all-purpose, full-featured consumer operating system, comparable in many ways to the last fifteen years of Windows distributions.

Ease of Installation

Linux Mint has been by far the easiest installation so far, with full support for all of my netbook’s hardware (including that Broadcom wifi card) as soon as I booted up the first time. The wizard-like installation is essentially the same as the one that comes with Ubuntu and Moblin, and includes a partitioning utility (as with all previous installations, I simply allowed the operating system to set up its default partition structure and erase the existing structure; all hail Dropbox and the solid-state memory of netbooks!).

Application Support

Like Ubuntu Netbook Remix, Linux Mint comes with a package manager that lets you easily find and install applications. I found that I didn’t have to use it much, though, because the distribution came with a full suite of administrative tools, a few games, Firefox 3.0, Gimp, OpenOffice, and . Indeed, the distribution was a tad heavy for a netbook; a minimalist approach seems better suited to the limited resources of the smaller platform. There are no options during installation to include or exclude packages, so removing unneeded applications would have to be a post-installation chore.

One of the drawbacks of the package manager system in any of these releases is that the user is limited to the application versions that have been vetted for your OS distribution; newer versions of applications are not typically included, and though they can be installed and run with some success they require more work at the command line than going the package manager route. Firefox 3.6 went gold while I was playing with Mint, and though I was able to easily upgrade on my Windows computers I found the process of upgrading on Mint just a bit daunting to proceed for short-term usage. Making application upgrades faster and easier, especially for applications like browsers that are frequently patched, would go a long way toward making Linux a more viable option for casual users.

Stability

I was very pleased with the stability of Linux Mint; I experienced very few freeze-ups or unexpected shutdowns, and network connectivity stayed alive when in use. Like most of the other platforms I’ve tried on the netbook, recovering from hibernation proved to be a challenge for the wifi, but Linux Mint was much more likely to recover than Moblin or Jolicloud.

Performance

Mint starts up quickly, and establishes wifi soon after booting. Network applications experienced occasional sluggishness, usually under expected conditions: multiple Firefox tabs, pages heavy in Ajax and dynamic presentation, etc. Overall, Mint has been a strong operating system in the areas that matter most.

Appearance

The Linux Mint UI resembles the Windows UI established back in 1995, with a “start” menu, task bar, and desktop on which the user can place frequently-used applications, folders, and files. Overall, the appearance is polished and professional; the green cast to everything can be a bit overwhelming, even around St. Patrick’s Day, but switching colors and backgrounds is as easy as it is on Windows.

The desktop setup is not especially well-geared to the netbook platform, though; the “start” button is a bit small, the desktop seems a bit wasteful of space, and the task bar becomes difficult to read when multiple applications are running. After working with the Moblin and Jolicloud interfaces, which are specifically targeted to the netbook footprint, I felt like I was using a far-too-small screen for a full-sized interface.

Overall Assessment

If I were looking for a Linux distribution to run on a desktop system, Linux Mint would be one of my first choices. Its interface is well-suited to larger displays, and the full suite of applications greatly simplifies the installation process. Mint appears to be a solid operating system for most home and small-office applications, and can certainly hold its own against commercial platforms.

On the netbook, though, it just didn’t feel like as good a fit as Moblin. If there weren’t other interfaces available that are geared to the netbook, though, Mint would be the best distribution I’ve tried out so far.

Netbook OS Roundup: Moblin 2.1

Moblin is a Linux distribution (versions are available based on both Ubuntu and Fedora kernels) targeted at mobile devices. It boasts a stripped-down UI, and a stable core of basic hardware support; its profile is very similar to Jolicloud, with a smilar (though understated) focus on social media integration.

I originally installed the Dell Moblin 2.0 Remix; it was an easy installation, with all of my netbook’s hardware supported out of the box, but the system was severely limited in functionality. It didn’t offer a package manager for easy software updates and downloads, and the browser–a stripped-down Mozilla version–was crippled by its lack of plugin support. (If I can’t install Adblock, Feedly, and Diigo, I have serious reservations about using the browser.)

Luckily, Moblin 2.1 is available, and includes the Moblin Garage for finding and installing applications, including a fully-functional Firefox 3.5. Unfortunately, Moblin 2.1 doesn’t have out-of-the-box support for the Broadcom wireless card that ships with Dell netbooks; Glen Gray offers a Broadcom driver and great instructions, though, so with a wired connection and a little time on the terminal I was up and running.

Ease of Installation

Like Ubuntu and Jolicloud, Moblin is distributed via a disk image that can be booted from a USB stick. And also like Ubuntu and Jolicloud, the wizard-based installation process is very easy to walk through, with advanced options for partitioning your disk and such. (Since I’m only running one OS at a time, I had the installer wipe out my old partitions and set up its default main partition and swap.) The 2.1 installation conked out on me a couple times, but on the third try installed cleanly. Aside from the wireless setup, the netbook was up and running in less than 30 minutes.

Application Support

The Moblin Garage is between Ubuntu’s Synaptic and Jolicloud’s application repository in terms of ease-of-use and thoroughness. It offers categorized listings of popular Linux applications (Firefox, Thunderbird, Gimp) that can be installed very easily. The list is a little smaller than Jolicloud’s (though these are, for the most part, real applications, rather than Prism versions of web sites), and doesn’t include some of the bigger packages (like OpenOffice) that Synaptic lists. The focus seems to be on the applications that are most easily installed and used on the netbook’s smaller profile.

Garage didn’t include Dropbox, but I was able to install it (the Fedora version worked best) through the package manager with no fuss: not as easy, perhaps, as plucking it from the Garage, but not too difficult.

Stability

For the most part, Moblin stays up under normal usage. The wifi periodically conks out when the netbook wakes up from hibernation, and doesn’t maintain WPA credentials consistently between sessions, but overall stability is good.

Performance

Moblin is a fast-booting system, though the wifi can be slow to initiate. I’ve found that Firefox is plagued by frequent sluggishness, though, particularly in network operations (Ajax calls seem especially sluggish: Feedly and LibraryThing were noticeably less responsive under Moblin than under Ubuntu and Jolicloud). I suspect that the root cause of both the performance and the stability issues is the Broadcom card and driver; with a card that has a native driver, or with a later revision of the add-on driver, things may improve in this area.

Appearance

The Moblin interface is quite impressive, and geared to the small netbook screen. A tool bar appears at the top of the screen when you move the mouse up, consisting of a dozen (somewhat cryptic) monochromatic icons representing different tasks: a “status” icon for updating Last.fm and Twitter, an Internet icon for accessing the built-in browser (the same hobbled one that was part of 2.0), an enhanced clipboard (very handy for storing links and quotes for a blog post), and your collection of installed applications. The aesthetic is not unlike Sugar, the OLPC platform developed for children.

Switching between applications is accomplished with alt+TAB, a familiar enough maneuver. Unfortunately, the “zone” architecture sometimes results in “lost” application windows. For example, when Firefox restarts after installing a plugin, it isn’t automatically brought to the front; you need to alt+TAB into it to discover if it’s back up.

The tool bar is locked down; at least, I never found a way to add or remove icons. And the Internet “zone” appears to be locked on the Moblin browser; to use my Firefox install, I had to go to the Applications zone and search for the icon. It would be nice to have a little more control over this configuration; it’s a useful and powerful tool bar, but made less than ideal with its static setup.

Overall Assessment

The user interface is Moblin’s strong selling point for me; I like the tool bar despite its limitations, and I like that the UI generally gets out of the way when I need it to. It’s a simple, uncluttered layout that lets me get right to work, and which fits beautifully inside the confines of the netbook.

I do wish, though, that the wifi support were a little more stable, and that the tool bar were more configurable. If, when I get to the end of my OS travels, there’s a Moblin 2.2 (or 3.0!) on the horizon, I’d be perfectly happy to make it my permanent netbook operating system.

every day, in every way, getting better and better

Pardon our improvements? by John MortonI’ve worked on a variety of projects in my IT career, from small Lotus Notes applications where I’ve been the business analyst, developer, tester, system administrator, and support engineer, to multi-year enterprise initiatives with far-flung teams and huge project management systems where my role has been very narrowly defined. I’ll admit to a preference for the former–I like to write code, and waiting weeks or months for the first solid requirements to trickle in is painfully dull. But all of the projects, like most IT projects, have been plagued by the usual disconnects, missed opportunities, and frustrations with delivering what the users really want on time and on budget.

My current project, though, has been surprisingly successul. We released our first version in November, after two months of development and testing on top of about six months of thorough analysis (most of which happened before I joined the project), and since then we’ve released new and improved versions on a monthly schedule. The customer has been pleased, the application has been solid, and we continue to meet the users’ expectations.

What’s the secret?

To a great extent, it’s due to a very talented team of developers, testers, project managers, analysts, and business users. We work together well, have open and honest communication, and set up realistic and reachable goals for each release. The problem with talent, though, is that it’s not necessarily reproducible; you can’t bank on having good people in every role, or even on having good people at the top of their game most days. A project that relies on talent alone is bound to fail eventually.

What has really worked for this project is a philosophy of continual improvement. Our driving principal has been, to borrow a line from Jeff Atwood, version 1 sucks; ship it anyway.

My current workplace doesn’t have a formal “methodology” for development, no waterfall gate-checks or SCRUM masters, at least that I’ve encountered. There are rudimentary project controls and such to meet corporate governance requirements, but development teams are left largely to organize their own efforts. As a result, we’ve landed on some practices that borrow heavily from various flavors of “agile” development without professing the full “agile” theology; the guidelines that I’ve found work best on this project, and that may be reproducible on other projects, are pragmatic and contingent, flexibly implemented within a loose framework. This may not work everyplace, on every project, and it doubtless has some scalability issues, but for a mid-sized project with an aggressive schedule, these are some practices that have worked for us:

Manage the requirements to the schedule: hit the dates by containing the enhancements

We have a huge list of things we’d like the application to do, ranging from simple tweaks to pipe-dream fantasies. They’re all good requirements, all worth meeting because they represent what the users really want. But they’re not all going to go into the first, second, or third release.

Instead, we’ve promised a monthly release with at least one major system enhancement, and as many smaller enhancements as can be realistically squeezed into the time frame. Like the big rocks fable suggests, we focus on the one big thing first, and then categorize the other requirements as hard, challenging, or low-hanging fruit. Once the big requirement for the next release is ready, we knock off the smaller requirements as time permits, always mindful that no small enhancement should jeopardize the big one. It sucks to leave low fruit on the branch, but we keep our spirits up in the knowledge that we’ll have a long harvest season if we keep the customer happy.

A little spice and sizzle helps, though

The “one big rock” is usually a meat-and-potatoes affair, and it’s always filling and nutritious. But we’re also sure to include a little spice among the smaller enhancements. Refreshing the style sheet, adding a more attractive screen layout, or providing an extra screen of administrative information on the application’s performance is often cheap, easy, and low risk, but it’s very useul for maintaining customer satisfaction. The users may not notice that you’ve shaved an average two seconds off the web service response time and implemented a really nifty sorting algorithm–indeed, you’d better hope they don’t notice those things, because their only evidence should be when they fail–but they’ll ooh and ahh over a nicer interface.

Track every requirement, no matter how small

Indeed, make your requirement-tracking as granular as possible. Break the big requirements up into bite-sized chunks, and build good estimates for them (this is where something like the Pomodoro Technique can really shine). You don’t know which rocks are big and which are small unless you track them, and you don’t know if you need to scale back your release features unless you do estimates.

Open up the black box and let everyone see the work list

Having a good requirements and bug-tracking system is critical to managing in a progressive-enhancement environment. We’re using FogBugz, but other tools–Roundup and Bugzilla come to mind–are also useful. Even a shared spreadsheet is better than nothing. The key requirement is that everything is on the table and visible to the entire project team; having the project progress available at a glance, and maintained in real time, is the only way to keep everyone honest and ensure that releases happen on schedule.

Build plenty of testing time into the schedule

I’ve known thin-skinned developers who don’t like testers. Personally, I’d rather have someone on my team find my bugs before a customer does: it’s easier and cheaper to fix problems before your release date, and a good, thorough tester can be the difference between a product that people love and one that makes their jobs harder. In our current project schedule, we have a code cut-off date a week before the release date, after about three weeks of development; this should be adjusted for larger and more complicated projects, with even more time dedicated to serious testing.

Release early and often

That “three weeks of development” in our project is really three weeks of development and testing. As soon as you have something to show, even if you know it’s not ready for release, get it out there for your testing team to break. If you’ve got users who can spend time looking at things that are in development, so much the better: unvarnished responses to early iterations can flesh out requirements and ensure that you’re meeting the customer’s needs. There’s nothing worse than releasing something that’s been carefully developed, thoroughly tested, and still misses the customer’s core requirements. During the last two weeks of development on my current project, I’m deploying something to the shared development environment nearly every day (and if I had an automated build and deploy system, I’d be checking in updates even more often).

Build a solid architecure in the beginning, and build out modularly

My current project lends itself well to continual improvement, because it was architected from the beginning to be modular. It’s a service-oriented architecture that uses the Apache Commons Configuration framework to abstract the business logic into XML documents. It’s developed to Java interfaces and abstract classes as much as possible, with an eye toward identifiying and reusing patterns; if something can be accomplished through XML rather than code, that’s the direction we go.

SOA is a good fit for continual enhancements because the application layers can be clearly separated from each other; you’re less likely to break something if you don’t have to touch it. But the same principals apply to any development platform: make code small, abstract, and reusable, and avoid great big tangles of spaghetti. If you can’t see the whole method on your screen without scrolling, don’t adjust your monitor resolution: break the code up and look for the patterns.

The next release will be better

Whether the customer is pleased as punch, or grinding their teeth in angst, that’s the appropriate response: the next release will be better. The requirements we missed in this release are first on the docket for the next; the new requirements that have emerged from the testing rounds have been captured and scheduled for future deployments; there’s nowhere to go but up.

Provided that you set a pattern of actually delivering on this promise, the customer will be willing to accept that they won’t have the perfect system out of the gate. And if the customer is involved at every stage, and has a hand in the requirements triage and testing, they’ll be happy to play along with incremental enhancements. Something is almost always better than nothing, and unless they’ve got the self-control of toddlers they’ll be willing to defer some of their gratification, especially if they get a little taste of real improvement at each release.

I can imagine projects where these guidelines would fail to deliver: big enterprise initiatives with lots of interrelated parts are hard to release quickly in small pieces. At the same time, though, this may be as much a matter of perspective as of scale: if the project is too big for continual enhancement, maybe it’s really two or three or ten projects that need to be broken up and managed independently, with a longer test and integration period set aside to mesh the components. If it’s possible to deliver a little bit more often, rather than a lot after a really long time, my bias is toward the former: it keeps everyone working, ensures that real requirements are identified early, and shines some light into IT’s darkest boxes.

Netbook OS Roundup: Jolicloud

Jolly Cloud by Todd BarnardLast weekend, I installed Jolicloud, a Linux distribution (built on Ubuntu) that extols the virtues of a minimalist, cloud-based operating system. In a week of using it, I’ve found it to be very similar to Ubuntu in usability and performance, and not a bad fit for how I use the netbook.

Jolicloud markets itself as a dual-boot OS, intended to be installed side by side with an existing Windows installation. They are targeting netbook users with Windows XP or Windows 7, who are looking for a lighter alternative but aren’t quite ready to abandon the Windows platform. It’s also available as a stand-alone OS, though, installed into the primary partition of the netbook, which is the option I chose.

Ease of installation

The download and installation was pretty familiar. The Jolicloud ISO is made available over BitTorrent, which was a bit of a hassle for me: I had to download and install a BitTorrent client, and the ISO download was a little slow. I can understand the decision to use the BitTorrent model–it offloads the downloading costs from the Jolicloud infrastructure–but it did pose an additional hurdle for the casual downloader. After downloading the ISO, I had to download and run the Jolicloud USB creator to make a bootable USB drive.

The actual installation was identical to Ubuntu’s: basic configuration (user name, password, location, language, keyboard, etc.), snappy bootup, and then application installation. Jolicloud recognized my hardware, found my network, and within less than 30 minutes of running the install I had a fully-functional netbook.

Application Support

The Jolicloud application directory is a pleasing graphical environment, with applications organized into categories and represented by an icon and description. The expected tools are here: Dropbox, Wine, OpenOffice, and Gimp are all listed, and installation is quite simple.

Most of the applications in the directory, though, aren’t really stand-alone applications: they’re Mozilla Prism renderings of popular web sites, like Facebook, Twitter, and HootSuite. I installed a few to try them out, but found that they were more disruptive than useful in this format. On the netbook, my primary tool is Firefox, and I find it much easier to manage a collection of Firefox tabs than a collection of application windows. With bookmarks and plug-ins in Firefox, I can treat sites like parts of an interconnected application, which is a very different model than the iPhone-like site-as-application model. This may work for people who are used to the single-threaded iPhone environment, but I found it far less than useful.

Another innovation in the Jolicloud OS is a social network of its very own. When you set up your local account, you also have the option to establish a Jolicloud social account. Within the Jolicloud dashboard, you can find and “follow” other Jolicloud users, even seeing which applications they’ve installed. To be honest, this isn’t a selling point for me; Twitter, Facebook, and LinkedIn seem more than sufficient for my “social” computing needs, and I’m not sure that anyone should know or care that I’ve just applied the latest patches to Gimp. I can imagine that there are people who would find this to be a selling point, though (probably the same people who would like the Facebook and Twitter “apps” from the Jolicloud directory).

Stability

Jolicloud is comparable to Ubuntu Netbook Remix in the stability department. When in use, it tends to stay up and connected; when waking from hibernation, though, it frequently becomes groggy and needs a hard reboot to recover. My WiFi connection goes through phases–it is usually established soon after rebooting, but occasionally becomes unstable. Recovering the connection is usually automatic, though has required manual intervention and even a reboot in some cases.

Performance

Again, nothing special here; overall good performance, with occasional bouts of sluggishness when in heavy use. The OS boots quickly, usually in under 30 seconds, and Firefox starts up snappily. Some of the Prism applications can be sluggish, but after their novelty wore off (after about half an hour) I never went back to them.

Appearance

Ubuntu users will be right at home: the Jolicloud desktop is basically the Ubuntu desktop, with a few system icons reworked. Application categories are listed on the left, system resources (networks, disks) are listed on the right, and application icons are presented in the middle. There are tools built in for tweaking the desktop, and I suppose one could install a different desktop manager if one felt compelled, but it’s a functional and attractive look out of the box.

Overall Assessment

Jolicloud is a solid netbook operating system. It installs with relative ease, and does the basics that a netbook needs to do.

The “social” aspects don’t appeal to me, though; I don’t need to be “connected” whenever I use my netbook, and don’t need another social profile to maintain. And the Prism applications are largely superfluous; they don’t add anything to the experience that isn’t available in a more seamless, integrated way through a regular browser.

If I had to choose between Ubuntu and Jolicloud, I would probably stick with Ubuntu. If I wanted a Linux OS to run alongisde Windows, I would probably still stick with Ubuntu for its more advanced package manager. But Jolicloud is a good netbook choice, and a little slimmer than Ubuntu.

Fortunately, I don’t have to choose between Ubuntu and Jolicloud; the beauty of the netbook is that my choices are dizzyingly complex. And so now it’s time to wipe the flash drive clean and try something new.

Netbook OS Roundup: a series

linux linux everywhereThe operating system world is a crowded space–Windows, Mac, various flavors of Linux, FreeBSD, Haiku, Android, Chrome, and any number of odd and specialized projects. For the most part, though, actual usage on PCs is limited to Windows, with a smaller share of Macs and tiny numbers for Linux. This isn’t terribly surprising, given the prevalence of Microsoft operating systems in OEM builds and the difficulties involved in switching operating systems, especially on a computer that’s responsible for running your household. When I was faced with the problem of upgrading my 8-year-old computer, I opted to stick with the Windows rut that I’ve been in for almost 20 years, since purchasing an IBM PS/2 with Windows 3.0: the thought of switching from Quicken, Photoshop, and Vegas, even if the open source alternatives are just as good, was simply too daunting.

With my netbook, though, I don’t feel the OS lock-in. I very quickly moved off the Dell Linux build that shipped with the netbook to an Ubuntu netbook remix, and have dabbled a bit in other distributions. Swapping out the OS on a computer that is used most of the time as a browser or e-book reader, and occasionally for light word processing, is far less daunting a prospect. And there are so many operating systems available for netbooks, most of which can be tested for free, that there’s no excuse for a technically-savvy netbook user to try out a few systems.

My criteria in reviewing the operating systems I’ll be trying out are geared toward my own netbook usage; these may not be your criteria. But perhaps these reviews will be of some use. My interest are:

Ease of Installation

I’m technically savvy, and comfortable in a UNIX shell, but I don’t want to tax my brain too much to get a netbook OS installed. Netbooks are lightweight, and so ought their installation procedures be: I’m OK with downloading the ISO, copying it to a USB drive, and booting it up, but if the installation is even easier than that I’ll be especially pleased.

I’m also looking for an OS to recognize my hardware and network with minimal fiddling. Again, I’ll edit config files and download drivers if need be, but an OS that works out-of-the-box (or off-the-thumb-drive) on my Dell Mini is my preferred platform.

Application Support

On the netbook, a browser is the key tool. For me, a current Firefox version is preferred, since I’m using Firefox on my home and work computers are synchronize bookmarks across all three. If not Firefox, then Chrome is OK.

I’d also like to be able to use Dropbox (as an application rather than through the web interface), and a simple word processor. Reading e-books from Project Gutenberg is a nice feature, too. Beyond that, my application requirements on the netbook are pretty light.

Stability

The netbook should stay on and connected with minimal fuss. Frequent rebooting, dropped network connections, and sudden bouts of sluggishness are not appreciated. To some extent, stability is a function of things beyond the OS: the actual hardware, and my Internet connection (home wireless network, sharing a USI Wireless connection); but a good OS rolls with the punches.

Performance

I don’t expect blazing speed on the netbook: it’s small, with limited RAM and processor resources. But I expect fast startups (due to its small footprint), quick network connections, and reasonable responsiveness.

Appearance

Looks aren’t everything, but they’re something. I can accept utilitarian functionality for some things, but I appreciate a desktop that is at least pleasing. Eye candy ought not to come at the expense of performance and stability, but the user interface shouldn’t be a mere afterthought.

The things I’m looking for in a netbook OS may not be what most netbook users want; my comfort with the technical details will likely sway my judgment away from ease-of-use toward stability and performance. But if your netbook profile matches mine, you may find this series helpful.

I’ll be looking at Jolicloud, Puppy Linux, and Haiku in the next few installments. Fedora, Mint, and Ubuntu are likely to be covered as well. If you have a favorite OS that you’d like to recommend, let me know in the comments and I’ll gladly give it a spin.

A box in the clouds

Cardboard Box PC (Top) by TimRogersI’m embarking on a little experiment with netbook operating systems; there’s a lot of interesting activity in the lightweight OS world–Ubuntu, Jolicloud, Chrome, Android, etc.–and I’m curious how the different systems stack up. Each weekend from last weekend until I run out of operating systems, patience, or time (or land on the ideal OS paradise and never want to leave), I’ll be installing a new platform on my Dell Mini and rating it on usability, stability, features, and other criteria specific to the netbook space.

One of the things that has kept me from making big OS changes on my netbook in the past is that getting Firefox reconfigured is such a hassle. While I’ve been using the Xmarks plugin for bookmark and password synchronization between home, work, and my netbook since the plugin was called Foxmarks, getting all of the other plugins installed and configured after wiping out the netbook has been a tedious chore. About 90% of what I use the netbook for is browser-based, so this is a relatively big deal for a little computer.

The solution that I’ve landed on is actually pretty simple, and uses two nice utilities in concert.

First, there’s FEBE, the “Firefox Environment Backup Extension,” a nice Firefox plugin. FEBE will create backups of whatever Firefox components you choose–plugins, themes, bookmarks, cookies, etc.–and restore them. You can set it up to do scheduled backups, restore settings into a new profile, and manage selective backup configurations.

And then there’s Dropbox, an online file storage and synchronization service. I’ve been using it to easily synchronize writing projects between my Windows PC and netbook, and it works like a charm: silently synchronizes the files that I place into its directories, and seamlessly integrates with the file systems on both my Windows and Linux computers.

Before I uninstalled Ubuntu on my netbook, I ran a full backup of Firefox from FEBE to a directory under Dropbox’s control. Then when I installed Jolicloud, I added the FEBE plugin and installed Dropbox. In just a few clicks, I had all of my other plugins plus bookmarks, passwords, and other browser settings back in place.

I admit, it was a little disconcerting to be suddenly confronted with more than a dozen Firefox tabs for each installed plugin after the FEBE restore ran. But it was a lot easier to close tabs than it would have been to reinstall all of those plugins.

The same concept could, of course, be used with other combinations of tools. FEBE natively supports Box.net, for example, and there are some other tools for doing Firefox backups (I’ve used MozBackup before, which handles the whole Mozilla suite, but it’s a Windows-only utility and therefore not terribly helpful on my netbook).

When I move on from Jolicloud in a few days, I’ll be going through the same steps again, perhaps with a few refinements. Simple is good.