Slashdot Mirror
Computer Science Curriculum Using Linux?
I couldn't resist posting this question from Kris Warkentin: "I am helping a professor at my school develop some projects for a third-year Operating Systems course. I told him that Linux would be good for that sort of thing, both as an example and as fodder for development. It is a single term (13 weeks) and students in Computer Science, while competent, are not exactly experienced programming wizards like Alan Cox. So, the question is, does anyone know of any nice little Linux-based programming projects which would give a feel for the OS internals? Maybe some of you have actually taken a course where you wrote a device driver or something? Any ideas or suggestions would be welcome."
This is a real cool idea. Are there any other schools doing something like this with Linux?
i'd suggest doing things with the real time linux kernel (rt-linux). While the student activity may not be directly benefitial to the linux movement, it is an understandable subset of the linux kernel which is designed to be easy to interact with from other kernel modules. besides the rt-linux project is important for embedded systems(an exploding market) and could definitely use a few more eyes.
at my university, the 3rd year introductory OS course uses topsy as the os background
and it involves writing such things as the
virtual memory handling as one of the assignments.
http://www.cse.unsw.edu.au/~cs3231/
as it is now linux is probably too complex to be used, ie modified/improved on by most 3rd year students doing an intro OS course...
We spent a lot of time working with the things that you would need to have programs running simultanously on a single processor: mutex, protected memory schemes, and such.
Maybe other colleges teach less theoretical OS classes, but I really don't see how it would fit in with what I took. (Granted after taking the coure I'm in no way a kernal hacker either, so there is probably a place for this somewhere...)
I would recommend looking into the book "Linux A-Z" by Phil Cornes. He starts off with an introduction to Linux for the complete beginner, but later on introduces neat little projects like Tiny Socket Library, Tiny Shell, Tiny Daemon and Tiny Device Driver. The writing is spare, accurate and elegant, and the book is even typeset (as far as I can tell) in Latex (love those computer modern fonts, just like the GNU manuals).
Of course the material might have to be updated a little here and there to make sure it doesn't lead the students down any blind alleys, but the beauty of the self-contained "Tiny" case studies is that they contain enough code to illustrate the principles being expounded - just tweak them a little if the system interfaces have changed and they'll still be great teaching material.
Chris Morgan
We also use Operating Systems: Design and Implementation (2nd edition) (Tanenbaum and Woodhull) as a textbook which includes Minix media and goes into great depth about the Minix OS.
The Linux kernel may not be as well documented for educational purposes.
For relatively advanced students, I'd recommend writing their own simple filesystem.
/proc telling various things about the system state.
For beginners, a new directory on
Or re-develop an existing device driver.
One of my OS courses involved loading BSD3.0 on a machine. The instructor gave us an overview of the internal structures and by the end of the course we had to make a significant modification to the kernel. The modification didn't necessarily need to extend the product in a meaningful way, it just had to interact with the kernel in a manner that demonstrated we had an understanding of the kernel. I.E. My project was to create a new FS that would encrypt/decrypt the data being written/read to this filesystem. Modifications were made to the utils such as mount to recognize the new FS and ask for passwords. The encryption algorithm was just XORing 1 to the data but the point of the exercise was not to design strong encryption but to show knowledge of the kernel internals. With Linux it would be easy to instruct the students on the structure of the kernel and how to extend it with modules. Have them write simple programs to drive printers through the serial port. Get them debugging kernel code. Once you are elbow deep in, new and more complex projects will present themselves such as different scheduling algorithms. Don't underestimate what the students might be capable of.
I'm currently taking an operating systems course in my 2nd year at university. The course uses MINIX as its example operating system. This includes using examples of how MINIX implements, say handling concurrent processes, in the leactures and also using MINIX as a base for the practical work in the course, although we don't actually fiddle with the MINIX code itself. I think that whatever OS you use in an OS course it is important to remeber that just studying that OS will not give a rounded a view of how OS's work. Rather the implementation of the OS studyed should be used as a getting off point to also look at the many alternative ways in which OS features can be implemented.
At my school we are using Linux for our OS class now. We tweeked the RT scheduler , and added a new type instead of just FIFO, it was similuar, but did allowed jobs to be prioritezed before they started excuting. Starting with the proc entry was a good place to get going from. The device Driver was also a very good project. The device driver we impletmted was just a message queue. IE a /dev/msg entry where you would open the device, write some string, and it was stored in the kernel, Then reads on the device would return the messages in the same order. Good Project. For the final project we are working on a file system. They dont think we can code well enough so its all similuated in user space, but hey Im gunna wedge into the kernel cause thats just uber cool. I would also recomend groups of 2 students, try and give 1 - 2 weeks for each project, and then do the filesystem last, give 4 weeks, and make it kernel space.
Have you actually _looked_ at the kernel sources?
It's quite unapproachable. Not because the things that are being done there are particularly complex, but it's all over the place and almost completely undocumented/uncommented.
Sorry to say, but the lack of documentation and plain simple comments is caused by laziness, arrogance and selfishness. This will detract from the usefulness of Linux because people such as yourself will be driven away. It will reduce the size of the developer community and will _of course_ reduce the quality of the product.
This will only get worse as it's going from a simple singly threaded model into a much more parallel design. There is NO SUBSTITUTE for carefully documenting your locking strategy. The designer's intentions cannot be practically reverse engineered from the source and without a clear understanding of the locking strategy the only people who can effectively maintain and grow it are the original authors, as long as they remember what they were thinking at the time.
And who can we blame for this situation apart from he-who-waddles-on-water?
- Anonymous Linux kernel developer.
During my last term I took Intro to Operating Systems we used a set of source code from berkely and washington called nachos. It basically emulates a MIPS 2000 platform. It is set up to have around 5 or 6 projects. Multithreading, File systems, Multi-processing, Memory Management and others. There are ports of the code for BDS, Linux, Solaris etc.... I suggest you go here for ideas. http://www.cs.washington.edu/homes/t om/nachos/
Here are some of the things I've enjoyed doing
:)
as school here at Concordia (the university in
Montreal)
Writing a simple shell with support for pipes
and i/o redirection.
Writing a simple server-client applications (some
kind of echo or file transfer client)
Writing a program to dump a file to stdout by
reading the disk blocks directly.
Writing a rudimentary undelete for ext2.
Using semaphores to solve simple multi-thread
problems (one writer-may readers, cars on a bridge
etc)
IMHO, a number of smaller projects is more useful
than one large one because the students can find
what they like and then can maybe expand on it later when they become open source contributors.
Just look at any part of the system and ask "I
wonder how that works" and voila, a project will
hatch out of that slowly.
Good luck!
Dana
Wouldn't Minix (or, perhaps, a very early Linux) be better for for most educational (kernel work) purposes? Linux is getting kinda large and, generally, that means that it gets harder and harder to extract the concepts from the code.
;)
I would think that a highly modular (read: totally unoptimized except for clarity) small kernel system would be vastly superior for most educational use. Note that I understand that, at the highest levels, there is no substitute for studying reality in all its complexity. But most of education involves building to that level and LInux is a big chunk.
As for non-kernel work, which the questioner seems to be suggesting, I imagine Linux would be perfect. You would only need to look at particular pieces of code when your device driver behaves unexpectedly. That the code is there and royalty-free is a huge advantage. That the code is solid and well tested is priceless.
Geeky modern art T-shirts
I just finished a course like this. We used RedHat
5.2 (with a nice, relatively simple 2.0.x kernel
that reduced the learning curve a bit). We had two
kernel programming assignments:
1) Add process scheduling groups.
We added a couple new system calls that allowed processes to create and then join new
scheduling groups. You could set priorities for group member processes and then any time one
member of the group came up, the highest priority TASK_RUNNING process in the group would
be selected to run instead. This lead to pretty useless behaviour but didn't involve anything
other than adding to the scheduler, so you didn't screw up the behaviour of non-group-member
processes.
2) Add a new in-RAM filesystem to the kernel.
We had to add a 128K in-RAM volatile (your data disappears when you unmount the fs) filesystem to
the kernel. This was nice because you didn't have to create any user-space tools (other than
your own version of mount). When you mounted one of these filesystems the kernel allocated
128K and created your filesystem on it. You could mount as many as you wanted and use them
just like any chunk of disk space. This was a great way to learn the basics of Linux' rather
cool VFS.
Neither of these projects was hugely difficult but
they weren't trivial either. We also had to write
some basic kernel functionality benchmarks and
compare Linux 2.0/Sparc (our systems) vs. some
Solaris/UltraSparc systems. That was interesting
as well. This was a great course, so long as you
liked alot of programming.
in the Carnegie Mellon operating systems course (mostly taken by juniors/seniors, tho it isn't specifically a "3rd year" course), you don't start with any operating system.
... that's kind of the point :)
The course is taught on SPARC emulators, which run on (you guessed it) SPARCs and make the architecture a bit more manageable. But you write the operating system
It's not all that complex an operating system, nice and straightforward and unix-ish, but it's a hell of a lot for one semester. The course is done in project groups, and it has a reputation as about the hardest class out there.
I've had friends in the course get back after a week almost exlusively in the lab. They show up friday afternoon in a zombie like state...
--"What did you write this week in OS?"
--"Huh? Oh, inter-process data streams. You know, pipes"
--"Neat"
--"pipe pipe pipe! pipe! PIPE! PIPE!" [nervous sobs]
At the University of Maryland we wrote an extreamly primitave OS (no filesystem, no memory protection, but it had a text mode windowing system!). We did it from the raw hardware, so it was pretty damm chalanging. You learn a lot of things that way (like how to really write intrrupt handlers, not how to use someone else's framework!).
I think there is a lot of merit in that approch. It was the only class at UofM where we touched bare metal (the assembly class was close though). I think it is important that CS students do that at least once.
I also think students could benifit from doing larger things to an existing OS. But as a diffrent class. I would focus not on things Linux needs, but things the students could learn from. Like putting in a fixed-priority scheduler, and then testing for priority inversion, and finding a way to fix that. Maybe adding a batch scheduler. Writing a driver for a simple piece of hardware (like the serial port). Maybe something slighlty more complex, like something that DMAs. Maybe an IDE controler driver. Sound cards would be better then IDE controlers, except that would be a pain in a lab enviroment, and the hardware changes from year to year.
I know none of this would directly benifit the Linux comunity, but it would greatly benifit the students. Remember it is easyer to grade a project with a known outcome then something open ended! It is also easyer for the TAs to advise students on smaller projects with known results. The students will gain some first hand knolage of formerly abstract concepts, and some knolage of Linux internals.
When I taught our (UNC-Charlotte's CSCI) graduate operating systems course, assmuming that the students had already received an undergraduate OS course (sadly, sometimes too hopeful of an assumption) which covered the core basics of memory management, process management, context swtching, and introduces the two-layer device driver approach (our undergraduate course uses the XINU book), I picked up where that course left off, covering more about device drivers, I/O descriptors and their interaction with system calls, the filesystem (on-disk implementations, kernel implementations, different implementations at different mountpoints), then finishing off with distributed systems. One large component of the course was reading the Linux kernel source code in order to see a "real world" implementation of the coding concepts discussed in class. I have aways been a critic of how too many CSCI courses focus solely upon writing projects, yet don't spend enough (or any) time having the students read non-trivial code. We wouldn't ask novelists-in-training, essayists-in-training, or poets-in-training to write more than we've asked them to read, would we?
Anyway, two series of projects accompanied the lectures and assigned code readings. The first was to design and implement a basic interactive shell, first with basic file redirection and piping, later adding redirection to TCP sockets. This project aimed at giving the students a taste of systems programming that they may not have otherwise received, plus hammering in the UNIX concept that read() / write() will work on any sort of descriptor, be it pipe, file, or socket; even without the knowledge / cooperation of the process doing the I/O. At the time of writing the projects, the students were to read though the kernel code which implements the major system calls that they were using in order to see what was really going on (or at least to get a general idea that it all wasn't magic -- it all boiled down to "C" source code somewhere).
The second project suite was the implementation of an inode-based filesystem, starting from the ground up. First write a simulated mini-SCSI bus that supported two types of devices (one with 512-byte sectors, the other with 4096-byte sectors, just to ward off assumptions at the inode/block management layer). Once that works, add an inode manager that can use one of the virtual SCSI disks. Lastly, add a directory services module on top of the inode manager, so that we can manipulate files, directories, and symbolic links.
Ultimately, the projects asked a good deal from the students, as that the majority of them had not written any multi-threaded OO systems that made use of message passing (over the SCSI "bus"), so not only did they get to simulate some kernel components, they also had to come up to speed with some relatively advanced programming designs. The folks who used C++ learned the hard way that (at the time) debugger support for multithreaded programs was, um, challenged. Folks who wrote in Java had a bit of an easier time. Depending upon the level of knowledge in your undergraduates, I would not recommend the filesystem project. The shell project, OTOH, would be applicable to either 3'rd/4'th year undergraduates or graduate students, as that it hits home on the core UNIX datastructure -- the I/O descriptor. If the students were to have root access to the boxes, then I would have them perhaps extend an existing kernel subsystem or to write a new driver given an existing one. What about a thorough examination of the Linux scheduler / context switching algorithm. Could they cut any fat from it, as the IBM JDK folks did? What about examining the timer system? What about implementing a new "toy" virtual device driver, such as /dev/random (not that it is a toy, but that it doesn't correspond to any single piece of hardware, per se), such as a simple message passing port? One process opens it up, writes to it, then closes, followed by another process opening it and reading from it. That would demonstrate upper-layer device driver interfaces, plus the issue of passing bulk data to/from user space, and why time spent memcpy'ing becomes a factor in I/O bound systems.
Oh yeah, one other thing. You might want to think about obtaining the source code for more than one OS kernel (say also a *BSD kernel or the Solaris kernel -- being at an institution of higher learning, you should be able to get the Solaris source code w/o charge) in order to have the students compare / constrast the different approaches taken.
Have fun with the course!
In my OS class (and at other schools like UC Berkeley, Duke, and Harvard) we used a package called NachOS. It runs on a MIPS emulator, and you write large chunks of the OS yourself. We had to write processes, system calls, filesystems, VM, schedulers, applications for the OS (the shell was just 5% of assignment 2). The final assignment is to write a couple different schedulers or other subsystem, then performance analyize the hell out of it, which was really interesting.
Granted this course has a reputation for being WICKED hard. The whole OS is multi-threaded etc etc, so you have to deal with all the fun race condition issues just like a real OS. Running on a simulator makes life much better for a couple of reasons. 1) crash/rebuild/restart/debug cycle is MUCH FASTER. 2) debugging real kernels w/o having two machines (for serial debugging) is not fun, plus you've got to have the machines for the students, which can be a pain. 3) come on, device drivers aren't the _interesting_ part of the OS, so using a system where thats already done is more useful.
I liked doing this better than what other people here have suggested. I think just writing a device driver is kinda silly. It's a reasonably straight forward project, not really a good thing to do in an OS course, having students working with all the important OS components is much more useful. Starting with Linux is not a very good idea because of the large code base, and from what I've seen it's not really the best code for students to read. I would recommend one of the BSDs if you really want to go with the whole OS paradigm, especially FreeBSD when McKusick comes out with "The Design and Implementation of the FreeBSD Operating System." A second OS course or a Graduate level one is a better place to have students dive into a real OS, at that point you know the background theoretics of OS work, and you've written a fairly large code base of your own. Then it becomes much easier for students to dive into a real OS and do some research.
For books I'd say the Tanebaum book (already mentioned here) and the 4.4BSD book are very good.
--Britt
No, really! Even though I am not well versed in kernel design, just flipping through the FreeBSD kernel code will teach you quite a bit about how the system works at a user level. The Design and Implementation of the 4.4BSD Operating System is an excellent resource to have handy when learning to program at the user level in Unix. If you use it, you will have a far greater understanding of how the kernel and libraries are handling the calls you make and you will quickly understand programming more.
Linux Kernel Internals 2e Beck, Bohme, Dziadzka, Kunitz, Magnus, Verworner Addison-Wesley 1998 480 pages ISBN 0-201-33143-8
Linux Device Drivers Rubini O'Reilly 1998 421 pages ISBN 1-56592-292-1
Linux Core Kernel Commentary Maxwell Coriolis Press 1999 575 pages ISBN 1-57610-469-9
Applied Operating System Concepts 1e Silberschatz, Galvin, Gagne Wiley 2000 840 pages ISBN 0-471-36508-4
You do realize that learning UNIX is not essential to having a CS degree. People can be master programmers without ever having touched UNIX. There are many reasons, but the main ones are...
A) Everyone uses Windows. Face it, a deep knowledge of Win32 is much more usefull than a deep knowledge of UNIX in the commercial application world.
B) The Win32 is easier to learn and has more coherent resources. Sure the UNIX APIs have much more documentation, but the books put out by MS give a pretty good overview of the entire API.
C) CS degrees can also be in algorithms and programming techniques. In that case it doesn't matter what OS one uses, becuase most calls will be standard C or C++ library calls.
D) CS degrees can also be in computer graphics, in that case windows is the best OS to use because it has the best hardware support for graphics APIs. And if your programming so low level that you're not using OpenGL or something of the sort, then your probably using DOS.
Just because many people use it in the CS field doesn't mean its the only way to go. DOS is probably the best for beginning level CS courses, and for application design, BeOS is probably best because its API is so easy to use. For scientific and other hardcore stuff, UNIX is probably the way to go.
A deep unwavering belief is a sure sign you're missing something...
Actually, don't critisize NT for having fork() take parameters. NT was designed for threading from the ground up, and fork() and some of the other POSIX stuff doesn't mesh to well with it. Its a problem in general for systems that aren't POSIX at the core, I know BeOS really doesn't like forks() and once you use one, you lock yourself out from using BeOS threads.
A deep unwavering belief is a sure sign you're missing something...
My experience has been that the thing that programmers find hardest about kernel work is learning how to think about how things interact in time - ie non-sequentially - I spent 5 years unix kernel hacking for a living and even for the really experienced people I worked with this was something they had to think hard at to get right - it never seemed to become they just understood intuitively. Now after 10 years as a chip designer it's become 2nd nature.
Also make sure there's something to do with cache coherency - learning where the right places are to flush the cache (and not to do it too often) when 2 concurrent things are communicating (a dma controller with a driver for example) - this is something that requires a good detailed understanding of the hardware that's underlying the system
Andrew Tanenbaum: Modern Operating Systems, Prentice-Hall.
This is a very good book for introductory Operating Systems.
I learnt one of my programming strengths from Tanebaum's book: multi-processing/threading (experience in the real world has lead me to believe most people have no clue when it comes to programming concurrent code). After taking an OS course, people should be able to describe a solution to the Dining Philosopher's problem (I used to ask about this when conducting interviews of potential new hires, explaining it for those who weren't familiar with it - I was shocked by how many people couldn't deal with it). Every program I right these days has concurrency issues. My course taught this through a thread package that abstracted threads to their base concepts without getting into operating system specific implementation details (it incidentally ran on Linux). Getting bogged down with an operating system's implementation details just causes confusion in an introductory course, making it more difficult to learn the base concepts.
The last project of the course was a bit more specific, and involved writing a mini-shell for Linux, with some of the c-shell functionality (commandline parsing, sychronous and asynch program execution, etc). But by then we were familiar enough with the concepts that we ready to try doing it for real (although a lot people were still able to bring down the Linux boxes by eating up the process table).
My advice: work though Tanenbaum's book, which will explain the most important OS concepts: stressing fundamental issues in design, process management, memory management, synchronization, interprocess communication,, file systems, shared resource management, etc. Then on the practical side, base the assignments on concurrent programming. This takes time to learn, it's best/only learnt through experience, and is a critical concept to understand.
Andrew Tanenbaum: Modern Operating Systems, Prentice-Hall.
This is a very good book for introductory Operating Systems.
I learnt one of my programming strengths from Tanebaum's book: multi-processing/threading (experience in the real world has lead me to believe most people have no clue when it comes to programming concurrent code). After taking an OS course, people should be able to describe a solution to the Dining Philosopher's problem (I used to ask about this when conducting interviews of potential new hires, explaining it for those who weren't familiar with it - I was shocked by how many people couldn't deal with it). Every program I write these days seems to have concurrency issues. My course taught this through a thread package that abstracted threads to their base concepts without getting into operating system specific implementation details (it incidentally ran on Linux). Getting bogged down with an operating system's implementation details just causes confusion in an introductory course, making it more difficult to learn the base concepts.
The last project of the course was a bit more specific, and involved writing a mini-shell for Linux, with some of the c-shell functionality (commandline parsing, sychronous and asynch program execution, etc). But by then we were familiar enough with the concepts that we ready to try doing it for real (although a lot people were still able to bring down the Linux boxes by eating up the process table).
My advice: work through Tanenbaum's book, which will explain the most important OS concepts: stressing fundamental issues in design, process management, memory management, synchronization, interprocess communication,, file systems, shared resource management, etc. Then on the practical side, base the assignments on concurrent programming. This takes time to learn, it's best/only learnt through experience, and is a critical concept to understand.
Follow this link for the thread package that I learnt from (Carleton University, Ottawa, course 95.300). It runs in Linux, it's light-weight, it's simple, it helps with learning the concepts.
Given the Debian team is mostly in their mid teens, they're perfectly capable to learn this stuff.
The message on the other side of this sig is false.
Hmm... I'd have mixed feelings about using Linux for this sort of class, because I'm a big fan of hands-on learning. And, if you think about it, writing a device driver isn't much like designing a whole OS.
Around here, our OpSys class uses the Tannenbaum book (which includes lots of samples from Minix, a simpler OS that was designed for teaching purposes). In small groups, students then implement most of the major OS subsystems (memory management, file system, boot loader, etc), while being given code for some of the more dull things (i.e., the shell, although I did just have to write a job control shell for another theoretically-second-semester class and it was a boring $%!#%). The cool thing is that, at the end of the semester, you have a floppy disk with your own primitive OS on it.
--JRZ
Computer Science studies at the university level are still not focused enough towards helping the student find a job afterwards.
Thank God! If you leave college with a strong background in programming and theory (even if you mostly just know C/C++ and Linux or Unix), I mean, one that covers theory of large-scale programming, OSes, and especially algorithms, you'll have a long-term base that will last you even if we all end up progamming in some bizarre, currently-unknown lagnuage on 3-dimensional displays running on BeOS 9.12.
Why? Because, if you know your stuff, you can always pick up a couple of books or take a quick training class (cost: $100 - $2000 ) to learn the newest industry trend. But if you don't learn the theoretical, university-style fundamentals, you will most likely never learn them, and go through the rest of your life as a fairly mediocre programmer.
In particular, it's scary that I've met people who graduated with nothing more than a series of "Programming in X, level Y" classes. A friend of mine intereviewed someone who came from a curriculum like that, and asked him to write "strlen()". The applicant (a VB programmer) thought about it, then proceeded to write a program that repeatedly split a given string in half until it ended up with only one character, then counted the number of splits it took. Wow.
You can learn "skills" any time. Use your university time to learn theory, if you want ot get your money's worth!
--JRZ
Linux is pretty much finished now, so finding new things to do can be
either hard or give you a feeling that you're not doing "real
work". But what about GNU HURD? It's a work in progress right now,
needs a lot of help, and is a microkernel, which is a much more modern
design. How about contributing?
- Adi Stav
Currently, they teach a lot of computer theory with BSD based systems. A lot of the campus infrastructure runs with FreeBSD, and the fact that the CSRG was started there and Kirk McKusic teaches there sorta helps that along. Reviewing FreeBSD kernel code is easy because its clean, fast, and it makes sense. I've read through a few other Kernels and none of them made as much sense as the FreeBSD kernel did, maybe it shows bias, but I know quite a few people who feel that way.
Every time I read through Linux source, I have to grep to find things, its pretty imposing.
not really. linux may be large but all the drivers are really small. complexity is great to learn from and its not that hard. it took me two weeks to write a barebones driver. i'd recommend a fairly simple project that illustrates some important concepts for this sort of thing. maybe a small kernel based timer to drive an external application of some sort, a small filesystem driver, a small network driver for a crude serial port network device or something similar. the palmpilot is a great help to hook up via the serial ports or a small serial terminal with a small microprocessor which can be programmed to simulate various simple system concepts and/or hardware interfaces.
If even one university put this sort of class project into operation the open source community would benefit tremendously. Imagine: instead of having a new flavor of mp3 encoder coming out every day, students could all pick their favorite and make it better.
And I don't think I need to tell you that this would be an important learning process for CS majors today, given the open source revolution we seem to be in the midst of. Writing the code is important, but learning the CVS model of development has real-world implications (even if you go to work for a commercial software entity like I did). Any coder can sit down and knock off a simple program from scratch; it takes real knowhow to learn how to work with and leverage other people's code.
It's rare that you're presented with a knob whose only two positions are Make History and Flee Your Glorious Destiny.
I believe that Linux would probably be too complex for use in an introductory-style OS course. Perhaps we are missing the point here - OSes used in teaching courses should be a) simple, b) easy to modify and c) allow investigation a selection of concepts, without having to know it all at once. They are not for contributing to Open Source success.
:-). When I left University, they were using Minix. Perhaps something else has come up since then, but I can't convince myself that it is Linux.
In my undergrad OS course we used some funky custom-built thing on PDP-11/03's (Oooo... those front-panel switches
I agree with what you said, that NU for DOS is not needed.
But I am NOT talking about NU for DOS. I _am_ talking about NU for windoze.
Have you played with the latest version of NU for windoze?
You'd be amaze how many things they have there. Some of those things are _seriously_ needed for Linux.
And I am not joking.
Muchas Gracias, Señor Edward Snowden !
>>>>>>>>>>>>
My experience says otherwise. I know patch-installing, MS Dev subscribing, hands-on Windows MCSE/MCSD gurus who can definitely be said to have a deep knowledge of Win32. But that's it. Win32. One set of APIs. The Microsoft-centric way of doing things. "Click on these wizards here and it will do it all for you" kind of programming. Of course when it comes to having to digging down to the bones to find out what is going on - perhaps to solve a difficult problem - they're clueless. They don't have the source to the OS so they can only make educated guesses at best as to what might be going on. >>>>>>>>>>
Thats a pretty sad group of programmers then. The problem is that you believe that sterotype that all Win32 programmers use app wizards. Some do, mainly hobbyists, but I know that in circles of serious programmers, even using something like MFC is frowned upon. Most can dig down into the roots to find a difficult problem. The 3D studio MAX guys could probably whip 99% of the Mesa or KGI guys when it came to graphics code. If you're talking about less serious programmers (like most Linux programmers are) then yes, maybe they do use MFC and app wizards. Windows is a fundementally different paradigm from UNIX, especially Linux. Most apps that ones uses in Linux are made by people who do it on the side. On Linux these people have to use the low level code, but on Windows they'd probably use app wizards. On windows however, you're mostly running apps from major developers, who hate MFC and app wizards.
Second, I never said that windows was properly documented. For the course of a few years of college training however, you're not going to need anything more than Petzold's books and some books and algorithms. Sure there are a bunch of undocumented things, but there their mainly because your not supposed to use them. You can't critisize MS's documentation guys. DirectDraw alone has 600 pages of documentation in a word file. As for not having source code so one can learn about the inner workings in solving a problem, all I can say, is that you shouldn't need to. First, programmers have been getting along fine for decades without the source to the OS. Second, if you need the source to understand whats going on, then the API is badly designed, and the documentation is inadequate. Third, its people who look at the source to take advantage of the system who are the root of all the legacy crap today's OSs have to carry. As for CS degrees in algorithms,
A) Windows is friendlier and more familier to work with
B) VisualC++ is $99 for educational purposes. My high school has hundreds of licenses for it. Whats so expensive about it?
A deep unwavering belief is a sure sign you're missing something...