I’m finally going back to revise and re-record my older videos. Not only should this greatly improve the sound quality, it also gives me a chance to correct errors and make the narration clearer. It also allows me to rethink the structure of the whole series. Currently, the videos are all ordered in a linear sequence, such that viewers are expected to view them in a specific order. In the revision, I’m rethinking this order and sorting the units into tracks:
Track A (intro to coding):
- a simple programming language
- HTML and CSS
- 2D graphics (with the HTML canvas)
- object-oriented programming
- code practices
Track B (fundamentals):
- bits and bytes
- numbers as bits
- text as bits
- hardware basics
- operating system basics
- programming languages
- Python collections
- the Internet
- server-side web programming
- the C language
- data structures
- searching and sorting algorithms
- Unix system calls
- terminals and shells
Track E (misc.):
- the Java language
- cryptography basics
- version control with Mercurial
The tracks should be viewed in alphabetical order, except tracks A and B can be viewed in either order (or in tandem), and C and D can be viewed in either order (or in tandem). Within each track, the videos should be viewed in order (except for track E, where the viewing order doesn’t matter).
Even though I’m working from earlier work, it’s surprisingly time consuming. I’m effectively writing all new narration for each video and edited many of the slides. On top of this, my audio editing process is even more tedious than before, but I think the better quality narration is worth the time.
Revising the whole series will take at least the rest of the year. In the meantime, I’m also working on the game programming series, including the next installment, which covers texture mapping.
Finally got this one finished. I ended up dropping coverage of a few topics, like bookmarks, but I’m otherwise pretty happy with it.
Next up is a unit on build tools and build processes, though this one will probably be a few months in coming.
I’ll also get around to updating the Python supplements to better reflect the new videos.
Next up, version control with Mercurial.
Sill working on a version control unit covering Mercurial, but I decided the Python supplementary material would be better delivered in video form instead of just text. The new “Python continued” videos cover a bunch of Python miscellany, and a soon-to-follow set of videos will cover Python collections.
This one’s a long one (2 hours), mostly because I cover the better part of a whole web framework, web2py.
Up next is probably a unit about version control focusing on Mercurial. I’ve also gotten suggestions for build tools and debuggers, like make and dbg.
It’s also about time to create a short (5 min) intro video for the whole series to lay things out for first-time viewers.
Finally finished and posted “Unix terminals and shells”, which runs about ~80 min. This one was a dog to make because I had to get into details about terminals and bash that I wasn’t clear on. Hopefully I didn’t end up saying anything too inaccurate.
I’m thinking of supplementing the unit with another video just about the 30-or-so most commonly used commands.
I’ve yet to write notes and a proper intro, but the video itself is up for Unix system calls. I think I’ve finally cracked the approach for covering terminals and shells after reading the whole GNU BASH manual. I also found this about tty’s a useful resource.
The video lecture for the OOP unit is now done and on Youtube, though I’ve yet to produce notes for the unit.
Next on the list are Unix system calls and Unix terminals and shells, which I’ve moved up to a position immediately after Python but before C. Putting system calls before C may seem odd, but it’s quite deliberate: the system calls are described in broad detail without reference as to how exactly to call them and how to properly handle errors.
After that, I’ll focus on redoing the old videos, starting with first programming language.
Python video is up, as is the supplementary material for Python.
The OOP unit is next, and that’s a short one.
You’ll also notice that I’ve turned most of the notes and supplements into proper blog pages so they look much nicer, and I’ve added intro pages for most units.
In other good news, I can now upload videos longer than 15 min to Youtube, so I may begin uploading the video for each unit in one big video rather than splitting them into ~10 min sections. I wonder though if some viewers prefer them divided into sections.