I'm a young programmer who desires to work in the field someday as a programmer. I know Java, VB.NET and C#. I want to learn a new language (as I programmer, I know that it is valuable to extend what I know - to learn languages that make you think differently). I took a look online to see what languages were common. Everybody knows C and C++ (even those muggles who know so little about computers in general), so I thought, maybe I should push for C.

C and C++ are nice but they are old. Things like Haskell and Forth (etc. etc. etc.) are old and have lost their popularity. I'm scared of learning C (or even C++) for this same reason. Java is pretty old as well and is slow because it's run by the JVM and not compiled to native code.

I've been a Windows developer for quite a while. I recently started using Java - but only because it was more versatile and spreadable to other places. The problem is that it doesn't look like a very usable language for these reasons:

It's most used purpose is for web application and cellphone apps (specifically Android)

As far as actual products made with it, the only things that come to mind are Netbeans, Eclipse (hurrah for making and IDE with the language the IDE is for - it's like making a webpage for writing HTML/CSS/Javascript), and Minecraft which happens to be fun but laggy and bipolar as far as computer spec. support.

Other than that it's used for servers but heck - I don't only want to make/configure servers.

The .NET languages are nice, however:

People laugh if I even mention VB.NET or C# in a serious conversation.

It isn't cross-platform unless you use MONO (which is still in development and has some improvements to be made).

Lacks low level stuff because, like Java with the JVM, it is run/managed by the CLR.

My first thought was learning something like C and then using it to springboard into C++ (just to make sure I would have a strong understanding/base), but like I said earlier, it's getting older and older by the minute.

What I've Looked Into

Fantom looks nice. It's like a nice middleman between my two favorite languages and even lets me publish between the two interchangeably, but, unlike what I want, it compiles to the CLR or JVM (depending on what you publish it to) instead of it being a complete compile.

D also looks nice. It seems like a very usable language and from multiple sources it appears to actually be better than C/C++. I would jump right with it, but I'm still unsure of its success because it obviously isn't very mainstream at this point.

There are a couple others that looked pretty nice that focused on other things such as Opa with web development and Go by GOOGLE.

My Question

Is it worth learning these "experimental" languages? I've read other questions that say that if you aren't constantly learning languages and open to all languages that you aren't in the right mindset for programming. I understand this and I still might not quite be getting it, but in truth, if a language isn't going to become mainstream, should I spend my time learning something else? I don't want to learn old (or any going to soon be old) programming languages. I know that many people see this as something important, *but would any of you ever actually consider (assuming you didn't already know) FORTRAN? My goal is to stay current to make sure I'm successful in the future.

Disclaimer

Yes, I am a young programmer, so I probably made a lot of naive statements in my question. Feel free to correct me on ANYTHING! I have to start learning somewhere so I'm sure a lot of my knowledge is sketchy enough to have caused to incorrect statements or flaws in my thinking. Please leave any feelings you have in the comments.

The Results...

I'm truly amazed by the amazing responses, most of them so nicely pointing out my misunderstandings and misjudgments. I've learned quite a lot from this and I'm excited to hopefully utilize everything I've learned! I'll probably start learning Haskell next (the not so old language, albeit over 20 years old - hahaha) and then start looking at some other options around me.

Many good questions generate some degree of opinion based on expert experience, but answers to this question will tend to be almost entirely based on opinions, rather than facts, references, or specific expertise.
If this question can be reworded to fit the rules in the help center, please edit the question.

Note that simply being "old" does not automatically mean "bad" by default. Some of the most fantastic programming so far was done on the C64 30 years ago.
–
user1249Jul 1 '12 at 23:07

8

FWIW almost every language has uses - if someone laughs at you for using almost any language (Java is slow, .Net is for M$ bitches, Haskell is impractical, C++ is too old etc) laugh right back at them and tell them about using the right tool for the job ;)
–
MartinJul 2 '12 at 2:04

5

Where did you get "Haskell and ... have lost their popularity" from?
–
leftaroundaboutJul 2 '12 at 7:57

13

For a young programmer, you have too many assumptions. Get rid of them, they are clouding your mind.
–
Matthieu M.Jul 2 '12 at 15:05

13 Answers
13

The thing with learning drastically different languages isn't about learning the languages, it's about getting exposure to different approaches to problems. Tools for the toolbox as it were.

One thing to note is that Haskell isn't particularly old and it is actually a very good candidate for someone only familiar with mainstream languages. Even a very old language like Lisp is very useful to learn due to its influence on things.

