Matisyahu's Blog

A few ideas have been rolling around in my head for quite some time so I thought I may as well put them out there – I could very much be wrong (most likely) but I’ll ‘put them to paper’ then see how embarrassed I am within a few years. A topic that I see regular come up in conversionsations is in regards to software quality, performance, memory usage and general efficiency is the lamenting over how ‘inefficient’ modern software is while waxing poetically about ‘the good old days’ (while ignoring back in the ‘good old days’ the same accusations of ‘inefficiency’ was levelled at the very software that people today consider efficient) how the software was more efficient. The whole discussion reminds me years ago learning about the different generations of programming languages and how with each generation the underlying technology is abstracted which enabled portability, removed the need to manually manage memory and a lot more in the name allowing the programmer to be more efficient with their time.

The benefit of abstracting the complexity away means that programmers can focus on functionality that end users want rather than spending large amounts of time dealing with issues that for the end user they’ll never see. It is no different than abstracting away version management to an intelligent piece of software that keeps track of source code, changes, associating changes with bug reports and who is assigned to take care of said functionality being added or bug being fixed. Abstracting complexity away and allowing the computer to take care of the details makes programmers more efficient – freeing up time so that they can focus on their work rather than having to spend that time on ‘house keeping’.

Apple for example created Objective-C 2.0 garbage collection but it was only available on macOS but that then was replaced with Automatic Reference Counting which was available on all platforms (for Swift and Objective-C) – all the benefits of abstraction without the overhead associated with it. Another good example of abstraction is Grand Central Dispatch to make concurrency easier (the functionality has been ported to other operating systems) – the rough equivalent of that would be Thread Pools on Windows. We moved from a situation of single cores and dual cores to now we’re in a world where on my laptop I’ve got 12 cores. Most applications were single threaded or limited in the number of threads being used because of the added complexity and at the time it make much sense because there was limited benefit given most were just running dual core or maybe quad core. The problem is that if you want to deliver more performance and responsiveness thus a better experience for your end users then it will require you to make greater use of threads to make use of extra cores. The solution? hand some of that complexity off to the system to take care of.

When it comes to AI and LLM it makes me wonder whether the direction over moving to Java and .NET with garbage collection, just in time compiling etc. is being overshadowed by new memory safe languages such as Rust and Swift along with in the future the use of AI and LLM for C/C++ code based being able to traverse large amounts of source code then establish relationships between parts of the code base to then pick up the sort of issues such as memory bugs that result in security vulnerabilities. I personally I don’t see ‘vibe coding’ replacing programmers but what I do is AI and LLM being used to make programmers more productive because they’re not having to spend their time doing ‘housing keeping’.

I bring this up because there is a big push by many within the technology space to make data centres a lot more efficient – yes, there is the environmental benefits but there is also benefits to the bottom line with less power being used and more profit being made. The benefits of abstraction means you don’t have to deal with a whole heap of things you’d have to hand code but that abstraction sometimes comes with an overhead cost – for the end user the difference isn’t probably that noticeable but if you’re running a large data centre that overhead can be measured. There was a great comparison a few years ago comparing Perl, Python, Java, .NET and a few other frameworks/languages when compared to modern languages like Swift and Rust – the differences were staggering and that was with the using the latest techniques such as Python with Just In Time compilation which certainly improves performance but there is still the matter of the overhead of using a JIT model.