After cruising this board for the last several years, as well as reflecting on my own journey as a programmer (coming up on 10 years now), I have come to the realization that many programmers take the same steps as they mature their craft. I have outlined them below as I see them. I am interested in what you all think. Did you take the same steps? Am I missing steps? Choosing A Language Choosing a language is often the first road-block for new programmers. With the plethora of languages available, as well as the greatly varying opinions on the best way for new programmers to learn, often beginners will get stumped at this stage while trying to figure out just how to begin. The best advice? Just dive in somewhere. No matter what, you are probably going to hit your head on the rocks. Understanding The Jargon and Tools The next hurdle for the new programmer is understanding the jargon and the tools that come along with programming. Variables, functions, methods, libraries, compilers, linkers, debuggers, development environments, version control software. Syntax errors. Program design and flow. Often beginners get hung up and frustrated trying to do minute things like include header files (or even figure out why they are important). The rabbit hole is steep, and very, very deep. Most of the time, new programmers just want to start by doing -- but there is a steep learning curve, especially if you are young or have never studied a related field. This Isn't As Easy As I Thought Many new programmers quit at this stage when they realize that this wasn't going to be quite as easy as they thought. It is a tremendous hurdle. The First Big Program If a budding programmer can wrap his or her mind around the new concepts and stick with programming long enough, they will soon begin writing very small demo programs to build up their abilities. Soon, these demos begin getting bigger and bigger as the programmer begins to feel more confident. Many times the beginner will decide to tackle something too large and be knocked down. But finally, they will choose a concept of enough magnitude that it represents a large milestone in their learning, but is still achievable. If any competent programmers look at the source to this project, they normally cringe. Premature Confidence Programmers who reach this state often begin going on message boards and helping out beginners. They are confident in their abilities, and begin coming up with larger and more grandiose schemes with their newfound skills. They are over-confident, and often cocky. Often they spread misinformation and bad habits to beginners. They also often begin learning a second or third language, though often don't get much further 'intellectually' in the language than they did in their first. I Can Do It Myself This stage follows closely after the last, and occurs when programmers gain more confidence in their programming. Often they are good enough at this point to work on larger projects, but their implementations are often poorly designed and inefficient. However, without formal critique, the programmer never knows. Often, in this stage, they begin writing more complex software, which could easily be finished by the implementation of appropriate libraries. However, in this stage, the programmer attempts to implement everything themselves. In public, they often write this off as a 'learning experience.' In private, they say it is because they don't want to learn the other software. Deep down, it is because they think they can come up with just as good a solution. While programmers in this stage can be difficult for many more mature programmers to deal with, I consider it a crucial step. Often, in this step, programmers learn vital lessons on what NOT to do, which are just as important as learning what to do. The next three steps often happen in a random order, and most often, in parallel. Understanding Computer Science In this stage, programmers begin to learn that Computer Science is not Programming. They begin learning about the theoretical foundations of information and computing. They begin learning about algorithm efficiency, computational complexity, programming language theory, and many other important fields. They begin to understand how these important topics extend beyond the computer, and how programming is merely just an implementation of these ideas. They come to the realization that programming is nothing more than syntax, and with the core foundation of these ideas, it doesn't matter what language you use. Understanding Software Design Here, programmers begin to understand how to design programs. They learn the concepts of software engineering and the software development life cycle. They focus on such topics as cohesiveness and coupling. They begin learning design patterns, and misusing them. Badly. But as time goes on, the programmer begins developing better habits. Understanding The Computer In this step, programmers begin to truly understand how the computer works, from the ground up. They understand the basic concepts of memory, the hard drive, the processor, networking, and the operating system. They understand cache misses and paging. They understand the trade-off between memory and speed. Most importantly, they begin to understand how programming relates to it. Mastering a Pragmatic/Academic Domain In this stage, programmers often begin focusing on a pragmatic domain; something similar to developing software for the iPhone, or writing Windows applications. They may gain expert knowledge of a specific library or package, like SDL. They may become experts in topics such as networking or graphics. Often, these pragmatic interests become academic interests, and the programmer goes on to research subjects such as machine learning, graphics, scientific computing, software engineering, computer engineering, language design, algorithm design, parallel computing, et cetera. As an example with GDnet, we will see programmers who may be experts in OpenGL, but more importantly understand the underlying theory of graphics programming, so are able to efficiently transfer their ideas to other APIs if necessary. Being Pragmatic After gaining domain specific knowledge, the programmer often begins using libraries designed for that field. Soon, the programmer realizes that he would be better suited by using domain specific libraries to tackle his problems all the time. This is where you see programmers begin using libraries like boost that they previously neglected. Instead of taking the time to write all the components of a 3D engine, programmers in this stage may instead simply write the glue between the appropriate libraries. Or, if they are interested in writing games, simply find the 3D engine that best suits their needs. From that last step, I don't know. I can only truthfully say I entered it in the last couple of months. But now that I am in it, I can recognize other people entering it as well. So, for all of those who are steps beyond me ... what comes next?

