Help! Buster has busted.

I got my new Rpi4 today. After some hours I got it all working nicely. Then I used the Openbox Configuration Manager for a few final tweaks and now I cannot move or close filer windows, which leaves the GUI unusable. I suspect that Buster has not yet been fully debugged. I cannot access the Raspberry Pi forums just with NetSurf, so I put this cry for help here.

Is it only filer windows?
Did they work before the final tweaks?
Can you revert what was changed?
Start again and do it incrementally?

I’m guessing it’s some sort of Linux?

A brief Google shows somebody else has stuck windows, seems that they changed the widget theme in lxappearance and it then all went wrong. Sadly it was a bug report thread, not a solution/fixit thread…

I got back on the road by reinstalling Buster. The Rpi4 is distinctly faster than the Rpi3. The more I see of Linux the more I appreciate the simplicities of RISC OS. It may not succeed, but at least RISC OS tries to package applications into single directories that can be moved around, deleted and so on, as a single object. You install a package in Linux and there is stuff scattered all over the filing system. I have just moved from one version of Raspbian (Stretch) to another (Buster). There was software that I had working in Stretch that I would have liked to have also in Buster. Had it been RISC OS I could have saved the application to a memory stick, installed the new OS, and then loaded the application back from the stick – well, sometimes it still works. But I am not sufficiently savvy to know how this sort of thing can be achieved in Linux, apart from re-installing the package from the repository.

The more I see of Linux the more I appreciate the simplicities of RISC OS.

Good summary.

but at least RISC OS tries to package applications into single directories that can be moved around, deleted and so on, as a single object.

Some will try to convince you you’re wrong. Technically they’re right. But at the end of the road, they are simply and fully wrong (see dependency hell).

Haven’t used a properly packaged linux distro in a while, have you?

I do, everyday. But nothing really solved the dependency hell.

Under Windows, for each application, the system keeps a copy of all DLL used in a hidden directory. The system will load the DLL x time, but will suppress unneeded instances later. It’s not like static linking, but it’s not really a success either.

In the Open Source world, it’s better, but not perfect. The last time (years ago) I used Ubuntu for desktop, I needed to opt for XFCE, to compile my own LibreOffice (crashes with the one provided), my own Wine (really too old in repositories) and my own Firefox. The three of them with an almost complet set of dedicated DDL. Summary: most of the DLL installed were used by only 1 application.

The same can be said for what is inside the DLL. Most of the time they are way too complex for the real needs. Many times, I compiled software that was smaller and use less memory in static form under an embedded Linux OS than when they use DLL on a more traditional system. I can understand the technical objections. But from a user point of view, it’s the same software and the same service. So there is absolutely no good reason that can explain this.

Today, for me, Linux is only for servers. The CentOS offer (OS and repositories) is really adapted to business servers: everything in repositories is quite modern and compiled against the same set of DLL. Efficiency.

And of course, behind all of this, there is the idea of liberty.

One day, the OS was a toolbox. A toolbox to help you to use hardware and make software. You could use it… or not. Today, the OS is a framework & conductor. You must use it and you must follow its rules. A very important paradigm shift. Unknown too.

Last example: DOS VS Windows: “In many ways I think low level programming was more practical in DOS since the OS never got in our way and was a natural launching board into system programming. Modern windows is a major road block for system-level programming enthusiasts, end users are locked out of their own machines.”

https://www.osnews.com/story/130323/petes-qbasic-site/#comments

Of course, I know the design of modern OSes is better. But I know too we did sacrifice liberty for security and stability. Anyway, I’m lucky to know and use RISC OS.

Having self compiled instances of LibreOffice, Wine and Firefox bring along their own sets of shared objects (SO – DLL is Windows) can be considered wasteful, yes, but that is not what is generally known as dependency hell. They don’t conflict with items with the same name on your system.
As an aside, I’m not sure I would consider Red Hat derivatives ‘properly packaged distros’, but I can’t make a definite claim about that, just hearsay…

And of course, behind all of this, there is the idea of liberty.

