PHP might be good to learn (so long as you avoid the bad habits it invokes) if you interested in web programming. I know others might scoff a little at that suggestion: but the online documentation is stellar and you can pick up the basics in a few weeks.

C is also hellishly useful because it will teach you some core concepts. In fact I would poke around in C anyway whatever you choose - just for "background".

Option 1. Python is not a bad choice, and neither is Ruby. In either of those languages, in a couple weeks, I'd say you can write yourself a "Guestbook" or something. Spanning the Gamut of "Web 1.0 apps" like forum, guestbook, blog/cms, etc. in a language is a nice easy way to get the basics.

Completing option 1: You can hack together simple web apps. A bit more effort will get you enough Javascript to use jQuery.

Option 2. Start with Scheme. Check out HTDP and/or SICP (google the acronyms). You can write real, useful programs in Scheme and/or you can move into Clojure, which lets you write anything you could write in Java (i.e. the libraries are all available). Spend some time here - write some simple games, and then maybe a web app with the existing frameworks. Consider picking up a language in the ML family, or Haskell, to learn about purity. In fact - with Clojure and e.g. Ocaml, you've got enough speed & flexibility than you probably never need to learn anything else. But...

Next, learn C. C is a great beginner's language for imperative programming. It's less ulcer-inducing than assembly, but you're still close to the machine. You'll want to implement a book of basic CS data structures and algorithms in C, and deal with all the thorny issues involved in making them fast and stable. In particular, you'll notice that cool data structures are really just different ways of re-arranging pointers. Conversely - by re-arranging pointers, you can do a LOT of cool stuff!

Eventually, you'll have to learn about OOP despite all the functional craze these days, so go to Java. Much of the online literature about OOP was written for Java. Go to Java before C++ - but eventually, get to C++, because everybody uses it.

At the end of option 2, you will have a good layer of fundamentals. You will hopefully have done at least 1 or 2 projects in functional, close-to-the-metal, and OOP environments. Hopefully, you will have gone through and implemented the standard CS algorithms/data structures in each one, understanding the subtleties therein. You can confidently go on from here to learn the skills how to write video games, databases, trading platforms, custom server apps, etc.

C makes an excellent (and important) SECOND language, but a pretty terrible first, IMHO.

Django is the same. Until you get an understanding of the basic concepts, its painful and annoying, but once you do, its a breeze and you'll have a lot of fun.

If you're feeling adventurous check out virtualenv right away (Python not Django specific)

This is like telling someone that they shouldn't buy a tambourine because it won't help them learn to conduct the London Symphony.

Mind you, I'm not saying that your first 10,000 lines of PHP code won't be filled with bad habits. I'm suggesting that your first 10,000 lines of code will be filled with bad habits whether or not that code is written in PHP. The secret is to keep practicing and learning.

As a language, PHP is not as good as Ruby or Python. It's less flexible, less elegant, and has less expressive power. But I assure you that placing a flexible and elegant tool in the hands of a beginner doesn't magically give them good habits. You can write ugly global-filled procedural spaghetti code in Ruby, and that's exactly what beginners are likely to do, unless they have a great teacher looking over their shoulder and correcting them. And how many people do? Most programmers are compelled to teach themselves, because their teachers either don't exist or are hung up on Java, an absolutely awful beginner language. That's why so much of Web programming is done in PHP, a language which has evolved to be very easy to teach to oneself.

I have reluctantly concluded that, if you force a self-taught beginner to start with Ruby or Python, all you do is add that much more friction to their learning curve. These languages are harder for a beginner to work with, in part because they are so flexible and general-purpose. Everything about PHP is relentlessly focused on the goal of getting your web page running -- it's got one use, it's got a canonical set of docs, everyone's Hello, World looks the same and can be run on an $8/month shared host in five minutes by following a simple recipe. Python was invented before the web and has a diversity of uses, which makes the books thicker and the setup more complicated and lowers the odds that any given web page about Python has anything to say about the problem you are trying to solve. Ruby is all about OO programming, which is great after you know what the hell OO is and how you should be using it. Before that, you'll either write Ruby that looks like bad PHP or you'll cut and paste idioms from Rails books without understanding them.

I wish I knew how to get more people using better languages. And I fear that I do know: They need good teachers. But, in the absence of a lot of great hackers who are primarily interested in teaching, and assuming that you aren't one of those rare people who can just pick up SICP and instantly feel a rapport with the authors [1], your best bet is to just get started. So if Python doesn't grab you, try PHP.

---

[1] I wish I had known to start with SICP; I think it would have worked out great. But I'm the guy who got so bored with BASIC and assembly that I taught myself Pascal three years before I got my hands on a Pascal compiler. It occurs to me that I may not be typical.

If you like Python, you can be a easily be a professional Python programmer and learn other languages only to get a different perspective. You can make a career successfully with Python alone and it is as real (though perhaps less traditional) as any other language.

