Blog

On Software Portability

guest post by Jörg Lenhard

On Software Portability

Christos Nikolaou Memorial Ph.D. Award at SummerSoc.
From left to right: Prof. Dr. Guido Wirtz (my Ph.D. advisor, Uni Bamberg), Prof. Dr. Dr. Frank Leymann (Uni Stuttgart), me, Prof. Dr. Wolfgang Reisig (HU Berlin)
On June 27th, 2016, I had the honor of being distinguished as the first recipient of the Christos Nikolaou Memorial Ph.D. Award at the 10th Symposium and Summer School On Service-Oriented Computing (SummerSoC) in Crete, Greece. Starttech Ventures supported the award as sponsor and also by giving me the opportunity to write this blog post.

First things first: I am Jörg Lenhard, now a postdoctoral research fellow in software engineering at the Department of Mathematics and Computer Science of Karlstad University, Sweden. The item the award focuses on, my Ph.D. thesis titled “Portability of Process-Aware and Service-Oriented Software: Evidence and Metrics”, has been created at the Distributed Systems Group of the University of Bamberg, Germany.

In a nutshell, my work is about analyzing and measuring a particular aspect of software quality, namely software portability, for a particular type of software. So why does software portability matter?

I want this blog post to be understandable for non-technical readers and will try to avoid tech-speak, although a little bit of technicality is required. But let’s get started: Today, we build software out of a combination of various things. Oftentimes, this is a sort of general-purpose runtime environment and an application-specific part. In a sense, your operating system (Windows, OS X, Linux) is the runtime environment for many different applications (your favorite web browser or word processing software). In my work, I do not deal with operating systems, but with a special type of server-sided runtime environments and software, which normal users never see. Nevertheless, the principle is really the same.

The problem is the following: when you choose a certain runtime environment, you are locked into that environment. You have to pay for it, perhaps even for re-occurring license costs, and you cannot simply take your installed applications and move them to a cheaper or better runtime environment. In distributed systems, we try to address this problem with software standards. We have standards that describe what a runtime environment should provide and how an application and its source code can look like. If an application conforms to a standard it can be freely moved, that is ported, between any runtime environment for the standard without effort. You can easily get away from a low-quality and high-cost environment and use a better and cheaper one.

This sounds too good to be true? Indeed! We are in the unfortunate situation that vendors brand their products with a standards’ acronym, say BPMN or BPEL for instance. This lures users into spending money on the product, although the product might offer very little standard support and just locks-in the user as usual. Despite the existence of standards, an application might only work on the product on which it was originally developed. An analogy you might experience occasionally is with HTML, CSS and web browsers. HTML and CSS are used to define the structure and layout of web pages that should be rendered identically with any web browser. However, browsers do not necessarily support all parts of HTML and CSS, and may even support custom extensions. As a result, web pages might be rendered differently in different browsers and also web applications might behave differently.

In my thesis, I do not focus on HTML and CSS, but looked at the most important standards for implementing service orchestrations, again BPMN and BPEL, took several different runtime environments for these standards, and built a system that allows to check how well these environments support the standards. The results were somewhat surprising and disillusioning. Large parts of the standards are hardly supported by current runtime environments. It seems that, despite huge efforts in standardization over the last ten to twenty years, standards have largely failed their goal: There is no multitude of runtime environments that support a standard as specified and we cannot rely on standards alone if we care about software portability. My thesis provides verifiable and reproducible evidence for this sorry state.

But I did not stop at providing data for the status quo. Portability is something nice after all! We want the applications we build to be portable. Therefore, in a second step, I tried to develop and test methods that aid software developers in building more portable software. Essentially, I used measurement and inspection methods, something quite common in software engineering. The idea is that you, as a developer, should inspect your application for every change to its source code, to see if new issues were introduced and how software quality develops. Today, there is a lot of automated support for this task with continuous integration technology. If you monitor software quality over time, you can see if it diminishes in the long run, which should be a hint to do something about it.

My contribution was to enable this quality assessment and issue detection with regard to software portability for the distributed software I was interested in. I developed measurement and issue detection methods and metrics, and implemented them in inspection tools that developers can use. To see if their usage is actually feasible, I tested these methods and tools on a considerable amount of open source software, and tried to tune them if they did not.

To sum up, in my thesis, I provide evidence that software standards do not ultimately solve every problem of software portability, as some vendors might want to make us believe. Moreover, I tried to provide developers with a tested way of building software that is more portable.

If I got you interested and you want to know more, you can always look at my thesis, which is available as open access. Of course, you can also contact me.

Finally, I need to say that I feel deeply honored for being distinguished by the award, a thing that seemed impossible on the long and winding road of doing a PhD. I want to express thanks to the award committee and to Starttech Ventures for making all this possible. Really, a thousand thanks!

Jörg Lenhard

On Software Portability was last modified: September 19th, 2018 by Starttech Editor

Starttech Editor Starttech Editor

Contact Starttech