+1. The difficulty is that, among other things, an OS is a database (remember Pick?) that can be structured in all manner of ways: e.g. do you have a directory /usr/share/icons for holding the graphical representations of objects (Linux), or do you leave it up to the objects themselves to have them as components (RISC OS)? Most human endeavours evolve slowly, and require shared conventions, so that most OSs are held back by poor choices made decades ago, and by a lack, not of documentation, but of explanations of the original choices.

I must also say that I find Linux hugely impressive. Lots of things work well. But (and now we get back to liberty) each distribution adopts its own ways of doing things. The word distribution can vary in meaning from a botch-up by an enthusiastic tinkerer to the impressive edifices on which many businesses depend for their livelihoods.

I think OSs need to make it clearer for their users which parts belong to whom. Often readonly system resources can be overridden by user-configurable ones (think of !StrongED and !StrED_cfg) but the naming conventions vary from distribution to distribution. I like the way that so much of Linux can be configured just with a text-editor.

the system keeps a copy of all DLL used in a hidden directory.

C:\Windows\System32 is hidden?

Actually, it keeps installed DLLs within Windows, using an extremely braindead method of counting installs vs uninstalls (braindead because a number of installers skip installing the DLL if it is already installed, thus throwing the counters off) where the best response is to ignore the prompt and just leave the DLL in place (even if it isn’t used, you’d need to audit every program to know that, so it’s better to just leave well alone).

You can also hold DLLs within your own directory that will be used in preference to the OS ones; this is useful if the DLL is something specific to your app (like PtrIIC in my WinTTX, or CRC32 for my Psion paint program (writing 32 bit CRC code in a language (VB) that doesn’t understand how to binary shift was unthinkable, it was painful enough unpacking the bitmaps using integer multiply and divide!)), but the plan falls apart even more the moment somebody puts a system DLL in their own directory, and especially if it’s older than the system one!

There isn’t really a viable solution to having potentially multiple system libraries where apps can use the one they prefer yet the system doesn’t get full of multiple different versions of the same thing.
I rather like the RISC OS way of enforcing backwards compatibility due to only being able to install one copy of any given library, so breaking changes would be a bit of a dead end. It isn’t perfect, but it’s arguably better than having muliple different libraries; or worse – needing to have multiple different libraries.

Some will try to convince you you’re wrong. Technically they’re right.

Any application that cannot have its install directory moved from, say, $.Apps to $.Public is, quite simply, broken.
We may make small concessions for some forms of DRM (which ought to be less important these days) but if an app cannot be moved around within the system, it’s basically taking a metaphorical dump on everything that makes RISC OS what it is.

Things may not be so simple moving from one machine to another, as an application is entitled to have system-useful resources within BootResources, and its configuration within Choices. That doesn’t mean it’s a free-for-all, stuff should be put in BootResources if it is available to be a system resource. So a module I write to aid a program (MoreKeys) doesn’t really qualify, but ZapRedraw (and its fonts) does.

The app is still movable, you just need to know about “the other stuff”.

The three of them with an almost complet set of dedicated DDL.

This might be because the way that Unixen load their libraries – by name and version. I remember my PVR had multiple instances of one of its libraries (actually two, the rest were symlinks) because different things linked to different versions. Because clearly backwards compatibility is an unknown instance.
It happens on Windows too. How many .Net frameworks do you currently have installed?

You must use it and you must follow its rules. A very important paradigm shift.

Indeed, but needs of users have changed. Back in the early days of RISC OS, it was quite common for games to reconfigure the machine (*Unplug Econet!) and force a reboot in order to come back with the greatest amount of memory. I’m quite sure Jon Abbott could tell you horror stories of the weird shortcuts old games took to make everything just a little bit faster.
In the 8 bit days, it was normal to hijack the entire operating system and take over the machine. To that end, the BBC Micro is an anomaly in having a rich featureful operating system. Many of the 8 bit computers were little more than the barest minimum to offer a rubbish incarnation of BASIC and whatever was necessary to get stuff loaded from tape/floppy.