Also, Java and .Net are not interpreted and I expect you're making some incorrect assumptions based on that mislabeling.

@JörgWMittag: I think that says more about Java than about Haskell though.
–
Tikhon JelvisJul 2 '12 at 5:55

1

I program in only Haskell and Java...but to be fair, no mainstream language has a type system anywhere near as good as Haskell. (And I have to say, OP..._lots_ more stuff than what you mention runs on Java.)
–
Louis WassermanJul 2 '12 at 13:17

1

Haskell is over 20 years old by now, and standard Haskell is just as old as standard C++ (they're both from 1998).
–
fredoverflowJul 3 '12 at 6:34

Stay Fit: Get Regular Practice

Practice makes perfect.

The more code you write AND read, the closer you get to enlightenment / mastery as a programmer / developer / software engineer / guru / ninja / craftsman / hacker / buzzword-of-choice. By not only coding and reading more, but also trying our new ways of writing code, the more open-minded you (hopefully) remain.

Learning About New Paradigms and Language Features

Maybe you won't be able to translate what you use in brand new Super-Language-X to your Enterprise-Language-Y, but maybe you'll be able to recognize when it could have been a good fit. Maybe you'll be able to know when to integrate a different technology or stack in your project to fit a particular purpose. Or maybe you'll know how to use the features of language Y to emulate the cool feature of language X, and refactor your code to benefit from it (and potentially enlighten other co-workers along the way).

Be a Jack of All Trades... Master of Some?

You don't know which language will become mainstrain when it's in that "experimental" stage, so you shouldn't worry too much about betting on one of them. Chances are, other people will make the same bet and will be intrigued when they see these showing up on your resume. Add one tool to your belt. In our case, there's not much problem with how much it weighs in the end.

Sure, you can't become a master of all trades. But you could be a master of one, and pretty good at the rest. You're learning a craft, and ours is multi-faceted. Doing regular exercises, attending workshops, grabbing a book, writing a new pet-project and other similar things are our way to keep up with the ever-increasing pace of change in our field.

Stay Adaptable

If you don't learn to adapt, it's hard to do it when you need it. By constantly learning new things, you get better and better each time at picking new stuff up (as long as you don't constrain yourself to very similar challenges).

It's like the "Stay Young" Oasis song goes: Stay young and invincible.

Stay Visible: Understand the Recruitment-Agency's Radar

They use keywords and technologies as check-boxes. We use them as honey-pots for mindless recruiters.

It works both ways. As long as you really know your stuff, then having lots of stuff on your resume is good. It shows your adaptability and breadth of knowledge. Plus, if you really master a few of these, and are decent in a few others, it allows you to modulate different versions of your resume for different positions and jobs.

If you're going to read Paul Graham's Beating the Average, (or anything else he writes on the subject of programming, for that matter,) take it with a grain of salt. A lot of the stuff he has to say about programming practice is 50% right and 50% dangerously wrong.
–
Mason WheelerJul 2 '12 at 22:47

@MasonWheeler:It's controversial, like many things you can find out there from known industry "giants", self-acclaimed or not. Many people would disapprove of Zed Shaw's writings as well, like others would of Norvig's. Everything is to be approached with a critical mind: I take it as a given for anything, and assume (hope) so do people at this level. A lot of writers will present topics in light of a specific situation, not fitting everybody's. In fact, you see this here everyday in answers as well, yet by "popular" force they'll be revered as "best" answers. Still, it's informational.
–
haylemJul 3 '12 at 0:49

Another good reason to learn brainf*ck is to understand how basic a Turing-complete programming language can be. A common argument when programmers compare languages is “well they’re all Turing-complete”, meaning that anything you can do in one language you can do in another. Once you’ve learnt brainf*ck, you’ll understand just how difficult it can be to use a Turing-complete language, and how that argument holds no water.

Learn at least a half dozen programming languages. Include one language that supports class abstractions (like Java or C++), one that supports functional abstraction (like Lisp or ML), one that supports syntactic abstraction (like Lisp), one that supports declarative specifications (like Prolog or C++ templates), one that supports coroutines (like Icon or Scheme), and one that supports parallelism (like Sisal).

My first thought was learning something like C and then using it to
springboard into C++ (just to make sure I would have a strong
understanding/base), but like I said earlier, it's getting older and
older by the minute.

Well, this is a giant pile of fallacy. People who know C have a harder time learning C++, because pretty much everything they think they knew about how to use the language is a giant pile of wrong. There is virtually no idiomatic C that is even remotely good C++. You are better off simply learning C++ from scratch. People like myself who volunteer their time to help other people learn C++ spend a massive proportion of it trying to teach people to drop their C habits.

As for popularity, well, C++ is experiencing a bit of a re-emergence recently. People noticed that actually, performance does matter, a lot, and you can't get away with running every component as a managed one, and Modern C++ (especially with C++11) is absolutely nothing like the C garbage they thought it was, and it's really not that bad at all. It's not really getting older. It's getting newer. The new Standard is a vast upgrade- and there are no suitable replacement languages, either current or in the pipeline, for many of the areas C++ is used in now. This is not least because there are no languages with decent C++ interoperability (even C++ itself), making it difficult to migrate away from existing C++ codebases.

People laugh if I even mention VB.NET or C# in a serious conversation.

Get new people. AFAIK, VB.NET doesn't really exist for any reason except to help migrate away from VB6 and isn't really a worthy goal in as of it's own right, but C# is a real language. It's kinda like Java, except they then added actual language features and some nice libraries. C# is a very popular, well-supported language with very good tools in VS, which doesn't suck that badly, and is a solid, if not exceptional, thing to learn.

It isn't cross-platform unless you use MONO (which is still in
development and has some improvements to be made).

MONO is pretty stable. Plus, ultimately, 90% of desktop consumers (or was it 80%?) run Windows right now. If you're gonna develop a desktop application, it's an open question as to whether the non-Windows-users are worth the time to support, even if you use a cross-plat language.

Ultimately, you could get a lot from learning a language like C++ or Haskell, which focuses on strong compiler technology rather than a massive runtime.

Just don't pick PHP. The only thing you can learn from that is how not to build a language.

A significant percentage of the recent additions to the C++ standard only exist--like a significant percentage of additions in times past--to patch existing C++ flaws. Rvalue references, for example, add a bunch of extra complexity to work around a bunch of performance and complexity problems related to copy constructors, which only exist because C++ allows objects to be used as value types, which is 100% completely wrong and there's a good reason why no other OO language does that.
–
Mason WheelerJul 2 '12 at 22:53

@MasonWheeler: Rvalue references also enable perfect forwarding, and move-only types. Performance was only one of the three major causes for their introduction. Value-typed objects is just fine. Plus, of course, you can write your own reference-typed objects in C++ all you like.
–
DeadMGJul 3 '12 at 7:52

Also, it's funny how even with all those performance problems, C++ was still the fastest language around.
–
DeadMGJul 3 '12 at 8:21

1

@FredOverflow: In C#, all objects are reference types. Structs can be value types, but objects can't, and this is for a very good reason: if objects get used as value types, you throw a huge monkey wrench into inheritance and polymorphism and end up having to use all sorts of ugly hacks like copy constructors, where assigning (or passing) a descendant object to a parent type variable doesn't actually assign that object. It completely screws up Liskov substitution, which is the entire point of using OOP in the first place. It's a horrible idea, and I'm glad it never caught on.
–
Mason WheelerJul 3 '12 at 12:59

1) Every programmer should learn C, even if it's old. It's a great language for getting close to the machine. From Joel's advice to CS students....

