Hacker News new | past | comments | ask | show | jobs | submit login
Ask HN: Learning multiple languages vs. mastering one
157 points by trtobe on May 23, 2018 | hide | past | web | favorite | 131 comments
Hi All. I am struggling to find/understand the best path to improve my knowledge/skills. I have a decent knowledge/experience in Java and now I am facing the dilemma either mastering Java or looking to other options to extend my programming language tool set mainly looking at: Javascript/Python/Scala/Kotlin/Elixir/Haskell/Swift.

I am interested in distributed system/data engineering and also in finding easily new well payed job. I know it's not possible to learning and master them all in a short time so I would like to pick 2. What I am struggling the most is how well to evaluate the language and get the best from it. Each time I pick one I end up giving up after 2 weeks as I always go back to Java.

The way I evaluate is simply by going to project euler and go through the problems from 1 to 20 then I don't know the next step to take from there. I find myself going through the crazy articles comparing languages and lose focus and give up.

Would be appreciated if you can share how you manage to focus on learning a new language or if it's worth at all learning/moving to a new language.

Update: forgotten also to ask what language do you advice and in 1/2 sentences why. thank you

Programming Languages are just like Human Languages. Every culture builds a common form of expressing ideas based around their shared values, needs and outlook.

Restricting yourself to one Human language limits your thinking and perspective. Each time I acquire a new Human Language, I find myself thinking differently and understanding people more deeply. Speaking French and German allows me to be a better communicator in English.

Human Languages can also provide means to an end. Learning German allows me to become a German Citizen. Learning Mandarin would allow me to start a business in China.

The same goes for Programming Languages. As mentioned by others, different Programming Languages were developed by people with different values, needs and outlook. Each time I learn a new Programming Language, I learn new forms of expression for my problem.

Programming Languages allow you to do different things. Depending on what you want to do with your career, choose differently.

Some languages are more useful than others. If you only know Java then you have a lot of learning ahead. I would explore in this order:

  * Python - You can do almost everything well in Python. Make lots of stuff  
  * Command Line & Bash - How systems are glued together. Deploy the stuff you make.  
  * GNU Regex & awk - How to find things and process text. A key building block of programming is processing text.  
  * HTML5 & Javascript - The right way to make most visuals. A frontend for your stuff.  
  * C - How all the above works underneath. Understand the stuff you made.  
  * SQL - How to handle data in databases. Persist the stuff.  
  * Haskell - Pure functional programming. Your Python and JS code will improve. Make the stuff beautiful.

This is a great answer to a question we all face in our programming careers - what do I learn next? With an understanding of all of the items you mentioned, the OP will be a much more well rounded, valuable programmer. At that point finding a better job will just be a matter of showing people what he/she knows.

The hard part is knowing _how_ to measure your skills. A while back I came across an article called the "Programmer Competency Matrix" and it stuck with me (google it for reference). Essentially it's a table of CS/programming skills with measurements 0-3, and it gives the reader a way to measure/track their various competencies.

After I read that article, I took his matrix and added my own additional rows/columns that I'd like to be proficient at. To the OP - I suggest doing something similar. Write out a list of all of the programming skills/languages you'd like to have (and need to advance your career), and give yourself an honest rating. Ask a programmer friend to rate you as well. Then ask yourself - what 0's do you want to turn into 3's, and weigh that against your career choices. Then plan your learning accordingly.

Like mjmdavis said: programming langs are a means to an end.Making a choice on where to move forward isn't just about your career - it's emotional/artistic/personal. You don't want to choose a language you hate just for a paycheck. I find that being more self aware (with my matrix) has helped me learn the skills I needed faster and more intentionally.

Good Luck!

It's inevitable you will have multiple languages / platforms comprising your stack. Bash scripts for admin. Golang to write servers. Data science in Python. JS / D3 on the frontend. C# / Unity 3D modelling and scripting. Even low level C / Assembly if you need performance optimizations.

I think mastery of cloud development and deployment is crucial going forward. Start experimenting locally right on your laptop with minikube, microk8s, snaps, prometheus. And get a sense of designing scalable systems.

You should have the ability to immediately estimate project costs. So you can give potential stakeholders a ballpark figure to open negotiations. Billion item recommendation system running on spark that serves 100K+ requests per second deployed to 1000 node cluster. Will it cost under $100 per hour? Or do we jump to tensorflow and a few large gpu instances for half that. Once you gain sufficient mastery. It will become second nature. And you can concentrate on design and building.

Best of luck :)

> It's inevitable you will have multiple languages / platforms comprising your stack. Bash scripts for admin. Golang to write servers. Data science in Python. JS / D3 on the frontend. C# / Unity 3D modelling and scripting. Even low level C / Assembly if you need performance optimizations.

It's not at all inevitable. I would - indeed do - use Scala for all of the use cases you listed.

Python is the de facto language for the deep learning part of data science, the interface to TensorFlow, PyTorch and Keras. Others may be possible but all the examples, books, etc. use Python.

Hey, someone found a golden hammer! Better throw out all those other tools, who needs 'em.

Programming is not carpentry. The best programming languages (IMO) are general-purpose, and the gains from being able to know a single language in depth and reuse the same tools and techniques across different domains outweigh those from using different languages in different domains.

Depends. Yes, learn a general-purpose language, and learn it well. But also, learn some other things well enough to be able to use them. Use them when they make the job easier.

For example, my main language is C++, and my second language is Java. But when the problem I have is picking snippets of text out of a text file, I reach for Perl, because Perl is far better at that than either C++ or Java. I don't want to "reuse the same [C++/Java] tools and techniques" in that domain - it's considerably more painful than using Perl to do it.

>But also, learn some other things well enough to be able to use them. Use them when they make the job easier.

I've found that even if I don't need to use a language after I've learned it, the skills and experiences I pick up while learning it improve my code as a programmer.

I've learned how to write fast code in C; learned how to write flexible template code in C++; appreciated the "batteries included" standard libraries of Python; wrote concurrent code in Go; used sum types and functional programming in OCaml.

My friend wrote an article[1] that says there is still no silver bullet for programming, and I agree with her.

Perhaps even if you think it is better to master a single programming language, you might better master it by seeing how other languages approach the same problem.

[1]: https://chameleon.kingdomofmysteries.xyz/articles/harmful/st...

> For example, my main language is C++, and my second language is Java. But when the problem I have is picking snippets of text out of a text file, I reach for Perl, because Perl is far better at that than either C++ or Java. I don't want to "reuse the same [C++/Java] tools and techniques" in that domain - it's considerably more painful than using Perl to do it.

