1. Lexing - DFA's and NFA's, hand coded or with a lexer generator, relationship with regexes
2. Parsing - LL, LR, table driven, recursive descent, hand coded, parser generator generated
3. Interpretation - simulate control flow and data representation in a host language
4. Translation - generate bytecode for an existing vm like JVM or CLR, or assembler for processor architecture of your choice
5. VM - implement you're own vm, choose an instruction set, implement garbage collection
Getting a handle on this set of knowledge and skills will take you a considerable way to becoming a 'master'.
This for me is the major takeaway from the article. Trying to learn material 2 levels up is unhelpful. It's especially bad since most of us are used to formal schooling where level progression is determined for you
I really wish that every profession came with a tutorial (outside of a four-year college program) saying "here's exactly what you need to learn, in exact order, to get started."
Ideally you would approach this from both ends. On one end you are learning bottom up. On the other end you see what you need to make and you backtrack from there until something you know and you try to make your way up.
I've found I don't really level up by reading books or tutorials.
I level up when I actually do a project by myself from start to end. For the projects I do, there tend to be parts I know and parts I don't, so I still Google for the relevant bits and pieces that I don't understand.
So I guess keep working on projects that have parts you don't understand. There also need to be parts that you do understand, so that you don't feel like you're jumping in at the deep end.
On a side note, I'm not knocking reading books. They help me become aware of certain ideas, but I don't learn them completely until I've implemented it myself.
I find reading books, articles, tutorials is a great way of finding out what you don't know and what you might want to try tinkering with next to level up, because otherwise you just use the same techniques over and over, but to actually level up you need to get down and dirty and write a lot of code.
Actually, I use Clojure quite a bit, so that won't scare me at all!
I've already got Programming Clojure (and The Joy of Clojure - not on the list), Structure & Interpretation of Computer Programs and Concepts, Techniques and Models of Computer Programming. Purely Functional Data Structures and How to Solve it have been on my list for a long time too. Some other books that I haven't heard of before on that list look very interesting though!
I didn't really mean that I don't get value from books - I do - just that I find books to be only the first stage of learning and most useful in telling me what it is I don't know, which I then can study and try for myself and its the experimentation and tinkering that actually makes it sink in.
I second the practical approach of working on projects. I've learned so much just by trying to do things I wanted to do, but didn't know how to do at the time.
That's where computer science comes in. CS deals mostly with abstract concepts -- algorithms, data structures, parsing...that type of stuff. If you train your mind to think in these terms, then you start seeing programs as the sum of their parts (state machines, stacks, trees, grammars) and complex programs become less of a black-box. In effect you're transforming And because you can now picture how someone else has built their program, you just put those same pieces together and with a bit of thinking and googling, you can glue them up into something similar. Eventually you'll be able to picture your own solutions from scratch.
The thing, though, is that computer science is math. A different type of math, but math all the same. It's something you have to work at your own pace, patiently. Deliberate practice is not just a catchy phrasing. It's a very important concept. I stress this because I made the mistake of rushing through a lot of this stuff. I only half got it, but it's worth taking the time to fully understand even seemingly simple concepts because it opens up so many possibilities!
So in order to solve your tutorial problem ("what you need to learn, in what order, to get started"), I would suggest you pick a problem that's interesting to you, find out what sorts of concepts it depends on (what data structures are involved, what fundamental algorithms, ... that sort of thing) and work your way from those concepts to the solution (a working program). For example, if you were interested in building databases, you might want to learn more about b-trees, but in order to learn about b-trees you might need background in simpler data structures and work your way up. You might also want to learn about how to build a query engine, so you might want to learn more about lexing, parsing, and all that. From there you just learn how to implement those things (or find a decent library) in your language of choice and go from there.
I'm increasingly sure you simply can't go straight from nothing to no slides, and trying to force it will just cause you and your audience pain. In particular, only by giving a number of talks do you learn what the 3 things are you HAVE to have on your slides -- just being minimal for minimal's sake isn't useful.
Note this applies to UI design. A bad UI makes it impossible for the end users to "level up".
Typical example: Start with the corporate standard database system, Excel. You end up with secretaries doing the equivalent of a simple SQL "JOIN" by hand. Hopefully using copy-paste instead of hand typing. Sadly I only dream I was kidding. On the bright side technology has improved as in 2013 we use Excel for this task but in 1996 I worked at a big iron financial services corp where the master customer database was a word processor file.
Before Excel, they wouldn't be doing it all. Baby steps.
Spreadsheets as a paradigm is HUGELY successful at allowing normal people to do number crunching—number crunching that pre-spreadsheets would have required a programmer, and most likely, would never have been done at all. I think that's a win, even though we can (and hopefully will) go beyond that over time.
Spreadsheets were a thing before they were put into computers, you know...
http://en.wikipedia.org/wiki/Spreadsheet
> The word "spreadsheet" came from "spread" in its sense of a newspaper or magazine item (text and/or graphics) that covers two facing pages, extending across the center fold and treating the two pages as one large one. The compound word "spread-sheet" came to mean the format used to present book-keeping ledgers—with columns for categories of expenditures across the top, invoices listed down the left margin, and the amount of each payment in the cell where its row and column intersect—which were, traditionally, a "spread" across facing pages of a bound ledger (book for keeping accounting records) or on oversized sheets of paper (termed "analysis paper") ruled into rows and columns in that format and approximately twice as wide as ordinary paper.
Spreadsheet applications made book keeping jobs much easier, to the point that book keeping (not programmer) is on the outs as a speciality job.
The power continuum of the developers wielding those languages isn't mentioned as much, but clearly is an important issue. I've worked in blub languages with developers who are so many levels above me they are not even speaking the same language anymore. The problems they are trying to solve take for granted all I know, all I struggle with, and all I still haven't even learned yet.
The more I "level up" in development, the more I'm convinced there is not enough attention paid to how to really advance through those levels. Right now I'm three languages into "Teach Yourself Programming in Ten Years", http://norvig.com/21-days.html but what about after that? And that is just one man's brief and not well-explained suggestions.
I'd love to see other developer's suggestions for how they advanced past that.
The biggest issue though is it's almost impossible to know your skill relative to the rest of the development world. We can't just time ourselves writing a script, like in the olympics, so almost all of us have a hugely overinflated or underinflated sense of our own skill. Everyone has hundreds of anecdotes proving their value over those who by any metric would be our betters (years of experience, languages mastered, formal education, etc).
I'm reminded of when I was a brand new developer in my first job, how pleased with myself I was at my commit messages, compared to my officemate. Sure, he worked on patching a financial aid system written in three languages, two of which I'd never even seen, and I only wrote sql queries to be run by hand, but I knew what made me better: commit messages.
This confirmation bias is one reason I like pair programming, especially between two partners of different levels. Suddenly the lower gets to be faced with someone who gets done ask the same things and avoids this problem and that problem. They see their relative place, and can aspire for levels greater, which before would never have occurred to them even existed.