It alternates between incredibly fun and horrendously frustrating.

Python is a good choice. Very versatile and has a lot of really good resources.

If you enjoy coding and are good at it, you can pretty much print money, so it's worth trying out. It will be apparent fairly quickly if you don't like it though. I don't know of anyone who has spent years coding only to realize they hated it.

Python is OK. I would recommend learning Java, C++, or C#, as all are popular and there's a lot of information about them. C++ is how I learned, and I find it's easier to branch out to Java from C++ than the opposite. C# has the best of both worlds, so that's also an option.

Right, C++ is one I tend to hear a lot about in day to day life, I'm considering starting there or Java.
But taking your point into account possibly C++ would be a better starting option.

I'm not a fan of Java personally. C++ would be much better. What you'll find though is that the language really doesn't matter so much as your approach to coding. Once you've got that down its very easy to pick up new languages.

And be sure you learn vim : )

I second (third? fourth?) the C++ recommendation. As others have said, it's easier to move from it to others than vice versa. It is also an extremely flexible language that supports a lot of different fascinating programming idioms, and you can write just about anything in it (though more specialized languages will be more efficient for certain classes of problems, like web services).

Also, becoming good at C++ will, IMHO, teach you more about writing efficient code and thinking about everything that's going on, in *any* language you may use, than just about any other language.

Vim is OK. If you're a student you can get Visual Studio 2013 Professional for free from Dreamspark, which is an AMAZING C++/C# development IDE, with lots of extensions and plugins.