These days, people expect full multitasking, applications to play well with others, and a very rich set of services. I wrote a simple program (under Windows) to connect to my IPcam and display a series of still frames. I used a DLL to do the HTTP fetches. I created a ‘picture’ box that I assign the fetched JPEG (as a big string) to. I don’t care how it works, I just want to get data from this URL and have it appear in this box as an image. Because one just expects this sort of thing from a modern system. Indeed, RISC OS is far behind the curve here. FFS, for Manga I had to write my own fetcher and redraw code! ;-)

The same can be said for what is inside the DLL. Most of the time they are way too complex for the real needs.

I think the hundred-odd megabytes of shared libraries that get loaded with Otter to be utter bull**it. There’s no possible way the so much code is necessary.

Translation: In my use case using this specific piece of software, I cannot conceive of needing so much code. However, that doesn’t mean that such (different) code mightn’t be useful for something else in the future.

I suppose you could level this criticism at RISC OS too. When’s the last time you used the System Sprite Area? Or FilterManager? Or PipeFS? That one person may not doesn’t mean that nobody else does.

I think low level programming was more practical in DOS since the OS never got in our way and was a natural launching board into system programming

Logical fallacy.

On an older PC, or maybe a newer one with UEFI disabled, one can boot DOS (isn’t there a clone called FreeDOS?) and they can bare-metal to their heart’s content. One might suggest looking at Minix (big, but a well written book explains it all) or something like https://sourceforge.net/projects/michalos if you want to learn about OS design and do all that fun low level stuff.
Complaining about not being able to do bare metal programming on a security sensitive modern 64 bit OS is a bit like complaining that you aren’t able to do your daily commute to work in a Learjet. It’s just a dumb argument.

To give another example, I turned my ESP32 device into a webradio. I’m listening to Eagle ‘80s as I write this. ;-) I told it to fetch data from this URL, throw it to this bit of hardware, and periodically write some messages to an IIC LCD. The best bit? I barely had to do any coding at all. The web fetch was a default library. The MP3 codec and IIC LCD were both downloadable libraries. The WiFi stuff is handled by the firmware built into the ESP32. All I needed to do really was to join the dots (it’s just a shame that building a ~10K sketch takes longer than building the entirety of RISC OS from scratch, it’s somewhat offputting).
If I wanted RISC OS to do that? Well, DigitalCD doesn’t stream on the Pi2, it stiffs the machine (no idea why) so rolling my own would be… somewhat more involved. And we’ll gloss over the use of the Vonets widget because we don’t even have a WiFi driver as yet… ;-)

Seriously, though. Back in the day when my hair was coloured, operating systems were mostly a set of services designed to get the machine running in a known state with operational, if rudimentary, access to the attached devices (the rubbish BIOS serial driver, and all that crap for memory over the 640K limit). These days, operating systems are expected to do a lot more. Consider the idea of “get this file from this website”. Should every application write their own fetcher? Hell no. There should be a system resource that you can call that will just toddle off and do that, notify you of how the activity is going, and provide you with the data.

RISC OS is almost there with AcornSSL, AcornHTTP, and URL. It’s not perfect (doesn’t handle redirections, for example) but it’s a great start. My Manga now uses it when using AcornSSL. It’s like 30 lines of code versus the 300 that a custom fetcher runs to. This is what I would expect – some resource that “just gets on with the job”. So I’m really happy to see AcornSSL, AcornHTTP, and URL. It makes life much simpler. I ought to write a blog article about it.

But I know too we did sacrifice liberty for security and stability.

We’re doing that In Real Life too. Of course, it’s mostly a bad pantomime orchestrated by government actors who are potentially more concerning than these bad guys we’re supposed to be afraid of, but nobody ever said it was an ideal situation. There’s not really an answer – freedom and security are incompatible concepts, because there’s always some dumbass that might think it acceptable to set fire to a building with people inside, use a vehicle as a weapon, enter school with a bunch of semi-automatics, or fly a plane into a skyscraper. It doesn’t happen often, but that’s not much comfort to the families of the dead…

so that most OSs are held back by poor choices made decades ago

That pretty much sums up my thoughts on Linux (and all the other Unix clones).

