Sorry, I haven't released any sources/binaries yet
My signature says: "14 todos away from 0.1". A basic outline of what these are include (I won't list them all since it means digging through my source directories looking for my todo.txt):
- Finish IPC (half-implemented)
- Optimise my system calls
- Move trivial code (for disks, FS, keyboard, etc) outside of the kernel.
- Fix a lot of bugs and finish my VFS.
- Work on a more elegant way to communicate window contents between Application <->Window Manager <-> Video Driver
My last 4 todos are simple applications I'm going to write (a program launcher, a text-based calculator, a process manager front end, a simple pixel manipulation example).
So basically, 0.1 will include a basic GUI with 2 types of windows (console and window frame buffer), a VFS (with floppy/FAT reading), IPC, and a few programs.
After 0.1 I plan to release 0.1.5 which won't add any features, but while I was developing I was making a list of potential optimisations which I'll implement to 0.1.5 (as well as concentrating on bug fixes). When I'm happy with the stability I'll progress to developing 0.2.
For 0.2 (the details haven't fully been planned) I'm going to get a mouse system working then focus mostly on my third and last type of GUI windows; control windows. Control windows will contain widgets, and the drawing of widgets and controlling widgets (passing text, mouse events, etc) will be handled by the library. When I have a base widget system working I'll add a few primitives (labels, checkboxes, text boxes, etc). Possibly if I have time I could add an image box widget that I can load a bimap image into.
I planned on reaching 0.1 this Chrismas break, but I've been extremely busy and haven't been able to find the time. And my motivation has been jumping between my OS and my other project (my game framework which shares concepts with a microkernel - drivers represent Direct3D, OpenGL, Windows, etc. and servers represent scene graphs, garbage collection, logic, etc.).
--------
Anyway, I'm sort of half/half in switching to C or staying with C++. There are limitations, but some of my greater design goals over come these.
Against C++:
I can't point to functions within C++ classes making vtables practically useless. I know I can use interfaces but only if I know the function I want to be called (and it's parameters and make it's the same function in every class) and inherit from the interface. Mostly used for IRCs and timer events.
For C++:
Some of my 'greater' design goals get around this. As things are moved out of the kernel I don't need function pointers because my drivers receive events (IRQ fired, timer expired, etc).
Against C++:
It's sometimes hard to define what should go into a struct and what should go into a class. e.g. A process and thread can be represented as a class since it's the Process class is the reasonable place to put a function for association a thread with a process. A FAT header would be be better stored in a structure, since it's a more like data you read from rather than an object you interact with. Some things are less blurred. E.g. An mounted instance of a file system, a struct would be simpler to pass around between my file system drivers and VFS, except in I could make the mounted instance a class with Read/Write/etc operations so I can just call those without having to find which FS the instance belongs to and pass the struct as a parameter.
For C++:
Interfaces and objects greatly simplify code and make it possible to wrap the messiest low level code in elegant and abstract classes (and also vice versa
). Inheritance is a god send (devices and drivers all inherit from a base device and driver class which common functions (detect, install, read, write, etc) and reduce the need for long function names: io_device_read() can be named read() in the Device interface class (with each specific device having it's own implementation) existing in the IO namespace.
The differences between using C/C++ in my kernel aren't really to do with the differences in the language but rather the methodology of programming usually associated with the language (C: store everything inside of structs that are passed around vs. C++: wrap everything in classes and namespaces).
For now I'll probably stick with C++. I only thought about using C for my kernel (not my drivers) because in a perfect microkernel the only thing which should exist inside of the kernel is process mangement, IPC, and minimal device management. The more I move out of the kernel the simpler the kernel core becomes making C (and representing processes and devices as simple memory structures) seem feasible again. And the overhead of calling a function is much lower than calling functions between classes since you don't have the overhead of saving and changing the class states (although in reality this is only a few extra instructions).