Learn C before graduating

Part two: C. Notice I didn't say C++. Although C is becoming
increasingly rare, it is still the lingua franca of working
programmers. It is the language they use to communicate with one
another, and, more importantly, it is much closer to the machine than
"modern" languages that you'll be taught in college like ML, Java,
Python, whatever trendy junk they teach these days. You need to spend
at least a semester getting close to the machine or you'll never be
able to create efficient code in higher level languages. You'll never
be able to work on compilers and operating systems, which are some of
the best programming jobs around. You'll never be trusted to create
architectures for large scale projects. I don't care how much you know
about continuations and closures and exception handling: if you can't
explain why while (*s++ = *t++); copies a string, or if that isn't the
most natural thing in the world to you, well, you're programming based
on superstition, as far as I'm concerned: a medical doctor who doesn't
know basic anatomy, passing out prescriptions based on what the pharma
sales babe said would work.

2) Languages can be good for learning mindsets, even if they aren't commonly used. Learn Scheme (or LISP) to understand functional programming, even if it isn't trendy. From another post on this board.

Congratulations, it sounds (to me) like you may be
going to one of the few schools left that actually tries to teach
computer science. Learning Scheme as a first language is (IMO) a very
good thing. No, it's not as commercial as many others, but it's an
excellent language for learning the real essence of computer science.
– Jerry Coffin Oct 20 '11 at 3:32