If on the other hand your goal is to learn programming in depth, I would first start with C to get a better feeling for how things work on a low level and I would then start moving on to representatives of different paradigms (a solidly oop language, a functional language, perhaps a domain specific language like SQL or two.)

If your goal is to get a job and be employable, I would learn VB.NET. It is in high demand(at least in the area I am in) and if you know it then learning C# (also in fairly high demand here) is practically effortless.

For sheer ubiquity, JavaScript can't be beat. In five years, I suspect we will all be writing a lot more JavaScript, no matter whether we are frontend web developers or not. But, for now, the backend is still better written in one of the other languages I've mentioned (or PHP).

gdp mentioned HTDP and SICP. He's right, though you have to phrase your question differently...because the language of those books is not a language most real world programmers would suggest you learn. And yet, if you want to be a good programmer, there are probably no better resources. The books and lectures are available for free from various (legal) sources, and provide a really solid foundation on which to build your programming skills. I strongly suspect spending 3-6 months on these two resources and learning Scheme would accelerate your development in any other language enough to repay the upfront cost within a year or two. Becoming a programmer is a multi-year investment, so that's a really good deal, even if it looks like the long way around.

If you want to become a good enough programmer that it becomes pretty much irrelevant which language you are asked to code in, I would recommend starting with something like Scheme, perhaps with the aid of either:

http://en.wikipedia.org/wiki/How_to_Design_Programs or http://en.wikipedia.org/wiki/Structure_and_Interpretation_of...

You can use many languages to learn, but I'm pretty sure Python is indeed the best choice for a first language.

It's freely available and runs on all major operating systems.

http://www.squeak.org/

And then if you get Peter Seibel's "Practical Common Lisp" book and learn Lisp, you'll be completely ruined for any "blub" language like Java or C++. But you'll be light-years ahead of the crowd...

http://download.savannah.gnu.org/releases-noredirect/pgubook...

I started out trying Scheme, Java, Ruby, etc. and was constantly in a state of confusion. I could never just go with it because I'd always want to understand the implementation of the commands before using them. Ruby was particularly bad - I had no clue how a language or computer worked and was constantly overwhelmed with all of the different options for doing something.

Programming in assembler you get a small set of commands that won't take long to memorize, and you'll have to build up from there. It's not as hard core as people make it out to be - when I was really into it, I could produce output in at a similar rate to C. Once you get a little assembler under your belt, you could begin mixing it with C, and you'll get a rock solid grip on C strings, callback functions, pointers, etc. that so many people have trouble with.

EDIT to add:

Also, using GDB (the Gnu DeBugger) with Emacs text editor is excellent for learning assembler - must use it!

This will give you invaluable insight in how a computer works on the inside, then work your way 'up' from there.

That's much easier than to have this feeling that there is this 'magic carpet' that is holding you up in the air but you have no idea how it works.

Almost every high level language will make a lot more sense if you come from the basement up.

This is a great idea!

If for some reason you don't want to work with actual hardware, I reccomend this book(http://www1.idc.ac.il/tecs/) . Dr Schocken uses Java to build a variety of emulators all the way from flip flops to a small computer you can write Tetris for, using a compiler you build.

A google tech talk based on the book is here http://video.google.com/videoplay?docid=7654043762021156507

"Almost every high level language will make a lot more sense if you come from the basement up."

Exactly right.

If you want to take this route for taste of programming I will take a Haskell, it is much more easier to start with it if you do not have much experience with imperative paradigm.

Why? It's got many of the advantages of scheme, and it's a language that'll treat you well the rest of your programming career (assuming you continue to use emacs).

Also, the immediate feedback and lots of example source is pretty nice.

1. Virtually no syntax, which is often problematic to first time programmers of C-style languages: "You mean I have to have this curly brace here, and this semicolon there?"

2. Only one choice for looping, recursion. Recursion is a fundamental concept in computer science and programming, yet many people do not grasp it. Scheme learning materials will teach you how to write recursive programs the right way. Plus, recursion is a very elegant, and easy to understand way to express many algorithms such as those used in sorting, a common exercise when learning programming.

3. Higher order functions - This makes it easy to teach abstraction. Build small components that do general things (i.e. fold, map, filter). This sort of thing applies to OOP down the road, as well as to every other paradigm. Break things into small units that do one or two things and that's it.

4. Unbounded numeric tower, which means you don't have to focus on things like, "ints can only express up to 2^32 if they are unsigned," which in many courses has to be taught (prematurely, I'd say) to explain why I can't compile or run a program that multiplies the largest numbers I can type. Something the curious will surely try first.

Objects in their very naive form area pretty straightforward concept to get (Oh a Car is a type of Vehicle).

