Slashdot Mirror
Ask Slashdot: If You Could Assemble a "FrankenOS" What Parts Would You Use?
rnws writes: While commenting about log-structured file systems in relation to flash SSDs, I referenced Digital's Spiralog [pdf], released for OpenVMS in 1996. This got me thinking about how VMS to this day has some of, if not the best storage clustering (still) in use today. Many operating systems have come and gone over the years, particularly from the minicomputer era, and each usually had something unique it did really well. If you could stitch together your ideal OS, then which "body parts" would you use from today and reanimate from the past? I'd probably start with VMS's storage system, MPE's print handling, OS/2's Workplace Shell, AS/400's hardware abstraction and GNU's Bash shell. What would you choose?
What are these parts I keep hearing about? I use systemd.
Windows kernel, Linux UI.
Dear Slashdot: next time you want to mess with the site, add a rich-text editor for comments.
Maybe some people do not appreciate it, but I think that having SOM (System Object Model) and WorkplaceShell (built over SOM) gave some functionality that was never exploited properly. So, building a Frankenstein I will put over the GUI, SOM (maybe the open NOM and somFree) and the Desktop elements will be built over it. (like Workplace Shell). Check out this OS/2 reference graphic: http://www.edm2.com/index.php/...
Custom OS is not about what is in it but all about what is left out. Custom OS for appliances that only has in it what is actually necessary for that appliance, maybe just maybe incorporate application into the OS rather than a separate post boot load.
I think future trend will be a shift from more flexible universal operating systems to more modular, take every out that is not necessary for this particular appliance operating system, this to simplify security and even application level features become modules added into the operating system, so one quick boot to full functionality. So a much more modular operating system.
Chaos - everything, everywhere, everywhen
As long as I can use IBM's JCL: https://en.wikipedia.org/wiki/... to run my jobs, I know I can be truly productive.
FreeBSD kernel, Solaris networking/clustering capabilities, and a sort-of Windows UI (Imagine Windows 7, not the metro interface)
Currently, what I'd really like is something that's mostly a typical GNU/Linux system, with OS X's GUI and reliable support for Windows and Mac applications.
DCL (the VMS CLI) could also do with a major rework and enhancements.
True, but there are elements of DCL that are worth bringing forward as well - particularly the ability to define the command syntax at operating system (shell) level and bind it to programs. For those who who haven't developed under VMS, there is operating system (shell) defined syntax with which you declare what parameters, switches, options, etc. that your program desires. The syntax is robust enough to specify which options are optional, required, mutually exclusive, etc. When you build your program, you "compile" in your command syntax and at run time DCL handles syntax checking for you. Coding work for processing command line parameters is greatly reduced. You also get bonus stuff like integration to the help system and automatic shortening of non ambiguous switches.
VMS supports very elegant file versioning, which I found a very useful feature. By default, every time you open a file for write (and you modify the file) you get a new version of the file (kind of like copy on write at the file level). When you list the files in a directory, you can see all the versions of the file with the version number being an actual part of the file name(file.text;1, file.text;2). On a per file basis you can set how many versions you want to keep around and the file system will automatically purge the old versions as new ones are created. When opening a file you can specify any version you want, or if you don't specify a version you just get the latest.
The file system also supports specific backup related attributes that integrate with the backup system. This lets you specify that a file should be excluded from backup and if I recall, tracks if the file has been modified since the last backup.
Win 7 GUI (with Win2K Pro GUI as classic mode) with WinFS** from Longhorn Alpha and WIMBoot from Win 8.
**-What is sad is that the WinFS demo was in 2003 and here we are in 2015 and we have YET to see anybody give us what they showed in that demo! Where is the file system that can just scan vids and pics and assign metadata like "girl in blue dress" or "white truck" and let me find any file by using human expressions without requiring the user to fill in the blanks?
ACs don't waste your time replying, your posts are never seen by me.
Can you imagine being the nephew... Having this kind of technical advice on a regular basis, PLUS working at Apple. Se-weet!
lucm, indeed.
Built on type safe language, so no buffer overflows. Layered on a type-safe assembly language. Immutable everything. Defined channels between components. No memory sharing anywhere.
Our recent article in Operating Systems Review, Singularity: Rethinking the Software Stack, is a concise introduction to the Singularity project. It summarizes research in the current Singularity releases and highlights ongoing Singularity research.
Overview
Singularity is a research project focused on the construction of dependable systems through innovation in the areas of systems, languages, and tools. We are building a research operating system prototype (called Singularity), extending programming languages, and developing new techniques and tools for specifying and verifying program behavior.
Advances in languages, compilers, and tools open the possibility of significantly improving software. For example, Singularity uses type-safe languages and an abstract instruction set to enable what we call Software Isolated Processes (SIPs). SIPs provide the strong isolation guarantees of OS processes (isolated object space, separate GCs, separate runtimes) without the overhead of hardware-enforced protection domains. In the current Singularity prototype SIPs are extremely cheap; they run in ring 0 in the kernel’s address space.
Singularity uses these advances to build more reliable systems and applications. For example, because SIPs are so cheap to create and enforce, Singularity runs each program, device driver, or system extension in its own SIP. SIPs are not allowed to share memory or modify their own code. As a result, we can make strong reliability guarantees about the code running in a SIP. We can verify much broader properties about a SIP at compile or install time than can be done for code running in traditional OS processes. Broader application of static verification is critical to predicting system behavior and providing users with strong guarantees about reliability.
The law is a weapon of the government, not a protection for the likes of you. Surely you understand that.
For what it's worth, Powershell on Windows is actually pretty nice.
-- I wanna decide who lives and who dies - Crow T. Robot, MST3K
BSD style kernel .NET or Java
MacOS X multithreading
Solaris networking and filesystems
MacOS 9 system layout and management (auto install/remove via drag and drop)
Windows 7 start menu
System level support for IL - such as
Control strip from MacOS9
BeOS multimedia engine
Linux device drivers
AppleScript/REXX application scripting
OpenBSD code auditing standards, firewall
OpenVMS system partitioning, file versioning and backup
My Other Computer Is A Data General Nova III.
You do realise that most of those wishes are granted with any modern Linux install? Hardware support has gotten a lot better (mostly it's just "install and go" now), software support is either (a) native versions of the stuff you want, or (b) installable using WINE (not everything works well with WINE, but it also is much better than it used to be). Installing software on Linux is in my opinion easier than most OSes, as long as it's in the main catalogues: just go to your software manager, do a search, click install. Even for more obscure stuff, it's maybe just adding a repository, which is a simple "Google for it, then copy and paste a line or two of text". Apparently, Linux also has native ZFS support.
Or am I missing something here?
Simple, non-nonsense interface, reliable ALT+TAB (damn you OS X!), good package manager, with all the redundant filesystem management wizardry. Good support for GPUs and the latest OpenGL/DirectX as well.
BeOS has an incredibly responsive UI. I am not a software engineer so I am not sure which part of the OS is in charge of this, but it's something no other OS has been able to do, before and since: be perfectly responsive to user commands (keyboard and mouseclicks). What this means is: no matter what the computer is doing at any given time, the UI will react to the user commands. There is no file-copy too big, a computational task too complex, that the reaction to a user's command would be delayed. BeOS has spoiled me so much, because with that OS, user comes first, always.
"The agriculture ministry is not in charge of Gundam" - Japanese ministry official.
Yeah, pretty much this. Also, I find that a much under-appreciated feature of Cinnamon is that it has a working "do not let an app steal focus" option; it is really quite amazing how much under most OSes, we get used to something being able to interrupt us mid-typing. Of course, I do sometimes have to get used to the fact that this can also mean that the app I wanted to start only appears on the taskbar and not on top of what I'm doing, but I'd far rather than that have something jump to the front two or three times while it opens, like I get on Windows.
There was a desktop OS called Domain/OS from Apollo Systems. Rumour had it that Apollo was founded by Multicians who fled from Honneywell. It was a great OS on a lot of levels, not least you had native Domain/OS, BSD4.3 and System5 UNIX, an amazing shared filesystem, and networking that was literally plug and play.
Then of course HP bought it and killed it in favor of HP/UX, sigh.
Who, me?
TL;DR summary - at the end of the day the gamer wants a tight Windows system. The server admin wants a tight server (LAMP, WAMP, XAMP, MEAN, etc.). The hardware developer wants all the latest drivers. The R/T guys want predictable and repeatable, and Donald Trump wants it not to be produced in Mexico. However, that's not what OP asked about, and his interesting article relates to features on clustered filesystems that are cool to have and not available outside of the [really out of date/obsolete] OpenVMS.
Long Version:
Whenever someone asks about "best" OS or app or features to have in one... invariably it leads to the proponents of Windows, Linux, FreeBSD, MacOS, (and kudos to the poster who brought up BeOS!) etc. all jumping to extoll their virtues.
Ironically the OP asked about OS and everybody jumped into talking about monolithic kernels... filesystems, and only a couple discussing other elements of the OS which is queue system (OpenVMS really had that one sewn so tight it was awesome).
Interestingly tho the original ARTICLE talked about a clustered filesystem environment. It would appear OP is right on this one - only VMS did it. Some of the functionality for single-host stuff is now beat by BTRFS, but the clustered writeback, locking, and other features mentioned in the PDF are without compare in anything else today
Ehud
Tucson AZ US
JCL really allows you to get down and dirty with the metal and specify exactly what you want. What cylinders to store that file on, whether there's blocking. Even useful stuff like whether the operator should put a ring in. (no kiddies, that's not putting a ring on it a'la Beyonce)
Java applications never took off like they should have because of the write-once-look-like-shit-everywhere problem
The main problem I have with QNX is with QSSL (now Blackberry). The royalties for QNX have always been high, and has made it tough for me to convince management to use it in projects. The technology is fantastic though.
“Common sense is not so common.” — Voltaire
There were two things I liked about the VAX/VMS filesystem that I would port over. The first is version numbering. A file would start as filename.1 and the number would increment with each edit/save cycle.
The second thing would be logicals and overlayed directories. They worked like a stack of transparencies like the human anatomy entry in an encyclopedia. The base layer would be a read only version of the operating system. Above that would be a writable layer. Above that, for development users, would be test versions of new OS elements. Regular users wouldn't see these layers. Above that would be applications (read only) with a writeable layer above it.
The purpose of the writeable layer over the read only layer is to trap attempts to overwrite system files.
When our name is on the back of your car, we're behind you all the way!
I'd add the ability to run Windows binaries in emulators, but they can't access other programs than themselves. If that was a problem, add a phantom disk image so it could see other files that you place in the phantom disk image. Imagine each Windows emulated program saw their own personal c:/ , and it and you can populate it with files.
So... Wine with a new WINEPREFIX for each program?
I figure if the software you download can't get out of the Windows emulator or its own personal filesystem, it can't mess with your OS or the rest of your filesystem. If it can't record your keystrokes unless you have the window actively open, a keylogger can't get you either. The problem is that we probably don't have perfect Windows emulation. Another problem is you have to be able to trust your drivers or that is a possible vector to an attack.
Run Wine in a Docker image? That's pretty well-sandboxed. and easy to set up.
Linux hardware support has got a lot better, as has software, but to pretend for one instant it's comparable with Windows is lying to yourself.
Except AIX has allowed up to 256 character usernames since 5.3, released in 2004.
It has occurred to me before that a 64bit memory space is adequate for most purposes (except really big computers), and then a hierarchical arrangement of 64bit address spaces (essentially give each 64bit memory space its own index, with 0 meaning local-default or something like that). Similarly, I started thinking through the idea of a really minimal Forth for 64bit chips where, rather than strings naming words, we just limit things to strings of 8 1-byte characters, possibly using a different character set than ASCII, and ordering it so that lexicographic ordering is identical to the native integer ordering of the processor (then you can remove all need for string processing from the Forth, and move it, if needed, into a frontend).
Chuck Moore (of Forth fame) once commented about the database. Casual users forget that their filesystem is a database, and quite possibly one that is far from optimal for what they are doing with it. Viewing memory and storage as a database of 4K pages, and working up is something that to a certain extent already happens, but making it explicit in system architecture makes a lot of sense to me.
Ideally I would have a system where a minimal Forth like this sits at the bottom level, then there is a minimal Lisp for higher level stuff, with access to a sufficient compiler infrastructure to do basic assembly and writing of components. As for system architecture, I would strip away many of the abstraction layers we currently have. View both storage and memory as a database of 4K pages, each of which is natively viewed as a vector of 512 64bit integers, and viewing smaller cells as fractions of a 64bit integer, and larger cells as vectors of 64bit integers.
As one goes up, implement systems for the various programming paradigms, borrowing from languages such as the various oo languages, the various functional languages, and things like erlang, and the bright ideas that turn up in webserver systems such as nginx and node.js (that is, lightweight 'threads').
The difficulty with any dream like the above, however, is to avoid the 'design by committee' problem of ramming in every pretty idea you see, and of trying to arrange things so that the complexity of the end result system does not blow up massively as things grow towards what we would expect of a modern operating system.
John_Chalisque
System V was introduced in 1983.
The reason there has not been a new version released since then is because System VI couldn't run emacs.
One thing I love about xfce (I tend to use UbuntuStudio on most of my machines) is the ability to assign arbitrary keystrokes to commands in the desktop preferences. I thus use the Windows key (call it Meta if you like, but I am too used to calling it Windows, especially since it has a Windows logo on) so that Win-W launches my default word processor, and then if necessary modifiers like shift and ctrl will launch an alternative word processor. Win-T launches the terminal, Win-G does gimp, Win-Shift-G does krita, Win-E does the file manager (having got used to this one on Windows), Win-K does kodi, and so on.
Rather than rely on some dodgy AI to figure out what I want, give the user an easy way to teach it what you want, so that one can easily teach the user how to train the computer to respond. The idea that a few software engineers in a country a few thousand miles away can anticipate how I would want to use the computer is just silly, but that is what Apple, M$, and many desktop environments effectively do.
This hotkey arrangement means that I can go from off to word processor in three touches (power button, which boots to desktop*, Win-W) and about ten seconds. With windows 8, already booted and logged in, it usually takes me longer than that, and many more touches, to get a working word processor. Likewise for other common apps (Win-B does Firefox, Win-Shift-B does Chromium)..
One thing I dislike about how things are on my Linux boxes at present is a kind of 'fragmentation' in the sense that only certain bits of my environment can be directly controlled from the command line, and the command line is limited compared to a language such as Python. I would personally take the idea of sending messages in a command language that would, in practice, resemble a simplistic Lisp, as a core of all applications. UI events like changing font in a word processor or changing colour in a paint program would resolve to commands sent to a mailbox in the app somewhere. This would make the MVC paradigm much more explicit, and I would have the ability to 'log in' to a command processor built into every program (essentially stick such things into the runtime -- look at F-Script anywhere on Mac Os X for an idea about what I am describing).
In particular, if I can conceive of a simple task for, say, my word processor, I would like there to be an easy method to tell it to do this. I am a big fan of the idea of pervasive scriptability, But that does require more thought about the nature of the scripting languages: you want something data-structure based (like Lisp) that is easy to compose programmatically (so that any old scripting language can compose a script for this pervasive scripting language) and easy to pass between processes, whether local or remote (so that a script can throw a complex request to a process somewhere else to handle).
*and I take care to use encrypted containers for anything that I don't want someone with physical access to my machine to get at.
John_Chalisque
Additional things to bring from Amiga:
That said, don't look to Amiga as a model of stability . . . it wasn't. All it took to bring one to a red guru meditation was to attempt to read past EOF.
www.wavefront-av.com
Just to set the record straight, after the GE merger it was the people who were originally from Honeywell who fought to save Multics and the GE alums in Phoenix (AKA the Dinosaur Factory) who fought to maintain the dominance of God's Chosen Operating System. I know this because I was there, on the losing side.
There is quite a bit that is legitimate in criticizing the new trend of 400 layers of abstraction each adding their overhead for the sake of rapid development. Those old development models produced more stable and dramatically more efficient software. Nobody really denies that, they just argue that developer time is more valuable than computer time and improvements in hardware make up the difference in most use cases.
But what happens when hardware stops getting dramatically faster? We'll have to go back to making things more efficient to see gains and suddenly you'll have a great deal of respect for dad who could make a word processor with 90% of the functionality of word that weighed in under 1mb and ran smoothly on as little ram with a processor your smart phone could emulate 200 times over. There is a reason where the browser makers, the home of high level abstraction and high level languages, are finally all actually in agreement and collaborating and the thing that brings them together is making c/c++ compile to a uniform standard that all browsers can execute at near native performance.
The circle comes around, it always comes around.