Today, things like scripting are very common among new programmers, because they find it easier to get into the programming mind set if they start there. Of course, they eventually move onto greater languages, such as c/cpp or java. But, sometimes they get stuck with that scripting language. Why? Because, scripting is easy!
Easy is the simple way of saying a language is high level, more abstracted from the hardware. Abstraction is good. Our brains are not built for thinking like machines. Our brains are unfit for constantly calculating numbers. Our brains are generally good for making decisions, something computers, who's only job is to calculate numbers, could never do more efficiently then us! So, when a programming language is more abstracted from the hardware, it becomes more human. With a more human language, a programmer can work much faster with the language, becoming more productive and creating better software faster!
Now, some good examples of a high level language include, but are not limited to -
Of course, if there is high level, then there must be low level, right? Some common low level languages are
Assembler is a much bigger category, but for this article/rant's sake, I decided not to go into it.
Anyways, another way to think of low/high level is like our atmosphere. Imagine, your looking at the ground from space. You can't see all the underlying systems of our planet, your too far away, but you can see the planet as a whole. Now, the closer you get to earth, the more you can see, and the less abstracted things are. In the sky you can make up more details. The lower you get, them more you can see. As you start to get closer to the ground though, bugs are much more frequent. And of course, when you hit the ground, it's riddled with them. That's kinda how low/high level languages work.
Now, I'm sure some may argue that if your a good programmer, then you'll find less bugs on the ground, but that's completely beside the aim of this article, and anyone who claims that should get a swift :rtfm: in the behind!
Now, back to easy! Easy languages are higher up because they are more abstracted from the hardware. They help improve development speed, because programmers get to think as humans, not machines. Because of this abstraction, high level languages are very portable. For instance, Lua scripts can be run both on the pc and the psp with almost no effort on the scripters part. Back in the day, this is what made high level languages so powerful. They lost speed, but they were easier to distribute and port to other computer architectures. While assembly language failed, because it could only run on one specific type of machine, c and basic prevailed, because one could write a program for one computer and use it on another!
Programing started to get much easier at this point. All the noobs made little games and apps in basic, all the pro's made big games and powerful, fast programs in c, and all t3h u83R 1337 h4x0rZ made fast programs in assembler. But for the assembler programmers, all they had was speed!
Which brings us to the next topic, the speed of a programming language. How well can a programming language perform come runtime. Well, assembler is just about as fast as you can go, but that's out of the question. It's not portable, and it you work much slower! On the other end of the spectrum, we have scripting languages. They are simple, and very easy to work with. The developmental speed gain is pretty impressive, especially in languages like Python or Lua. But, scripting fails when it comes to speed. They overhead from running a scripted language is just so massive, no real programmers will actually consider it sane to write an application (photoshop, maya, blender, inkscape, gaim, kdevelop, ect.) or a game (halo 15, WoW, Counter Strike, Super Mario 28, Final Fantasy M) in a scripted language. The over head is far too massive!
Now, compiled languages are special. They can be extremely portable, they are fairly fast, and they can have enough abstraction and features that they speed up development speed almost to the point, if not faster, then a scripted language. C comes to mind, it's fast, portable, but not that abstracted. Java comes to mind also. It's extremely portable, it's abstracted, but since it has to run in a virtual machine, the overhead is comparable to scripting!
But then there is C++. With all of it's complexity, it's an extremely powerful, language. The overhead isn't that noticeable compared to C, it's portable, and once you manage to get all the concepts down, it is very easy to do perform complex tasks! C++ is a language who's speed is very comparable to C (the fastest compiled language ever), it's portability is comparable to java, as it can be compiled on just about anything these days (though java runs on a vm, so it's still more portable. but vm's are cheating anyways...), and it's power and flexibility greatly outweigh scripting languages! (it's STL is massive!)
That hardest part about learning c++ is learning how to use it. Because of it's massive amount of features, it can get very overwhelming. Most people, including 1337 programmers, are turned off by this. But, Once you learn C++, you can do just about anything with ease.
Which brings us back to the topic, what makes a good programming language. C++ is not perfect. But it's the most balanced language I've ever seen. Don't get me wrong, I wouldn't say that C++ is the only thing one would ever need to know. For simple, repetitive tasks, a simple script will suffice. For proprietary programs (yuck!) that need portability, Java will suffice. For kernel programming, C will get the job done. For small devices that require the most speed possible, like a fire alarm or a pacemaker, assembler is perfect. But, for applications and games, c++ is perfect. It let's you develop fast, allowing for many features, without loosing to much execution speed. And your code can be compiled on just about anything.
A programmers language of choice is very dependent on what they find them selves programming the most. There is no such thing as the best language. Programming languages are nothing more then tools, and you need to use the proper tools for a job.