OSDev.org

Hi all, I am new here and wanted to get a feel for what everyone's goals are.

I just started (I have hello world ), but my first goal would be to get interupts working, followed by a file system.

I also want to get grub 2 working (so I don't need to boot qemu with -kernel) but I don't know how to use mkisof properly (it just puts the img in it):(.

Future goals of mine would be to run files (any type not too picky), and get into protected mode. I want my OS to use paging and after that I would introduce a GUI. (then IDK what would be next). These are my goals (in order for now), what are yours? Do you want a GUI before a file system etc?

Looking forward to hearing from all of you!
nolag

There's a lot here: http://forum.osdev.org/viewtopic.php?f=1&t=7695

os goals never ends, so end of a goal means the begining of another goal. OS is a vast enough that which will never end till end of life..............a

series of goals are there......

Combuster concept is absolute Right

"After you finish the first 90% of a project, you have to finish the other 90%." - Michael Abrash.

For info on booting with GRUB2, read the GRUB 2 wiki page.

I can only talk in past tense.

I come from the Amiga camp. I always felt AmigaOS did many things "right". Filesystem layout, GUI responsiveness and intuitivity, MUI look & feel (and configurability), device driver handling, general transparency of the system. For a long time, I had hopes for the Amiga successors to get their act together and push back into the mainstream. But one concept after another died (QNX-based, Linux-based, Tao elate-based, ...).

April 2001, yet another concept was buried, and I was finally fed up. Distinctly unimpressed with Windows, and considering Linux to be too FUBAR to become the mainstream solution, I actually had (miniscule) hopes that I could come up with a project that salvaged the good ideas from AmigaOS, combining them with the "business charme" of Windows and the stability of Linux to become a "big thing".

I wasn't the right man to pull off that kind of stunt. I "went public" too soon (before the project had accumulated enough direction), allowed too much high-level discussion in all possible directions, and was too busy getting infrastructure set up to realize we should've started some coding right away. I also overestimated the amount of work I would be able to put into this (despite making a severe effort that put everything else, including family and job, into second row).

Project died officially in 2004. Some scraps survived: PDCLib, a coding style guide, and an article about component versioning. Plus the work I did put into the OSDev Wiki: convincing chase to make it a Wiki in the first place, administering the PhpWiki it originally was, and writing most of the GCC Cross-Compiler, Bare Bones and C++ Bare Bones articles (plus, more recently, the Makefile tutorial).

Plus, of course, accumulating a ridiculous post count on this most excellent board.

I agree goals are never ending and tht's the nature of life. whether it's knowledge, money, pride, power, etc... goals and desires to get more, make more and to reach higher and higher goes on and on ---> reason for existence of this magical world.

That said, I started with a simple hello world standalone program like many of you guys and here is where I am and what more I want to cover in near term

Till date
1. Protected mode, IDT, Call Gates, Int Gates, LDT, PIC, PIT, RTC
2. Mem Management using intel's page directory infrastructure
3. Task scheduling and management using intel's TSS architecture
4. Using grub boot loader
5. Filesystem
6. Re-compile grub with mos filesystem plugin - so that it can load my os from disk formated in mos fs
7. Converting my os from flat binary to ELF
8. ELF exe and dll loader
9. Simple command line SHELL msh, minimal libc (stdio, string stuff), libmterm (mos terminal lib - curses like but nothing from ncurses),
libmcal (mos calendar library) and finally a simple text editor "edit"
10. cross compile and run "gcc, as, and ld" and compile a small "c program" on MOS and run it
11. Mutex
12. Floppy Drive (intel floppy controller)
13. ATA IDE controller - covering few vendors --- reluctant to complete because of next point (USB)
14. UHCI and EHCI USB driver - with support for "Bulk Mass Storage Device"
15. DiskCache Manager - Uses B+Tree
16. Booting my OS from a usb thumb drive on a real PC and write a simple c program, compile and run it

Currently working on:
1. Converting MOS from C to C++. Finding it very nice... using templates and virtual function
2. Increasing disk io performance
3. code clean up, bug fixes

Future Goals: (again never ending - but what I can see upto)
AAA. Make interface standard and bring in lot of good to have and easy to use features in Shell (msh), editor(edit), UI and in all possible components
1. Message Queue based IPC mechanism
2. USB mouse (and mostly keyboard as well)
3. GUI
3. Network card adaptor driver
4. Virtual memory manager (as in swap space/page-in/out stuff)

Interestingly enough, my motivations are a lot like Solar's, except for one major thing: I come from the Windows camp. There's a lot of things that I think Windows either got right, or could have gotten right, but Microsoft seems to have lost their way. The look and feel of the default Explorer shell is intuitive for the end user, the NT-based kernels are stable, and when properly configured, the system really does run well. However, there's quite a few problems lurking beneath the surface, and those really couldn't be fixed without starting over.

• A few examples:
• Windows was originally based on DOS - a single-user, single-tasking system. Even now, Microsoft seems to struggle with the multi-user concept and can't seem to keep a clear division between user data.
• The Windows registry. This is one idea that I really, really wish they hadn't dropped the ball on. A central database for configuration is a brilliant idea (much easier to administrate than multiple cryptic configuration files). However, Microsoft fell on their face by not providing a uniform, secure way to access the registry and make changes.
• Too-tight coupling between kernel and drivers. Even in the most recent OS's, the entire system can be brought down by a poorly programmed device driver. They're doing a better job with it, but it's still a fundimental design 'problem' that can't be changed thanks to backwards compatibility.
• Security, security, security. Too many holes to enumerate - and yes, they're doing better (UAC, DEP, tons of OS lockdowns with recent OS versons and updates), but there's still so many problems with security that just come from how the OS was designed that can't be completely fixed.
• A 'SYSTEM' account that's (normally) inaccessable to the end user. I'm sorry, no. No no no. There's no reason why the system should have more control over the machine than I do.

I know I'm not the guy to make the next big thing. I'm certainly not smart or creative enough. But I have my motivation, and what the hey, I might make something neat along the way.

OS development is fun, and you might think that by starting today you will get some results comparable to successful hobby OS'es by next month.

But in reality, it's likely to be something like that:

1998:
-Type description into a txt file
-Rename it as game.exe
-Run game.exe
-Wonder what went wrong
-Start thinking

1999:
-Get to know bat files and ansi.sys
-Call that program-off-ZIP-disk-selector an OS
-Make a calculator for it
-Make changeable backgrounds for it.

2000:
-Learn Turbo pascal
-Write better Windows, with round and triangular windows
-Write better DOS, with current directory always shown
-Write a way to load that thing from under MS Windows in windows's place
-Take over the world!

2001:
-Learn assembler
-Rewrite that tanglebox into the efficient machine code
-Figure out why BIOS can't load gif files
-Make better Windows that fit on a floppy, square windows would suffice
-Take over the world?

2002:
-Learn C
-Learn protected mode
-Learn programming and algorithms theory
-Learn what does OS means
-Learn how CPU's work
-Learn how games are really made

2003:
-Find Linux
-Learn why backups are necessary, the hard way
-Find another Linux
-Learn why rm -rf / is not the same as format C:, and why second partition does not constitute a good place to keep backups

2004-2007:
-Graduate
-Enroll in University's Computational Mathematics and Cybernetics faculty
-Discover that Operating Systems department actually teach supercomputer programming
-Learn Delphi
-Learn Java
-Learn Lisp
-Learn Prolog
-Learn FORTRAN
-Learn UML
-Implement every algorithm there is
-Make sense of Linux kernel sources

2008:
-Recover that assembler clustertangle and rewrite it into pascal
-Design a system architecture and rewrite it again
-Make way for loading programs
-Make way for loading drivers
-Learn how PC hardware works on the bottom side
-Make VFS
-Make VFAT driver
-Make floppy driver
-Make VESA driver
-Make some kind of GUI to get larger console
-Make memory manager that can release memory
-Make task manager that can wait
-Make pascal compiler

2009:
-Redesign the clusterentangle again.
-Dissolve the kernel into userspace
-Debug VFS
-Debug VFAT driver
-Debug memory manager
-Debug task manager
-Make some IPC primitives
-Rewrite "pascal" compiler into pascal compiler
-Get USB to work
-Get CDROM to work
-Make ISOFS driver read most CDROM's
-Make OpenGL renderer device
-Get significant amount of code to work for perceivable amount of time without crashing the OS
-Abandon all hope of fitting it on a floppy

2010:
-Offset common code to libraries
-Clean up and keep a consistent design
-Redesign userspace to fold on itself, with consistent interfaces and minimal code reuse
-Add compression support to the program loader and linker
-Make it fit on floppy again
-Redesign kernel affinity
-Port some games and programs into the now-stable-looking OS
-Achieve OS uptime of 1 hour while playing around with compilers and games
-Think up a way to make it all useful
-Take over the world

Yet, 11 years and 14 OS rewrites later, i'm still far from the last two goals

For the most part, the goals of my operating system project were to implement purely whatever paradigm I'd just been learning about.

For instance, way back in the dark ages (high school) I learned about C++ and object-oriented programming. Suddenly, I wanted to write an operating system where everything was an object. I had no idea how to do that, and I was trying to implement it in C, but that didn't matter.

Then I learned about distributed computing systems. Suddenly, my goal was to write an object-oriented distributed operating system. "Applications would just be classes," I'd say, "and processes would be objects that could be transferred to whichever computer was most idle." I didn't get far with that either.

A few years back I learned Lisp (something I heartily recommend). Then, I wanted to write an operating system where everything was just a function (in the Lisp sense), and the entire user experience was a Lisp interpreter. I'm still working on that one. So far I've got ~500 lines of code.

I try not to focus on too much at once. This is why I separate my goals.

My immediate goals is a very stable and fast single-processor only kernel that can handle errors intelligently. To get this, I need to fix any stability problems, implement mutexes, file locking, better VFS, device locking, and some form of IO scheduling.

My goals after that are basic posix support (mainly signals at this point). Once I do that, I'm going to re-port all of binutils and coreutils so that they are updated and running better.

Beyond that, for my OS's first major release, I'd like a better shell and interface.

For the next kernel version I'd like to support SMP.

For the next OS release, I'd like to have an installer so that I can install it to a hard drive from a disk.

-JL