Lots of things work well.

Yes, there are many things on Linux that are good and pretty solid. Unfortunately, the bazaar model means that there are about as many things that are half-finished bug ridden rubbish. It’s probably not helped that the technical definition of Linux is actually the kernel. All the rest, the distribution. My God, how many are there now? How does one even know which to pick?

I think OSs need to make it clearer for their users which parts belong to whom.

Not the responsibility of the OS. An application ought to cover dependencies and such in the documentation.
Of course, the fact that huge swathes of software is released with no documentation is… not helpful.

I like the way that so much of Linux can be configured just with a text-editor.

It’s 2019. Why no pointy-clicky? RISC OS has had a pointy-clicky Configure for ages.

The problem with script/text files is that the choices may not be immediately apparent. How many of you have bookmarked that site that explains the things that can be put into the Pi’s CONFIG.TXT file?

We may make small concessions for some forms of DRM (which ought to be less important these days)

I think the Microsoft e-books story shows exactly why the whole DRM setup is a “thoroughly awful idea”¹
Everyone should bear in mind that while the vendor of a product retains the right to turn off the use of something you paid for to allegedly use for your lifetime any scheme is bad, bad, bad.

How many .Net frameworks do you currently have installed?

People complain about multiple DLL’s taking up space? Take a look at .Net – the damn thing is bigger than RISC OS and its complete HardDisc included apps.

In my use case using this specific piece of software, I cannot conceive of needing so much code. However, that doesn’t mean that such (different) code mightn’t be useful for something else in the future.

That’s what happens when you load a shared library capable of doing everything short of AI² for one simple application

RISC OS has had a pointy-clicky Configure for ages

Even with massive developer resource (although fragmented and pulling different directions) Linux has to do catch up. First Linux kernel 1991 (that’s RISC OS3 A5000 time)

¹ Being polite

Why no pointy-clicky?

Most of it is. The average user who installs e.g. Debian doesn’t have to bother with textfiles. The not so average user however can, if he wants to.

I think the Microsoft e-books story

I was meaning in the context of RISC OS. It may be that the “power” applications have some form of locking themselves to a specific machine that may include recording where it is installed.
(wasn’t there one that encoded information into the datestamp of one of the system resource directories? that’s a bit naughty… Impression-without-a-hardware-dongle? ;-) )

while the vendor of a product retains the right to turn off the use of something you paid for to allegedly use for your lifetime any scheme is bad, bad, bad.

Amazon did that too. The Tc&Cs are pretty clear, you pay for a licence to access the content, but you do not own the content. Pretty clever defining e-books as computerised data and applying all that licence guff.
Of course, the flip side of the coin is that, being “mere data”, it’s not that hard to turn a Kindle book into an epub…

That’s what happens when you load a shared library capable of doing everything

Otter needs to load a hundred megs of stuff because the libraries aren’t that modular. The QT5 widgets take 9MiB, so if you need one widget, it’s going to have to load ‘em all. With function names that appear to be stuff like “_ZN20QGraphicsProxyWidget15mousePressEventEP24QGraphicsSceneMouseEvent”, I’m not sure where to start!

Of course, it may be that on other systems, these libraries can be loaded into memory that is lazy-loaded and/or swapped, so code is only ever actually present in memory when it is being executed. With that in mind, there’s not going to be any impetous to break large libraries into smaller pieces.

Linux has to do catch up.

Or just start a holy war over systemd and write Yet Another Window Manager. ;-)

It’s 2019. Why no pointy-clicky?

It’s 2019, and there has been pointy-clicky for the commonest parts of the configuration for years and years. (For other things, yes, there are text files; equivalent to what you’ve got to use regedit for.)

Be careful, or you’ll end up sounding like Lying Boris talking about the EU. A recent example, at time of writing, is his claims of what the EU says about transporting kippers. He was, of course, lying.

(I’m not accusing you of lying, but you are perpetuating an untruth.)

but you are perpetuating an untruth

I was actually responding to the comment that (quote) so much of Linux can be configured just with a text-editor (unquote) and wondering if there was a friendlier method. Is a question an untruth now? I asked, two people responded that it can be done the UI way for the common stuff – and you make the good point about RegEdit.

