OSDev.org

Just out of curiosity, how good are you at OS development? On a scale from 1 to 10?

What are you currently trying to figure out or learn about? And what was the last thing you figured out or got working?

I'd say I'm a 5/10.

The last thing I learned was the x87 FPU instruction set and usage. The last code I got working was a single-pass nested command parser for my console app.

The next thing I'll be working on is a common API for my network device code, and for the networking system (TCP/IP, ICMP, etc.), I think.

I have got some basic task switching code working, but I haven't tried virtual memory, user mode (ring 3), or any of the more advanced instruction sets, like SSE or MMX. I also don't have a real memory manager, yet. Just a simple counter that keeps track of the next available memory address.

What about you guys?

It's hard to say, really, on such a silly subjective scale. Especially when people are bad at communicating what they've done, what they are working on on the forums and on #osdev. I tend to randomly rant in #osdev about what stuff I'm doing, especially if I encounter something I don't like. I understand there are many osdevers that quite simply don't need to talk that much about their accomplishments, or no longer are that active community members. It makes it hard to compare yourself.

A useful measurement is whether someone is self-hosting, and the various degrees of it:

• Not self-hosting.
• Able to compile small programs under your OS.
• Able to build your OS under itself. (Self-building)
• Able to build your OS under itself on real hardware, reboot, and the new version boots and is capable of the same. (Self-hosting)
• Self-hosting, and able to also build all third party software ports under your OS.
• You actually prefer developing under your OS rather than cross-developing. (Actually self-hosting).

Presently, I'm at the self-hosting stage where I am capable of building some, not all yet, ports under my OS.

Based on how the amount of stuff I've ported and the strength of my user-land, and on what I've seen over's do, I'd rate myself highly on a 0-10 scale. But that's just part of the picture, for instance, my kernel is of lower quality and has some issues, and my drivers aren't that well written, so that would get a much worse score.

I'm interested in how this stuff can be objectionably quantified. Stuff like code quality, appropriate use of hardware features, security, amount of code, how many contributors, how many users, how respected in the osdev community, how readable, how documented, that kind of thing. I think achievements are generally informative of how well someone are doing at osdev.

Hi,

sortie wrote:Based on how the amount of stuff I've ported and the strength of my user-land, and on what I've seen over's do, I'd rate myself highly on a 0-10 scale.

Let's say OS development is 50% design and research, and 50% implementation.

Some people are able to port existing things because their system is so similar to other OSs. These people have often done very little of their own design, very little research, and shown almost no innovation.

Some people are not able to port things because their system is so different. These people have often done their own design, their own research, and shown the most innovation.

On a scale from 1 to 10; the first group aren't OS developers (they're only "OS implementers") and they should be limited to scores from 1 to 5.


Cheers,

Brendan

Brendan wrote:Some people are able to port existing things because their system is so similar to other OSs. These people have often done very little of their own design, very little research, and shown almost no innovation.

I'd like to think of myself more highly than that. My design is largely based on existing implementations, but the details do matter.

I've been deliberately working to perfect the design. I make the design self-consistent. I add new extensions where they are needed. I refuse to implement ill-designed interfaces. I fix salvageable code to do things as it should. I say “No” to things I deem stupid.

There is a contrast to systems like GNU/Linux, where much crap code is in the base system, and few seems to mind. It's really bad at being what it is designed to be, it hides itself under awful layers of portability, compatibility, and people expecting software to stay bad. I might base my design on existing systems, but I'm striving to do what the other guy does, but better.

Finally, I'd like to remark that even though I follow a system interface specification, there are significant other areas where I am entirely free to design as I wish.

I was really more curious about "you" and your personal opinion about how much you "know" about OS development. The CPU, the various components and how they work, the approaches the other OSes have taken and whether you have your own solution for those approaches.

Basically, a 10 would be able to start writing an OS from scratch, and end up with a working, usable, quality OS without asking for help, or having to "learn" anything from reading documentation, spec sheets, or other source code. (Using documentation for reference purposes is fine...)

A 10 would be able to create an OS that could (in some fashion) browse the web, play MP3 audio, render video at a respectable frame rate, and support at least one video card model, one sound card model, one usb controller interface version, and at least one storage device.

Even if it took 30 years or more, a 10 would eventually be able to pull this off.

SpyderTL wrote:Basically, a 10 would be able to start writing an OS from scratch, and end up with a working, usable, quality OS without asking for help, or having to "learn" anything from reading documentation, spec sheets, or other source code. (Using documentation for reference purposes is fine...)

What is the difference between reading documentation to learn compared to reading for reference?

Everyone at some point needed to learn the 80x86 instruction set and we may all now reference (relearn?) the manual from from time to time to look up an obscure rarely used instruction.

SpyderTL wrote:A 10 would be able to create an OS that could (in some fashion) browse the web, play MP3 audio, render video at a respectable frame rate, and support at least one video card model, one sound card model, one usb controller interface version, and at least one storage device.

