Developer Q&A: Syllable OS

Syllable developer Kaj de Vos

Image credit:

Image credit:

Elements of Syllable were inspired by AmigaOS (via AtheOS) -- what is it about the Amiga operating system that people found so appealing?

A good question. To be honest, in the beginning the main draw of the Amiga was its brilliant hardware. Games usually started by disabling the operating system and then proceeded to program the hardware directly.

It was only later, especially when used as a productivity machine, that people discovered that the operating system was equally brilliant.

It was way ahead of its time for a consumer device, doing many of the things that are expected now from a modern machine. Thereby it turned out to be the most durable design of its time, which is still being used and developed today, on very different hardware.

The people who discovered these qualities liked it for its responsiveness, flexibility and ease of handling while giving them an unprecedented power in doing things that were very new.

Different people will give you different reasons, but my take is that it was a matter of success breeding success, because it was a winner and it helped you be a winner.

Just following on from that, do you think that there are places where other current operating systems have gone off track?

Don't get us started! In our view, it has been mostly downhill from there. It is well known that the best technology usually does not win in the market.

The Amiga was a rare case where it did for some time because it was a pioneer market, and it probably gave many technologists false hope.

Due to organisational causes, large companies have huge difficulties developing new operating systems and other substantial innovations, which can be seen in the technology news every day.

Innovative and integrated designs like the Amiga and Syllable need to come from very small, very focused groups — especially software systems, because they are mental exercises.

These incubation groups are by definition not equipped to market the result. The Amiga was developed by such a small technology group that was saved from bankruptcy by the then-largest computer manufacturer in the world, who ran it in the ground in later years by squandering the technological advantage.

This scenario has played out again and again in similar cases. Only a few companies have found a balance between these conflicting requirements, and only for limited periods of time.

All we have are compromises, and I will freely admit that Syllable is one of them. For someone with deep technical understanding it is easy to point out what is wrong with current systems. It is just extremely difficult to do it better.

For a company, it is natural to shift the compromise towards better marketability. What we are trying to do is to shift the compromise towards better technology.

We think this can be made viable because the internet and open source has changed the relationships between companies and technologists. As an open source project on the internet, we can exist without the substantial support that used to be needed.

Companies can help, but we do not need them, so we can survive a company that would go off track trying to sell Syllable. The internet is also a marketing tool, so if our proposition of easy access to innovative technology is not enough to interest companies, we can still try to market it ourselves.

As for what is wrong with mainstream systems, many things can be listed, but in essence, most of them come down to excessive complexity and artificial limitations of capabilities.

Early systems used to be structured around functional capabilities, such as the tradition of modular command-line programs on Unix-like systems (which Syllable also supports).

More recent systems are structured around marketable units. As an example, you take a picture. To import it in your computer, you often need programs supplied by the manufacturer of your camera. If you are lucky, you can circumvent these, but why should this be necessary? The software is not even available for any but the most mainstream systems.

On indoor pictures, you want to remove the 'red eye effect' caused by the flash. On outdoor pictures, you notice the horizon isn't straight and you would like to correct that.

These are common, but technically complicated manipulations on pictures. The correction of red eyes may be offered by multiple applications on your system. The straightening of horizons may require you to buy yet another image manipulation application.

Why can't you plug in the camera, have its icon appear on your desktop without extra software and click on it, then click on a picture and be offered one option to correct red eyes and one option to straighten a horizon?

Because commercial interests like to sell you these basic abilities over and over again in different, overly complex collections called applications. We are fine with companies charging for innovations, but the current situation impedes progress.

The Amiga ecosystem developed a solution for this more than two decades ago.

Similar to modular Unix command-line programs, many graphical Amiga programs had standardised interfaces that opened up their capabilities as building blocks that could be mixed and matched.

Besides greatly increasing flexibility and potential, such frameworks greatly reduce complexity by standardising on shared infrastructure.

Sadly, even though open source arose from the tradition of Unix building blocks, it has largely failed to develop this ability on user-oriented graphical systems.

It does exist to some extent in network systems, often because it was already there by building them on the modular Unix system.

This modular design arose in the small technology lab that incubated the Unix system four decades ago. It has never been modernised or succeeded by an encompassing new modular system after Unix left the research lab and was further developed by multiple companies and the open source community.

Graphical open source programs tend to mimic the commercial programs they are trying to replace, and have grown equally complex.

Above the basic, well designed Unix system layer, open source systems have fragmented into a kaleidoscope of competing and experimental graphical subsystems and application platforms. Their mantra is that choice and competition are good.

That all sounds well and good, but our problem with it is that none of these competing choices have even matched the quality of the integrated systems that we admire.

This lack of integration creates artificial borders between software and actually blocks proper competition between software functionality. We continuously end up with two annoyingly different programs that can remove red eyes and zero programs that can straighten horizons, and never the twain shall meet.

Something gives us hope, though. We cannot fix closed commercial systems, because we cannot modify them. Open source, however, thrives on alterations.

We design our own modular frameworks and modify existing open source software to plug into them as building blocks.

It is still a compromise, because we invite complexity by not building everything ourselves. But that would be too perfect, because it would take too long.

However it does mean that we are fighting a war on two fronts, if you will. Commercial interests, once established, resist standardisation and modularisation because they level the playing field with competitors.

In our experience, volunteer open source developers often really do the same thing, though out of 'Not Invented Here' syndrome instead of commercial considerations.

Join the newsletter!


Sign up to gain exclusive access to email subscriptions, event invitations, competitions, giveaways, and much more.

Membership is free, and your security and privacy remain protected. View our privacy policy before signing up.

Error: Please check your email address.

Tags open sourceoperating systemsoperating system

More about AmigaLinuxSDL

Show Comments