A Mariner Story - Part II

The first thing to do in exploring Mariner is to actually run it. This is relatively easy to do given that the Mariner team offers an already built ISO image and also the possibility to build such an image from sources. I opted to use the pre-built ISO.

A Hyper-V runner

The next step is to boot the ISO image into a VM runner. Oracle VirtualBox is good enough on Ubuntu so I tried it but ... I had to reinstall:

• dkms
• virtualbox-dkms ...

... and then I had to add the new MOK key to allow the kernel load the VirtualBox-specific drivers securely.

Booting ... not

After these corrections one might think Mariner ISO will boot on VirtualBox just like that. Not really ...

In my case the boot loader was spinning continuously asking me to type F12 to select a boot drive and the only drive available was the HDD which, obviously, was not bootable at the time.

A detail no one talks about

The fix consisted in ticking the System | Enable EFI (special OSes only) option in the VM settings because Mariner is a special OS, perhaps.

Once that was done the installer loaded nicely from the ISO and I was able to install this version of Linux on the virtual HDD. Then shutdown, evict the ISO from the virtual optical drive and ...

... lo and behold, ladies and gentlemen, it takes just a few simple steps and only a couple of small annoyances to have a CBL-Mariner instance up and running!

In short, Linux rocks. So does Microsoft.

PeachOS - Part 2

In a previous post I wrote about my new foray into the fascinating world of operating systems.

The picture below shows that sometimes even a letter (A, in this case) is worth a thousand words.

A Mariner Story - Part I

 

The main focus of my current work at Microsoft has a lot to do with CBL-Mariner - the Microsoft Linux distro that is being used heavily within our cloud infrastructure and beyond.

More precisely, me and my immediate colleagues are involved into porting a part of our Telecom infrastructure to this platform. Without entering into details, it is an exceedingly rewarding effort that results in knowing some internals of this platform quite well - and fulfilling a business necessity into the same time.

The job is made easier by having direct access to the Mariner team itself along with a lot of internal documentation and help - one of the many delights derived from working for a business that produces widely-used core technology.

And yet, the question remains: what is it like using Mariner from outside? What can be learned from it? Well, this series of blogs (i.e. "A Mariner Story") will try to give some answers in this respect.

What?

I hereby initiate a series of blog articles recording my dwellings with this platform as an outsider. These articles will make use and refer to exclusively public sources and technologies. In fact, I write this introductory article on Ubuntu 20.04.3 LTS directly in the browser.

The Mariner version addressed will be whatever GA version is current (1.0 at the time of this writing). The whole material will be based on experiments carried out outside of my work duties. The scope will be to explore the platform for the sake of technological curiousity and without any particular business purpose in mind.

When?

Starting today. While I cannot promise a cadence, I'll try to publish often enough to maintain fluency.

How?

The whole experiments will be carried out on the latest Ubuntu LTS (20.04.03 at the time of this writing) and the platform will be tested via publicly available tools such as Oracle VirtualBox.

I already dedicated an Ubuntu box (recycling an old computer of mine) for the purpose and Windows will be considered only to demonstrate WSL or Container on Windows capabilities, if needed. In such case, Windows 10 Professional will be the platform of choice.

Who?

The target audience are people with a passion for Linux and who wish the learn more by building, configuring and tweaking a new but important Linux distribution.

Disclaimer

If not obvious from the paragraphs above, this effort is entirely personally motivated. It is not required or endorsed by Microsoft and the opinions expressed herein are my own and not of my employer.

Ready?

Yes.

OpenStack

 

Given that the holiday season is approaching, I am treating myself with another pursuit: OpenStack Certification, 2/e.

I undertake this new endeavour not because I wish to become an administrator but because OpenStack is an essential IaaS platform for virtualized Telecom.

One never gets bored with technology.

PeachOS

 

I started a new course on Udemy: Developing a multi-threaded kernel from scratch - authored by Daniel McCarthy, an instructor whose high-quality materials I used before.

The course brings the student to the stage of booting a toy kernel from USB on an x86 architecture via QEMU. The name of the toy kernel is PeachOS, hence this article.

The course covers several major topics:

• initial setup
• real-mode development
• protected-mode development - the largest part by a wide margin
• improvements related to FAT16
• briefing on assembly language for x86

It brings fond memories. In short: 138 brief but dense lectures and 28 hours of fun!

You can take the boy out of Microsoft ...

 

... but you can't take Microsoft out of the boy.

This is a phrase full of wisdom I've heard many years ago from a great man. So true.

Today is my second first day with Microsoft. I am joining the Azure for Operators group within the larger Azure Division led by another equally great man. I'll work and learn and work again from London and be part of the newly acquired Metaswitch team.

