As I read the list, I noticed they were severely out of order, with unconvincing excuses for why one thing led to the next and poorly placed this-is-where-s###-gets-real moments like "You begin to understand." :-p But that's fine. The list is probably a valid reflection of the author's own experience with programmers, and I doubt it stereotypes programmers in any harmful way.
What follows is an autobiography by counterexample. That is, it's my anecdotal evidence for the original order being out of whack.
For a high-level view (or for the sake of tl;dr), my progression is 1-8-M-4-5-7-2-10-7-9-9-3-9-M-6-5-9, and I consider my progress to be incomplete in levels 2, 8, 10, and M.
---
Level 1, The Read-and-Type
Level 8, Meta Man (In the sense that I approached every problem by designing a new language, not in the sense that I actually implemented easy-to-use languages and tools! I'm still working on that, lol.)
Mystery Level, Computer Scientist (in the sense that I hoped my pseudocode languages were advancing the state of the art, though they really weren't)
Level 4, Object-Dot-Method Guy
Level 5, Multiple Paradigm Man (in the sense that I knew that I could get certain things easily from one language that were more difficult or impossible in another)
Level 7, Architect Astronaut (not because I confused complexity with value, but because I was finally able to shoehorn abstract concepts into existing languages rather than keeping them in pseudocode)
Level 2, The Script Kiddie (in the sense that I started using filesystem calls sometimes but not on a whim)
Level 10, Language Oriented Designer (in the sense that I decided it would always be true that with certain shoehorned pseudocode, it makes life easier to admit it's a language of its own)
Level 7, Architect Astronaut (in the sense that my languages would have had kitchen sinks at this point in my life)
Level 9, Functional Nirvana (but only in the sense that I knew I'd learn a lot about custom syntax from a lisp)
Level 9, Functional Nirvana (in the sense that as I approached lisp--by way of Groovy--I discovered the sweetness of using first-class procedures for list comprehension, custom control flow, event handlers, etc.)
Level 3, The Librarian
Level 9, Functional Nirvana (in the sense that I actually started using a lisp, Arc)
Mystery Level, Computer Scientist (in the sense that I realized the language-oriented technique I wanted to pursue was not available in any language, and I expected to need to advance the state of the art)
Level 6, Architect Apprentice (Thanks to my frustration at the places Arc's modularity, customizability, and extensibility falls short (especially its modularity), and the fact that there was no other language I liked better, I've focused on Arc library design in particular and learned what approaches I liked and what approaches I could expect even if I didn't like 'em.)
Level 5, Multiple Paradigm Man (in the sense that every way to improve on Arc's code reusability seemed to require a compromise)
Level 9, Functional Nirvana (in the sense that I've realized that expressing certain kinds of modularity takes a reactive model and/or a static type system, and that an understanding of pure FP does me wonders for elucidating the semantics of both of these things)
---
For humility's sake, here's a list (a checklist?) of the levels I know I haven't fully explored:
---
Level 2, The Script Kiddie (in the sense of not being shy to write a program to automate a mundane task)
Level 8, Meta Man (in the sense of implementing easy-to-use languages and tools)
Level 10, Language Oriented Designer (in the sense of implementing easy-to-use tools for myself and others to make languages with)
Mystery Level, Computer Scientist (in the sense of framing my work in academic terms)
Hey, that is comprehensive. And I do agree that the levels in the article reflect the author's own experience, which he also admits. Like yours, most people would follow paths different from the progression in the article, though I don't think most would document it quite as thoroughly!