C, C++ and Java are industry
byproducts of computer science. Scheme's entire roots are in computer
science. The languages in commercial use have as much to do with
computer science as McDonalds has to do with cuisine.
– JasonTrue Oct 20 '11 at 5:30

These guys are correct; you are confusing
computer programming with computer science -- as Dijkstra said, that's
like confusing telescope construction with astronomy. Scheme is about
the best language there is for learning basic concepts in computer
science. If you're expecting that taking a computer science degree is
about learning how to write line-of-business apps in Java, you might
be enrolled in the wrong program.
– Eric Lippert Oct 20 '11 at 7:40

Almost all developers I know have learned C/C++ by themselves.
You don't need university for that. – mouviciel Oct 20 '11 at 7:48

For the same reason that zoology courses teach evolutionary biology,
anatomy and animal behaviour rather than how to muck out an elephant
stall – jk. Oct 20 '11 at 7:58

Now despite attacking your original premise, I think you should be commended for your curiosity. Too many people become obsolete due to a lack of curiosity. Taking advantage of your personal development is a great sign that you will develop well. The people who learn the most are the ones willing to keep asking how things work.

"Almost all developers I know have learned C/C++ by themselves. You don't need university for that.": Same here. At my university they gave us assignments in C, but didn't give us a C course. They just expected us Computer Science students to go get a book and learn it.
–
GiorgioJul 2 '12 at 5:15

1

Having to learn C is quite the torture. My sympathies.
–
DeadMGJul 2 '12 at 15:18

2

Actually learning C was the easy part, the real torture started when we had to move to C++. ;-)
–
GiorgioJul 3 '12 at 19:26

ANY language you learn is going to change in the next 5 years. It isn't about learning a language that you think might be around a while, but rather, learning HOW to learn. The more exposure to learning the language and the process of learning that language will help you tremendously in the long run!

The last company I worked for used their own in-house language. It was similar to visual basic but not the same. Just for the fact that I knew other languages, I was able to pick their language up a lot quicker than the other employees.

I learned Japanese after I learned C++, BASIC, Pascal, and I can say that learning a computer language and a foreign language take the same skills. Those skills can be lost or sharpened. If you have the drive, keep it going and learn new languages!

(ps. as for learning FORTRAN or assembly, I think it is valuable to at least take one semester of the older languages. It makes you think about stuff you just take for granted in the newer languages, things like flags, memory allocation and such.)

You'd better learn as many "old" languages as you can, if you ever want to be a programmer. Start with Lisp, get a good grasp of Forth, pay a close attention to the evolution of all the Wirth languages, evolution of Fortran, rise and fall of Prolog, sneak into the secretive Ada ecosystem, get your secret weapon from learning Occam. Chasing the "mainstream" is the stupidest thing an aspiring programmer could ever do.

I agree with you on the exposure part of things. Though I know Java, C, C++, Javascript, Python, Ruby and a bit of .NET (primarily because I hate anything M$ <- personal opinion) I'll have to say that I really love programming in D.

D has a really nice feature set (most of them are implemented in C++/Java (languages which have class abstractions) etc) but the one thing I absolutely love the most is generics and delegates(makes it easy to implement callbacks). That apart you get a much simpler syntax to deal with in comparison to C++. D has a really efficient garbage collector, though you can choose to handle memory yourself (especially when interfacing with C/C++ modules). Though D does not have loads of user contributed modules that shouldn't be a barrier for entry. You can easily interface with existing C/C++ libraries (which are pleanty) thus making it redundant for need of modules.

D has its own standard library (Phobos) which serves the need for all common programming problems. There is also an alternative library (Tango-D2) which you can use either with Phobos or by itself. If you are a web developer and in the need for writing an event-based server, Tango has a nice Selector abstraction (tango.io.Selector for only select(), poll(), epoll()). I have found it to perform even better than libev.

Not that I would disapprove of learning D, but to someone who already knows statically typed, OO and procedural, non-low-level languages it's certainly worth more to learn a language that emphasises a different paradigm or is a bit closer to the metal. There's not much experimental about D, either.
–
leftaroundaboutJul 2 '12 at 8:24

1

