At MWC Canonical was showing off something quite clever called Ubuntu Core, While there is not much groundbreaking here, this OS variant puts together existing bits in a very useful way.
Ubuntu Core started out more or less as the Ubuntu Phone OS with all the bells and whistles under the hood that make a mobile OS suitable to the task. The main change between Ubuntu the elder and Phone is not the UI, it is the packaging system. Phone uses containers rather than the traditional Linux methods of shared libraries, everything else is just fluff on top.
If you don’t know what containers are, they are the new hot topic that hasn’t really got the public eye like ‘cloud’ or ‘IoT’ has. This means it is both amazingly useful and buried so deep a user will never know what it is. Most OSes have shared libraries and files in common folders, so you don’t have 37 copies of the same library on your system. This saves disk space, memory, and theoretically speeds things up.
The downside however is what Windows victims refer to as DLL hell, essentially when you have multiple conflicting versions of said shared files with no resolution or worse. The way Windows manages things you can have multiple different files with the same name stepping on each other, programs removing critical bits of other programs, and lets not forget plain old corruption. Adult OSes tend to be much better at handling this kind of stupidity but still run into the odd ‘whoopsie’.
Since shared libraries came into being, disk space, memory, and CPU speed has increased by many orders of magnitude. What made sense for an 80MB HDD doesn’t have the same gravitas in a world of 6-8TB drives. Same for memory and CPU time, we are awash in it. Shared libraries still save space but 100MB or two isn’t exactly critical in a modern system.
That is where containers come in, they sit between a shared library OS and a VMM, they have one OS instance per device but the rest is all put in discrete packages although not technically separated from each other. The OS is still shared but everything a program installs is done as a single package and nothing is put in common directories. Programs can’t step on each other, period.
Most modern phone OSes do this in one form or other and it leads to remarkable stability and upgrade-ability, it is rare for a modern mobile OS to get corrupted from an installed program. Please note this is not to say they are all good, just that user program management is much better than modern ‘heavy’ OSes. Ubuntu phone being a modern mobile OS implemented containers to manage user space programs.
What this means is that when you load a program, it comes in a discrete package containing everything it needs to do the job. It does not rely on any files other than what the base OS it is targeted for has plus what the package brings to the party. When you remove it, nothing external gets touched, only the things that installed with it go out the door.
This is a major boon for upgrades more than anything else. If you want to install Foo V7.3, it doesn’t matter if you had Foo V7.2, V3.1, or Alpha.00031. The old version is wiped, the new version is put in, and any user data that is needed does not need to be touched. Then again it is up to the program to handle data from older versions of itself but the package itself will run just fine regardless of what was there before it, there is nothing to conflict with.
Containers can also guarantee an upgrade works, it will install and the hashes will line up or they won’t. If something goes bump in the night, wipe the directory and pull down a fresh copy. This is amazingly powerful and essentially underpins how modern mobile OSes can function in spite of user stupidity. Once again Ubuntu Phone is containerized and while I can’t say I have tried it, it is not a major technical trick and the underlying OS code is rock solid.
That brings us to Ubuntu Core, think of it as a subset of Ubuntu phone. If you take Phone and strip out the UI, what do you have? Something akin to Ubuntu Server when compared to Ubuntu Desktop, no or minimal GUI and a command line. It runs fast, clean, solid, and takes minimal resources. You might recall we just spent quite a bit of time saying that we are awash in said resources so why does less matter here, especially if you backpedal with containers?
These devices run Ubuntu Core
The answer to that is IoT and other embedded devices that may not be awash in memory, storage, or CPU space. Ubuntu is both x86 and ARM clean so you can in theory run it on some pretty meager devices and that is where Core comes into play.
One of the biggest headaches with IoT devices is managing them, if something screws up when you push an update to your sensor on the bottom of that bridge 50M above a roaring river, it is problematic to plug in a monitor and keyboard in to fix things. That said it is much easier than doing the same thing to your polar orbiting satellite when that goes amiss. You can see why containers make a lot of sense in this space, even going to that HVAC controller between floors 78 and 79 of your skyscraper is a job most would prefer to avoid.
That is where Core comes in, take Phone, strip the UI but retain all the remote manageability, upgrade-ability, and features that users want. In theory it should make the embedded and IoT space a lot saner to deal with by minimizing stupid conflicts that just shouldn’t happen. Updates may not be exactly atomic but they are pretty much guaranteed and pretty much idiot proof unlike fat Oses. In theory one app running on your embedded touch screen turnip slicing controller can not screw up another, period.
So that is what Canonical brought us with Ubuntu Core, a mobile ready, cross-platform, containerized package based OS for embedded and IoT. Nothing new technically, just taking proven tech and applying it to a space that has a crying need for such tools and support. Now you can just manage all your IoT devices remote and securely, plus you have the massive cross-architecture Ubuntu package library behind you. Core is a really good idea.S|A
Latest posts by Charlie Demerjian (see all)
- Intel looks at laptop power usage - Nov 23, 2020
- AMD slide confirms our delay story - Nov 19, 2020
- AMD stays trendy and delays Milan a bit - Nov 13, 2020
- Intel delays a mainstream server platform once again - Nov 12, 2020
- Intel releases Server GPU and significant software updates - Nov 11, 2020