The difference between Boris and myself in this respect is that I don’t claim to know what I’m talking about (hence the question!), Boris…. Does. Though I can only imagine it’s people with the intellect of a Daily Express reader that still believes a word he says.

his claims of what the EU says about transporting kippers

Well, I do understand they’d like to get rid of Farage…

He was, of course, lying.

That should be the default assumption for anything he says. It’s just a shame that the country is in such a catastrophic mess that the man who would be Prime Minister is able to lie, have the courts find in favour of his lying (“people could choose to ignore it”) and still blatantly lies and nobody seems that bothered any more.
I have a suspicion that with Boris in charge, Brexit might become a mere sidenote in the downfall and dissolution of a once proud empire.

The Tc&Cs are pretty clear, you pay for a licence to access the content, but you do not own the content.

Well, there were these things they put in software packages that set out terms and conditions that were quite clear – ruled illegal by the EU courts (among others)

In e-publishing I quite agree that the originator of the work has a right to any payment they request as reward for the work.
However, selling either right to possess or use in perpetuity to an end-user and then redefining the period or terminating it is fraud – which is why MS offered the refund to dodge the legals. It does however highlight the fact that with these DRM schemes you spend money on a set of books, for example, but the vendor seems to have the right to step into your home and burn the books when they want.

I have a suspicion that with Boris in charge,

You can’t help wondering whether someone would decide that the American¹ model for disagreeing with a leader(Lincoln, Garfield, McKinley, Kennedy) ought to be used rather than the standard British grumble into a mug of tea. Mind you, with Boris a head shot would probably miss any working grey cells…

¹ We had a one-off (Perceval 1812)

the right to step into your home and burn the books when they want.

Oh, I don’t disagree. For any ebooks I buy that are interesting to me (and not cosies that I get for mom from time to time) are rapidly converted to a non DRM format. It’s really simple: they supply, I pay. If they throw in all sorts of conditions…

the American model for disagreeing with a leader

I don’t recall whether it was here or on ElReg, but I pointed out that a bullet in the head of an annoying leader will not change anything. There’s always another ass waiting in the wings. We thought May was going to be awful? (she was) Well we’re about to see how fast the spiral to the bottom happens.

The problem isn’t the lying cheating racist misogynistic idiot, it’s the people who voted for that to be their representation.

but that is not what is generally known as dependency hell.

True. But it’s really a lot of complexity… for nothing.

C:\Windows\System32 is hidden?

No it’s not here. XP is not affected.
On Vista+ it’s somewhere in WinSxS. 1/3 of the size of the whole Windows Directory.
More than 7 GB of crap here. Several versions of the same DLL. One for each application.

Indeed, but needs of users have changed.

Not sure. I mean, it’s not sure these changes were needed because of new expectations.

security sensitive modern 64 bit OS i

You can have a secure modern OS without putting barriers at the OS level. For example with managed code.

IMHO it’s really better than to put many restrictions in the Linux kernel, while permitting user mode code to be able to generate code. It’s like a set of doors, with the keys potentially left under the carpet.

Bare metal use is possible today via drivers. The problem is that there are way too complex to use. I could say the same under RISC OS. Where is the easy C template to make a FS? Is there some examples to use multicore? (it exists, but it’s not so easy to understand :) ).

These days, operating systems are expected to do a lot more.

That’s not a valid reason to do a lot less… or to be more complex to use.
Everything should be simpler. If it’s harder, it’s bad designed.

I know that we consider today that children should learn programming with high level object oriented languages. But it’s a mistake. We need simple things to learn. And later, simple things to go faster. Almost nobody will learn how to drive with an helicopter. A bike is really better. Even if it’s not the best solution.

Why the success of Python, PHP, HTTPLib? Simplicity.

Where is the easy C template to make a FS?

Writing an FS isn’t easy.
Doing it in C is harder still as much of RISC OS expects an assembler-centric API.

However… X-Files is open source and written in C (with veneers), and now one can also look at DOSFS.
But as I said, writing an FS isn’t easy.

