Printer-friendly version

This course in introductory Linux kernel programming is the first in what will be a series of online courses published by Crash Course, so it's worth explaining in some detail the delivery model and how this is going to work.

All Crash Course online courses are, first and foremost, courses. That is, they're not simply explanation or tutorials; rather, they're designed to incorporate labs and exercises and commands to run and, in some cases, even homework assignments you'll be given to work on before the next lesson. Quite simply, if we describe how to do something, you'll be expected to actually do it and see the result.

The pricing model for Crash Course offerings is also something you might not be used to. Every online course will be eminently affordable, as you can see with this first course which has a registration fee of only $39 (CAD). That's not per lesson, that's for the entire course. In addition, every course will release at least its first couple of lessons under the Creative Commons license, so that potential students can check out the first part of the course at no charge, and even use those first few lessons in any way that's compatible with the CC BY-SA license. And now about the course itself.

It's important to emphasize that this is an introductory course in Linux kernel programming, for people with no experience in that area. That means that this course is not designed to make you an expert kernel hacker by the end. Rather, the goal here is to establish a solid foundation of the fundamentals that will let you take off from there and get into more advanced topics (some of which wil be the subjects of future Crash Course offerings).

As for the syllabus, while this might make some people uncomfortable, it's still in a state of mild flux for a very simple reason. As we're producing each lesson, I'm reserving the right to arbitrarily shift material around, or tweak a particular way something is explained, or even to add entire new topics on the fly if I think it will add value to the course.

In short, while some people want to see an exact list of every single topic that will be covered in this course with its official predicted publication date, that's not going to happen here. What I can do is guarantee that, in addition to what has already been published, we will be covering, at the very least, all of the following topics:

• using git to build custom kernels,
• the ins and outs of module entry and exit code,
• working with module parameters,
• communicating with modules via the ioctl() mechanism,
• debugging using the /proc filesystem and sequence files,
• the mechanics of system calls,
• the debugfs filesystem,
• modules and the kernel symbol table,
• memory allocation primitives in kernel space,
• device registration,
• and whatever else I can cram into a first course in kernel programming.

and possibly even more depending on how the schedule works out. So, at the moment, that's as confirmed a syllabus as you're going to get but, based on student requests as the course progresses, we're certainly willing to entertain adding the extra topic or two as long as it doesn't fall outside the scope of this being an introductory course. I hope that addresses any of your concerns.

Finally, if you have questions, well, rpjday@crashcourse.ca. That's me. And so is this if you want to keep up with course developments via Twitter.

Your mission now is to work your way through those first few, free lessons, test everything and see what you think. Happy hacking!

Robert P. J. Day
Crash Course