I found that beginners develop an unrealistic idea of how programmers actually is done because they see me using a different set up than I actually use when I code. When I code I don’t use a screen that’s 1080 pixels tall. I actually use a screen that is much larger than that and sometimes even used two screens.
The Planned Features
- UHD quality video at 2160P resolution, but with smaller files for people with limited download Internet.
- A combined format that starts from a beginner level and goes all the way to completing many projects of increasing degrees of difficulty, effectively being two books.
- As with all my books HTML and PDF formats will be available.
- A total of 62 exercises.
This weekend I will be publishing the first exercises that I’ve written which will be up to exercise 6. This first release will be a draft, and should include most of the videos for those exercises. I will then be able to post probably three or six videos a week depending on the difficulty of the exercises. The first half of the book is just basics so that’s pretty straightforward, but the second half of the book is actual coding on small projects so those are little more difficult.
Finally, as I said before the price on the book now is $20 and that’s 50% of the final price of the book is done. Because this book is basically two books, and it’s going to use 2160p video the final price for the book is going to be $45 instead of $40. That means you original purchase of $20 is now even more of a discount once the book is released.
Current Table of Contents
- Part I: Basics
- Section 1: The Beginning
- Exercise 00: Gearing Up
- Exercise 01: A First Program
- Exercise 02: Comments
- Exercise 03: Simple Math and Strings
- Exercise 04: Variables
- Exercise 06: Escape Sequences
- Exercise 07: Prompting Input
- Exercise 08: Command Line Arguments
- Exercise 09: Files
- Exercise 10: Files, Args, Variables, Oh My
- Exercise 11: Functions
- Exercise 12: Functions, Files, Variables
- Exercise 13: Modules
You can see that this book goes a little faster than my other beginner books and has a lot less repetition. By Exercise 13 we’re already loading in external code, writing functions, opening files, and other simple tasks. In my previous books students didn’t reach this level until Exercise 25.
- Section 2: Logic and Flow Control
- Exercise 14: If
- Exercise 15: If and Else
- Exercise 16: While Loops
- Exercise 17: Lists and For Loops
- Exercise 18: More Lists
- Exercise 19: Data Objects
- Exercise 20: First Game
We then get into Logic and Flow Control, where you learn how to make the first useful bits of actual computation.
- Section 3: OOP
- Exercise 21: Simple OOP
- Exercise 22: More Complex OOP
- Exercise 23: Prototype Inheritance
- Exercise 24: OOP Game
I then introduce OOP, but it’ll be just enough OOP to be dangerous, in keeping with the theme of Part I.
- Section 4: FP
- Exercise 25: Functions and Recursion
- Exercise 26: Transforming Data
- Exercise 27: Applying Functions
- Exercise 28: Scope and Closures
- Exercise 29: Currying and Accumulators
- Exercise 30: Events and Callbacks
- Part II: Projects
- Section 5: Hacks
- Exercise 31: Parsing Command Line Arguments
- Exercise 32: cat
- Exercise 33: find
- Exercise 34: grep
- Exercise 35: cut
- Exercise 36: sed
- Exercise 37: sort
- Exercise 38: uniq
- Section 6: Data Structures
- Exercise 39: Single Linked Lists
- Exercise 40: Double Linked Lists
- Exercise 41: Queue and Stack
- Exercise 42: Sorting Algorithms
- Exercise 43: Hashmap
- Exercise 44: Binary Search Tree
- Exercise 45: Binary Search
We then implement some very simply and naive versions of the classic data structures, and start to focus on quality and testing.
- Section 7: Testing and Hacks
- Exercise 46: xargs
- Exercise 47: hexdump
- Exercise 48: tr
- Exercise 49: sh
- Exercise 50: diff and patch
The student then combines testing and quality with quick hacks to apply their knowledge so far.
- Section 8: Parsing
- Exercise 51: Finite Sate Machines
- Exercise 52: Regular Expressions
- Exercise 53: Scanners
- Exercise 54: Parsers
- Exercise 55: Analyzers
- Exercise 56: Puny Python
- Exercise 57: Calculator
- Exercise 58: BASIC
Section 8 will get into the very basics of parsing programming languages.
- Section I: Final Projects
- Exercise 59: blog
- Exercise 60: bc
- Exercise 61: ed
- Exercise 62: sed
Finally, they finish off with a set of open ended projects that are meant to combine everything they’ve learned so far.