Is there some examples to use multicore?

It exists, but it’s a very early incarnation. It’s like looking at storyboards and wondering why it isn’t a finished film… ;-)

You can have a secure modern OS without putting barriers at the OS level.

The barriers are there because of security. The moment that you allow one single thing unfettered access to the low level workings of the machine is the moment you’ve just thrown away any pretence of security that the OS may claim to offer.

Bare metal use is possible today via drivers.

Indeed, but there’s a rigid protocol and a lot of hoops to jump through in order to have a driver do its thing without screwing up the rest of the system. That doesn’t mean it can’t happen – certain Prolific drivers are notoriously buggy and some devices clash in a way that usually stiffs or blue screens the machine. This is what happens when the security fails; and since I’m talking about XP it may be that later versions of Windows have stricter enforcement. Certainly, my Android phone has been running for ages without a reboot because the OS takes care to not let some errant thing bring down the OS.
As opposed to, say, that cascading error that can sometimes happen with RISC OS where everything “just dies” app by app.

or to be more complex to use.

It is a very good reason.

Once upon a time a microwave oven had a single control. It was a timer. You turn it, it counts, then goes ping.
Then as they got more advanced there were two controls. A timer that goes ping and a power setting. Actually the magnetron inside is fixed power, so it fakes lower power by turning it on a bit, then off a bit.
Then we got what was basically the above, but with a digital timer and some more advanced controls for how and when the magnetron was running.
Then since a microcontroller was involved, it was only a short hop to programmable microwaves where you could say 100% for two minutes and then 40% for a further six.
Some models have steam detection so can make that “100% until it boils, then 40% for six minutes”.
Obviously the latter case is going to be more complicated to use than turning a single knob like in the early microwaves. That’s because it can do more.

It’s the same with operating systems. The BBC MOS didn’t understand the concept of “fetching data from a remote machine” (I don’t count Econet, that’s simply a networking protocol), nor did it even understand the concept of sprites (let alone JPEG), you needed add ons to play MIDI and the OS wouldn’t play MIDI via the internal sound system. It couldn’t record audio. There was no WindowManager or, indeed, any form of UI built in.
Now many many more things are “expected as standard”.

Old operating systems could fit in a 16K ROM. Modern ones take megabytes for the basic core, and potentially gigabytes for a full install.

Because app authors don’t want to have to decode image data, or write web fetchers, or implement their own drop down list widget. That’s all the responsibility of the modern OS. Fetch this, display this, list these… That’s what a modern system is expected to do. As Steve said in the other thread, imagine software development if RISC OS had something like .Net.

I know that we consider today that children should learn programming with high level object oriented languages. But it’s a mistake. We need simple things to learn.

That’s exactly why they’re using a high level language. It’s much simpler to create a “program” by dragging visual representations of code blocks around than by staring at the BASIC prompt.

   Do 100 Times:
     Turn Red LED On
     Wait 1 second
     Turn Red LED Off
     Wait 1 Second
   Loop
   Done

Something like that has immediate effect and abstracts the child from all the low level crap that gets in the way.

You know, in my day, the LED control would mean poking data into the VIA’s internal registers to set specific pins as output, then more poking to set as output on or off. And that would be obscure lines of code like &FE24=(1<<6) (don’t check, I just made it up) rather than something clear like Turn Red LED On.

I believe that children should be taught on the simplest system that allows them to understand the concepts without language peculiarities getting in the way. Children generally want to see immediate results – that’s why most of us wrote 10 PRINT "something here" : GOTO 10 as our first program. Maybe twenty keypresses, instant gratification. Because as a 10 year old in the mid eighties, seeing your name scrolling around a MODE 7 screen was just joyous.
My daughter, if I had one, would probably begin on scratch.

Then, once she understood the concepts, I might introduce her to BASIC on a BBC Micro because I also believe that in order to be a good programmer, one must have some semblance of understanding of what goes on inside the machine. To know why writing a simple file filter (to, say, strip HTML down to plain text) will work if every single variable is declared as floating point, but why doing so is wrong even though it works.

