Like most myths this may have started from an original truth, but is now a lie. I am it’s latest, but I suspect far from only, victim.

Let me explain. For over a year now I have been developing a plugin for the RAW developer Bibble and it’s recent successor, Corel AfterShot. These plugins are developed using c++ and the Nokia QT framework, which theoretically allows the same code and user interface design to compile and run on Windows, Linux and Mac.

As a died in the wool Windows developer, that’s where I started. There’s a QT add-in to Visual Studio, so with a bit of juggling I managed to get one of the examples to load into VS, build, and run using Bibble as the target executable, and I was off. I was on a fairly steep learning curve in respect of the programming model, but I had very few problems compiling and running things.

When it got to the stage that I had something to share with the Bibble community I published the Windows version, and another member of the community kindly cross- compiled for the other platforms. There was another learning curve to make sure my code compiled cleanly on the other platforms, but nothing too drastic. For over a year I sent code updates to Jonathan, and got compiled Linux and Mac libraries back.

Although Jonathan still provides a very helpful service, it became apparent that if I wanted to have full control over the application versions I support, and be able to verify my plugin’s portability, I needed the ability to compile and run each version myself. I wasn’t prepared to buy and carry extra hardware around, but maybe VM technology would work.

I started with Linux. I had a couple of false starts but quickly found a site which has pre-built VMs for most Linux distributions (http://www.trendsigma.net/vmware/), and homed in on Lubuntu – based on Ubuntu but with a quite Windows-like shell. I downloaded and installed AfterShot and QT Creator, loaded up a copy of my code, and clicked “build”. And it worked first time! Getting a completely slick solution took a bit more effort, but it works so well I don’t now even copy the Windows code, I just open the same directory from my Linux VM and run the Linux builds in place.

So far so good. Now for the Mac. What could go wrong?

Apple’s antipathy to virtualisation is well known (see http://www.andrewj.com/blog/2012/mac-osxa-third-class-os/), and strictly speaking you’re not allowed to run OSX on non-Apple hardware. However, I got a legal copy of Snow Leopard, and found advice on the web on how to run up an OSX VM. You have to be patient, especially as it can take a couple of goes to boot the VM cleanly or install software, but generally it works pretty well.

First challenge: installing software. Unlike Windows or Linux, where non-trivial software has to be installed by a program which does useful things like error checking, on the Mac you often just simply drag a package of files to “Applications”. When it works, this is nice and easy. But if it fails, and I’ve now experienced this several times, it does so silently leaving you with a broken installation, which may not be obvious until things don’t work.

Eventually I manage to install Bibble, ASP, QT and, adding 30% to the size of the OS, XCode, the Mac development environment. I open QT Creator, and try to open my project. The first problem is that QT puts platform-specific settings in a small file alongside the main project files, and this has a fixed name, so you can store either the Linux or the Mac settings, but not both. Sigh, and copy the files from Windows to a local directory on the Mac.

After a bit of juggling, I got the plugin to compile. I then had to set up the deployment steps, renaming and copying files. Cue the next annoyance. Deployment configuration requires copying and adjusting complex filenames and paths. On Windows, you right-click any file or folder and there’s an option to copy the path to the clipboard. I was delighted to find that exactly the same trick works on Linux. OSX has no such simple solution. In the end I found a page of instructions on the web, which involved setting up macros as the like, but it wasn’t “easy”.

So I’ve compiled and deployed my plugin. Start AfterShot. Half the plugins and tools are missing, including mine. Re-install AfterShot, reboot the vMac, and now the standard tools are there, but still no sign of my plugin. The files are there, but the log has a very cryptic message about how my plugin “does not contain any recognisable symbols”.

Cue about 5 days of testing, trying different things, emails and posts on the Bibble forums. To cut a long story to a tolerable length…

1. No one seems to know how to compile successfully using QT Creator on the Mac, you have to convert to XCode,
2. XCode can’t cope with spaces in your folder or filenames. Another reason why the code can’t be shared directly with Windows and Linux,
3. When you’ve finished compiling, you have to do an extra step called “fixing the paths”. The QT/XCode combo manages to embed hard-coded pathnames in the executable files, which fail immediately you rename or move it. This doesn’t happen on the other platforms. Fortunately there are scripts available to perform the fix, but it’s certainly not obvious,
4. It’s all very sensitive to precise choices of SDK versions and the like,
5. Plugins for Bibble have to be compiled using a different QT version to those for ASP, and you can’t have more than one version installed on a Mac (ironically this restriction doesn’t apply on Windows or Linux, where there’s no problem just using the latest libraries for both). I had to use the “clone” feature of VMWare to create a “branched” VM with a different installation – on a physical machine I’d be sunk.

That’s not quite the end of it. One of the SDK features I use in AfterShot relies on an asynchronous processing model. On the other platforms and on a physical Mac my code runs fine, but on the “vMac” it returns invalid data. This is clearly a Bibble/Corel problem, but one for which no-one has yet offered an explanation or fix.

Now I accept that some of this may be down to my use of a VM, and some is definitely weaknesses in the Mac versions of the QT and Corel software. But setting those aside, the fact remains that the Linux exercise was genuinely quite easy, the Mac version far from it.

So there are lies, damn’ lies and statements about how “Macs are easy, they just work”. The next person to repeat that lie to me may suffer a painful injury to a soft part of their anatomy…

I’m a Windows user, spending much of the working week away from home. I get a vast amount of value from virtualisation. It allows me to carry just one PC with multiple “client specific” images, and enables me to keep running legacy software almost indefinitely. My main client uses the same technology to provide legacy support for essential software, which in long-cycle engineering businesses can easily be 20-30 years old, as physical assets in such businesses age many times more slowly than the computing equipment around them.

I also develop plugins for the Bibble RAW processor. The same code should work on Windows, Mac and Linux, but you have to compile and test on each platform to confirm this. I’ve recently added a Linux Virtual Machine to my kit. This was remarkably painless, just a few hours work, and I can now rapidly cross-compile and test my Windows-based developments under Linux. If there’s an issue which means having to support more than one flavour or version of Linux adding it would be trivial.

I just can’t do this for the Mac. I don’t want to buy and carry another laptop (which would be useless for any other purpose), and you can’t get virtualised OSX, either as a VM or as a service, through any legal and “safe” route. The result: as far as I am concerned OSX is a “third-class” OS, almost a “technical ghetto”, and I have to rely on the good offices of other developers to deliver my plugins for it.

People will put up with a lot in the name of love. Maybe Mac users “love” their computers enough to tolerate this behaviour. But looking in from outside I find Apple’s attitude perplexing and very annoying.

To find out more, visit www.andrewj.com/plugins.

I recently converted my blog from an old bespoke (= “custom”, for my American friends) solution to one based on WordPress. However, this created a problem, in that the WordPress model is to hold all content in the database, and that wasn’t the right model for me.

Firstly, I have a number of articles which are very long for a blog post, and I had no interest in restructuring them. I also didn’t want to break external links to the existing articles.

Next, I decided that I wanted the freedom to continue to write in that style. Some of my writing takes several weeks, and it works for me to draft it as separate HTML pages. I also sometimes want to include active content or multiple images, and I don’t want to create a large and unwieldy WordPress database full of such stuff.

Finally, my online photo galleries are managed and generated using Jalbum, and I wanted to find a way of neatly integrating single images into my blog, complete with the watermarks and metadata extraction which Jalbum manages so well, without duplicating that functionality in WordPress.

This is probably typical of many older web sites, but WordPress doesn’t really embrace the integration of external content. This article describes how I solved this problem, and a WordPress plugin I have developed to make my solution reusable.

I’ve just spent a week-end migrating my website to a new hosting server. As part of that process, I had to rewrite all my old ASP code using PHP. Here’s what I learned:

1. The Apache/Linux community have misleadingly changed the meaning of “ASP”. If you bought a Linux-based hosting service 5+ years ago with “ASP”, it meant a *nix port of Active Server Pages. That worked for me, as I could develop it on Windows. Now, if you buy a Linux hosting service with “ASP” it means “Apache Server Pages”, and the embedded language is Perl. Useless!
2. PHP has positively the worst combination of features for a language:
   • A c-based language’s sensitivity to case, ending semicolons and curly bracket counts,
   • None of the protections against errors in the latter that a C++/Java (or VB) language gives you, like strong typing and forced variable declaration,
   • No single-step debugging. Now I accept that this may not be 100% true, so don’t all write in with the names of all the debuggers I didn’t find in a quick search for tools on Sunday morning, but certainly I don’t have one at the moment,
   • It runs differently on Windows and Linux, and in a way I haven’t yet understood 100%, so I can only test by uploading to my live website.

That said, I’ve still got it! I’ve managed to convert my blog and my book reviews, and I’ve actually improved on my old code for the latter. Just please let me have VB.NET back for my next major project.

OK. </rant>

However, Martin’s essay goes beyond common programming and data techniques to look at the development of specialist tools which he calls “Language Workbenches”. I’m not completely convinced that we need these in the world of XML and XSD. If you have a defined schema for you XML-based DSL (and aren’t all the many *ML langauges just different DLSs?) then any schema-sensitive editor will provide you with good design and editing support. The leading IDEs (e.g. Visual Studio) all have such a tool built into their core capabilities. Surely we now have a sufficiently sophisticated set of XML-based tools and standards that we have an opportunity to exploit synergies rather than re-inventing the wheel?

Steele’s argument is highlighted by the paper’s unique style – he uses a small but growing language himself. He writes using only words of one syllable, gradually adding other words he has defined in these terms.

The paper works at many levels. As well as the fascinating intellectual exercise in style, it makes a strong case for:

• simple but extensible programming languages,
• improving the extensibility of Java, rather than its core vocabulary,
• an agile community process for developing languages, rather than up-front design of great monoliths,
• the communication power of simple language and words.

Steele exhorts us to think about extensibility mechanisms – if we get these right then the core functionality can always grow. And by example, he encourages us to use simple, direct language and benefit from its discipline. On both accounts I agree wholeheartedly.

In my recent work I’ve discovered a few patterns of my own, and I’ve started a page to document them.

First up is entitled “Change Indicator” . You may have a legacy system with an EAI adaptor, or a similar source of messages, which reports on the current state of key business objects. The messages will typically tell you when something has changed, but not necessarily what has changed, but the latter may be important to downstream systems. This pattern shows how to use EAI elements to add this information in a way which is totally transparent to the legacy system and existing users of the EAI scheme.

For the technically inclined, I’ve built my blog using a combination of VB.NET, Active Server Pages, and a bit of XSLT. This allows me to develop my site using FrontPage and IIS, and run it under Apache. If anyone’s interested I’ll write a technical note on it.

However, they rely entirely on Monte-Carlo simulation. I believe that where the curve is defined by, or can be approximated by, a few discrete points, a relatively simple analytical solution can then be used in place of simulation.