kontrawize

Moving from openSUSE Linux to Ubuntu

I've been using openSUSE Linux for many years now, and never saw any compelling reason to switch to Ubuntu.  There still isn't a compelling reason for the most part, but I will shortly get my new Nokia N900 phone, which runs Maemo, a derivative of Debian Linux.  The Maemo SDK requires a Debian Linux to run it, and I want to run it, so I decided that was a good enough reason to move to Ubuntu.

I've had a couple of goes at moving to Ubuntu 9.10 "Karmic Koala".  Along the way I also tried Debian Linux 5.0.3.  I rejected vanilla Debian because the package management seemed weak.  Linux distributions with the GNOME desktop typically come with the "Evolution" e-mail client.  Since I use Opera for e-mail, I don't want Evolution wasted disk space.  Under openSUSE, it is easy to uninstall the Evolution client (although you have to leave the "Evolution data server", as some packages have dependencies on it).  With Debian, I couldn't remove the client or anything related to Evolution, which suggested bad package management to me.

Moving from openSUSE (using GNOME, not KDE) to Ubuntu was straightforward.  You basically just need to copy your files across from your home directory, plus your files from anywhere you have installed your own applications (e.g. "/opt").  When copying your files

• you can use NFS, or tar to move your files (it's faster to just tar without compressing, if you have the disk space to do so;
• don't use Samba or ZIP files, as they lose important permission information.

After copying your files across, make sure your home directory has "rwxr-xr-x" (755) permissions.  Also, in your home directory you should run the following to delete configuration files that can cause you problems (and which don't appear to lose anything important for your desktop):

rm -rf .config .gnome*

That's all there was to it.  I haven't fully set up all of my applications yet (i.e. need to add some icons to the menu, etc.), but otherwise it's all looking good.  While I've described moving from openSUSE to Ubuntu, I expect it should be similarly straightforward to move from Ubuntu to openSUSE.

Converting a MagicDraw UML Model into Enterprise Architect format

I like UML for modelling, in spite of it being too focussed on object-oriented design.  However, interoperability between UML file formats is woeful, even though there is a common XML format for UML, called XMI.  Unfortunately, each UML tool vendor has found a different, incompatible way of using XMI, it seems.  It really holds back UML tools; we live in a world where people now expect interoperability.  The interoperability between UML tools is vastly less than, for example, the interoperability between OpenOffice and MS Office.

However, the "300lb Gorilla" for many vendors is Eclipse, which has its own built-in UML editor.  While the Eclipse implementation doesn't have the same degree of development and features as the commercial tools (although making great strides), the commercial vendors can't ignore it because so many organisations use Eclipse now as their primary Java IDE.  This means that many UML tools can import and export Eclipse ".uml" and/or ".uml2" files, so the Eclipse format was recently recommended to me as a better way (than XMI hacking) for moving model between different UML tools.

This morning, I tried this, using the ISO 20022:2009 draft profile as the example.  This contains both the ISO 20022 profile (stereotypes) and the ISO 20022 type library.  From MagicDraw, I opened "unifi-profile.mdxml" and then selected "File | Export To | EMF UML2 (v2.x) XMI File".

 

I saved to an empty directory, where it created 13 ".uml" files, including "unifi-profile.uml".  That's one thing about the Eclipse format, you end up with lots of files, not a single "project" or "model" file like other UML tools.

I then started Enterprise Architect (EA) and created a new, empty model.  In the project browser, I right-clicked on the top level "Model" node and selected "Import Model from XMI...".  This opens the "Import Package from XMI" dialog, which contains a button "Import EMX / UML2 Files".  Pressing that button gets you to an alternative dialog which allows you to import your Eclipse model.

However, when I went to import "unifi-profile.uml", I couldn't because EA expected UML2 files to have a ".uml2" extension, while MagicDraw saves them with a ".uml" extension.  Luckily, the solution was as easy as renaming "unifi-profile.uml" to be "unifi-profile.uml2" (note: without renaming any of the other ".uml" files).

Did it work?  Well, partially.  It did import the type library, which is good.  A couple of bogus double-entries were created, but these were easy to find as they didn't have stereotypes like the actual type library members.  EA didn't import the actual profile (stereotypes), which wasn't a big a surprise to me.  EA doesn't yet support the full range of UML 2.x metaclasses (these represent UML constructs - classes, attributes, associations, etc.), while MagicDraw does.  That's a pity, it means I will have to construct the profile by hand, as step towards providing EA support in the Londata UML Message Generator.

Generating XML With Scala

As I mentioned in "Generating XML Schemas from ISO 20022 UML models", I am using Scala to write an implementation of the ISO 20022 method for generating XML Schemas from a UML model.  The code is in two parts; the first part processes a MagicDraw UML model via the MagicDraw Open API (a Java API) and produces a simple XML representation of the ISO 20022 message information that is contained in the UML model.  That simple XML representation can then be processed to produce resources such as the XML Schemas; in a later iteration, I also plan to support generation of ASN.1 specifications for the same messages.  ASN.1 is the way that ISO 20022 messages will be able to be binary encoded rather than XML encoded, for situations where volumes require something more compact than textual XML. At the moment, I have just finished writing the code for generating the XML Schemas from the simple XML representation (having previously written the code to generate the simple XML representation from a MagicDraw UML model).

Back to Scala and XML, a major reason for using Scala rather than Java for this code is that Scala has better built-in support for XML. In spite of some really top XML people having worked at Sun in the last decade, the XML facilities in Java have never been more than an awkward tacked-on piece that continues to make Java developers resistant to using XML.  Scala goes a long way to addressing that problem, and making XML straightforward to work with.

For example, in Scala I can write

val x = <document><h1>Example of inline XML in Scala code</h1></document>

which creates a value "x" of type "scala.xml.Node". Note that I didn't have to put the XML in quotes to convert it into a string.  Scala knows what XML is, so you can use XML directly.

If you need to insert values into the XML, you can do it like this:

val famousText = "To be or not to be"
val speaker = "Hamlet"
val famousPhrase = <phrase speaker={speaker}>{famousText}</phrase>

and the value of "famousPhrase" is

<phrase speaker="Hamlet">To be or not to be</phrase>

Braces are used to indicate where something in the XML should be intepreted as code.  For attributes, if the attribute value is contained in braces, the enclosing quotes are omitted.  Some of you may think that this looks not unlike ASP or JSP, and in some ways it does, but it is neatly integrated into Scala.  These expressions can appear in any Scala code, they aren't forced into separate files as you typically have with ASP and JSP.  Also, the resultant expressions are understood by the code to be XML, not just text with angle brackets.  I can extract values from the XML using a path notation:

val extractedSpeakerAttr = famousPhrase \ "@speaker"
val extractedSpeaker = extractedSpeakerAttr.text

The result of this is that "extractedSpeakerAttr" is an XML node sequence with one node, an attribute; "extractedSpeaker" is a string with the value "Hamlet".

This is why I like Scala for working with XML. It's a full general purpose programming language, like Java/C#/etc., but the code you write for working with XML is short and to the point, comparable to XQuery. For my XML Schema generator, it seems like the best solution. Brevity is still one of the best ways to keep your code maintainable, and to keep the cost of that maintenance down to a minimum.

By the way, if you want to try out these Scala example, just download and install Scala, and type "scala" at the command line. That starts the Scala interpreter; you can type the above code, and it will print out the results. It's an easy way to get a feel for Scala and what it can do.

How XML Could Have Averted The Recession

"How XML Could Have Averted The Recession" is the name of the presentation I am giving at this year's XML Summer School in Oxford (UK), 20-25 September 2009. The title is a bit whimsical; I'm not claiming to know how we actually could have avoided the recent financial crash, but I will be discussing how open standards, open data and timely disclosure might have helped us avert the recent failure, and how it might help us avert future failures.

This will be the 5th XML Summer School I've presented at. You won't find a better set of presenters anywhere in the world, if XML and related technologies are your interest. The Summer School is small enough that you can get to meet all of the presenters socially during the week, and the presenters keep coming back year after year because we all enjoy the fun we have together socially.

So, if you can come, you will be very welcome, and I hope to see some of you there. If you can make it, you won't regret it.

Generating XML Schemas from ISO 20022 UML models

As I've mentioned in the past, I'm the principal UK expert (yes, the "PUKE") for ISO TC68/WG4, the ISO working group that has produced an updated version of the ISO 20022 standard. ISO 20022 is standard for defining messages based on definitions in a central repository, with a focus on banking and finance. Those of you whose are involved with financial messaging via the SWIFT network will have used ISO 20022 messages whenever you use one of the XML "MX" series messages. WG4 has produced a 2009 version of ISO 20022; it is currently a committee draft which has gone to TC68 for an international vote, so it is not yet an approved version; the current approved version is the original 2004 version.

My particular interest in ISO 20022 is in the part that describes how to generate XML Schemas from UML models. I like the repository based approach where you can share components between related messages, but don't have to implement that sharing at the Schema level, with includes and imports. ISO 20022 has one Schema file per message, and that makes life easier than if you have to get people to set up a hierarchical directory of cross-linked Schemas correctly.

I wrote an XML Schema generator for the current 2004 version of ISO 20022. That generator works with XMI (UML in XML) files produced by Enterprise Architect (from Sparx Systems), and is implemented as a series of XSLT scripts.

For the new 2009 version of ISO 20022, the good people at MagicDraw donated licences for WG4 to use their UML editor, and so MagicDraw is the UML editor that was used to develop the new metamodel and UML profile. For this reason, for my new implementation I decided to target MagicDraw (I might support other UML editors too, later, depends on how many requests I get).

I decided to continue with my previous approach, working from the XMI, this time using a mix of XQuery and XSLT. XMI is a rather generic XML format that can be hard to read and understand, so I consider it error-prone to try and generate XML Schemas from the XMI directly. Instead, I distill the XMI into a much simpler XML format which reflects the structure of the ISO 20022 metamodel, an "XML DSL". I then process that simpler XML file to generate Schemas or anything else. So, the plan was to use an XQuery to generate the simple XML, and then XSLT to generate the Schemas (there are some things that are easier in XSLT than XQuery).

However, it turns out that the latest XMI 2.1 standard is loose around how UML stereotypes (user annotations) are represented. So, after some failed attempts at "reverse engineering" how MagicDraw represents stereotypes in XMI, I decided I needed a different approach. Instead, I am using the MagicDraw Open API to read the contents of an ISO 20022 UML model. This means I need to be using a Java program, or something that runs on a JVM.

Java itself isn't great for XML, in as much as the code tends to end up rather more verbose and unreadable than it need be. I tried Groovy, which has some reasonable support for XML, but moved away from that because the XML support is incomplete. It seems that in a number of languages, the people who implemented the XML library didn't really like XML, so they decided to only implement support for the parts of XML that they thought were worthwhile. For users, that causes nothing but problems.

What I am currently using is Scala, which is convenient because you can just start typing XML as the value of a variable in the middle of a program, and Scala knows what to do. I've now written the code to generate the simple XML format. It hasn't been as easy as it should have been, because Scala support in IDEs is still weak (I use Intellij), and because Scala's integration with Java is good but not as good as it could or should be. For example, Scala avoids the use of null values. It does have some support for them because it needs that to work with Java libraries. However, at times when Java code would give me a null pointer exception, I find my Scala code just hangs, leaving me with a lot of searching to do to find what went wrong and where. Still, the code is more readable than Java, and things can only get better, so I'm planning to stick with Scala for this.

Once I have XML Schema generation done, the next thing to look at is ASN.1. ASN.1 ("abstract syntax notation") is an ISO standard for designing messages that predates XML, and has been most widely used in the telecommunications industry. Note that I wrote in a previous post that ASN.1 was the format used for ISO 15022 messages (more-or-less the predecessor to ISO 20022). That was wrong, I want to point out; somewhere along the line I got the wrong idea, and in spite of my saying it in a number of WG4 meetings, only recently did someone from SWIFT point out that I was mistaken.

Anyway, WG4 has added support in the 2009 version of ISO 20022 for ASN.1 as an alternate message syntax to XML Schema. Now, ASN.1 itself is actually multi-syntax. There are a couple of binary encodings it supports, plus there is a more recent XML encoding. The ISO 20022 profile of ASN.1 has been constructed so that, as closely as possible, an XML message that is valid according to the XML Schemas will also be valid as an XML encoded ASN.1 message, and vice-versa. Since ASN.1 messages also have a binary encoding, this new ASN.1 support means that ISO 20022 will have an official binary encoding as well as the existing XML encoding. It will be interesting to see how the usage of XML versus binary ISO 20022 messages goes over the next few years; banking and finance applications have size and latency challenges for which plain-text XML often isn't suitable.

I should be able to generate the ASN.1 grammars for the messages from the same simple XML that I use to generate the Schemas. Doing so will show that the simple XML genuinely decouples that back-end code generators from the format of the input UML model; that's something I need to have the possibility to support UML editors other than MagicDraw in the future.

If any of this interests you, either ISO 20022 or my work on Schema and other generators for ISO 20022, feel free to get in touch.

NetBeans 6.5, JavaFX 1.0, Groovy and arithmetic training

I'm reasonably good at mental arithmetic, and I want my son to learn to do it as well. I think it's a disadvantage in life if you have to search for a calculator every time you need to add, subtract, multiply, or divide a couple of numbers. For that reason, I've written a number of arithmetic training programs for him. The first one I wrote was written in C# using the GUI building abilities of a cross-platform Java/C# IDE that I used to use, Xdevelop. Actually, I would still be using that IDE if they hadn't stopped supporting it a couple of years ago; I thought it was great.

Eventually, I wanted to write a second version of the arithmetic program, one that adjusts to the user's abilities. This is a fairly simple technique that I learned back in my educational multimedia days. You make the problems harder each time the user gets one correct, you make them easier each time the user gets one wrong. In this way, the program can quickly auto-adjust to the user's current level of skill. For this second version, I decided to use Java and Swing, but I wanted to use something like a GUI builder. You can write a user interface directly in Java, but it's a slow tedious process, and I don't have the time to waste on that. At that time, there was an early version of JavaFX available. JavaFX allowed you to declare the structure of your user interface by defining a simple structure of components within components; a bit like an XML file, but not XML, a hierarchical syntax more akin to Java syntax. It wasn't as good as a full-on visual GUI builder, but still seemed easier and more manageable than writing Swing code directly in Java. If you are writing JavaFX, I strongly suggest you download NetBeans, as its built-in JavaFX support is not bad. There is also a plug-in for Eclipse, but no plug-in (that I know of) for Intellij. There is a slim version of NetBeans now that has just the bits you need for Java and JavaFX development; it's much smaller than the "complete" version of NetBeans.

Anyway, this new arithmetic program has worked very well, but I need to make a few minor improvements, so I thought I should check the latest version of JavaFX. Recently, JavaFX 1.0 was released, and this has changed significantly. The old version was a simpler way to write Swing programs, the actual 1.0 release now has a "Stage" and "Scene" metaphor that is reminiscent of the Macromedia tools I used to use in my multimedia development days, particularly Macromedia Director (Adobe subsequently bought Macromedia). That's a good thing; those Macromedia tools really impressed me because both programmers and artists could use the same tool and usefully contribute to the final product. The same can't be said of most programming IDEs. The Macromedia tools were genuinely inclusive, in a way that so many software development tools are not. There is something wrong when so much software still only targets only the cleverest 5% of users. The other 95% deserve to have a chance to contribute as well, and they tend to be excluded unnecessarily.

Anyway, NetBeans 6.5 has support for JavaFX 1.0, including a new "palette" of visual items that you can drag-and-drop onto your "Stage". What I found, though, is that JavaFX has lost its ability to do Swing GUIs. Instead, a bit like the Macromedia tools I used to use, you have to lay things out yourself based on absolute pixel locations. This kind of user interface development works well when you have a very graphical interface created by an artist, and when you have an IDE that makes it easy to work with images, etc., and lay them out visually in the correct pixel positions. However, I'm not an artist, and NetBeans 6.5's JavaFX facilities are poor when compared to Macromedia's tools from 1996 (yes, over 12 years ago). I would hate to have to use NetBeans to do any serious JavaFX development. If JavaFX is going to compete with Flash, it can't just do the run-time, back-end things properly, it also has to be easy to author. At the moment, it is generations behind, and I really wonder which group, Sun or other, is going to be able to step up and provide the necessary interface, if it is to be a success.

Having discovered how different JavaFX 1.0 is from old JavaFX, it occurred to me that I was better off porting my program to Groovy. Groovy is a Java-based scripting language that compiles to Java byte codes and can use any Java library, so it's easy to learn if you have a background in Java development. Like JavaFX, Groovy provides a syntax for declaring the structure of a user interface (and uses a similar structure for XML, very useful, but a topic for another post sometime). Unlike JavaFX, Groovy uses the normal Swing components, so the conversion was fairly straightforward. It took me about a day, mainly because I was learning Groovy at the same time as doing the conversion.

The only significant difference between Groovy and the old JavaFX is that JavaFX has a neat "bind" keyword that can be used to make the value of a field in the user interface stay synchronised with a particular variable. It's a simple idea, but very powerful. It removes a lot of event handling code that you would normally have to add to a Java program. So, the Groovy version of my application required some new event handling code. Luckily, Groovy provides "closures", essentially "pure" methods that aren't attached to a particular class, and these simplify the writing of event handling code. As compared to converting to JavaFX 1.0, converting to Groovy and adding some event handling code was definitely easier. My son has his new arithmetic program running now, with some new features. Groovy is stable enough that I shouldn't face the same migration problem the next time I want to add some new features.

The more I use Groovy, the more I like it. It's worth the time to learn it, if you write enough code in plain old Java and would like to save some time.

Null propagation, part 3

Almost two years ago now (#1, #2), I wrote about the idea of being able to modify the way Java handles the situation where a method is called on a null value. Normally this causes an exception; I was wanting such a call to return a null instead, so that the result is more like what happens with XPaths when a node in a path doesn't exist. For example, the XPath

/document/person/address

doesn't cause a program exception if there is no <person> element, whereas

getDocument().getPerson().getAddress()

will throw an exception if "getDocument().getPerson()" returns null. These exceptions make it painful to use Java (etc.) for working with XML, because you end up with so many try/catch blocks to deal with of the places that an exception could possibly be thrown.

So, it was interesting when I stumbled across the fact that Groovy (a Java-based scripting language) solves this issue! Groovy has a "?." operator, which returns null if called on a null, and executes the method normally if called on an object, i.e. "a?.b" is equivalent to "a == null ? null : a.b". So

getDocument()?.getPerson()?.getAddress()

will return null if "getDocument()?.getPerson()" returns null. That makes Groovy (for this and other reasons) a better way to write your XML processing code in Java, if you are trying to keep your code as simple and maintainable as possible.

The Virtual Laptop ― From Linux to Windows XP, part 2

John Cowan submitted a comment to my post about switching my laptop from Linux to Windows XP. He asks, quite reasonably, why I need to install OpenOffice directly on my laptop if I do my work in VMware virtual machines. Don't I only need OpenOffice in the virtual machines? Shouldn't I keep the laptop itself free of almost everything except VMware Server?

The answer is something of an 80/20 rule. There are compromises that you have to make in running VMware on a laptop (and even on a lot of desktops). The two most obvious ones are

• available memory;
• available disk space.

My laptop has 2G RAM, and that is the maximum it supports (it's 2 years old, what can I say? This Christmas, at a large UK chain called PC World, they had £499 laptops with 4G RAM and 250G disk, both figures about double what I have now. But I don't have one of those). When I'm running both Linux and Windows in VMware virtual machines on my laptop, I'm running 3 operating systems at the same time, 2 x Windows + 1 x Linux. That's quite a squeeze. I can only assign 768M to each virtual machine, which is less that most people are used to having these days when using Windows or Linux. It's just barely enough, really, although it is enough for the most part.

Now, there are certain common services I sometimes want to run that are used by both my virtual machines. The most important is my Subversion repository, but I also sometimes run XML or relational databases. As I'm already so squeezed for memory, there is no way I can run extra virtual machines for these. I also don't want to run them within one of my existing virtual machines, because them I'm forced to run both at once. It's better to be able to run them independently, not the least because I sometimes need to bump the memory up to double (1.5G) in order to run something big, and that means one virtual machine only. The upshot is that I have to run certain common services on the host directly, there isn't really a practical alternative.

There are also some applications that run sufficiently better on the host, enough to make it worth using the host directly. Skype is a key one for me, but also Bibble Pro which I use for processing RAW photographs from my digital SLR. And why OpenOffice? The main reason is because, when I'm giving a presentation at a conference or meeting, there is always that natural tendency for technical things to fail at the worst possible moment. Adding a virtual machine into the equation is just an extra distraction that I don't need. Additionally, sometimes I might want to quickly look at an office file that someone has put on a USB memory stick. I don't want to have to fire up both a host operating system and a virtual machine operating system just to view a word processing document or a spreadsheet quickly.

I am nonetheless fairly strict about what things I do on the host operating system, and what data or files I keep on it. Any data or files on the host have to be backed up separately to my virtual machines, which is important. I don't do e-mail on my host operating system (maybe the occasional bit of webmail, nothing more than that), nor anything much else that is part of my daily work tasks. So, it's 80 for the virtual machines and 20 for the host operating system. I think that's a reasonable compromise.

Data modelling, metamodelling and MPS

One side of the work I do for my clients is XML and related technologies, the other side is general data modelling. One thing that interests me in data modelling is the use of metamodels. Now, what is a metamodel? Normally, people switch off or break into a cold sweat when they hear "meta-anything" in a sentence. However, there is nothing scary about metamodels. A metamodel simply defines what things are allowed to be in your data models; it's a model of what you are allowed to have in your data models.

Why do we need metamodels? It's because data modelling is usually done using general purpose modelling technologies. Examples are E-R diagrams, UML, and XML Schemas. Any of these general purpose modelling technologies give you more features than you need or want in any single project. It can be a major problem to constrain people to use as few features as possible, which is what you want to make your data models as simple to understand and as cheap to maintain as possible. The role of a metamodel is to define a limited set of features which are the only ones that can be used out of all of the features that the general purpose modelling methodology provides.

For example, it's common to find people using XML Schemas that (a) use elements only for data, not attributes, and (b) use local element definitions only in the XML Schemas, not global element definitions (root elements accepted). This constraining of XML Schema to a simple subset of its features is equivalent to defining a metamodel that is a subset of the full metamodel for XML Schema. In practice, you can implement just such a "metamodel validation" on an XML Schema by applying some kind of schema language to the XML Schema itself. As it happens, XML Schema editors often won't let you apply an XML Schema to another XML Schema, but you can apply both Schematron and/or RELAX NG to XML Schemas in order to implement checks that the XML Schemas conform to your metamodel (i.e. your design rules).

UML is widely used for data models, and metamodels for UML are written in using a thing called MOF. With the latest versions, UML 2 and MOF 2, MOF is now a subset of UML that can be used for writing metamodels which constrain UML models. Sadly, support for validating UML models using MOF metamodels is still poor (at least in any tools I have used), but I live in hope that within a couple of years it will be possible to validate a UML model with a MOF metamodel as easily as you can validate an XML document with an XML schema.

Today I was catching up on some reading, and I stumbled across a mention of JetBrains Meta Programming System (MPS). I tried an early version of this a couple of years ago; it lets you design custom/bespoke mini programming languages (or mini data formats) that are specific to a particular purpose. The MPS tutorial is a good way to get a feel for MPS, what it does, and how it works. There is an obvious analogy between defining a mini-language for a task rather than letting people loose with a general purpose language, and using a metamodel to constrain people's usage of the features of a general purpose modelling methodology. MPS allowed you to define structured data models that have something of the feel of (simple) textual computer program, or a textual data file like a simple properties file. Although they have the look of text files, they are actually structured, and in some ways it's not unlike generating form-based user interfaces or Web pages. MPS is a neat looking tool, and it's free. I like JetBrains (commercial) Intellij IDE for Java, because it's so clever in the degree of analysis it does of your code as your write it. I was amazed how many issues it was able to point out to me as I was writing my code, before I even compiled it. If the JetBrains folks can apply the same cleverness to MPS, it could be a useful tool. That said, it's not the only tool that can generate user interfaces from models. Eclipse has EMF (like a cut-down version of UML) and Visual Studio has support for Domain Specific Languages (DSL). All of these tools are working to the same end, to provide you with a way to allow people to work with only the minimum set of features that are needed for any particular problem, so that they produce the simplest, most consistent, most maintainable solution that they can.

Metamodels and their equivalents let you take a complex software tool or methodology, and constrain it to effectively turn it into a simpler software tool or methodology. It's a bit more effort, but for a project of any size, it can pay real benefits in the end.

The Virtual Laptop ― From Linux to Windows XP

For over 2 years now, since I bought it, I have been running openSUSE Linux on my laptop. Although I spent a lot of time making it work, more or less, I have also lost a lot of time in trying to get simple things to work well. For example, with a laptop, it's useful if you can hibernate it, and do so quickly and safely. Also, when travelling, you want things like Skype to work well. I never managed to get these kinds of "mobile" aspects working well enough. So, when I recently had a couple of hard disk crashes on my laptop in the space of a couple of months, I decided to bite the bullet and switch my laptop back to Windows XP. That's what I've done, my laptop is running Windows XP now.

The reason I could switch so quickly, in less than half a week of spare time, is because most things that I do are done in VMware Server virtual machines. So, as long as I can run VMware Server on a PC of any sort, I can quickly be up and running with my working environments.

Is Windows better than Linux? No, not really. I'm trading one set of issues for another. However, my new principle is that you should stick the the operating system that comes with your laptop. Not because that operating system is better than any other, but because it should work with the hardware in your laptop; manufacturer testing of the operating system with the hardware is worth a lot in practice. So, while hibernating is now much better (I can hibernate even with VMware virtual machines running, something that was out of the question with Linux), I've already had problems with software not running properly when installed, or new installations seeming to stop previously installed software from running. Linux has a sophisticated system for managing dependencies between versions of software, and Windows doesn't seem to have anything to match, so Windows is a generation or more behind in terms of making different software applications co-exist. I'm losing that, compromising instead to get better hardware support.

By the way, where does all of the disk space go in Windows? I don't like the idea of having just a single huge disk partition as is the default for Windows, so I split my partition (using "Parted Magic" - free and recommended by me) so that I have a C drive for Windows and application files, and a D drive for data. I thought 25G should be plenty, even for something as profligate as Windows XP (which itself is still leaner than Vista). However, with XP and selection of applications (including VMware Server and the Novell edition of OpenOffice 3, which are big installs), I now find I only have 4G free out of 25G! Where did my disk space go? I've examined the C drive once, but the numbers don't add up, something is missing. I may have some large "system restore point" file backups, perhaps. I'll be checking into that as I go along.

Windows XP needs more protection than openSUSE Linux, which comes with built-in support for disk encryption and also comes with Novell's AppArmor, which is a better way for Linux to protect against viruses/etc., than the virus-signature-based approach that is most common for Windows. That meant software to buy. I like to use Norman software (not Norton) for virus checking and firewall, because the firewall allows very fine-grained control over incoming and outgoing network connections. To encrypt my hard disk, I decided to follow Bruce Schneier and use PGP Whole Disk Encryption, which is straightforward to use and also provides support for signing and encrypting your files using PGP.

By the way, my laptop may be running Windows XP, but remember, I do most of my work in VMware virtual machines, so I'll still be doing most of my work in Linux. I'm just trying to get the best of both worlds.