What Level Programmer Are You?

Everybody's talking about how programming is the skill that we all are going to need. [Except those folks who might feel that most programming could be turned into wizard-like tools. Insert long discussion about Strong AI.]

But what's a programmer? Is the guy who set up his own Apache Web Server a programmer? How about the guy who created a complex Excel spreadsheet? The guy who made his own RPG level? Minecraft players? When we say "Everybody is going to have to know programming" what, exactly, does that mean?

We need a set of programming levels.

• Level 1, The Read-and-Type: This is the guy who can read how to set up a web server, go through the directions, and get the thing working -- as long as nothing goes wrong. He knows how to use a text editor and basics of the file system he's on. He also has to have some ability to move and manipulate files, like using zip or FTP. He can use abstract symbols in a structured, explained way along with having system skills.
• Level 2, The Script Kiddie: Can write a linear script to tell the computer to do something. Able to learn and use symbols on his own. Should be able to script out a very simple solution to do something useful for himself in bash or VB if given enough time and written instruction.
• Level 3, The Librarian: This is someone who has learned some libraries or APIs and have the ability to learn more. He knows that for whatever scripting language he is using, he needs to be able to connect libraries to it. If he had to, he is able to read manuals and do that on his own. He is also able to search for libraries on the net and use them. He is able to find and sometimes even create his own symbols for his job. (Can write a function or declare and use a struct). Most beginning system administrators fall around here. Also beginning users of advanced Macro systems, like Excel.
• Level 4, Object-Dot-Method Guy: Beginning to learn coupling and cohesion, this person starts organizing their scripts into objects with public and private members and methods. This is your six-week-programming miracle, the introductory .NET programmer. He's supposed to play with a wizard, know the libraries, and then construct something that fits inside of classes that are given to him. If he's not using classes, he can create his own modules or code files. Some advanced users of scripting systems get this far. There are a lot of advanced Excel shops with stock brokers who have basically coded their own VBA application without really knowing it who are in this level.
• Level 5, Multiple Paradigm Man: Once you are able to crawl, you get into all sorts of trouble. A common next step on the programming ladder is being able to work in multiple paradigms. You can code C#, but you also know how to build tables and write SQL. You can write acceptable C, but you also can work with Javascript and HTML. You're not a master of either skill, but you're able to understand different ways of looking at the same problem. You know you've reached this step when you stop saying "We could fix this in X" for every question where X is the language you first really understood.
• Level 6, Architect Apprentice: This comes as you really begin to engage in the craft of programming. You begin to deeply understand the libraries and APIs that you use everyday for work. It's not that you have memorized them. It's that you understand the different patterns the architects use to accomplish their goals. Want to draw in Win32? Probably going to need a handle to some GDI resource. Maybe a few. You know that a handle is a UInt32 hash into a system table somewhere -- a common paradigm for Win32. Want to add your own library to JQuery? There's a format for any new library. You know how that works and can explain why it works that way. As you work your tools, you begin to start thinking like the people who put the tools together. You also begin to learn how to refactor your code to the point it rocks. You start learning what code quality looks like. You begin to understand.
• Level 7, Architect Astronaut: The time comes for you to build your own API, platform, or library. Maybe it's a large project that requires it. Maybe you just want to take your new knowledge out for a spin. While your system is designed to solve a real-world problem for users, your target audience is maintenance programmers at Level 5. At this phase you're deeply into the Gang of Four, OOAD, templating, and best practices. Most of us make a mess the first few times into this area, not understanding that it's easier to make something complex than it is to make it simple. During this phase, which can go on for a long time, you continually mistake creating more complex and flexible libraries with building higher quality systems. Many times you (and hopefully a few others on your team) understand what you're doing, but to bring in somebody from the outside would take months of domain-specific training. Support personnel don't stand a chance -- most all support calls end up on the team's desk.
• Level 8, Meta Man: At some point, hopefully, you realize that much of the complexity you have put into architectures and frameworks can better be described as a Domain-Specific Language. Your target audience becomes programmers at Level 4. Yes, the coding complexity is greater, but the code itself is much shorter and the DSL opens up your code to go all kinds of places. In short, you become the writer of the script languages that beginning programmers use. Your systems are open to beginners through easy-to-use scripts and wizards. You can learn this skill separately, but most times after many large complex architectures, eventually you factor your way to a DSL. And then again. And again. Pretty soon you start seeing the pattern: well-understood problems lend themselves to DSLs.
• Level 9, Functional Nirvana: Moving into the bonus round, you start really learning how to program by learning Functional Programming. Your target audience is maintenance programmers at Level 3. FP makes you a better imperative programmer, helps you easily kick out DSLs faster, and can massively reduce the amount of code it takes to solve a problem. It can also be highly-scalable. With some functional languages you can even hot-swap while the system is running. Just like with all these other advanced levels, at some point you start feeling getting a bit of nirvana going on. FP must be the answer to everything! By this time, however, you've been through several of these stages of euphoria, so this one isn't as bad as the rest. The real world intrudes. FP, although less buggy and many times much faster, can be very difficult to code. Programmers have to carry a linker around in their head much of the time -- they have to keep track of lots of symbols. Eventually you realize FP is also just a step on the path, much similar to OOAD.
• Level 10, Language Oriented Designer: You view all programming as creating new programming languages. The only difference is what the new language is supposed to do. You understand how to create Object-Oriented languages, Functional languages, and simple untyped scripting languages. You know when each is appropriate. Your target audience is maintenance programmers at Level 2. You sit down for each project and ask "What kind of language do we need here?" At the end of your project you have a nice tool that both fixes the problem and is easily understood and extensible by entry-level programmers, freeing you up to move on to other things. You can easily make the case that most projects do not require language-oriented designers, but that's a story for another day.
• Mystery Level, Computer Scientist: This is either the pinnacle of programming or doesn't exist on the spectrum at all, depending on your perspective. This is the science of programming. Lots of cool stuff here. Your target audience is everybody else in the universe. But the focus is not on making things people want, it's advancing the state of knowledge. Because most other capability levels of programming are so people-based, these guys live in a different world, but a necessary one. How easy is it to cross back and forth between the two worlds? Beats me.

