Ugh, Java's the new COBOL. I'll write in assembly language before I write stuff in Java. Sure there's a few cases where I'd still choose to use it for pragmatic reasons, but using it to teach or learn is a mistake. Also, a lot of ex-Java guys seemed to be running to Ruby over the last few years. Ex-Perl programmers tend to run that way too, but for different reasons.
The only reason Java is popular is because that's where all the C++ programmers who didn't need hardcore performance or native look and feel in their desktop applications fled to out of disgust.
C++ is just a monstrous language with an incredibly dense standard -- no man alive knows the complete language, and those who get close forget the corner cases every time they step away to another language for a project or two. It seems to combine the functionality of C, Smalltalk, and ML, while taking a lot of their worst attributes along the way, and they keep changing the damn standard, so code you wrote yesterday doesn't compile today without a lot of changes, and code you write today might not compile tomorrow.
Objective-C and Smalltalk are much more dynamic, so they work better for Object-Oriented programming (which is inherently dynamic -- you should be passing around objects of all sorts of types, and duck-typing should be easy). On the other end of the spectrum, Haskell and OCaml or ML are much better if you need high-level features with static, strong typing that won't convolute your code with type declarations, but still gives you the same level of confidence in your code's correctness at compile time (which makes them highly static, but not in the needlessly tedious and verbose way that C++ and Java do things). Really, the only reason C++ became popular is that it tried grafting more advanced features on top of C, and C was once the end-all-be-all of everyday programming languages.
That's because if you learn some low level computer science concepts, C is really simple and straightforward. In other words, learning C is much easier if you learn it with assembly language... Otherwise you'll spend a few years not really understanding what you're doing (I spent at least 2 or 3), and you won't realize it. But back in the day, a lot of programmers already were assembly language coders, and so they moved up from assembly to C, simply because it gave you a lot of the same flexibility while providing a conceptually clean syntax. A lot of code was so low-level that the ability to manage memory how you want to easily and effectively, directly access hardware resources, and create your own abstract data types that simply point to the data instead of copying it all the time were big advantages -- advantages that let you write fast code without resorting to assembly language. And as a result, in a lot of areas today, C is still the man.
Which brings us to the question of where Smalltalk and ML come from, and the answer lies in a language that's now almost 50 years old -- Lisp.
Lisp is the ultimate programming language for experimenting with new concepts and ideas, or creating domain specific languages by adding your own language semantics using macros, while having almost no real syntax, which makes it really popular with the CS theory guys. High-level concepts like Object Oriented programming and Functional programming were tested out and implemented in Lisp before they were developed into their own languages. In a way, this makes Lisp the most powerful and abstract language out there. Not bad, considering how old it is.
But to most programmers, Lisp is quirky-looking, requires too much abstract thinking, and can be hard to interface with code outside of the compiler's environment. Seen from a Lisper's perspective, that translates to "beautiful, fun, and contained within a high level programming environment."
And then there's BASIC. Never really used it, but the idea of a simple, clean language for quick coding by people who don't know the machine inside-out is a pretty good one. I'd consider it the first real glue language. Python's a much more modern glue language, in that it has a lot of high-level features taken from languages like Lisp and Haskell, but its main focus is still clean, easy to read code.
So why the sudden, long talk on programming languages? Because I don't think you're incapable of learning how to write code -- not any more than most people are incapable of learning a few math formulas and how to apply them in a physics class. Rather, the state of Computer Science education is pretty bad right now, and so intro classes are some of the worst ways to get your feet wet with programming. A lot of classes have shifted towards "Industry" languages that are generally pretty bad, but have become widely used (namely Java and C++, mostly thanks to the wonder that was and still is C).
If you're not interested in all the arcane, boilerplate nonsense and coding styles that involve writingLongVariableFunctionClassAndMethodNamesLikeThis all the time, and just want to be able to throw stuff together and try it, give Python (with pyGame) a try or find a good BASIC (not Visual Basic.NET though -- that's really just C# in disguise). Don't make it a chore either -- just toy around with code snippets and try to get something cool going. Computers are a lot more fun when you're able to define what they can do.
Anyone who sneers at you for using something like BASIC and tells you to use something more "powerful" is just another stupid language-snob. When it comes to real computer science, languages won't save you from not knowing how to solve problems, write algorithms, or create data structures specific to your needs.
That's another reason to stay away from low-level CS classes at University -- you'll find a lot of C++ snobs floating around who are too proud of their mastery of the arcane C++ standard and over-confident in the magical performance inherent in compiled C++ code to learn other programming languages, discrete math, or how to really optimize software for performance using profilers and debuggers and a bit of theory on algorithms and computing. They also get caught up in coding methodologies and powerful IDEs and code refactoring tools, simply because the code they end up having to write is always so verbose and unmanageable when they get beyond small projects to real ones. You'll also find Java snobs who think they're better for sticking to an inferior and compromised Smalltalk, Ruby snobs who think scripting is the way of the future and that low-level code is pointless with today's multi-core processors, C# snobs who've found the next Java, and maybe even some C snobs who use it 'cause they use Linux.
And almost none of them will know anything about the history of Computer Science.
Anyway, welcome to the Compendium!
