What the World Needs Now is Fewer Beige Box Idiots

Keep your hands off the drivers.
 - Ken Thompson
Keep your hands off my operating system, motherfucker.
 - Steve Jobs

It's not enough that Unsanity are 'unsane'. It's not enough the egregious Landon Fuller supports unsupported (and dangerous) bug fixes for OS X - and that idiots use them. No: it's much worse. Read on.

Mucking about with the innards of an operating system is a Bad Idea™. It's a Very Bad Idea™. And any software or system engineer would instinctively know better. And the father of Unix made sure everybody got the message - even the terminally clueless.

But the world of OS X is plagued not by wayward professional engineers but by Beige Box Idiots©.

These are not engineers with backgrounds in mainframe environments or with merits in security and networking. They're idiots with backgrounds only in the Beige Box® who came to OS X straight from 'MacOS' and said 'why can't we do all that cool and groovy stuff anymore' - and they foist their ideas and products on an unsuspecting user base who do not grasp what's going on and can't be expected to either.

Only OS X suffers from this disease - and directly because there are so many Beige Box Idiots© with their hands on compilers, AppleScript Studio - and the drivers and the operating system.

They're idiots - but worse: they're dangerous idiots.

It's understandable - but not excusable - that these morons don't know what they're doing: they have no real professional background and OS X of all platforms suffers from a dearth of professionals - it's still 'Beige Box Country' with Conflict Catcher still hardly out of people's minds.

This user group who so proudly boasted of how little they knew about computer science are namely getting reamed royally today - by their so called 'developer base' who know just as little (or even less). And the end result is it's making OS X into a laughable farce that no one can take seriously - that Jim Allchin can get away with calling an iPod peripheral™.

It's high time this nonsense stopped. Either these morons get a real education and get experience working with real computer systems or they should do the graceful thing and leave these unsuspecting users alone.

Rule #1 if you're a 'user' and no more: if any piece of non-Apple software asks for your admin password you have a right to know why it's asking. And if you're not told? DON'T RUN THE SOFTWARE. PERIOD.

Whether you come to OS X from Windows or MacOS: you're running a 'real' operating system today. Mostly. There's still some Beige Box Cruft© hidden inside OS X to placate the Beige Box Idiots© but it can't hurt you if you don't give out your password. All that cruft can do is annoy you. And serious engineers have been patiently waiting for it to disappear - for everyone's good. There can be a lot of understandable annoyance but no real harm - not without that password.

But give away that password and you've sold your machine. It's no longer yours. It can be crashed and trojanised - and above all fatally damaged by every fool of a demagogue in the weird OS X software market.

The Advanced Developers Hands On Conference sometimes gets celebrity visitors (who might not know much outside their chosen fields). It can also get quirky speakers who have quirky things to say. To quirky people.

One such speaker (in 2003) was Jonathan Rentzsch. Rentzsch presented a paper called 'Dynamically Overriding Mac OS X' and already that title should send chills down your spine.

Under the title is a quote from the movie The Matrix which resonates well with Beige Box Idiots™ as it's about as technically accurate as they are.

'These rules are no different than those of a computer system. Some of them can be bent. Others can be broken.'

Rentzsch leads off with a few choice phrases to send you straight to Elm Street.

'Mac OS X is a whole new ballgame. The problem is that while the OS got game, we're missing the balls - the ability to dynamically override software functionality.'

[It's also extremely instructive to note Rentzsch sees the advent of a 'real' and secure operating system as a - 'problem'. As for Rentzsch lacking balls - we'll let the readers decide. Ed.]

And Rentzsch ends with some equally staggering rhetoric.

'Mac OS X is a new operating system with new rules. Fortunately, there's still enough wiggle room for us to dynamically override aspects of the system that are incorrect or require enhancement.'

That this is 'fortunate' is something only the Beige Box Idiots™ would agree to. And you the end user don't have to worry much about them and their 'problems' - as long as you don't use their stupid products.

And in between we see any number of gems of Rentzsch quotes which reveal where these people are coming from and how their Beige Box minds work. If they don't scare you then you might as well swallow the blue pill after all - you're hopeless.

[Webmaster's note: the following section appears to use a much larger font but in fact does not. It's just that what you're reading's so scary the words seem to leap out at you.]

'Dynamic overriding is the ability to change software at runtime, often in ways not originally anticipated by the software's original authors.'

'Besides being able to suppress, change, or extend functionality in prepackaged software, dynamic overriding also has the considerable advantage of being easy to remove. All that's needed is to disable the overriding software and relaunch the affected application (or in the worst case restarting the system).'

Unlike the classic MacOS, Mac OS X does not directly support dynamically overriding system supplied functions.

Ideally, overriding a system-supplied function would involve little more than discovering its entry in a universal table, saving off the pointer to the original function's code and replacing it with a pointer to the desired override code.

What is surprisingly feasible is to rewrite the function's implementation itself. The idea is to replace the function's first instruction with a branch instruction to the desired override function.

Function overriding is a useful technique in its own right, but it only realizes half the goal of reattaining [sic] MacOS 9 style system extension functionality.

MacOS 9 made it straightforward to globally replace or extend system-supplied functions with your own code. However Mac OS X, with its multiuser architecture and protected memory, makes this less obvious. Fortunately, if we explore the lower levels of Mach, we discover all the basic tools we need.

Mach offers the ability for one process to allocate memory in another process's address space via the vm_allocate() call.

In general, you can fully control the target process and override it as you see fit.

The downside to this remote thread technique is resource leakage. While the thread can successfully stop itself, it cannot deallocate its own code and stack blocks. This leakage isn't major - it only happens once per code injection - but it's something we'd ideally avoid. One reasonable solution is to inject a new 'injection manager' Mach server thread into a process. The idea is to inject a thread whose job it is to accept other injections via IPC. The 'manager' thread would then be able to effectively recycle the resources used by later code injections. Indeed, the entire need to spawn a new thread per injection would disappear.

Feeling shattered?

This is all extremely scary shit - and a real engineer would be terrified not only for the consequences but because of flashbacks to Comp Sci 101 - which people like Rentzsch either never passed, never attended, or at the very best forgot all about.

Perhaps even if you're not a 'real' engineer you can get a feel for what's going on: an amateur performs an operation on you, 'ad-libbing' your biology as things proceed.

'OK! But it looks like we messed up the spleen! Hey - let's not Panic™! Let's just yank out the kidney and hook it up where the spleen used to be! That's gotta work - right? Yeah! There! Good as new!'

Do you really want to trust your system to surgeons like that? There's no question these people know things about OS X you don't - that's not the issue.

Whether you're from Windows or MacOS: you have a real operating system today, so be happy for it.

Don't let the Beige Box Idiots™ ruin your OS X experience. As long as you don't use their products they can't.

And you don't have to understand everything about how OS X works. Even accomplished engineers can't do that. But accomplished engineers have a respect for the software foundations they build on - that's the only way your system can run smoothly and securely.

Make sure you respect those foundations too - and if anyone comes along with code injection or application enhancements you know now where to tell them to get off.

System 7 Bus Stop, Beige Box County.