DLL Hell: when you end up with multiple versions of the same dynamic library, and the system can't keep them straight without, for instance, embedding the version number into the name... which essentially makes it a static linker with shared file space. Or, you upgrade a library, and no existing application can take advantage of the bug fixes without a recompile, or at least, a relinking. Lame.
And no, what I mean by automatic updating is things like: I can upgrade, replace, or downgrade the HTML core of my web browser, and all apps that use it get the same behavior for free, no work needed. Or, Apple can upgrade a system library, say for instance, the font panel, and *every* application gets the new behavior for free. (This is one reason why every MacOS X upgrade has gotten *faster* than the previous release - as the core pieces are optimized, every single app gets the added speed boost, without the developers having to do anything, or the users having to go get a new version.)
Now here's where it gets fun - say the new version of the library introduces some incompatibility with the old library. No problem - the versioning is intelligent at the loader, and it grabs the appropriate compatible library version. Apps that don't rely on a specific version level get the newest library - those that require a specific version get the one they need. All automatically. The user doesn't have to do squat, but install the upgrades they choose, and the developer doesn't have to do anything but say which library and version level they need - everything *else* is handled automatically.
OS reimagining? Hmm - I really miss the NewtOS's concept of a data soup - there were no files, just a database of data that was tagged with datatypes, keywords, etc... ie, it was metadata before metadata was cool. Any app could request data that it could handle, and would get access to it. We're starting to see bits and pieces of this in other OSs now, a decade+ later, but it was pretty slick.
IIRC, it was Plan9 that had the processor cloud, where the microkernel could be ported to a ton of different architectures, and they could share in the workload across devices, the network, whatever. Neat concept, with some obvious blocks, but some definite advantages.
As for the UI, while I like the noun/verb approach currently in use (when applied methodically, and not ad hoc), gestures have a bright future, methinks, particularly on dedicated devices or units where input methods are constrained.
In the language level, we *seriously* need to stop dicking around with half-assed solutions like Java, and just get our asses over to a fully dynamic language. The only thing that's been preventing is developer inertia of not wanting to learn a new methodology. We have the cycles. Let's use them.
![[personal profile]](https://www.dreamwidth.org/img/silk/identity/user.png){kind=small}
(no subject)
Date: 2007-10-24 04:13 am (UTC)And no, what I mean by automatic updating is things like: I can upgrade, replace, or downgrade the HTML core of my web browser, and all apps that use it get the same behavior for free, no work needed. Or, Apple can upgrade a system library, say for instance, the font panel, and *every* application gets the new behavior for free. (This is one reason why every MacOS X upgrade has gotten *faster* than the previous release - as the core pieces are optimized, every single app gets the added speed boost, without the developers having to do anything, or the users having to go get a new version.)
Now here's where it gets fun - say the new version of the library introduces some incompatibility with the old library. No problem - the versioning is intelligent at the loader, and it grabs the appropriate compatible library version. Apps that don't rely on a specific version level get the newest library - those that require a specific version get the one they need. All automatically. The user doesn't have to do squat, but install the upgrades they choose, and the developer doesn't have to do anything but say which library and version level they need - everything *else* is handled automatically.
OS reimagining? Hmm - I really miss the NewtOS's concept of a data soup - there were no files, just a database of data that was tagged with datatypes, keywords, etc... ie, it was metadata before metadata was cool. Any app could request data that it could handle, and would get access to it. We're starting to see bits and pieces of this in other OSs now, a decade+ later, but it was pretty slick.
IIRC, it was Plan9 that had the processor cloud, where the microkernel could be ported to a ton of different architectures, and they could share in the workload across devices, the network, whatever. Neat concept, with some obvious blocks, but some definite advantages.
As for the UI, while I like the noun/verb approach currently in use (when applied methodically, and not ad hoc), gestures have a bright future, methinks, particularly on dedicated devices or units where input methods are constrained.
In the language level, we *seriously* need to stop dicking around with half-assed solutions like Java, and just get our asses over to a fully dynamic language. The only thing that's been preventing is developer inertia of not wanting to learn a new methodology. We have the cycles. Let's use them.
I'm sure I could come up with more... :)