I dont see no missing steps but wat u gots it too linear. I started with QBASIC so I went

QBasic: The First Big Program, Premature Confidence, This Isn't As Easy As I Thought,
Choosing A Language -> C++, Understanding The Jargon and Tools, The First Big Program, Premature Confidence, I Can Do It Myself, This Isn't As Easy As I Thought, I hate C++. And then I stopped programming. I came back and picked up C# 1.0 which wasnt too good. And Got Ocaml then haskell. And then:

Understanding The Jargon and Tools,domain focus, The First Big Program, Understanding Computer Science, pragmatism, design. I dont really understand how Computers work.

I think I skipped the "This isn't as easy as I thought" stage. Is that a bad thing?

The last step is enlightenment - there is no spoon. In other words, you realize that you can actually make computers do anything, given enough time. Soon after this, you realize that in order to effectively get more time, you need to rely on other enlightened ones.

By the way, most programmers I've met have written production software before they understand computer science or software design. This results in - mildly put - unmaintainable systems.

Quote: Original post by Oberon_Command
I think I skipped the "This isn't as easy as I thought" stage. Is that a bad thing?

So you're stuck at "Premature Confidence"? ;)

I never really did the 1st two steps. My father introduced me to programming when I was about 8 on GW-BASIC, I later came across an old C book/compiler in his study and started playing with that, before getting a free Borland C++ compiler later on. I never sat down and wondered "which language do I use"... and my first expereinces with programming were on systems which had no IDE etc!

Quote: Original post by d000hg
I never really did the 1st two steps. My father introduced me to programming when I was about 8 on GW-BASIC, I later came across an old C book/compiler in his study and started playing with that, before getting a free Borland C++ compiler later on. I never sat down and wondered "which language do I use"... and my first expereinces with programming were on systems which had no IDE etc!

Likewise. I started out wanting to make a web page, and was dissatisfied with the WYSIWYG editors of the late 90s, so I naturally had to learn HTML. After that, I started wanting more interactivity in my pages, so I naturally had to learn &#106avascript. Then, my parents bought me a Borland C compiler with a bunch of books for Christmas one year, so I just started reading them. In college, we were made to study C++, and then Java. C# is probably the only language I ever explicitly *chose*, and that was near the end of my college career anyway.

I guess it was easier in my days.

Quote: Original post by visage
Choosing A Language

I had no problem choosing a language since this brick only supported Basic.

Quote: Understanding The Jargon and Tools

Other than primitive jumps, it did not support functions or methods. Being an interpreted language, I had no need for compilers or linkers. Debugging consisted of little more than printing to a monochrome screen. No IDE or other tools available.

Quote: This Isn't As Easy As I Thought

Actually, besides learning to deal with the somewhat obscure and undocumented peek and poke commands, I didn't find it too difficult. [smile]

Quote: The First Big Program

Its lack of hard disk and its 16K internal memory weren't suited for large programs, so I think I pushed to the limits.

Quote: Premature Confidence

You guessed it. No real message boards in the mid eighties other than BBS.

Quote: Original post by WanMaster
Actually, besides learning to deal with the somewhat obscure and undocumented peek and poke commands I didn't find it too difficult.

Ack! I think I still have nightmares in the middle of the night about long lists of poke() commands [grin]

I've wondered what it would have been like just starting out now, though, with so many choices of wonderful languages/IDEs freely available, and so many horrible programming practices never to have to unlearn. However, in a way, it was easier to get hobby projects finished on my trusty C64, since my goals were orders of magnitude more reasonable then...

Quote: Original post by Rattenhirn

Quote: Original post by Oberon_Command
I think I skipped the "This isn't as easy as I thought" stage. Is that a bad thing?

So you're stuck at "Premature Confidence"? ;)

Ouch! He handed it to you there, Oberon_Command!
Are you just going to passively take that?



...

No, moderators, I'm not trying to start a flame war.
*Gets popcorn*. [smile]