You could construct many alternate paths here -- for instance, functional programming might come first for you, then OOP later on. You might also put in building your own compiler -- wasn't that fun in college? Or assembly. Or really understanding set theory and how it applies to both databases and programming data structures. Or writing your first true programming tool.

But this is the path I see most programmers follow.

ADD: Please read the (very short) follow-up for another look at this.

If you've read this far, you should follow me on twitter here.

--------------原文----------------

随着技术发展，编程悄然融入了我们的生活。我们已然离不开那些程序和编程语言。很多人都在不同程度地谈论着如何编程，也诞生出很多编程语言排行，那么程序员到底应该如何分级呢？

首先要明白什么是程序员。设计自己的Apache Web服务器的家伙？制作一个复杂Excel的家伙？还是能自己开发RPG的家伙？Minecraft的玩家？这些都属于程序员的哪一个级别呢？当我们说：“每个人都需要了解编程”，这句话意味着什么？

所以，我们需要制定一个程序员的等级，以便让程序员们了解自己所处的环境和发展方向。

Level 1，读写 ——他们了解设置Web服务器的方法，在普通情况下能够通过配置方式获取工作所需要的东西。他们有使用文本编辑器和文件系统的基础知识，还拥有移动和操作文件的能力，如ZIP和FTP。也能在结构中使用抽象符号、解析方式以及系统技能。

Level 2，脚本 ——能够编写线性脚本告诉电脑要做什么，能够学习和使用自己的符号。如果有足够的时间和书面指导，他们可以使用bash或VB编写一些简单脚本，为自己做些实用的事情。

Level 3，管理员 ——这些人了解库和API，并有能力学习更多。他们知道不管使用什么脚本语言都需要连接 库。如果他们遇到问题，可以通过阅读使用手册或是在网上搜索库来解决。在工作中他能够发现或是开发自己的符号（使用struct编写函数或是声明）。大多 数系统程序员都处在这个等级阶段，Excel的初级宏系统用户也同样处在这个阶段。

Level 4，高级实践者 ——刚开始接触耦合性与内核，他们能编写自己的对象化脚本（有公有/私有成员和方 法）。这些人能玩转技巧，了解库和构建类。如果不使用类，他们也能够创建自己的模块或是代码文件。高级脚本用户可远不止这样，有一些Excel技巧经验丰 富的股票经纪人，他们使用自己VBA作为基础代码，而没有意识到自己处于这个级别。

