OSDev.org

ik im not very good at much of topic response and creation on here, but i figure i throw this out there out of my interest. this isnt to show people that ur start then others because u started developing in 64 bit, but to see how it all began with you. What processor mode did u start in when u started developing operating systems, the main processor mode, i dont know much on the mac power pc or other non x86 processors, but id be interested to know. Did you start in real mode, or protected mode? (or other)
when did you start in that mode (when u started developing os's is the real answer)
ill start,


I developed my first operating system, a small cli (thing) interface with no file system in early 2009, my main processor mode was real mode and still is

I started in protected mode. It was difficult, but I managed to understand it a little when I also first learned assembly, and that took like 6 months to have a functional knowledge of assembly.

Of course, I learned several things, but as soon as I tried multitasking I was stuck at that point for a lot of time. I tried learning other things, but tried too fast, and with protected mode along with no codebase to build on, I couldn't make the kernel.
--------------------------------

Now I'm not even giving much importance on which mode to develop, at least I know I will do it in 32 or 64-bit protected mode.

Now what is really important to me is to really learn and grasp the operating system foundational concepts, as well as many elements/algorithms for different tasks, trying to cover every single aspect of what a system is expected to do.

Since an operating system is a huge package of programs that do different things, I know that I have to first learn what I should implement and also build a codebase. In that way, if I manage to have full compatibility for an ANSI C standard library, and have common memory, process, filesystem and graphics libraries (at least featuring only what I'm going to use in my applications immediately), then I would effectively have a similar programming environment to the one of the most recent and last relevant DOS days, only in 32 and/or 64-bit mode.

From there, it could be a lot easier to build on top of it, and figure out more advanced things, like inter-process calls, support for multicore systems, among other things, and only then, when the system is well defined, trying to program a text-mode interface and then a graphical one.

I started out on PMode and have currently no intentions of going for Long Mode, after all we've got PAE for 3.3+ GB. Had some problems in te beginning with getting my GDT to work, but I guess most of us do at some point.

My plan is to write a bootloader like a real-mode OS without support for multitasking. I don't want to try to write a kernel in less than a year or two, so I plan to write a very simple 3-stage bootloader and then add features to it, like a CLI and GUI (sort of like a cross between Chameleon and GRUB), and then, when I think I have enough knowledge, write a protected mode kernel for it to load.

I started with the power off

Or an OS running as a TI-83 program... What is this "processor mode" you are talking about?

Combuster wrote:I started with the power off

Or an OS running as a TI-83 program... What is this "processor mode" you are talking about?

It kind of sucks that I'll never be able to tell stories like that.

Then again, maybe in 50 or so years I'll be sitting with my programmer grandchildren all around me saying "Tell us the one about the 8-core CPU again!" (lolunlikely).

Most of us started out using compilers instead of assemblers so does it really matter that much? For me, it was the Borland Pascal compiler, targeted for real mode but that was pretty much invisible to me. I learned OOP by looking at examples before I even knew what segments were.

I learned C/C++ many years before ASM.
At the time i was only into software graphics.
After learning ASM i became interested in OS design.
My first few were some simple 16bit test OS'es.
Then to read the Intel manuals many times.
Now i can play with 32bit p-mode comfortably.
The hard part is writing many robust drivers.
I tried with gcc/grub but is way too complex.
After much reading i gave up HLL OS construction.
Now i only play with ASM for such things...

I began with Turbo C and Turbo ASM (pirated) in real mode. Those were fun days..

Personally I started on the TI-84, and then got interested in OSDev wanting to write an OS for the TI-84. After getting some documentation on the Z-80, which is still my favorite processor because of the huge impact it had on the market, I gradually changed my ideas towards writing an OS for the x86 platform. Ordered the manuals from Intel, at that time still paperback. And read through those manuals. Currently I'm writing a rather simple compiler because I wanted to try that. It can already be used to write an OS in, although it would be rather cumbersome. It is a protected mode compiler

combuster wrote: Or an OS running as a TI-83 program...

TI-Basic was literally the first language I learned. Last year I had to take Algebra I(like all other freshmen in high school), but I already knew just about everything . So my teacher allowed me to sit around and do nothing but play with the TI-83+ issued to me through the school. I made a bunch of simple tic tac toe like games but nothing serious. Recently went back and made a gui(*very* slow) for the fun of it. If I had any idea how to put the program onto it, I would attempt to learn Z-80 assembly.

My first osdeving was making a simple boot sector os with a cli and 3 commands in real mode. Then I made a Unix clone with my own version of X and some other stuff. sarcasm

I did what little OS development I got around to in x86 protected mode (GRUB FTW!). It's funny to realize I've been hanging out here for almost ten years now, when all the OS code I've ever written was a glorified "Hello world" (printing GRUB's data fields to screen). Ah well, someone has to do the framework thing, hm?

For an OS, I started in real mode cus I started with a bootloader Now its primarily protected mode though for both OS's.

Solar wrote:(GRUB FTW!)

Blasphemy!

I started by trying to tweak some x86 pmode code found on the internet. Then I realized that I didn't know what I was doing and hence couldn't go very far.

So I borrowed my brother's copy of "Modern Operating System", learned more about OS theory, then grabbed a pen and a notepad and started to think about OS structure. That didn't work that well either. I now knew what I was doing, but lacked a vision of where I was going. Even though OS development looked highly interesting to me, I didn't know exactly *what* I wanted to develop.

So I started to look around for some subject. And one day, I basically thought "There's something I hate in all current desktop operating system. I bet I can do it in a better and cleaner way". Started writing a blog to find out what was wrong more rigorously. And, a few months later, went into development of an x86_64 microkernel. So far, it goes well. I don't plan to introduce a revolution in the world of desktop computing, but rather to prove that it was possible to avoid all of its current issues quite easily through a well-thought design. That we don't need cloud computing madness and more powerful computers to make it both ready for the average joe and much more secure.

So what "processor mode" did I started with ? PMode ? Pen&paper ? Long mode ? In my opinion it's the latter, but I guess that it depends on what one calls starting ^^