317 karma · joined January 11, 2022
Not sure what the figure should be (x10?, x20?, x50?, x100?). That way companies that want to pay higher saleries to their CEO would have to increase everyone's salary.
But there would need to be a way of stopping companies just using shells and subcontracting all the real work to low pay subsidiaries.
Ultimately we will either have to forgo technological advancement in order to keep the current model where work is the primary means of wealth distribution or move to a completely different system for that. If machines can do our work to let us do more interesting things for us I say great.
The difficulty is the transition period where replacing people by AI without compensation will be advantageous for the first movers but not yet enough to break the system to force us to a new model.
It dominates everywhere from fairly small embedded, to super computers, with the one notable exception of the desktop, a shrinking market and mostly a historical anomaly (Microsoft cornered it before Linux was a viable player in that space).
I wouldn't say it is a "mere tool in the hands of big corporations". Sure these days most Linux developers are paid by corporations (a good thingg since that allows them to work full time on Linux) but the important point is that those corporations don't control Linux. Sure they can pay people to work on specific areas but they don't get to decide what gets merged or what the acceptance criteria are.
More generally, beyond Linux, huge swathes of new technology are expected to be open source or no one looks at them (think language and frameworks).
In the late 90s / early 2000s it became obvious that software development would no longer be about writing things from scratch but building on existing components. But there were two competing models for this. There was Microsoft's vision which envisionned a market of binary components that people would buy and use to compose application (that gave rise to the likes of Active X, DCOM, OLE) and the Open Source community vision that saw us building on components supplied in source form. It's clear that today the second vision has won. Even proprietary software now uses huge quantites of open source internally (take a look at the "about" screen on your Smartphone, TV or router).
LLMs may be the exception here for the moment (mainly due to the compute power needed for training).
Similarly in the open source world corporate sponsership is very helpful in allowing people to dedicate large chunks of time to things by employing them to work on open source (because its hard to do good work quickly on evenings and weekends) but corporations are usually bad if they try to control the development. That's why projects like the Linux Kernel do so well because corporations pay for hundreds to a few thousand developers but don't get to stick their oar in on technical decisions.
The only real way to "fix" that is for the tool to already know a lot about the problem domain but that means the tool is limited in scope and things become a lot harder once you try to go outsinde the things it's designed to do.
Executable specifications face the same problem. Seems like a great idea in theory to get the client / stakeholders to write a specification in a form that can executed to show the system does what's wanted. But very difficult to get them to do it. They come up with all sorts of complaints about the tooling but the real problem is that they don't want to precisely specify what their requirements are including edge cases but be vague and handwavy...
But the problem today is that very few people, in tech not just the general public, understand the low level stuff, especially among new people entering the field.
Furthermore software abstractions tend to be far more leaky than abstractions in the physical world you mention. And when they leak you need someone who understands what's going on under the hood.
Actually I don't think this knowledge is most important for people forming their own businesses at all - they have many other problems to sort out. But I think it absolutely is valuable working for someone else. These people are the "goto guys" and, ultimately, a "technical insurance policy" for the companies they work for.
A company producing tech products without at least a few people on staff who can dig into and fix almost anything is in a difficult position ultimately.
The figures don't seem to work out for me there. If we assume 10k homes (so just one ten thousand) that's 1.6kW per home, which isn't much (in most countries a single socket can supply 3kW)
So I think traditional Linux distributions will remain, at least as development tools.
Of course it is true that many end users these days get by with just a phone or a tablet but this is a general thing and also results in less Windows users too.
They only free us from doing stuff like going to an ATM to get cash (which means getting in my car where I live). I can choose how to spend that time, maybe I want to spend it going for a relaxing walk around my village (which has no ATM).
Buying online doesn't have to make you consume more - it remains up to you how much you choose to consume.
A 100% cashless society is off topic. I'm not saying we should be 100% cashless but I would like to see electronic payments accepted everywhere (not necessarilly exclusively) - the author mentions Germany which is a real pain with some places only taking cash.
Before washing machines they didn't really have any choice but to wash their own clothes (except for a few very rich that had servants to do it).
The same is true of many things - a huge proportion of the population used to be involved in subsistence activities just to grow food, and raise animals for food. Of course we still have to eat but a far smaller proportion of the population is now required to do those things enabling society to persue other things (science, technology, arts, ...)
While there are certainly downsides to digital payments (or at least the current implementations of them) such as dependency on the banking system and surveillance there can be no doubt that electronic payments are more convenient.
The problem with cash is that there are two separate steps which need to performed in separate geographical locations: 1) Getting the cash (from an ATM or a bank) 2) Spending it
What people want to do is #2 but with cash they also have to spend time travelling to some place to do #1. You can optimise this by carrying large amounts of cash to reduce the frequency and time spent doing #1 but that has obvious downsides (like risk of theft)
Using electronic payments doesn't force anyone to "go faster" it just spares them from having to do "busy work".
When you bring up an embedded Linux device, be it based on an old or a brand new SoC the first thing to get running is the UART connection, first to the bootloader and then to the kernel.
Setting up a data connection over QMI / MBIM however is much easier and more efficient than messing around with AT + PPP
That is obviously unsustainable. I get that they need to make a profit but there's no fundemental reason numbers have to keep going up and at some point they won't be able to go up anymore, even if the business remains profitable.
For example CPUs that run Linux open reference manuals are still the norm in the industrial range (chips like the NXP i.MX series, the TI SAMA ones or the fairly new STM32MP1) whereas in the mobile market (Qualcomm, Exynos etc) you can't get any information without a NDA and they'll only sign one with you if you're going to be buying millions.
The first category also tend to have good mainline support, the second stuck on ancient vendor kernels.
In the context of electronics "pin" (as in on a component) translates to French as "broche" but it makes no sense for a pincode!
For example for GPU drivers Mesa has tons of common code (NIR, GLSL parser etc) that is shared by all drivers with just the hardware specific parts being per driver whereas closed source vendor drivers reinvent the wheel each time.
Similarly for kernel wifi drivers there is a single MAC802.11 stack shared by all drivers.
Vendor drivers have an initial head start since those writing them have access to internal documents describing the hardware interface and don't have to do reverse engineering. But, over time, OSS drivers can be better as improvements to common code help all drivers.
In fact I think the best way hardware vendors could help OSS is not to provide drivers but documentation.
Freedreno (for the Adreno family) Etnaviv (for the Vivante family) Panfrost / Bifrost (for Mali)
All these RE efforts built on each other, although the GPUs are different the tools built to do the RE were shared (and I think ashai is benefiting too).
AFAIK Google has now hired Rob Clark the Freedreno maintainer who started all this to work on Freedreno for Android / ChromeOS
Upstream Linux now has pretty good GPU support for all the major mobile GPUs these days. The hold out has been PowerVR but they are now working on an official (not reverse engineered) driver.
While I don't have Apple hardware so haven't been closely following Asahi I dont't think that is true. Linux has supported Arm for years (more like decades) now. They've been doing excellent work on support for Apple specific hardware sure, generic Arm not so much since it was mostly done.
I probably couldn't stand a boss who tried to tell me how to do my job though but I've never had the misfortune to be in that situation.
The only reason it seems simpler on PCs is because the ACPI tables are supplied by the hardware vendor so they're mostly invisible to the end user. But that only works because they're mass produced and the variability between different manufacturers is fairly limited. Microsoft and Intel specified what the system firmware must do and enforced it through certifcations. Most PC firmware is also only tested for the case of booting Windows and Linux often emulates bugs...
The same wouldn't work for embedded systems which need far more flexibility.
Yes some ARM systems these days use UEFI and ACPI but that is for server hardware which is basically a PC where the x86_64 processor has been replaced by ARM and it is desired to have it otherwise work the same.
For example many modem modules these days have fairly powerful ARM SoCs running Linux and they also have another smaller processor running a RTOS or bare metal that does the radio stack. The whole module could be integrated into a larger device itself running Linux too (such as a payment terminal).
The terminal owner will probably consider the entire terminal software as "firmware" (since it's in a device and pretty opaque to them and they likely can't update just some applications like on their PC).
The developpers working on the code in the terminal will probably call what they do software and consider the stuff that goes in the modem module to be "firware" (and probably not differentiated between the Linux based and RTOS based parts of the modem).
The developpers working on the Linux part of the modem will probably consider what they do to be software and the firmware to be the RTOS based stuff that runs on the baseband processor.
I have the opposite problem on Android auto.
When I connect my phone (by USB cable) and start Android auto for navigation it also wants to use my phone for music too. The problem is that my daughter doesn't like my music and I haven't found a way of using navigation from my phone together with music from hers...
I generally end up using the built in navigator rather than my phone (which isn't as good as Google maps) to let my daughter control the music over bluetooth.
That depends how widely you define SoC and what level of "binary" you mean. For example a Linux userspace binary compiled for arm-linux-eabihf will run on most 32 bit ARM systems out there today and there is another one for 64 bit aarch64. So yes, it's not a universal ARM binary but its a long long way from being SoC specificic.
Vendor specific toolchains on ARM are pretty uncommon in my experience (they used to be a thing on old 8 bit MCUs).
Sure the memory map and peripherals do differ between SoCs but, under Linux at any rate, that is only a problem for the kernel and you can actually build a kernel that will run on multiple SoCs as long as they have the same ISA (by building the different drivers as module and suppling the appropriate DT.)
I regularly run the same userspace root filesystem (and in fact the same kernel except for DT) on multiple ARM v7 SoCs.
The same thing applies to trying to get business people to write "executable specifications" that can be used, if not to generate the code, to at least validate that the final system does what it's supposed to.
They always complain that the "tools are too hard" but the real problem isn't the tools but that they are unable / unwilling to precisely specify what the system should do. They just want to hand wave vague phrases and have their system magically perfectly defined. It's just not going to happen.
The problem though is that in the financial world there are rules and often laws about how much debt is acceptable and a bank will generally refuse to let you get into dangerous levels of debt whereas there are no such rules concerning technical debt so a company can keep piling it on until it eventually causes a collapse.
Negatives are problems to be solved, if enough people care maybe they will be solved too. Whereas positives don't need solving (though can still be good to think about to avoid throwing out the baby with the bathwater when addressing a negative.
Of course not all negatives can be solved themselves. If it's "X was killed due to Y" then of course X is dead so nothing more can be done for X but maybe we can prevent issue Y killing someone else Z in the future.
You can provide your closed source part as a precompiled library or object file together with the source code for the LGPL part and build scripts that let the recipient relink it with a (possibly modified version of) the LGPL code to generate a new final binary.
A pain yes but not impossible. Having a screen or not is irrelevant, nothing says the recipient has to access the source on the same device as the binaries run.