Yes, telecom. On the (public or private or hybrid) cloud. Hardware virtualization. Network protocols. Linux. More precisely, CBL-Mariner. Infrastructure software. Terribly exciting.

Flat-earthers: you are wrong. The world is round. You start from some point, you walk and walk and walk and walk and walk and walk and walk and walk until you arrive where you started from. Same place, but renewed. Both in geography and in life.

The phrase 'I've never ceased learning' takes new dimensions now. Awesome.

De blog is gesloten

 

I decided to close my blog on Finance. I haven't had much activity in there anyhow.

Why? Moreover, why deleting it permanently (which I did)?

When chapters are about to close, new ones start to open their inviting doors. A sense of nostalgia is inevitable but that is rightly balanced by the fragrance of the challenges afoot.

In short, nudge nudge, know whatahmean, say no more - the reasons will become aparent, soon.

Linux Kernel Development on Udemy

Just finished the Linux Kernel Development course on Udemy - delivered by a no-nonsense person who knows his craft.

Designed strictly as an introduction to the domain, this course gives just enough information to start making sense of the mysteries of Linux internals.

A little gem.

Azure as Platform for Service Providers: a talk

A not so new but very interesting talk on the potential of Azure to serve Service Providers.

Rust

 

I started learning Rust.

In fact, I should say I resumed learning Rust since since I commenced following "The Rust Programming Language" book (affectionately called 'The Book') a while ago.

This time, I follow a course on Udemy: The Rust Programming Language. I find that it offers the essentials while leaving it to me to go deeper into details when I need it. A very easy to follow course, I've already parsed 30% of it.

Java and Rust?

I work with Java, I love the ecosystem and I think it is a good place to get into and stay there. So, why Rust?

Well, besides the obvious that a software engineer should know more than one programming language, the benefit I wish to derive from this effort is to grow as a professional when it comes to concurrency.

Rust has this excellent feature called ownership. It is a simple yet brilliant scheme that addresses the problem of concurrent access and finding a disciplined way to do it.

Java solves the problem of concurrent access via mutexes, monitors and the like. Nonetheless, the burden of corectness is on the programmer: the compiler performs no check in this respect because the language itself is almost completely oblivious to concurrency (the well-known synchronized and volatile help but don't prevent).

Rust takes a different approach.

Instead of allowing multiple agents to modify concurrently and then introduce mechanisms for exclusion that the programmer must employ in the hope that they will get it right, Rust simply disallows multiple agents to modify the same piece of data into the same time.

How does it do it? By keeping track which agent owns that piece of data at any point in time and enforcing that only the owner may change it.

All great, but the brilliant part is not this. The brilliant part is that ownership can be inferred and tracked at compile time.

In other words, just as I can't mess up the field addresses in a type-safe language like Java or C#, I cannot mess up concurrent access in Rust - and both aspects are taken care of even before I run the program for the first time.

Still, Java and Rust?

Given that I will not use Rust professionally any time soon, what's in it for me as a technologist active in the JVM ecosystem?

Well, I believe that knowing Rust has the effect of a better awareness of concurrency and, arguably, of a better personal discipline when it comes to software where concurrency is unavoidable, the risk of error is non-neglijible and the cost of a mistake is high.

Whether the intent will deliver as envisioned, it is to be seen. Meanwhile I am having lots of fun with the language.

My Presentation at Ignite Summit 2021

 

My presentation at Ignite Summit 2021 has been uploaded on the Internet.

The video and the slides exist here.

I extend my warmest thanks to the organisers of such a great event!

If you missed the Summit, do yourself a favour and request the videos or subscribe for the recordings.

This is especially important to those interested in the architectural and technological aspects of this platform; some of the sessions are worth every second, many times over.

My presentation for Ignite Summit - approved

 

My presentation for the upcoming Ignite Summit got approved.

It is named "Business Transactions on Ignite, a real-world case" and it will handle how to build a solution that maintains the trasnactionality of business operations on top of Apache Ignite.

The full schedule of the event can be found here.

Apache Ignite - source code

 

After nearly a month I had the time this afternoon to fetch the source code of Apache Ignite. It is the next step after officially being accepted as a contributor.

I will spend a couple of weeks getting familiar with the code and then I will pick up one of the 'beginner' tickets. Even the longest journeys start with the first steps.

Meanwhile, I sent this past week my proposal for the upcoming Ignite Summit. It is about building business-driven functionality upon the rich computational model that Ignite offers.

Fingers crossed it will get accepted!

My Blog Redivivus

I resume posting on my blog after a long pause since I intend to become a contributor to Apache Ignite (and possibly other open-source projects).

Ignite is not only very important to the company I work for, but also of great interest to me (and the subject of in-memory computing in general).

I truly believe that, before we unleash quantum computing or other forms of computation, in-memory computing is the next and more achievable big thing.

Will come back with details soon.