By this definition probably no one on earth is a 10 as I doubt anyone would have learnt every part of a system and the design of each kernel subsystem.

SpyderTL wrote:Even if it took 30 years or more, a 10 would eventually be able to pull this off.

To achieve this that 30 years may have been wasted on the learning rather than implementing, a current 10 without distractions could probably pull it off in less than 5. No where near as sophisticated as linux or windows as an individual project but definitely a protected mode Amiga, GEM, DOS or CP/M type system.

b.zaar wrote:What is the difference between reading documentation to learn compared to reading for reference?

The difference is that a 10 would know how it works, and would only need the documentation to look up specific values, like memory addresses or port numbers. A 1 wouldn't even know where to look. In other words, a 10 could explain how it works to a 1, without looking at any documentation. A 10 could answer any question a 9 would have, or would at least know where to find the answer.

By this definition probably no one on earth is a 10 as I doubt anyone would have learnt every part of a system and the design of each kernel subsystem.

To achieve this that 30 years may have been wasted on the learning rather than implementing, a current 10 without distractions could probably pull it off in less than 5. No where near as sophisticated as linux or windows as an individual project but definitely a protected mode Amiga, GEM, DOS or CP/M type system.

That's fine. I was just curious.

Hi,

sortie wrote:

Brendan wrote:Some people are able to port existing things because their system is so similar to other OSs. These people have often done very little of their own design, very little research, and shown almost no innovation.

I'd like to think of myself more highly than that. My design is largely based on existing implementations, but the details do matter.

Details are important, but in the end they're just details - they aren't fundamental differences in design.

For some examples:

• For modern systems (where you'd like to be able to do things like rolling back to a point in the past), does it make sense to allow files to be modified?
• Does the file system have to be hierarchical?
• Is it better to have some sort of "persistent object store" with no file systems at all?
• For security, do you need any (e.g. single-user system)? If you do, is the ancient *nix style "read/write/execute, owner/group/other" really what you want?
• Does an all powerful super-user make any sense at all (they're only a glorified janitor, should they really be allowed to modify the company's accountancy data)? Can you automate and/or simplify things such that no administrator is needed in the first place?
• For modern "variable speed" CPUs that have lower power modes (e.g. speedstep) and higher power modes (e.g. turbo-boost); does it make sense to use time as the basis for scheduling?
• Is the way work is divided (e.g. "application = 1 multi-threaded process") really the best way? Should work be divided differently (e.g. many individual single-threaded objects or actors? Maybe one virtual address space per user, where "applications" are just plug-ins that all share the user's single virtual address space? Maybe some sort of "global work queue" where the OS just does the highest priority job and there are no processes or threads?). Does the work need to be divided in the first place (e.g. maybe everything is just a single LISP program, where "applications" are just more functions that get dynamically added to that single LISP program)
• For IPC, is it necessary to have signals and pipes and sockets and shared memory and....?
• For (virtual) memory, should there be any (e.g. "persistent object store" where an object is an on-disk structure and RAM is only use for caching?). Should it be private (e.g. individual single-threaded objects or actors, where nothing can access memory belonging to anything else)?
• What is executed? Is it native instructions, or is the OS some sort of "p-code machine"?
• How about the user interface - none, one or many? Can multiple users share one user interface? Would it be command line, "desktop metaphor" or both; or maybe something very different (e.g. designed for speech synthesis and speech recognition, with no video at all)? Could the user interface be designed for augmented reality, where (e.g.) a PDF file might be a virtual book in a real cupboard?

Cheers,

Brendan

SpyderTL wrote:What about you guys?

If the scale is from 1 to 10, I have to say 1. Saying that is the only safe future-proof statement. However, that is a hard question. Intermediate developers are likely to exaggerate the score. Advanced developers are likely to understate the score.

At the moment, I am not an advanced developer and therefore I am not understating the score because of that. Still, the score 1 is the safest option. It works whether I were a beginner or an advanced developer. I will skip the "intermediate" exaggeration stage.

I seem to have been only like a boy playing on the sea shore, and diverting myself in now and then finding a smoother pebble or a prettier shell than ordinary.

I'm a -1. I wouldn't even rate myself on a scale that covered the likes of Thompson and Ritchie. Luckily, I don't believe in arbitrary ratings. But I enjoy my hobby.

Okay, how about this...

What is the most difficult task that you have actually accomplished (and understand), and what is the least difficult task that you have yet to accomplish (or yet to understand)?

The level 1-10 is optional, but I would say that a 1 means that you don't know how to create a "Hello World" boot loader, and a 10 means that you no longer have any questions about any aspect of OS development...

Shameless plug. At least it gives a measurable performance

Combuster wrote:Shameless plug. At least it gives a measurable performance

I don't get the last one -.-

Combuster wrote:Shameless plug. At least it gives a measurable performance

You scored 30%!

Woohoo!

For the record, I resisted the urge to cheat... And I don't do a whole lot of C...

So the highest possible score is 90%? Or can you get double points somewhere?