Think about it – if you have a little falling blocks game, it’s easy enough to write but for screen coordinates (knowing it’s a MODE 28 style screen) you don’t need to declare the values as a 64 bit long long!

But all this talk about variable types and bits and stuff is useless without the idea of the core principles, and the mental mindset of being able to understand a problem well enough to devise a set of steps necessary to resolve the problem. Those always come first, and I suspect the problem with BASIC in the 80s (and why it is much maligned) is because it so often encouraged kids to sit and bash out appalling code that worked in preference to thinking properly about how to resolve a problem and writing better code afterwards. Yes, I’m as guilty as everybody else. Because scribbling notes on paper is boring. It’s much more fun to just “write code”, even if it has to be written three times as the scope of the issue makes itself clear along the way.

Almost nobody will learn how to drive with an helicopter. A bike is really better. Even if it’s not the best solution.

They aren’t really even related skill sets. You do not need to know how to ride a bike in order to pilot a helicopter. About the only similarly is that both have parts that turn.

Given that a helicopter is a three dimensional craft, the Cyclic (that’s the stick between the legs) controls the general movement of the craft by controlling the main rotor. It’s called that because it controls the pitch of the rotor blades independently of the rotor position, that is to say that each rotor will be at a required angle at a given part of its rotation. As the rotor turns, it’s angle will change. The effect of this is to control the direction in which the helicopter moves. The other rotor control is beside the pilot and looks like a handbrake. It is called the Collective because it controls the pitch/angle of all of the rotors together. The effect of this is to vary the amount of lift generated by the rotors to control the up and down movement. So a typical take off would be to pull up the Collective (more pitch, go up) and once up a bit to push forward on the Cyclic (adjust the pitch at certain points to cause the craft to move forwards).
There is also a Throttle, but unlike a car a helicopter is designed to run at a fairly steady engine speed and blade rotation. Flight speed is controlled by how much Cyclic is applied, and height is controlled by how much Collective is applied, not by making the engine go faster.
And finally there are two pedals for the rudder. This works by adjusting the speed of the tail rotor. The tail rotor counteracts the gyro effect of the main rotor in a carefully balanced system. By increasing or decreasing the speed of the tail rotor you can turn the body of the helicopter to the left or right.
And yes, a tail rotor failure means that the system will try to balance itself by having the main rotors and craft body spinning in opposition. When the rotors are what’s keeping you up, consider it a “uncontrolled fall out of the sky” event – https://www.youtube.com/watch?v=hnK9bGCvYtU

As you can see, little in common with a car, never mind a bicycle.

Why the success of Python, PHP, HTTPLib? Simplicity.

Python is popular because it isn’t hard to learn the basics and you can do a lot without too much code or weird syntax rules – which is why people use Python in preference to Lua, Perl, etc. It’s like BASIC for the modern world.

PHP? Simple? Hahaha! PHP is popular because it was pretty much the first actual programming language that ran on the server itself and offered so much more than Server Side Includes could ever hope to do. The language itself is a mess of dodgy evolution, contradictions, and a horrifically broken type system. But, just as Internet Explorer was “the internet” for loads of people, so PHP is “how to program on a server” for loads of people (myself included).
It’s worth pointing out that ROOL uses a different technology, as indicated at the bottom right of the page.
HTTPLib I’m ignoring, it’s a Python library as far as Google tells me.

Some will try to convince you you’re wrong. Technically they’re right. But at the end of the road, they are simply and fully wrong

May be wrong. Are technically right in general. May be wrong in some cases.

Simple apps tend to be monolithic. And that’s how RISC OS began. When RO3 appeared and apps needed the new modules, they could be included within the application directory.

However, further module releases occurred, which resulted in RISC OS’s version of dependency hell – run !A then !B and they both work fine, but run !B and then !A and something goes wrong (because A and B both included different versions of SomeModule).

Therefore developers were instructed by Acorn to install the latest version of a module into a shared location. This was almost always done by an installer, and not by the application itself. So if you move that application, you don’t take its dependencies with it.

