Steps in being a programmer

choffstein · 2009-06-24T17:47:40

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?

BeanDog

1,065

June 24, 2009 01:41 PM

Choosing A Language: I didn't have much choice at the time. My family had a Commodore 128D (D for Disk drive, that's right, 5.25" floppies baby!), so I worked in Commodore's BASIC for the first couple years, using the manual that came with the computer as my only guide.

Understanding The Jargon and Tools: I didn't until probably 5 years after I started programming. I first encountered this stuff when I learned C++ (after having been through Commodore BASIC and QBasic) with Visual Studio 6. I know they're pretty much universally derided around here, but I learned with a Teach Yourself C++ In 21 Days book, and it served me pretty well.

This Isn't As Easy As I Thought/The First Big Program: This happened before I really understood the jargon/tools. Probably because of that, actually. I hit this moment when I was writing an RTS in QBasic without using a debugger, with about 2 actual subroutines (using GOSUB/RETURN instead for the rest), running out of 64KB of memory, and actually exceeding the amount of code QBasic would compile. That's the first time I turned to the Internet for advice. Not the web, it wasn't really around then, but AOL 1.0's online directory of content. I found some EMS/XMS code for QBasic, and some mathematical formulas to help, wrote a code minifier, and I was back to the races.

Premature Confidence: This happened after I built my first game in C++/DirectX 7. For a graphic and embarrassing example, see an article on C++ headers I got published on GameDev back in 2000.

I Can Do It Myself: This happened about when I started learning Direct3D 7. I wrote my own point-light code, skeletal animation, and a couple other things. Looking back, it was all a disaster as an end-product, but it was very educational. This also reared its ugly head when I lost my license key to SourceSafe and decided to write my own (actually sold one copy...)

Understanding Computer Science through Mastering a Pragmatic/Academic Domain: These happened at University. It was extremely helpful to me as a programmer to see the fundamental workings of hardware (actually built my own rudimentary CPU on an FPGA) and software (e.g. recursive-descent parsing, data structures, etc).

Being Pragmatic: This happened on and since my last year at University. I started liking C#. I started using PHP for a bunch of stuff, including shell scripting. I became familiar with some server administration and existing tools. I started using existing frameworks to lighten my load (e.g. Bullet physics, jQuery, CakePHP).

Your next step? Millionaire entrepreneur, obviously. Just don't think that being a great programmer makes you a great person to run a company. That part comes separately.

Oberon_Command

6,371

June 24, 2009 02:24 PM

Another "what language do I use" skipper here, as well.

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"? ;)

I went past "premature confidence" years ago and remember it well. I know now how much I can improve. [grin]

Quote: Original post by polymorphed
Ouch! He handed it to you there, Oberon_Command!
Are you just going to passively take that?

Meh. I know what stage I'm on (getting into "understanding"). Yay, school.

DevFred

840

June 24, 2009 03:40 PM

Quote: Original post by laztrezort
I think I still have nightmares in the middle of the night about long lists of poke() commands [grin]

This how my cool C64 games started:

10 POKE 53280,020 POKE 53281,030 PRINT "<two special characters to set the font color and clear the screen>"

Those were the days... :)

Daerax

1,207

June 24, 2009 04:16 PM

there be also a debabelization stage where yous realizes that there is really only 6 or 7 languages maxish

ddn3

1,610

June 24, 2009 05:11 PM

The remaining steps are:

Diversification
Once mastery of the process and techniques, the programmer becomes aware of commonalities and patterns in process between various tools, disciplines and domains which transcend the objective realm. At this state the programmer gains an almost supernatural understanding of things computational, using intuition as much as deduction.

Mentorship
The true path to programmer enlightenment comes with the dissemination of such knowledge and growth through sharing and mentoring the next generation of programmers.

Enlightenment
If the programmer is aware and open minded enough they can become aware of the underlying meta-reality and its musical code like structure. Once only a user of this reality overlay they begin to conduct it, creating, moving, deleting reality much like a child playing with blocks.

Nirvana
The last stop for the programmer, full awareness has its price. Once glimpsed there is no turning back.

Enjoy! :D [ last 2 are just my guesses :) ]

-ddn

ChaosEngine

5,385

June 24, 2009 05:47 PM

While that's a pretty good series of steps, I searched this page and I couldn't find the word "communication" anywhere, so I'd say you missed a hugely important aspect of programming.

Communication
Software Development is communication. You are expressing your intent to machine, but more importantly you must clearly communicate with users and clients. Almost no software of any consequence these days is written in isolation. The ability to communicate your ideas to your colleagues and to collaborate is paramount. Most teams would prefer a competent programmer who works well with the rest of the team over a programming guru who doesn't.

if you think programming is like sex, you probably haven't done much of either.-------------- - capn_midnight

Steps in being a programmer

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

Steps in being a programmer

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

Reticulating splines