Iteration is more natural than recursion (I prefer recursion, it's elegant, but it's not how people think to start with).

And most users won't run into the boundaries of variables when beginning learning either.

The one thing I will give credit is that the syntax is less voodoo, but I still think the ideas of assignment and a mental model of state combined with the imperative "Do this" approach is easier for non-programmers to understand.

You will learn about pointers, which is important in ANY language, binary trees and stacks are good to know about too.

I must say (not for the sake of picking a fight, but because this is the answer to a real person's question) that I think this is not good advice. If you get into programming, sooner or later you might want to learn C, but for now it will only make the experience frustrating for you.

In fact, the abstractions you mention are what might be confusing for the beginner: Classes, objects, inheritance, polymorphism, iterators, high-order functions, closures, monads, generators, etc. all require as much book- and code-staring as either void or function pointers do for the first time.

I do however agree with you that C is harder and much less useful to learn than a "batteries-included", modern language like Python or Ruby as a first language.

However, that does NOT make it a _good_ first language. Sure, it can be good enough, but I'd argue that you'd get MORE out of learning a language like Python. Python is, IMHO, a great beginner language because it has all the abstractions, but (unlike Java) does not FORCE you to use them until you're ready to do so. It eases you into the complex concepts. It also shields you from buffer overruns and manual memory management. It gives much more useful errors when things crash and finally, an interactive shell is the best thing ever when learning.

You already know that though, since you agreed ;-)

But C is still a _good_ first language. And I don't mean "good enough" I mean that it has specific advantages and advantages relative to other languages including Python.

C is a small, mostly consistent language. So is Python (I'm certainly not saying Python is not a good beginner language), but C is smaller.

C compiles directly to machine code. There is a very clear, exposed path from C code, to binary code on the disk, to a process loaded into memory by the operating system and executed by the machine itself. These steps allow the beginner to see and practice the process that transforms a text file into an end-user application. Python caches a bytecode file without the user knowing, then executes that bytecode in its own environment that has abstracted most of the underlying machine.

C exposes the user to the underlying machine. Beginners don't need to be shielded from buffer overruns and manual memory management. In fact going for too long without introducing those topics practically ensures the programmer will never be good at it no matter what language they use. And it's not just memory management.

For a simple example of the ways C can be worthwhile to a beginner:

Learning how to use #includes is hard in C because it requires some understanding of the operating system, the compiler, and what software interfaces are.

If you don't know what '#include "goladus.h"' means, the extent it is related (or more importantly, not related) to "goladus.c", it means you probably have some fundamental misunderstanding about how the source is compiled and linked, and where the compiler looks for the particular files. Correcting that misunderstanding will result in big knowledge and conceptual gains. You see how the OS works with the software you write. You see how to reuse code and probably have some understanding of how it works at a binary level. OS knowledge will be valuable for anything else you use that OS for. The abstract code reuse concepts apply to most languages. The C-specific knowledge can be applied whenever a higher-level language like Python is capable of C extensions, and is also applicable to other operating systems.

In python, when you say "import goladus.post" it's easy and it works but it's basically magic if you don't understand the python module system. Understanding the python module system is worthwhile, but is fairly python-specific. Why doesn't 'import goladus.post.py' work? Or 'import "goladus/post.py"' Figuring that out isn't all that hard, but also doesn't give you any greater understanding about anything but Python's import syntax.

Sometimes experienced programmers underestimate the difficulty of learning something when there is a lot of magic involved. One thing that makes Scheme so appealing as a beginner language is that most of the language can be exposed fairly easily, all the way down to the compiler. C is similar, in that it is not too difficult to see directly how your code is manipulating the machine. When you learn C properly, you know exactly what your code is doing.

Python is a fairly small language, but under the hood it is still significantly more complicated than C. C is not an ideal choice in all situations, but for many it is really an excellent first choice if you take a good approach to learning it.

Anyway, I think C could be an excellent second language to learn. Starting with something having a similar syntaxis like Javascript could be a good choice and pretty helpful in the future too. Plus, you won't need an IDE, a compiler, setting up a server or a database, only a browser.

While I think C is a valuable language to learn and I agree with your reasons for learning it, I do not think it should be someones FIRST language. It would make a great second, though. Why? Because C (and C++) has a lot of confusing cruft that a beginner just doesn't need to know about. The noise in the language is too high and too much work is involved in achieving relatively simple things. A higher level language also has quicker returns, which definitely helps keep someone whos just starting out motivated. Most high level languages have better tools to learn with too, like an interactive read-eval-print-loop.

I would recommend Python. Not Python 3, but Python 2.6 - better library support. I recommend Python because it takes very little to get working and it comes with everything a beginner would need bundled. When you're learning, you don;t need direct hardware access, you don't need direct OS interfacing, you don't need high performance (and probably wouldn't get it anyway until you learn how to write good, fast C). You DO need to get things done quickly (its hard to learn, otherwise) and you DO need an environment that doesn't require much background knowledge to work in. In Python, a simple program is simple. Theres no need to learn about "main" (and therefore functions), about includes, printf format specifiers and so on - just to write a hello world. As your skill increases, you can gradually add more language features: conditional statements, loops, I/O, functions, data structures, classes, functional programming tools, libraries, metaprogramming. You dont have to deal with manual memory management and you'll get more meaningful error messages than "segfault".