What should have happened is that apps included whichever version they needed, and then if the RMEnsure caused that module to be loaded from the application it would also be cached in the shared location. Apps could therefore be moved, taking their dependencies with them.

Oh well, never mind.

What should have happened

There’s quite a lot of that in the RISC OS world. ;-)

RISC OS tends to err on the side of doing nothing rather than overdoing something. So clever little automatic things….just don’t exist.

It’s almost as if there wasn’t a great plan and it all sort of happened as needs arose. <sacrilege>

However, further module releases occurred, which resulted in RISC OS’s version of dependency hell – run !A then !B and they both work fine, but run !B and then !A and something goes wrong (because A and B both included different versions of SomeModule).

That’s one aspect of what I was referring to, elsewhere.

Therefore developers were instructed by Acorn to install the latest version of a module into a shared location. This was almost always done by an installer, and not by the application itself. So if you move that application, you don’t take its dependencies with it.

Which is of course the latest at the time the package was made and unless the installer has been written carefully it copies a probably older version over the users spangly new one.

What should have happened is that apps included whichever version they needed, and then if the RMEnsure caused that module to be loaded from the application it would also be cached in the shared location.

Which sidesteps the scenario I just mentioned. It’s almost like you know what needs to be done :)

Apps could therefore be moved, taking their dependencies with them.

Which would only be needed if the system didn’t have a copy already in the shared location (loop)
Yes, sensible.
How much does RMEnsure need tweaking to make it do the transfer? (possibly conditional on an additional parameter being given(only updated/checked apps would do it)

While on such things, !boot files – why do so many set variables, load modules etc? Surely that stuff only needs to be done when you run the app not when you glanced in its direction.

and it all sort of happened as needs arose

Could you possibly be referring to the unholy combination of expected Wimp version number and a &4B534154 magic number to initialise Wimp tasks…instead of, say, a flags word or something halfway logical?
Or recycling the &4B534154 magic number as a way of indicating to Wimp_OpenWindow that it is an enhanced “nested” open request…
The inherent brokeness of Wimp_AddMessages?
Why is BaseOfSprites not a ReadSysInfo entry?
Oh look, that magic word turns up in Wimp_DragBox too, because the API never thought to define a flags word in the first place so it got patched in as an afterthought (as in 3.80 or later).

;-)

How much does RMEnsure need tweaking to make it do the transfer?

RMEnsure, in the “MoreCommands” part of the kernel, IIRC, does very little. It compares the module version number with the version specified, and executes the command (via OS_CLI) if the version is incorrect.

Ideally, it would raise a ServiceCall or something passing the command line given in order that something else deal with all the rubbish that could be present in the RMEnsure command.

Some examples:

RMEnsure WindowManager  2.00 Error Hearsay needs a newer Window Manager
RMEnsure UtilityModule 3.70 RMEnsure CallASWI 0.02 RMLoad System:Modules.CallASWI
RMEnsure UtilityModule 3.70 RMEnsure CallASWI 0.02 Error This application requires [etc]

This is all one chunk:

Unset NetSurf$Start_URI_Handler
RMEnsure AcornURI 0.12 Set NetSurf$Start_URI_Handler 1
RMEnsure AcornURI 0.12 NetSurfRMLoad System:Modules.Network.URI
RMEnsure AcornURI 0.12 Error NetSurf requires AcornURI 0.12 or later. [etc]
RMEnsure AcornURI 0.12 Unset NetSurf$Start_URI_Handler

RMEnsure AcornSSL 1.04

The last example is interesting. It’s my Manga SSL loader. It simply calls RMEnsure with no command and checks to see if it threw an error (module invalid/too old) and if it did, it looks for the module and RMLoads it. It doesn’t use RMEnsure normally as we need to know if the check failed or succeeded.

Sorting out all of that, plus checking that the module attempting to be loaded is the same as the one referred to (you can’t just look for the RMLoad bit, look at the 2nd and 3rd lines!), plus verifying it is 32 bit compliant (just in case!)… all of that is possibly best left to a third party extension. But it will need a tweak in the RMEnsure code in order to call out to the helper.