Eclipse is good for Java and other languages (I forget what all it supports, I've used it for Scala mostly).

Advanced IDE are good for large scale projects but for learning, I think a simple editor is much better. It forces you to do things for yourself.

That's true. I have some friends who swear by Vim, and others who love VS. It depends on the person, budget, situation, etc.

Also, what is your degree in? That could make a big difference.

Java is easier to learn (and more forgiving) than C++ - I would start there.

I don't agree that Java is easier to learn. And even if it's a degree easier, the transition from Java to C++ can be painful. I've never seen someone have issues transition from C++ to Java, but the opposite way is often painful for beginners.

There is a lot of overhead and inefficiencies associated with Java that are not representative of most languages. It is also only useful for high level development. It is much easier to go from a low level language to a high level than the other way around.

I really recommend against C++. For starting, you should really only consider Python or C. They are at completely opposite ends of the spectrum, but both are easy to learn and get into.
C is rarely used in the real world (though I use it exclusively in my day job), but is the best foundation and it is easy to branch to everything else.
Python is easy to learn, has good real world applications, and you'll be able to write actually useful stuff in a few weeks. The drawback is that you'll be missing some background knowledge about how it actually works - which is usually not needed.

A good C programmer will understand his code down to do circuit level. Python programmers don't care about any of that - Basically it's just give instructions and watch the magic happen. Whichever sounds more interesting to you.

Personally speaking:
C++ is unwieldy, tedious and frankly pretty old fashioned
Java is intuitive, powerful and because of this a pleasure to program in, especially using Eclipse.
That being said, it's important to learn multiple languages. Python, C++, C# and Java are all great suggestions, and a great deal of it depends on personal preference.
Short answer: try them all, when you find the one you like, you'll know.

Why would you recommend C over C++? C++ has a lot of the low-level advantages of C with the added benefit of being Object Oriented, which is very important to know.

@abge: OOP can come later. C++ has a LOT of stuff that's hard to understand. I personally know no one who really knows C++. *
C on the other hand is a tiny language. You can learn everything detail about it in a month. When you write your code in C, you know exactly what is happening under the hood and why. I think it is the perfect foundation.
After you've mastered C, branching to C++, Java or any other OO language is a breeze. You shouldn't start with them.

*if you think you know C++, here's a very quick riddle: auto x = [](){x++;};

OK fair enough. I think a lot depends in what the OP wants. If he really wants to understand how languages and computers function, starting with C may be the best. If we wants to immediately start making use able programs, he should go for Python.

Pseudocode is where it's at

I know how to program in Comal and Turbo Pascal. Newer developments have passed me by.

My thesis was actually all done in FORTRAN

@ Sherincall: Technically that is a C++0x riddle. In earlier versions of C++ it would make no sense at all.

I started with python, and think it's great for absolute beginners. At a point where you don't understand a thing about programming, a simple language with loose syntax is perfect to build the programming skills which can later be applied to other languages. Otherwise you'll spend forever trying to master the syntax

Everyone else is offering excellent advice, but I've always wished I had learned a functional language such as LISP first, as it really trains your mind to think the right way, even if it isn't all that practical anymore.

Other than that, I think it's important to try C at some point, but it could be very frustrating to do so as your first languages. C++ and Java are both very powerful, but they're also pretty shitty. Python might be a good place to start, but it can also lead to terrible habits.

Lastly, Chaqa will be retracting his Visual Studio recommendation promptly, or bad things will happen to him.

@Jamiet: Fine. Suppose f(g(h(i(j(new MyClass())))));, where f/g/h/i/j take and return various combinations of MyClass, MyClass & and MyClass * (and const-ness). Do you think you'd be able to estimate when a constructor, copy constructor and operator= are called? How about destructors for automatic objects? God help us if we add exceptions to the mix.

It tries to be a low level language, but is so mangled and complicated (and buggy and inconsistent) that it's just pointless. Write critical code in C. Write everything else in Python or something.

@ghug: I retract nothing.

@Sherincall

"Suppose f(g(h(i(j(new MyClass())))));"

That's just bad coding IMO. In the interest of maintainability of your projects you should always value readability over conciseness when you write code and in most cases even over the code's efficiency. So that should probably read something like:

// Short description of what the hell MyClass is.
MyClass MyClassObject;
MyClass* MyClassPointer;
MyClass& MyClassReference;

// Short description of what the hell this code actually does
MyClassObject = new MyClass();
MyClassPointer = DescriptiveFunctionName1(MyClassObject);
MyClassPointer = DescriptiveFunctionName2(MyClassPointer);
MyClassReference = DescriptiveFunctionName3(MyClassPointer);
MyClassObject = DescriptiveFunctionName4(MyClassReference);
DescriptiveFunctionName5(MyClassObject);

Note that I might have gotten some of that wrong since I actually never use C++ myself. I think I sufficiently illustrated my point though.

I strongly, strongly recommend *against* learning C before C++. Learning C first will just teach you a bunch of wrong and limited way to think about programming, and then you'll take a lifetime to learn to get out of the ruts C forces you into and into better idioms, like type safety, OOP, and generic programming.

See this FAQ from the creator of C++:

http://www.stroustrup.com/bs_faq.html#prerequisite

As for Java -- among the other disadvantages that people have pointed out, including the important facts that Java is inefficient and Java programs suck, I think Java is worse to learn on becasue it has too much going on behind the scenes. One of the beauties of C++ is that the language does dang near nothing that you don't tell it to do. This really helps you learn about how programming and computers work, and it will help you appreciate, when you do move on to other languages, just what they are and aren't doing *for* you, and what that means in terms of efficiency, control, etc.

And also, speaking of control, Java gives you less of it. The Java philosophy is more or less that programmers are stupid and will make bad mistakes if we give them powerful tools. There's truth in that, but it's also restrictive and kills efficiency and (often) elegance.

Also, C++ is a thing of beauty and a joy forever.

Every language has some odd/ridiculous syntax. I don't think a language is bad if it can do/looks weird in CERTAIN situations.

That's like saying "I'd never buy a Ford Mustang because if the wheels are bad and I'm going 80 on the ice, it will flip."

Fun fact: Windows was written in C++

@oscarjd: Correct. I just did that as a really quick example. Consider this, for example:
MyClass MyClass::getIncremented(MyClass x)
{
MyClass y = x;
y.n++;
return y;
}
MyClass a = MyClass::getInstance();
MyClass b = MyClass::getIncremented(a);

Of the top of my head, I see: Constructor in getInstance, operator= for a, Destructor for the temporary object returned by getInstance. CopyConsructor for passing a as a param, operator= for y=x, CopyConstructor for passing y as a param. Destructor for the param x. Operator= for b. Destructor for the temporary object returned by getIncremented. And I'm sure I missed a few.

@semck: "One of the beauties of C++ is that the language does dang near nothing that you don't tell it to do. "
Yeah.. just like what I wrote above. That argument is exactly why I'm saying C is better than C++ for learning. I don't think anyone who learns C will be stuck without understanding the OOP concepts. Actually, I think that once you've learned C enough, and have created your own vtables and rtti and whatnot, moving to a language that has syntax support for it will be trivial.

Start with something like Pascal that has strong typing.

Sorry Sherincall, but there's nothing confusing or ambiguous whatsoever in what you've put. Whether a copy constructor was called, or which operator, etc. isn't quite that important, that's like arguing over a missing comma in a paper.

getIncremented makes a copy of the passed in object, increments its data member n, and returns this changed object. Getinstance, I assume, is a constructor to make a new MyClass object (typical syntax would simply be Myclass a = MyClass() ), and b is a, but incremented.

I was commenting on your remark that you know all that happens. You don't - Look at how many constructors and destructors are called. And then, if you enable optimizations, it will get rid of the temporary object when returning a class - Means less constructor/destructor calls. Those things could have side effects.
Sure, you should write them so they don't, but you don't write all the code. Hell, put a print in every constructor and on different systems you'll get different output.

When looking at the high level code, it seems easy to understand - Create one object, create another that has one field incremented. But so much stuff happens in between that no one knows - Just like in Java, for example. But unlike C++, in Java you know you have no idea what is actually happening. Here you fall into the trap of thinking you understand it.

Wow there are more of you out there than I expected.
My degree is in Accounting and Finance, but it's a degree that I'm really not a fan off. Which is largely why I'm taking a year out and working in retail and just earning money for the time being. I'm still academically minded though, and I just figured learning some kind of programming would be something I could self teach myself somewhat and has great employability potential, that's the plan anyway. I'm not looking to instantly start writing systems, I want a general understanding of programming and how it works first. And see where that takes me.

From what I've gathered from this thread, Python will probably be more fun for me, but C++ more useful.

A agree with Chaqa. It's not really that complicated. Or at least you don't really have to worry about it. Except maybe in cases where a constructor or a destructor does some very unconventional things. Arguably though, in those cases you should have picked another solution to whatever the problem was than to stuff it into the constructor or destructor.

Also, although again I'm not that familiar with C++, I would assume that modern compilers automatically optimize some of this stuff. For instance, assuming that thread-safety isn't an issue, then since the variable x in your example doesn't actually get changed within the function, there is no need to create a copy when it is passed, i.e. the function can simply work with the instance a that already exists outside of the function scope.