Agreed. I thought the OPs question was centered around "experimental" being something that isn't stable yet/backing corporate support/one which isn't mainstream. And even if you go for "experimental" being implementation of different paradigms i guess there are only few paradigms out there. And most of the languages implement one or the other. Then we come to which language is better/faster/easier to use/best for the job at hand. These factors differ from programmer to programmer.
–
Shripad KrishnaJul 2 '12 at 9:35

Languages are developed to solve problems in some sort of domain(at least at first). If you haven't faced problems that your tools can't solve in a way that you are comfortable with, you'll be hammering a wooden plank expecting to become a carpenter.
Try to understand the kind of problems the languages are trying to solve. The only difference between an "experimental" language and a new/hip cool guy language is the money supporing it, for example Go from google and Dart. If they were developed in my backyard, they will probably die in some forum and that's it. They only survive if they are good at explaining the problems they are trying to solve. Or the other way around, like Perl and C++, which are good at absorving ways of solving problems to keep being alive.
And i might suggest learning Lua, it's a language made for embedding inside programs, it's very fast and lightweight, which will give you tools to solve the big or small problems that some languages like Java can't solve in a straightforward way.
Taking the example of Japanese, if you just learn the syntax, grammar and alphabets, ignoring the culture, you will never understand why it's so complicated, and eventually forget all about it. It's not solving anything for you.

Learning multiple different languages will give you a broader view of programming. Emphasis on "different" - e.g. learning C# and Java will not teach you that much more than learning just one of them. But learning C# or Java, and a functional language (for example) will.

Having said that, as a young programmer, I think you would get a lot more value out of getting to know one language really solidly, before bouncing around looking at different types of language. It's not entirely clear from your question how well you know Java, VB.NET and C#. Are you confident that if you attacked a project using one of the above languages, your bottleneck would be the project itself, not your knowledge of the language? If you would spend more time asking yourself "how do I do this in language?" than you would spend thinking about the actual problem, then your probably need more focus on one of your current languages.

And personally I think you should take a pragmatic approach to deciding which one that is. Java is used for Android apps? Great, if making Android apps is something you're interested in. Irrelevant if it isn't. C# is not a great fit for non-Windows development? Bad news if you're interested in developing for Linux. Irrelevant if you're not. And so on.

And the "experimental" languages you mentioned? Pragmatically, they're going to be a poor fit when it comes to working with other people - you'll probably find a thousand people who know C# or Java for every one who knows Fantom. For personal projects, this is not necessarily a problem. If your goal is to increase your employability, it is.

You could say that learning to program in a language like Postscript or APL is arguably a waste of time primarily because the chances of you ever using that knowledge approaches zero. But by the same vein, you could argue that Ruby and Python are a waste of time if you never intend to use them for anything.

But few people would say that learning Lisp is a waste, even though you're about as likely to have to write Lisp as Postscript; but learning Lisp teaches you to think differently about your problem (hopefully), which is why most programmers will tell you that it's worth your time.

Still, I never shy away from learning a new language since the required time investment is really only an hour or four. And uses for a language like Lua pop up in the most unusual places, and you would have never recognized them if you hadn't spent a few hours running through the examples.

When you see a new language, read up a bit on what it's useful for. If it's a niche your favorite languages don't cover too well, then take a day to learn the basics. It's certainly time better spent than watching season 17 of The Bachelor or however else you may waste time. That way, if you have a use for it, it can pop into mind and you know where to find out more.

I'd personally really recommend looking in to Go. I've used it to write single-page programs that perform better than what would take three days and 13 third-party libraries in C or C++, and wouldn't even be possible in Python, C#, Ruby, etc. It was designed by people who really, really, really know their stuff.

Pick ones with different types. Group them by features, and pick one in each group. If you want to do this professionally, pick one that is used (so C++ over D for statically typed compiled language with template metaprogramming).

Poor D, it's a good language, but it lacks the killer app which C++ had: almost full backwards compatibility with the #1 language of the time (C for C++'s case). It's nice, but that important little fact will probably relegate D to sideshow status in the history books.

C is also the lingua franca of microcontrollers (when you only have 4K, you can't afford an 8K runtime). In that space alone, C has another good decade of active use ahead of it.
–
TMNJul 3 '12 at 14:58

Java used to be slow - I remember it being less than a speed demon in its first couple of years. Some people think performance was never improved.
–
MetalMikesterJul 3 '12 at 15:16