You learn a lot about PRGOGRAMMING (rather than having to deal with the low level complexities of C) which can then be applied to almost any language. If you outgrow Python (and I don't think you ever would, I know people who write some amazing stuff in Python, including HIGH PERFORMANCE CODE) you can learn C. I'd recommend it as a second language. Everything you've learned from Python will be applicable in C too. At this stage you should be well versed and pointers should come a lot more easily. You can also use Python and C together - its not even that hard.

You could easily replace Python with Ruby in the above, if you prefer. Python and Ruby are pretty much equal players.

If you don't mind going a less mainstream, I'd suggest learning Factor: a fast, powerful, very dynamic, native compiled concatenative language. It has pretty much all of lisps powerful features, with some ideas taken from Forth, Smalltalk and others, has an active community and very clean codebase. (The library code is some of the highest quality code ive seen) being stack based, it may take some effort to get into the mindset though.

If you can make the effort, you can learn programming with C. You need good learning materials (which are available), you need to work hard, and you need to focus on learning C rather than trying to cram C into an otherwise generic introduction to programming.

    Javascript
    C
    Python
    Scheme

    Erlang
    Haskell
    OCaml
    Mythryl

Also, I only recommend learning C first if you plan to do a serious, thorough study of the language and need it for a low-level project. Get C, A Reference Manual by Harbison and Steele, read the whole thing, and tackle a significant project with that knowledge. You can make progress with a half-assed approach to learning Python. If you try that with C it will be very painful.

Don't listen to these scheme/functional wackos. It's great -- and once you've been programming for a few years you should definitely learn it, it will improve your programming and allow you to think more elegantly about problems. But starting with scheme is like tying sandbags to your ankles and then training for the hurdles -- in theory you'll be able to jump like superman when you take the sandbags off in a few years, but realistically it's just going to make a challenging task even harder.

Just my 2c, of course. I started with BASIC, then 6502ASM, them Pascal, then C/C++, then a bit of APL and lisp variants, then Python (which was like a dream), then some more scheme, and now I pretty much stick to Python/C++, with a bit of Javascript on the side.

The other consideration is to pick a language that has some sort of structure and encourages a good understanding of underlying concepts. Working with C for example, really forces you to know and understand how a computer works. Something like Ruby (my favourite) allows you to easily ignore these inner workings. This has a speed and ease of development advantage, but could be detrimental to your core understanding of CS.

I personally love programming with Ruby, however from personal experience I can say the large amount of different programming styles which Ruby can encompass can cause you to write some really odd and sloppy code while you are learning. Additionally, there are an infinite amount of crappy examples of Ruby code, and relatively small amounts of good code. My recommendation if you go the route of Ruby is to ignore many of the articles/blog posts on beginning Ruby (they are drumming up ad traffic), and dig around in the source code.

Additionally, you can writ Ruby in a multitude of styles. Flexibility is always good, however, it can lead to some real serious slop. My first year or two of writing programs that were more than simple scripts were with Ruby, and they are some awkward and sloppy programs. However, the pleasure of producing those programs was probably greater than if I had tried to struggle through with something like C.

I am lately leaning towards suggesting javascript or actionscript for a first learners language. First off, both have an awesome ability to quickly get you something tangible. They have a really good layout system (mxml or html/css), and you can easily share your creations with others. Both can can be written in a C style, or can be very object oriented. Neither require crazy development environments.

If you want to learn an advanced programming language, try Haskell, ML (F#), or Lisp (Scheme).

C is a good programming language to learn. It can be quite unpleasant to debug C programs though.

Yes, but if you can do that, you can debug anything. Literally - Most high level languages are implemented in C, so debugging them eventually means debugging C code.

Once you're happy there, a move to Python, PHP, Ruby or Java will be relatively easy.

You don't need to know a language like C unless you plan to work with the elders.

I think Ruby probably has more advanced topics (especially meta-programming). I'm not sure if that's good or bad for a beginner. It's good in that you can keep learning and use the language for a long time. But it's bad that you won't understand everything for a while. That said, I was able to take advantage of the meta-programming that other people supplied (Ruby on Rails) just fine without understanding it at first. Now that I understand it, I find Ruby to be a very powerful language, while still quite simple to use. To me, it has the perfect balance of simplicity/elegance and power.

The most simplistic, user-friendly and well suited for all your tasks.