Not convinced. I used to work in a similar way (indeed I would've made a similar argument), using Java for a primary codebase and Python for lightweight scripting around it. But I found that it was possible to adopt a general-purpose language that did both of those well.

I agree with Imm

Check out this boat car btw! (http://yachtpals.com/boat-car-9158)

It’s a boat. And it’s a car. It’s amazing.

People are so stupid that they’re still buying cars that can’t go in water. When will they learn?

I first read that as "bloat" car ;)

Let’s rewrite the Linux kernel in Scala!!

I know we're just having fun here...but if we really could standardize on one language (or mostly one language) the development benefits would be insane.

That is an interesting response.

I wonder if it were equally possible with any language.

Could a Python or Java programmer say the same? I think there are probably a handful of languages that you could use for "everything". The limiting constraint is the presence of a reliable javascript compiler, followed by data science libraries (I think).

I think most languages could get close - see e.g. https://www.teamten.com/lawrence/writings/java-for-everythin... . Of course if you want to actually execute code in the browser then you need to compile to javascript, but I'm not convinced that's required as often as people think it is (Wicket offers a very interesting AJAX model where you re-render UI fragments on the server in response to changes - all the code that runs is Java, but the behaviour ends up very similar to if you had client-side javascript making a server call to fetch data). "Data science" means many things to many people; you wouldn't want to write actual linear algebra in Java (or any language without operator overloading), but again the cases where you can't reuse a prebuilt model from your language of choice are rarer than one might think.

Scala was explicitly designed as a "scalable language" with both the strong safety guarantees that you need for large-scale development and the lightweight syntax that you need for throwaway scripts. But a lot of modern language design is converging on the same set of features (e.g. static typing for safety but type inference for convenience, pattern matching for the safety of the visitor pattern but the convenience of an if/else) and would have the same abilities. E.g. in a Reddit post about Rust a couple of days ago people were talking about writing web services in Rust, and part of the rationale there is that while Rust may not be the perfect web service language, it's good enough that if you already have Rust in your stack you might well write web services in Rust rather than bringing in a new language. I haven't seen anyone doing data science in Rust yet, but I see no fundamental reason why the language couldn't be adapted for it.

Rust is better suited as universal language than Scala for me as I am writing also music applications, which really hate the garbage collector needed in Java/Scala, things that run on the JVM. I never really needed recursive types, but that's also something limiting on the JVM.

> Rust is better suited as universal language than Scala for me as I am writing also music applications, which really hate the garbage collector needed in Java/Scala, things that run on the JVM.

That's the conventional wisdom about GC, but I'm not sure how true it is these days - prototyping a video streaming program in a previous job we were surprised to discover that Haskell performed significantly better than C++ in that role. The JVM GC is quite tuneable and if you're willing to sacrifice throughput for latency you can get it quite low.

(Rust has a lot of good points but I won't be interested until it gets HKT).

> I never really needed recursive types, but that's also something limiting on the JVM.

What do you mean? Recursive types in the sense I'm used to work fine on the JVM; there is even e.g. a recursion-schemes like library for Scala (matryoshka).

> That is an interesting response.

It's a terrible idea. Writing and running scripts from Scala is incompatible with certain actions. Specifically provisioning and kernel configuration. There are lots of tasks that Scala is a bad tool.

Web browsers only run JavaScript, so in fact if you wanted to write front end code, then you would indeed need to know JS.

Even if there’s a Scala transpiler or WASM target - if you think you’re going to ship to production and blissfully never need to know JS...

I "know" javascript in the same way that I "know" SQL, or JVM assembly. It's part of the stack, you do want to be able to read and understand it, but you don't use it for programming (that is, expressing business logic) in.

Which proves the commentor’s first point:

“It's inevitable you will have multiple languages / platforms comprising your stack.”

Different senses of "stack". It's inevitable that there will be multiple technologies involved in the running of your code, which will involve multiple programming languages, and you will need to understand the behaviour of those technologies (though less and less as they mature - I wouldn't be surprised if it were possible to debug a compile-to-js language without understanding JS these days). But that's not the same thing as being able to program in those languages.

Scalia for frontend work? How do you do it?

People who want jobs don’t usually have the luxury of picking them by the languages used.

People usually get hired to use a particular primary language (though even then, I've worked in jobs where I was hired for Java that ended up switching to Scala mainly due to developer preference), but often have broad discretion over which languages to use for secondary tasks. Certainly in a lot of "Java shops" the pattern I've seen is that devs will not be second-guessed (or at least, will contribute to team consensus) in their choice of bash/python/ruby/scala/... for things like testing scripts or data migration tools, nor in their choice of coffeescript/typescript/... for frontend parts.

Data science?!

Oh yeah. Spark has lots of good aspects (though also some bad ones), and personally I find it much easier to think in terms of code with map/filter/aggregate/... than in terms of tables.

Go "T-shaped". In other words, be a "jack of [some] trades, master of [a few]".

Specifically, you almost have to choose modern JavaScript -- because you will need it on virtually any real project (it's everywhere), and you've already got the enterprise-y server-side covered. Don't get pigeonholed into backend-only, non-JS roles. Despite all the haters, es6+ is powerful and expressive.

You'll want to suppress your OO habits though, and embrace FP as much as possible.

Maybe get there by way of ClojureScript if you're up for it. Good luck! Have fun!

> virtually any real project (it's everywhere)

That's a bit of an overestimation to say the least. E.g., I work at a trading firm and we use all kinds of languages for all kinds of purposes on all kinds of weird platforms, but JS is not one of them (I don't think we use Java much either, because why would you, this day and age).

'Any real web project' would be more correct. Not everyone cares about web projects though (same as not everyone cares about non-web projects, as you've pointed out).

Maybe not in a trading firm, but Java is still heavily used across tech/enterprise companies. I used to work for a IB which used Java heavily and so do Spotify, Amazon, Google.

Strongly agree. I would take "any real web project" a bit farther & argue it's only for the time being. While WebAssembly won't kill JavaScript it is slowly creating a world where you can pick a different language if you want for front end web development. Monopolies are bad & it'll be great when this one no longer exists, for JS devs & everyone.

"I don't think we use Java much either": may I know what your trading firm uses?

Depends on the type of task and the target platform — C#, C++ and Python to name a few.

And, of course, VHDL (in certain projects)...

99% chance it's C++, that's what essentially all trading firms use.

Yeah, all of the trading systems I've worked with have been in C++. At a previous employer, they had initially written their entire stack in Java. But, performance was an issue, as was cost (this was back Java still belonged to Sun and they were running Solaris on Sun hardware). Right before I joined, they had rewritten most of the java components in C++ and were in the process of moving off of Sun hardware & Solaris in favor of Intel & Linux. Front end stuff was mostly C++/MFC on Windows, later was C#/WPF. Perl & Python were both heavily used there, as well.

T-shaped is excellent advice but there is something to be said for “paint drip shaped” skills too: imagine a thick line of white paint on a wall and how it drips down unevenly. Some of the drips/skills are very long, some are short, and most of the paint is that wide beam.

In relation to the OP then, being a master of an area is valuable, but so is knowledge of a few others in some depth and a lot of other areas at a much shallower depth.

I'd been hunting for this 'paint drip skills' for a while now. I finally found it again. It's from Kent Beck [0] (plus HN thread [1]) where as I kept on assuming it was from Paul Graham.

[0]: https://www.facebook.com/notes/kent-beck/paint-drip-people/1...

[1]: https://news.ycombinator.com/item?id=12226242

No doubt JavaScript is useful but I've been a professional game developer turned VR developer for 18 years without ever needing it in my career. I have friends who went into embedded development who are even less likely to need it.

I could get by just fine professionally knowing C++ and later C# plus a bit of assembly (more so in the past) along with HLSL/Cg for graphics programming. The other languages I've learned have been for my own interest / education and that's included only a very minimal amount of JavaScript.

I would sort of do a hobby project in the following languages (in addition to Java for Object Oriented Programming, although something obscure like Smalltalk can be fun for an evening):

- Haskell, functional programming with static types

- Clojure (or Common Lisp), functional programming in a dynamic language (and understanding the AST-as-syntax-homoiconicity)

- C/C++, "low-level" programming (e.g. pointers, memory management, registers, the basics of compilers)

- Prolog, Logic Programming as a completely different paradigm

Then after you've "grokked" the pros and cons of these languages, pick one language to become good at. It doesn't matter if that is Java, Java is a fine language; but being exposed to different paradigms broadens your horizon in my experience, and sometimes the idioms and ideas are portable. Personally I've done a lot of back and forth between Java, Python, Clojure and R . If the choice is mine I usually pick Clojure, but not always. Statistics and datascience I still do in R or Python just because the sheer amount of documentation and libraries available. I guess I've been influenced too much by Rich Hickey but he asks "would you rather become good at programming or at problem solving?", and for me it's the latter. Language paradigms help you to recast problems onto a different frame of mind, but at the end of the day it's your ability to help further a cause/business/idea that counts. Just my 2 cents!

Could you give some examples of projects for which each of those language (types) are useful. Because I think it is important to choose a language fitting with the problem (or the other way around if it's exercise)

I'm going to respond even though not OP, because I had this same mindset for a long time.

A while ago I was posting on one of the "how do I learn math as an adult" threads that inevitably pop up here, and I got an absolutely wonderful response full of details and resources, but I asked basically the same followup question: "Thanks so much, this is great, but by the way, how can I use these things?"

The hard part about answering that question is that these are fairly abstract mental tools that affect your very perception of problems. I don't ever bust out Prolog or Haskell while in my day-to-day work, or even directly and consciously apply Prolog or Haskell-style constructs, but I 100% approach problems differently as a result of knowing them. How can I demonstrate that? It's difficult. When I think about real work problems, I don't spend a lot of time doing some kind of meta-thought where I try to identify how I know to think that way. But I do know for example that my Java code ends up looking and feeling more Haskell-y when I'm done. And I know that my coworkers look at my JavaScript code for example and wonder how the hell I came up with a particular solution, and it's for the same reason: I just see it differently, because I've built up a more varied mental toolbox.

That may seem like a wishy-washy answer, but hopefully it has some use. Think of it like learning Latin or how to play an obscure instrument: they're not necessarily tools for application, they're for changing how you see language or music, or in our case, how you see problems.

EDIT: All of this isn't to say that discussions of languages in the context of a specific problem area can't be useful. Sasa Juric has a wonderful section on which problem domain Elixir excels at in "Elixir on Action," for example. I just think in many cases, as with Prolog and Haskell, the primary benefits appear at higher levels of abstraction.

I suggest Elm into Haskell.

Elm will give you the ability to do frontend work while familiarizing yourself with functional programming concepts.

Once you're OK with Elm, go to Haskell, which is a great language to get exposed to plenty of radically new programming concepts.

Once you have done that, and considering you have experience in Java, you will have a much broader view of abstraction thinking.

Just to back this up, I found Elm to be a really good way to learn Haskell. I actually started with Haskell, but Elm allowed me to practice a lot of my functional programming skills and the different way of thinking without getting in my way too much, and in a fun environment with immediate feedback (frontend development). When I went back to Haskell I found it much easier.

I don't see how you can learn Elm without knowing the basics of Haskell.

Trust me, you can. Elm was my gateway drug to Haskell. It's a great starting point, and the guide on the official Elm website offers everything you need to get started. Initially, I found Haskell overwhelming, but after spending a few months with Elm, which is a more narrow surface area, I found it much easier to sprinkle in Haskell specific concepts (typeclasses, applicative functors, monoids, etc).

That statement makes about as much sense as "I don't see how you can learn Haskell without knowing the basics of Elm". Arguably Elm is easier to learn from scratch since it is a younger language and does not have as much complexity baked into it as Haskell.

On a diffrent topic, I wrote a bit on depth vs. breadth (but it was more of a book topic than language): https://news.ycombinator.com/item?id=17128854

For programming languages it boils down to: know the abstract stuff across most/many languages, but drill down on a small amount of languages/frameworks to be more productive.

I'd say: get to know Java and Python in-depth, select a few frameworks to know well (as languages by itself aren't the most useful thing when you are developing complete applications without reinventing the wheel). Java and Python have the advantage of a rich legacy, long term development, good cross-platform availability and broad support.

If you are specialising in the direction of high-efficiency or platform-specificity, I'd suggest Java + Elixir or Java + Swift.

I'd regard Scala and Kotlin as "Java-alternatives" for when you want to do Java without doing Java. Same goes for Groovy (and Grails framework). It's not a bad thing but doesn't automatically yield better results or gets you better understanding.

Keep in mind that languages by themselves are only useful if you have a supporting framework and knowledge of abstract programming concepts (which are language-agnostic).

When you want to "do Java without doing Java", it's good to use alternatives that have some present or like future adoption, such as Scala and Kotlin. You won't get that with Apache Groovy and Grails -- virtually no-one's upgraded to Grails 3 or started new projects in it, and the Grails 2 plugin ecosystem has almost died.

What makes you think it's even possible to master a single language without learning others?

My experience tells me that monoglots reach false maxima because there experience isn't broad enough to realize that there are other maxima to climb.

Java is still, probably, my strongest language, but I strongly believe my craft would have stagnated around Spring/Hibernate if I hadn't taken the time to figure out how problems like typing, dependency injection, persistence, IO etc all work in other ecosystems.

Pick a language that is good for the market place you care most about. Mobile go with C or Swift. Science probably python. JavaScript if you like the web and if you like the perks of working in an Enterprise Java won't hurt.

If you are interested in big data/data engineering, I would recommend you to learn python and scala. These 2 languages have been used in everywhere for data engineer world. For instance, Kafka was written in scala/java. Spark was also developed in scala language.

For python, it will increase your productivity in a lot of things such as etl/some scripts and also be very helpful to access various libraries for dealing with data such as numpy/pandas.

In my opinion, the best way to learn these languages is to tackle some problems. You can just start by scraping some data, inject them into distributed messages/logs system like kafka/rabbitmq ,transform them by using some tools like spark,and process them and store into some places that you want such as hdfs/postgresql/cassandra/s3.

If your primary focus is to get a job,focus on languages, frameworks that are in demand.

If you already know Java, stick with it and learn an MVC framework to create APIs (I'm not a Java guy).

Learn HTML+CSS+JavaScript and then one UI Framework like Bootstrap and one SPA Framework (React or Angular).

Learn at least one RDMS - Postgres or MySQL they are the most popular open sourced RDMS

Learn Python. It seems to be the go to scripting language for data science and....

Learn about cloud infrastructure - preferable AWS since it's the most popular. You're going to have to host what you're doing somewhere. Opinions differ, some would say just to host on something like Linode, much cheaper and simpler.

Do a real project - making a tool someone (possibly you) actually wants to use - in the language. That's the only way to genuinely learn/evaluate.

For Scala (and I guess also Kotlin and to a certain extent Python), you have the advantage of easy JVM interop, so you can use them in an existing Java project. That's how I learned Scala (which I'd recommend): start by writing just a couple of classes (a small helper application with a main() where I wanted to invoke some of my existing Java code), start by writing very Java-like code, and then gradually work your way up. Don't try to force the fancy techniques before you have the problems they solve and can understand what they're good for. It took probably 2 years before I wrote any code that used (generic) monads, another year before I used any monad transformers, another year before I wanted to use final tagless...

In my experience learning other languages makes you better at the ones you already know. You get exposure to different ideas, paradigms, and tools that you can bring back to your main language. For that reason I'd suggest looking at others.

I agree, especially if the other language uses markedly different paradigms. Like, if you already know Java, learning C# is not going to massively expand your horizons, the languages are too similar.

Instead, you should try something like a functional language (like Haskell or a Lisp variant), or a dynamically typed language (like Python), or a language with a different memory management model (like C, C++ or Rust). It will give you practical skills and expand your horizons on how to solve problems with programming.

I'd recommend learning a few, here's my 2 cents:

- Start with Python, it's a very common dynamic language in the wild.

- From Python it's easy to learn Go and you'll want some Go experience if you want to work on distributed systems in today's culture.

- Javascript is another extremely useful one to know that you'll find everywhere, start with the book "Javascript the good parts".

Adding these in addition to your Java base would make you very well rounded, IMO.

In my 5-6 years of professional experience (startups and enterprise, full stack to infrastructure) I've never encountered Kotlin/Elixir/Haskell/Swift.

If you learned Elixir, it would not surprise me if you started to prefer Elixir for most backend projects.

Learning new languages teaches you new ways to approach problems. For example, Java is pretty much locked into OOP, but LISP, JavaScript, Haskell, C, and C++ offer different paradigms and different ways of approaching a given problem. Even when you go back to Java, having these experiences will give you a deeper toolbox when you face a new programming problem.

You should focus on two things:

1. Your "personality"

Properties/qualities that you like most. To discover what you really like you need to try different things. It might change over time as you become more experienced.

  - dynamic vs static
  - weakly vs strongly
  - oop vs functional
2. Impact and market.

You need to specialize in things that let you make the most impact. At some point, knowing specific APIs/Frameworks is more important for productivity. You also want to get nicely paying job and these will only come when you are expert.

  - frontend vs backend 
  - DevOps vs dev vs dba vs full-stack
  - networking vs distributed vs graphics vs web vs embeded
I would avoid Project Euler as problems are too small to evaluate anything other than syntax. Learning stuff like Kube or AWS is not particularly useful. Knowing what tool to use and how to put it together is more important.

Finally depends what you choose you might end up learning one language or multiple.

You should learn C. Most current engineers don't, and therefore the fundamentals of things like memory allocation, data types, call stacks, etc. remain a mystery to them.

I have one other comment to make. In my opinion, being a strong programmer is mostly a "knack," meaning it's not a particularly teachable skill. Some people are just amazingly good at it. If you are, great. If not, I suggest acknowledging that and fashioning a career that doesn't rely primarily on programming skills.

I'll throw out my $0.02, which is C is a terrible language to learn. Much of writing "good" C revolves around knowing all the pitfalls to check for, then dealing with the archaic error handling mechanisms. Tomes have been written on the subject of proper error handing in C.

> fundamentals of things like memory allocation, data types, call stacks, etc. remain a mystery to them.

I don't think C is especially good at teaching these.

Unless you roll your own malloc, the big difference in memory allocation in C vs. say, Java is that C requires the programmer free memory after allocation on the heap. This is more tedious than difficult.

Data types exist in other languages. You can unpack raw bytes of data using Java and simulate the behavior or unions.

You'll have to explain how call stacks are more exposed in C. Best I can think is calling conventions, but that's more the domain of compilers than language. Buffer overflow prevention, maybe (but again, I think that's more tedium to deal with).

C is great because it's a small language. But I don't think it's an especially educational language.

Yeah I just disagree. I actually think Java is a terrible teaching language. Folks for whom Java is the closest they come to the hardware tend not to understand the internals of how computers actually work well enough to do things like understand where bits fit into bytes or what happens if you recast an int into a double without converting the underlying data.

Many times that doesn't matter, but to me it's important to have a supple and complete understanding of the underlying ideas. Java fails at that.

When I referred to memory I meant more than malloc and free. It's things like understanding how an array of ints is laid out in memory and what happens when you treat it as an array of chars instead. If you talk about this to a Java programmer, their eyes are likely to cross.

Your argument seems more in the vein of "C programmers are smarter java programmers" while ignoring the actual discussion, which is C is not a good teaching language. Yeah, you'll learn some stuff by virtue of blindly running over the language's landmines. I don't consider trial by fire to be a great way to learn.

> It's things like understanding how an array of ints is laid out in memory and what happens when you treat it as an array of chars instead.

This is one of said landmines, as the size of both is architecture/compiler specific. The only thing you learn by stepping on this one is, "use fixed-width integers when you care about exactly how many bytes the value is."

(+1) this. Building your own lisp (http://www.buildyourownlisp.com/) might be a good start.

Noob question: Is there room for below average programmers? If so, where?

I wouldn't think of it in those terms. Most programmers aren't "amazingly good" at it. So, I'd say most work as ... programmers.

I just wanted to make this point because I've repeatedly seen folks frustrated by others who just get things faster and ultimately make progress much more quickly in their careers.

I think it's useful/important to acknowledge that programming is a bit like sports. It's not fair, but some people start with an incredible genetic (or something) advantage built in. I've seen this time and again.

Just to add to this, what you might see as being "amazingly good" might simply be the ability to cobble together pieces of (bad) code from various libraries, without really understanding how things work under the hood.

Incidentally, the best programmer I've ever met (he co-authored a very popular programming language) happens to be one of the slowist typists I've seen. I once asked him why, and he said "because I have to think."

Take your time and have fun.

It really depends on what you personally believe means "amazingly good programmer".

For some it means writing hard mathematical algorithms. For some it means writing the efficient and secure low level code. For some it means solving real problems fast by efficiently glueing existing code. For some it means great communication/management with 30 other programmers on team.

I think it is more about finding who you really are and following that than trying to become some dogmatic idea of what "amazingly good programmer" is.

Find your niche. The bubble effect is strong in all of us.

> Is there room for below average programmers?


If we assume that about a third of all programmers are "average" (whatever that means), another third is "above average", and one third is "below average". So, it's not actually a tiny minority, despite what Hackernews might make you think.

Programming consists of many different aspects: creating an architecture, designing algorithms, implementing them, hunting bugs, testing etc.

If you think you are "below average" in one of these areas, you can team up with other developers who are good in that area, and let them guide you.

For example, I work with somebody who is amazing at digging deep and really understand the low-level nitty gritty of bugs. But, they are not that great at building high-level abstractions. So when a task involves building high-level abstractions, we discuss these abstractions beforehand, write some mock examples that use the new abstractions etc.

Some developers aren't good at low-level stuff, but build great user interfaces. Some don't do that very well, but shine when it comes to automation.

To sum it up, "below average" programmers can be very useful to an organization with the right amount of specialization and collaboration/mentoring.

I've been slowly learning to program as a side project (I'm an architect, buildings not IT) and considering to adapt my career to a suitable niche in IT. Front-end/UI-UX seems to be the answer.

I used to hate (the lack of elegance of) JS but I got used. After a lot of dabbling, I'm still between React and Vue. While I prefer Vue, all jobs ask for React. Framework marketability seems to be crucial when/while you perceive yourself as below average.

A person can be an average programmer, and still a superstar if they are an expert in a problem domain. As an examples, shipping / order fulfillment has many weird nuances - things like tariffs, dealing with dangerous goods, differing address systems, etc. Expertise in practically applying the code is extremely valuable.

I have written books using a variety of languages that I also have used in work projects. I enjoy variety.

However, as a practical matter, learning just Java and Python really well will cover most areas of software development.

My personal preferences: I prefer Ruby over Python as a scripting language, but I am forced to use Python in my machine learning job.

I have used Common Lisp since about 1984, love it, and I am fortunate to get to occasionally still use it.

I like Haskell, but I am a ‘forever student’ and use a subset of the language that I understand.

EDIT: some knowledge of JavaScript is also recommended

> However, as a practical matter, learning just Java and Python really well will cover most areas of software development.

I disagree, given that both are interpreted languages, that excludes (practically) most embedded, low-level, high-performance software. Sure, you can use stuff like micropython, but it is not as practical as C is in that domain.

Don't overlook at any books or tutorials from now. Go to the php docs alone. See stackoverflow for special queries only if stuck. Like any langs, start with low objectives. First try to do some maths, display the results. Then work with texts, try to alter contents by program. String, array, object, learn to create, and alter them. Later see by youself what kind of database type suits well your objectives. play with it (Flat files? json?). Wow you can pass external arguments by the url. (Big moment here ;) )

From there start to play with the internet, load remote datas, parse them, put them to your database. Then melt this all. Learn bash php scripting and unix, start to make system calls (exec, system, passthru...) enjoy the speed. Learn conditions (With just if you can do everything...seriously), Learn looping(while, foreach) , exit conditions and timing. Try to recreate basics tools: grep, cut, head, tail, cat.. you will see it is fairly doable and very funny to do.

Get bored? Do some javascript!

You will see personal ideas flowering at high rate. Still keep your objectives as low as you can. Small projects all aside.

Now you have all this in mind, open a book, check other sources code.

Learn security a bit. (Or not it all depends to your objective). Check good practices.

Close the books. Cut the Internet.

Get over this fancy libraries that anyone advise.

Open your editor. You are the internet. Have fun. ;)

I used to be a Java dev (6 years ago)...

Over the last year I've been learning JavaScript + React (frontend) and TypeScript + Node.js (backend) for a side project. At times it's great because you can cobble together all these small modules to build something really quickly and other times.... everything gets updating so often and apis change.....oh I'm going to create a new project.... xyz module needs dependency abc...blablabla.

Also JS on the server is synchronous which is not natural for me to write it. I end up using async/await everywhere except for a few places.

So I've been thinking about to concentrating on a more stable eco-system so I can really master it. With that in mind, I've started learning Golang. Great if you're interested in web servers and distributed systems. It makes concurrency easy and it runs fast. Check out this post: https://grisha.org/blog/2017/04/27/simplistic-go-web-app/

For data you could use Python (#1) but I understand Golang is also a respectable in this arena but probably not the best.

Don't learn a new language for the sake of learning a new language. Learn it because it solves a particular problem better than your existing skill set.

For example Node.js is good for tiny Web Services/API endpoints using an event-based model. Elixir for writing highly concurrent systems.

Sure, both of these can be done with Java -- since it's a general purpose language, but the result with more focused languages is a more succinct solution.

I've made this transition over the last few months.

For the past eight years, aside from dabbling on my own, I've been a .NET developer. I've worked in startups, agencies, and good-sized companies, and have delivered more projects than I can count. I've also given talks at user groups, and have delivered open-source tools. I wasn't an expert, but I'd say that I knew C# and .NET reasonably well.

However, I always felt a bit of imposter syndrome. While the .NET world is more open than ever, you still feel like you're an apple in an orange-infested world. Literally everyone else builds on Mac/Linux, and while the tools differ between languages a PHP developer would have more in common with a Python developer than they would with a .NET developer.

So, I left a senior role and took a standard dev role in a software house with zero .NET tooling, and have forced myself to learn different languages in anger, instead of restricting myself to only learning in my free time.

It's been hard, but I feel like I'm learning loads every day. I've also learned things I would've probably ignored if I was doing this in my free time, like Ruby and Rails. I still feel like an idiot most days, but I'm hoping that in the next few years I'll go from being a solid C¢ developer to a solid developer, and that alone will go a long way towards getting over that imposter hump.

So, my advice is to try and learn what you can on your own, but if you feel that you are better served by working with this tools "in anger" or around a team that really knows its tools then look for a job that both allows you to do this. Once you reach a point where you're comfortable in a language, move to something new, but keep that language to your free time.

Learn more languages.

Learning other languages increases the breadth and depth of your software development skills. You will start to understand the various commonalities between different toolsets, and learn new ways to improve code in other languages.

If you are having trouble with discipline, pick a project that restricts your language choice. Build a front-end web app using Javascript, or build an iOS app using Swift.

I think the approach to learning that new language is not correct.

Master Java. What I mean is, learn how OO can be used to solve a problem. Learn why immutable classes were advertised as a best practice. Don't learn Java-isms. Learn why this language has certain features, and learn how to use those features. You'll be a master when you can take that knowledge and learn another modern OO language in a week, easy. For example, Python and Ruby should be easy to learn after that.

Learn a functional language afterwards - clojure, F#, Ocaml, Haskell. You'll feel naked w/o the OO backing. Master one of them.

After that, all the programming languages become roughly the same, all with their own -isms.

Distributed systems and data Engineering are not programming language specific - they are concepts that can be implemented in any language.

During downtime between 2 jobs, I used to look at different languages for like half a day each, just to see what they did differently compared to the ones I already knew. I was mostly interested in concepts, not syntax.

This has helped me to be quicker when picking up new languages or even frameworks. Because, well, nothing is ever really new, right?

(Note that I would not recommend this strategy to a complete beginner. You need something to compare what you are discovering to.)

As for recommendations, I would suggest you look at what kind of problem you're trying to solve. If you could benefit from the infrastructure something like Java EE provides you, choose Java or kotlin (those are mostly interchangeable). For scripting, choose bash or python. For client-side web stuff, JavaScript. And so on.

"Each time I pick one I end up giving up after 2 weeks as I always go back to Java": you don't want to leave your comfort zone, I guest. I suggest Scala. Start with Scala for the Impatient a little bit and then Functional Programming in Scala.

Everyone has an opinion about which language is better or worse. It didn't actually matter, they all suck in some way or another.


You'll find something you like over the others. But it's all just syntax at the end of the day.

The real mastery is programming paradigms. Some languages lend themselves to particular methods and some just can't, or can't do some easily, but just knowing that is important too.

I believe there was a HN about this a while ago but I can't find it.

All languages have flaws but that doesn't mean all languages are equally good or bad. Some languages are better than others but due to the complexity of the subject and the relatively few people who know many languages really well (along with perhaps some personal preference) there's endless room for debate on the exact ranking.

When I stopped caring about this and focused on problems themselves, I inevitably had to learn many things to get a problem solved. There was never a path that included one framework and one language. It was a spaghetti hodge-podge of solutions to patch work it together. I have kept JavaScript at the center of the glue whenever possible as its easier these days and having docker to abstract gory setup details and needing bash/git literacy, but other than that, you'll find yourself doing what needs to be done and consequently learning new things along the way as a side effect, not as a goal.

IMO, you can't master one language / instrument/ conceptual framework without a familiarity of several.

To be honest, I just try to build a couple of toy projects in whatever seems useful, and then I will try and build something professionally if I can a) get a client project and b) think its a useful/good fit.

As to the process, you're always better off with 30min a day rather than 2 hours on a Saturday. That's true for most things I've learned.

Specifically, I'd probably try and pick up Javascript, Ruby, or Python, as those seem to be the most portable to me. They also seem to be more widely adopted.

There's much more to programming/software engineering/software craftsmanship than just the language. Firstly, the majority of the languages used in the industry really only have superficial differences, they are all implementing the same OOP semantics, with minor differences and are mostly isomorphic to each other up to some syntactic sugar.

To really gain some knowledge out of learning a new language you should ideally cross boundaries to a new paradigm. The most commonly cited example now is Haskell, which is a fairly state-of-the-art language in terms of PLT research, and is a great illustration of the functional paradigm, due to its purity. The consensus among haskellers is that the code is much more concise + higher-level (case in point Xmonad being roughly 1/10th of the equivalent C software packages), much more type-safe and also easier to refactor etc. IMO, after I became productive in Haskell, programming in other languages seemed a bit like writing assembly (there's nothing wrong with assembly, in fact, optimising code down to cpu cycles was a favorite pastime of mine some time ago). Also, the boilerplate is much less significant compared to most other languages. (Case in point, again do the recent research in generics, GHC can automatically derive instances for various type classes. For instance, the most popular JSON package, aeson has the ability to automatically generate ToJson/FromJson classer for your types with no user code).

One downside of Haskell is that it may have a steeper learning curve, to really master it. Most of the reading will be from research papers and functional programming journals, but all this learning really does translate into a skill that pays off.

So my personal advice: if you really want to learn a new language, you should go with a different paradigm, e.g. Haskell if you're new to functional programming. But I would suggest instead just building stuff, and if you notice that your implementations are pushing your current language to its limits, see how other languages fare.

But IMHO, if you want to grow as a software engineer, you should just build stuff, build an operating system, build a compiler, build a database, build a web server, a game engine etc. You will cover far more theory and the learn more skills than just learning a new syntactic sugar.

>"The most commonly cited example now is Haskell, which is a fairly state-of-the-art language in terms of PLT research, and is a great illustration of the functional paradigm, due to its purity."

What is PLT? I didn't recognize this acronym and it was too general to Google. Thanks.

programming language theory

I think some people get lucky and can get away with living off being very deep in one language only, for long periods of time (like 10+ yrs). Eg. they are hardcore C++, and write compilers, or games, or find a good oppty at one of the big companies where they optimize code that runs on 100K+ servers, so it's a stable and well-paying job with lots of impact.

But I think for most people, including me, having a good grasp of a "ground layer" of languages is the way to go. It just makes you more swiss-army-knife, it reduces risk, opens up opptys.

For me, the base languages are:

- C/C++: so you understand what happens under the hood, how memory is actually managed, how it can "leak"

- Javascript(+HTML): so you can write your webapps

- Python: useful on the server side, for data science, etc; the most useful overall probably

- SQL: to get data out of your RDBMS; many people don't understand how powerful SQL is and end up writing imperative code that could be replaced with 5 lines of SQL, so this is a surprising blindspot for many otherwise good programmers. Beware of anybody telling you SQL is not a PL or it's not useful. A lot of your life runs on SQL, you just don't know about it.

- Bash scripting: nobody actually remembers Bash, we just monkey our way to something that works :)

... and of course take some (sometimes entertaining) detours into Haskell, Prolog, etc. For me, the big blind spot is mobile development, so maybe +1 for that.

Recently getting into kotlin and to a lesser extent Rust; also from a Java background. First of all, there's more to learning a language than understanding the syntax. That you can accomplish in a few hours, depending on your understanding of the underlying concepts. But from there to grasping new idioms specific to a language and generally being productive takes a lot longer.

You have to engage with it for longer time and be forced to solve all the day to day problems you are going to have. So, learn by doing that. Just pick any modestly scoped project you are interested in doing and start doing it. Start with something not critical but still interesting enough that it is worth doing. I tend to avoid completely academic stuff. Then build on that.

In my case, I've been converting Java code to Kotlin for a few weeks now and am getting to the point where I'm comfortable with the language. Kotlin is of course the easy thing to pick up if you are doing Java since it is designed to be easy to make the switch. So definitely would recommend doing that provided your team is OK with that. It starts paying off pretty early in terms of reduced complexity and verbosity and extra type safety.

Rust is a bit harder but the only way to learn is by doing. I've been taking baby-steps there but it looks worth my time. There I've been reimplementing some OSS stuff I did years ago with an eye to reviving those projects. Progress is more slow because it is too academic. But rust has a lot of new idioms for me to wrap my head around before I can use it professionally so slow is not necessarily bad.

@OP Just to give a bit of motivation for learning Kotlin - it's now the official language on Android. Not sure if Android is of interest to you, but either way at least you know it's in wide use and clearly a powerful language.

THE official language? Or an official language?

Isn't Java still the primary official language on Android?

You need to get out and help people. Learning a programming language without having anybody to help is like learning algebra without having any context of where/how to use it. It's perhaps a nice intellectual exercise, but you're missing out on the most important part.

Programming is mostly symbolic and mathematical. I love math and symbols. Fun stuff.

Making stuff for people is mostly, well, people.

Guess which one of these is more difficult?

You really learn a language when you're knee-deep in framework code, fuzzy requirements, conflict among stakeholders and the team -- and you've got to make something happen this week. Not when you're doing puzzles online.

Since you asked, in general if you feel like you've mastered an OOP language, I'd recommend going functional. F# worked for me because when I use F# correctly, the language/toolset helps teach me how to be more functional. Pure FP is always the goal, but you can do it in OCAML/F# and I don't think jumping right into something like Elixir or Haskell would have been as people-friendly. (Back to humans again)

In short, languages are great. Show me you learn a few. But that's 1%. 99% is people and problems. Show me you have lots of experience dealing with that while grokking out on the math and symbolic stuff and I couldn't care less which languages you know.

Little background, i am a mainframe Db2 DBA. @Work other than Db2, i use JCL and Rexx programming language(limited number of scalar functions to use but easy to work with). I decided to learn offhost platforms and languages endpoint is to host something on web or process something in cloud, since cloud is all up in the news, this was 3 years back. Started with C#(processing & analysis) & ASP.NET, i like the Visual studio but its a big dog, slows my system. Next proceeded with Java as i have studied java in college, best thing about java is if you have something in mind there might be a 3rd party library for it which will help you a lot in your learning path or development. I was interested in web development using databases, then you will have to go with JSP, i am not interested in JSP. So proceeded to learn python completed a course in udemy and for database programming you will have to learn frameworks thats another set of installs and courses. While attempting i was getting lots of issues and burning time, so i had put a pause on it and started looking for an alternative language for web development with conditions such as (platform independent, less number of installs don't want to slow my system) ended with NodeJS, javascript and bit of jQuery and i like it finished a course run by Andrew Mead and developing a personal TODO app in Google Cloud using firebase as database and hosting in firebase itself.

I have python in training plan as well, since it also has lots of 3rd party library and wide support from online community.

I like to keep my learning to a limited set of languages and not spend more time on learning.

As others have said, going "T-shaped" where you master a small number of languages and learn the basics on a much larger number is probably the way to go.

For language recommendations, it depends a little on what you're ready for, what cognitive load you can take on. If you need to pace yourself, focus on one or two paradigm differences at a time.

Want to "dip your toes" without giving yourself a ton of cognitive load? Try doing some work in C# - being familiar with Java, you should be pretty comfortable with its idioms, and can ease yourself into functional thinking if you're not comfortable yet. JavaScript and Python are good choices if you need practice with dynamically typed, interpreted languages. JavaScript is pretty much necessary at this point. If you're dealing with Big Data(TM) you may want to look into a functional language. Haskell is probably a good choice there, but F# may be worth experimenting with as well.

As for evaluating the languages, Project Euler is good, but I've personally found Advent Of Code more helpful for learning. Advent gives you sample input/output that is perfect for setting up unit tests, and the problems are less math intensive so you can really focus on the new language and what idiomatic code and architecture looks like.

Good luck!

In my information science bachelor I got introduced to Java and a little bit of PHP (by sheer chance). I had issues with programming.

In my computer science master I got introduced to (in chronological order): Objective-C (+ Cocoa Touch), Python, JavaScript (+ HTML5 & CSS), Bash, a toy processor ISA, x86 assembly, C (handy when you know x86 :D), ES6 (+ ReactJS).

I might have missed one or two. The thing is, I don't understand why people ask questions regarding learning a new language. Why not read up on why people find it awesome (I do it via HN), and then choose your project, or checkout what your favorite company that you want to work at is using and get to work?

I feel I don't have issues with programming anymore. All I know is that I don't know a lot, but I know enough to make things, I need some time to get up and running. I also know that the majority of people don't know a lot but can self-learn themselves as well to make things. I feel the slides of CS50 really show to what extent programmming knowledge is transferable. Though CS50 doesn't show the quirks of any language too well (except C, perhaps).

I always ask myself: am I missing something? Am I arrogant or accurate (or both)?

I'd say you're missing quite a lot and are a bit arrogant. You don't mention any functional languages in your list for a start so you're missing a whole programming paradigm that will change the way you think once you understand it.

Good programmers are aware that they never know enough but also that they have to get on with solving things and building stuff anyway. They spend their careers trying to get better and learn more, focusing particularly on what is most relevant to the problems that currently interest them.

Throwing in a vote for Clojure since you already know Java. It's a great bridge language into the world of FP, and it lets you leverage the JVM ecosystem, so you can take advantage of Java libraries/packages when needed. From there, you can bridge into Clojurescript for front-end, and reagent/reframe are great ways to learn how to build single page react-style apps (all the rage these days...).

I think there's a crucial component missing from a lot of the good advice here: pick a couple of languages to learn deeply enough to get into the language specification. To really appreciate the interplay between code and execution, you need to dig into some of the differences between how languages are actually implemented and distributed. This will teach you surprising things about the language's execution semantics and what it means to avoid undefined behavior.

Even interpreted languages like Python and Java have tremendous depth in their runtimes and design, such as JITs, memory management, and more.

Set a goal to learn as much about at least a couple of languages as you can, and you'll be able debug and understand programs much better. It will also ease your learning of new languages, because many of their features will fit into things you know already.

It's obvious, you MUST learn multiple languages. The real question is " When should one learn a new language ?" As you have mentioned that you have a DECENT knowledge/experience with Java, your next language on the checklist depends on what you want to do next ?

In picking a language, look for

1. Ecosystem. You _will_ need help

2. Friendly (to you) syntax

3. Target to achieve (in your case, it would mean a language that is frequently used in distributed system/data engineering)

Regarding "I find myself going through the crazy articles comparing languages and lose focus and give up.", I hear you. I've been there. Pick two and run with them. Once you start learning a language, stop reading articles on what other languages you can be learning. There is always something better down the corner. That doesn't mean you lose focus and drop whatever you're doing midway. Persevere, and you will prevail.

Finally, my recommendation, based on your requirements would be

1. Python (for data engineering - numpy, scipy, tensorflow, pandas and whatnot)

2. elixir (for distributed systems)

Hope that helps. Good luck!

A side note -

in addition to using Project Euler (which is maths-centric) to help learn language, you might enjoy Project Rosalind (http://rosalind.info/about/) which is bioinformatics focused.

I don't know what you want to master with Java, it's pretty trivial language. So if you don't know something about Java, you definitely should learn it. The JVM and surrounding libraries are a thing, though. But Kotlin, Scala, Clojure for example all running on JVM. So you can learn new languages while learning JVM and improving your overall Java platform knowledge as well.

If you want to learn something, Scala is awesome. It's a very complex language, so learning it will make you a better programmer, even if you won't use it.

For practical purposes I like Kotlin. But Scala is good here too. Kotlin just clicked for me, I like almost everything about it.

Clojure is a good introduction into Lisp family. I think it's worth to learn it too.

Here's what I learned in order: html, css, some JavaScript and php, more JavaScript and php, ruby/c/others, more JavaScript, more php(for work), more JavaScript

JavaScript is pretty crucial to learn no matter what your backend language is. Since your backend language can be JavaScript also, using node, you might want to focus on that. Php is where a lot of the freelance work is, and it's also one of the easier backend languages to get started in. I'd say once you're pretty proficient in fronted JavaScript and some backend php, then ask the question again maybe try some other language's backend.

My three cents:

1. Learn bash. It's the glue of the *nix world. It's not complicated but it's foreign enough that it's worth spending a few weeks really understanding.

2. Learn Javascript. It's the C of the modern era. Practically every piece of software in the world has to interact with Javascript, and the value of it is only increasing.

3. Learn C. It's the Javascript of the old world, and the foundation on which most of modern computing is built. If you need to get two things to talk to each other, the answer is usually C. Fortunately unlike its younger brother C++, it's a fairly straightforward language to learn.

I really can't recommend picking two languages at once. Learning one new language often involves having to adapt to a significant number of new idioms that can really stress the mind - I've never been successful at diving deep into two languages at the same time. Far better to pick one language and really focus on it for 6-12 months. Then, at the end of that time, think about whether you want to work on it for another 6-12 months or whether you want to learn something else. Sometimes the language just won't take early on, and it's fine to pick something else then too.

Since you already have a job role in mind, I suggest that you take a look at at job applications in that area, for example on https://www.indeed.com/. Look through the job requirements in various listings and see which languages they require. They probably mention a lot of non-language requirements as well that you should be familiar with. Don't just focus on learning a bunch of languages. If you do, you will be overly strong in languages and weak in other areas.

Honestly you need to plan things similar to anything in life. Have a 1000 foot view of what you want to achieve, which in this case is distributed systems, now break that down e.g. distributed fs, etc. And again paxos, raft and match it up with whatever language that has market share and meshes well with what you want in a language. If you get stuck breaking things down do very brief and simple research into it and do not fall down the interesting rabbit hole.

I've been heavily into Java/Spring since I started programming and along the way have done a year long stint in C#/.NET

I've been interested in Ruby on Rails from afar for ages but just this week I finally saw the light and got excited by how awesome it looks and have committed to becoming proficient in it. For me it's the excitement, the magic.

Perspective on existing knowledge will deepen with new knowledge gained, so theres always great benefits.

Languages are moving so fast recently that mastery is something of a moving target in a lot of cases. Often using different languages can give you a better insight into how features in other languages can be used - e.g. learning OOP/classes while managing all the complexities of C++ can leave you slightly confused about the whole thing, but if you go learn some Java where it's forced on you, it makes a lot more sense in C++.

I'd suggest to learn different _types_ of programming languages. That is, one object-oriented (like Java as you already have), one logical such as Prolog, one functional such as Haskell, you get the idea. In my mind learning several languages that all more or less belong into the same domain probably won't gain you any more insight into this field since all you're actually learning are subtle differences in syntax.

Learn whatever language will get you a job.

But for fundamentals, learn how a CPU actually works. Learn something like 6502 Assembly and make a game, or learn how a CPU emulator works for a game like Pac Man (take apart the source for MAME and then build it back up for just Pac Man).

At the end of the day, all of these fancy languages have to end up as 1's and 0's and run on an actual CPU. Too much abstraction can be a bad thing.

There's a book: 7 Languages in 7 Weeks that tries to pick a language from different "domains" (functional, imperative, prototype...)

Might be what you're looking for, a quick way to asses the landscape.

As for mastery: yes, you need to be able to master at least one language, and plan to always master the language you are going to use the most.

I would suggest PHP, then Java, then Erlang. These are useful skills that will carry you forward for the next 20 years.

If you want to get a job, either stick to something that is very popular (bigger pool, higher competition) or unpopular (smaller pool & competition).

If you want to create your own projects, you have so many choices here, but the safest bet is to use a popular solution - as a beginner it will be easier for you to get help.

In a multi core future only Java (C#) and C (C++) make sense because they share memory between threads. You can learn to dabble in JavaScript for single threaded web gimmicks. C++ only gives you streams, everything beyond that is over engineered.

So I would say: learn C!

All other languages should be avoided. Let the down voting begin.

it is worth learning a new language to get a broader perspective on how to write software. you can easily write network services (that can scale later) in java, but not in javascript. you can easily create interactive demos using javascript (with html and css), but not with java.

as for how to stay focused, participate in a hackathon and build something using a new language. i find this helpful as it forces me to learn different features of a language. i don't like to learn a language by following tutorials which treat me like a baby learning to take its first step.

i have little idea about haskell, elixir, kotlin and scala, but here is some advice on the others: javascript: for web dev, interactive demos or quickly writing backend services python: writing scripts, backend for web dev, analyzing data swift: ios apps

In my opinion learning new languages and even technologies opens our minds to think better. It would widen our vision. But, in the other hand, sticking just to one specific technology can limit your way of thinking to an specific paradigm or technique or what ever.

lots of advice on languages...

I'll just say, pick something functional and something dynamic.

Then, for something that will get you to do a little bit more than euler, try using https://adventofcode.com/

Javascript will open some doors for finding more dev jobs (probably not for data engineering)

Java was my first language, and i really only knew about object oriented programming. Learning to write functional code has really broadened my skillset

I came across this article that talks about this topic. It basically says focus on 1. http://norvig.com/21-days.html

Great article, however it doesn't say that really (perhaps you missed this bit)

"Learn at least a half dozen programming languages. Include one language that emphasizes class abstractions (like Java or C++), one that emphasizes functional abstraction (like Lisp or ML or Haskell), one that supports syntactic abstraction (like Lisp), one that supports declarative specifications (like Prolog or C++ templates), and one that emphasizes parallelism (like Clojure or Go)."

You can't master one language without learning others. If you learn several, mastering them will become easier, in proportion to the number you have already mastered.

I would like to THANK YOU ALL for your comments, honestly I did not expect that much comments. I will take time to review them and try to get the best from them.

last time I learned a new lang I did it by disciplining myself into following an Udemy course to the end

then tried to apply what learned in production (at work) as soon as possible so I don't forget

Learn 3 languages that do not look the same. Master any one

The problem with flitting between many languages is that these are very perishable skills. To be productive is not merely a matter of being proficient with the keywords and syntax, you need to have in your working memory vast swathes of the standard libraries so you know when to just use a standard function versus reinventing the wheel or spending all your time consulting the docs. This fades quickly if you aren’t doing it every day. I don’t think it’s really possible for most engineers to have more than 2-3 languages that they are really good at, whereas you can dabble in a dozen or more if you are just making small changes to existing code.

The real question is not which language is the best but what is the language and libraries most used in the industry/field you want to work in? Figure that out then go deep.

Don’t learn languages, learn frameworks instead. Pick a problem and find the most popular frameworks that are used to solve it. Learning language just for the sake of it is useless.

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact