Submitted by I always wondered what it would be like to write my own operating system, but I never took it seriously. Until now.
I’ve grown tired of cutesy and condescending software that doesn’t take itself or the user seriously. This is my effort to bring back the feeling of computing I once knew.
Roughly speaking, the goal here is a marriage between the aesthetic of late-1990s productivity software and the power-user accessibility of late-2000s *nix. This is a system by me, for me, based on the things I like.
Seriously impressive work, as you can see in the demo video of the current state of the operating system.
I’ve never heard of “condescending” software before. I’ve also never had the thought that my software “wasn’t taking me seriously.” In fact, I’ve never personified my computer at all. Well, maybe in one way, as my enemy when it doesn’t work.
I’m sure he meant that to be directed at the developers of such software. That said…
I think the project is interesting, but his reasons for writing it are not consistent with why someone would take on a project like this. While that can be said about a lot of the “user-friendly” and also some “power-user” oriented projects out there, it’s not an honest survey of what is actually out there. Yes, some projects make things stupidly simply, to the point where some functionality is lost (think Budgie desktop). And yes, other projects make things stupidly complex, requiring the user to know implementation details just to configure the software (think dwm and awesome window managers). But those are only the extremes. There are plenty of decent software between.
Additionally, I think the author is guilty of what he is saying about other projects. If his only complaint is user interaction, then why did he write yet another POSIX kernel, C library and math library? There are plenty of reasonable options out there: bionic, dietlibc, musl libc, glibc and even the BSD libc. Is the author honestly saying that none of those are reasonable implementations of the C standard? Then you look at his GUI… his scrollbar implementation does not even adjust based on the length of the document. This is a problem that NeXT solved back in 1985! Is he honestly arguing that the old design is more functional?
Anyway, so many things wrong with the author’s prose that it takes away from his accomplishment: a kernel, libc, supporting libraries and GUI written by a single person. He would be getting a lot more love from me had he just said he did it because he could, and I think that would be true of you, too.
teco.sb,
Looking at his commit history, I’m not so certain he wrote all those things himself. Certainly, a few of his headers is a straight up copy: https://github.com/awesomekling/serenity/blob/master/Kernel/ext2_fs.h https://github.com/awesomekling/serenity/blob/master/Kernel/elf.h
All the more amusing/redflag is that he’s deciding whether he wants to go with a 2 clause BSD licence, when he is straight up lifting GPL’d source from elsewhere.
There’s a big mix of newer C++ stuff and low level C-style stuff, which leads me to believe a lot of the lower level stuff is copied from elsewhere and he’s put a C++ interface over bits of it.
I’ve written >95% of the code myself, but there is indeed a small backlog of functions I borrowed from nicely-licensed sources whenever I just wanted to keep hacking instead of getting stuck in some details. There are some chunks of BSD code in LibC and a single-file zlib implementation in SharedGraphics. I had one GPL header in there (elf.h) that I got rid of after someone pointed it out.
I have been in open source for a very long time, so I’m not ignorant about these things, my project simply got flooded with unexpected attention and was not in the most prepared state (you can’t even build it without spending 2+ hours setting up cross-compilers!)
Serenity also includes a bunch of code I’ve carried around in my personal snippet library for over a decade so it’s definitely the case that parts are not representative of the way I write programs today. The malloc() implementation is probably the oldest of them.
awesomekling,
Haha, I know the feeling. There are times I’ve done really great documentation, and other times things are just throw away or “do this as quickly/cheaply as you can”. It’s like Dr Jekyll and Mr Hyde.
I’ve written a malloc too. By using thread local variables you can speed things up quite a bit over the typical libc implimentations for multithreaded code. Tracking memory with TLS allows us to eliminate a lot of mutex/synchronization that kills performance. I only used atomic synchronization when it was necessary to allocate/free memory from a global pool, but I made sure this wasn’t necessary for most invocations (ie to balance the memory between threads in case thread allocates memory and another thread frees it).
These are the kinds of projects I like to work on. Although if it were me I would be more interested in focusing on how I think things should be from the ground up rather than to do “yet another unix” clone. It’s good experience either way, and I understand that it’s easier to go with the flow, but I don’t feel that unix & clones got everything right and I often feel unix clones end up compromising on better designs just so they can align better to the way unix/linux do things.
From what you’ve expressed so far, we probably agree on many of these sentiments about technology. The thing is, I used to be more idealistic when I was younger, but now the world has pounded me into submission: unix/linux/posix despite their faults, are “good enough”.
“Then you look at his GUI… his scrollbar implementation does not even adjust based on the length of the document. This is a problem that NeXT solved back in 1985! Is he honestly arguing that the old design is more functional?”
Amiga solved that problem in 1985,
NeXT was just founded that year and had nothing to show yet.
But otherwise you are right: the GUI and al the other parts are just more of the same old concepts… that’s what he probably wants.
Atari ST did it a year before : https://i.pinimg.com/originals/98/1e/cf/981ecfc8ef3d327a5d55697b8fea8c3c.png
Amiga and ST came out in the same year (85).
(and both systems were far from stable in the first year and not yet on ROM but loaded via disk….)
@cybergorf: Not looking too much into technical details to know who got the biggest. Development of TOS started way before, and stable or not, the “scrollbar implementation [did] adjust based on the length of the document”, which was the subject.
Atari ST sort of wins on this, since it was based on DR’s GEM which is where it most likely was first implemented.
That’s indeed what I want. The general idea is to mash up the things I like from various systems and build something that feels just right for me.
Regarding that scrollbar feature, I actually implemented that just a few days ago. Here’s a demo just for you fellas! https://www.youtube.com/watch?v=EoScn0X2DFM
Very nice!
Thats what all serious OS development comes down to in the end: scrollbars
Now what about these little arrows?
I know some people used them back in the day … I never understood why. They just add visual noise for me.
Also scrollbar-area should disappear completely it there is nothing to scroll…
@cybergorf: arrow allows to move a line/page away without having to drag’n drop the scroll bar. Some applications have scrollbars disappearing when zooming out enough (ie. Irfanview) and some other applications hide them even if they shouldn’t (ie. Office on Windows 10), it depends.
@Kochise
I know the different types of scrollbar behavior quite well and e.g. macOS hides them almost everywhere, which is also wrong since you don’t know anymore if there is something to scroll or not…
Also the behavior should not be dependent on the application but be always the same thoughout the system.
And I do know what these little arrows are supposed to do, but that should be archived by simply clicking on the “empty space” next to the actual scrollbar
You don’t use Windows, obviously.
“Oops, something went wrong. We’re not sure what, but it was probably our fault. Please try again later.”
This was an error I received when trying to setup a Windows 10 laptop. Not only is it a ridiculously condescending way to phrase an error, but it also tells me absolutely nothing about what the hell happened. It turned out that the default user profile was corrupted and wouldn’t copy, so why not just tell me that? There are similar things all over the web and mobile apps now. Or how about this one:
“We’re getting things ready. Please be patient.”
Personally, I’m sick of it. Exchange 2016 even has emojis in its error messages in the admin center in place of useful error messages and codes!
So far, Apple does this less, but even they’re guilty of it with things like Siri, attempting to make the thing more human when all I want it to do is do what I told it to do. It’s a machine, not a person, and coding it to pretend phrasing like a person does not fool me and gets in the way!
Author here. I see we share this pet peeve, so thank you for expanding on it
Nice, reminds me a lot MonaOS : http://monaos.org/ https://github.com/higepon/mona
How? And why?
MonaOS is based on a microkernal, while Serenity is a monolith.
MonaOS is C++ while Serenity is C.
Serenity is UNIX/Posix, while MonaOS is not.
The only thing both projects have in common are translucent windows….
Both made by one guy. Not looking too much into technical details to know who got the biggest.
Does it use X-Windows or did he implement a GUI of his own? That part would make it interesting.
It’s a custom client/server architecture inspired by other windowing systems including X11.
Server: https://github.com/awesomekling/serenity/tree/master/Servers/WindowServer
Client library: https://github.com/awesomekling/serenity/tree/master/LibGUI
Just curious if you had considered using GNUStep at all for GUI elements / applications. I realize it’s early days, but your OS looks like it has an Apple/NextStep feel to it.