Level 5，掌握多种技能 ——一旦上升到这个级别， 将会遇到各种各样的麻烦。常见编程下一阶段就是能够使用多重框架。这些人可以编写C#，也知道如何创建表格和编写SQL语句；可以编写C，同时也会使用 JavaScript和HTML。这两个技能并不代表他们就是大师，只是要学会在理解同一个问题上，需要通过多种不同的方式来找寻答案。

Level 6，初级构架师 ——这阶段的人才算是真正的从事编程工作。他们每天的工作就是要深入了解库和 API。并不要求他们必须记住这些，但要了解用不同的模式去实现自己的目标。想要在Win32中绘制？可能需要一些GDI资源句柄，他们知道句柄是在系统 表某处的一个UInt32 hash——常见的Win32范例。想在自己的库中添加jQuery？新库里有很多格式，他们应该知道怎么做并且能解释其工作方式。与此同时，也要开始学 习如何重构自己的代码并突显亮点，增强其代码的质量，慢慢地你会理解。

Level 7，资深构架师 ——他们的时间是用来创建自己的API、平台或是库。也许这是一个大项目的必需品， 也许只是他们个人想把自己的学识推广出去。他们开发的系统为用户解决实际问题，所面对的受众群是Level 5程序员。在这个阶段需要深入OOAD，模板和实践。我们大多数人在刚开始都会搞得一团糟，不能理解怎么用更加简单的方法将复杂事情简易化。这个阶段需要 历经很长时间，需要不断修正错误，开发高质量的系统并创建更复杂、灵活性高的库。当他们从外面接受几个月的特定培训回来，肯定希望团队其他人都能理解他做 了什么。

Level 8，诠释者 ——在某些时候，希望这些人能意识到大量复杂信息投入结构和构架中可以更好地形容特定域 的语言，其受众群体是Level 4程序员。代码的复杂性增大，就能减少代码的数量，DSL开放可以将代码展示到各种地方。总之，他们将成为程序员使用脚本语言方面的作家。通过易于使用的 脚本和导向将他们的系统开放给初学者。可以分别学习这些技能，但大多数情况是在复杂的结构后，最终走向DSL的道路。很快就能看到最初规模：利用自己编写 的DSL能够很好的理解问题。

Level 9，函数式编程 ——慢慢接近奖金，他们要开 始学习如何函数式编程。其受众群是Level 3的程序员。函数式编程是必不可少的，帮助他们轻松地脱离DSL，并能够大幅度减少代码数量来解决问题，同时拥有较高的扩展性。某些功能语言在系统运行时 可以hot–swap，慢慢就会感觉到已经接近先进水平。函数式编程是一切问题的答案，它可以减少Bug，提升开发效率，但代码也相对来说很难学。程序员 的脑海里需要时刻记忆很多东西——他们必须要记住繁琐的复杂符号。但是，结根到底函数式编程只是道路上的一个阶段，就像OOAD一样。

Level 10，面向语言设计师 ——他们查看所有新创建的编程语言程序。惟一的区别是新语言应该做什么。他们 了解如何开发面向对象语言，语言功能和脚本语言，知道每一个语言在何时何地的用途。其受众群是Level 2程序员。他们对每一个项目都会问：“这个项目我们需要什么样的语言？”在项目完结后他们将会得到一个很好的工具，既解决了问题并易于理解还扩展了入门级 程序员。大多数项目不需要面向语言设计师。

上帝级别，计算机科学家 ——要么就是编程的顶峰要么就不存在，这个取决于自己的观点。这个就是科学规划，在里面 有很多很酷的东西。任何一个人都是其受众群体。但重点不是在于做人们想要的东西，而是促进学术的发展。因为大多数编程能力水平都是基于人而言，人们居住在 世界各地，也是必要条件之一。如何简单的在两国之间相互来往？

你在这里可能受到很多启发，例如，首先学习函数式编程再学习OOP。你也可以开发自己的编译器，这不是大学的乐趣吗？或是程序集，或是真正理解集理论，或是如何开发适用于数据库与编程数据的结构，或是开发你的第一个编程工具。

这些是我所看到的大多数程序员所遵循的道路。（张祺/编译）