I am currently an iOS developer looking broaden my horizons. I'm currently learning Javascript as it seems to be the next big thing. What would you suggest ?
The .NET framework[0] is always useful and I think it's here to stay for a long while. You'd be able to write mobile apps using Xamarin or business apps for Windows. Also apps for the new Ubuntu mobile OS will be possible.
Personally I find Go[1] interesting and it's something I'm hoping to pick up in the coming year. It seems like a fun language, well suited for building web services that handle lots of traffic.
Lua[2] might also be nice to learn. It's used for scripting in a lot of games. For example: in World of Warcraft you can create your own Lua add-ons. Lua can be easily integrated into your own apps / games, since it's just a small C library. It might be a good language to learn if gaming interests you, since lots of games make use of Lua in some way.
And as someone else already mentioned in this thread: functional programming will become bigger in the future. You can use the functional programming style with .NET if you choose to learn the F# language.
actually... if you are in the UK and into games its a great place for that - plenty of studios around.
Although mostly in the south east there are well known studios in Scotland, Ireland and the north and midlands. Rockstar, Havok, Ubisoft, Natural Motion, Rebellion and Codemasters come to mind as a few of the bigger names who have studios further from London.
however the tech requirement for AAA is almost exclusively C/C++ (with good hardware and API knowledge strongly preferred for some specialities like audio, rendering, physics, AI, networking...)
Things like C#, Java, Ruby, Python will be limited to internal tools - although there are a lot of smaller companies making HTML5, JavaScript or Unity games or even still flash games which are aimed at the broswer.
5-10 years is a very long period. To me: JavaScript looks exciting, current trends clearly show the rise of JS.
However, just a decade ago, a large majority of Internet used JS primarily for form validation, which was sad. A lot of web developers were not comfortable leaving their code open for the visitors to see.
I personally believe JS will continue to soar but I also believe that nobody can answer this question perfectly as nobody knows the future.
In any case, if you spend a lot of time learning any language very well, the time required to learning another language after that, decreases substantially.
Learn basics - concepts of programming. 90% of developers use imperative (procedural) and structured (OOP) paradigms. But the world of the programming is not so close. There is a lot of other interesting and applicable paradigms, including declarative (functional and logic programming), metaprogramming, semantic, and many more.
Learning only programming language (PL) people are limited to scope of that language. Learning paradigms (better in terms of one of PL) you gain knowledges which are "portable" between PLs of the paradigm. You will have a boost when switching PL of the same paradigm: learn PL faster, looking into PL's features and not its basics.
I recommend to check out before you choose what to learn: Lisp dialects like Closure, CL, etc; Ruby; Go / Rust; Java.
Technologies go through cycles - PHP was hot in 2006, Ruby peaked in 2010, Javascript (and Node.js) is currently hot, and it's quite possible that Go will be hot in 2-3 years.
It's foolish to learn a language under the assumption that it will be relevant for 10 years. If you asked this question in the early 2000s, PHP would be the answer, not Javascript.
The best strategy is to continuously brush up on skills. Experiment and dabble with new languages and frameworks as often as your time allows!
I think you're a little off. First, if Ruby has peaked (not convinced) it was later than 2010[1]. Same with PHP and '06.
Second, once a language/framework/toolset reaches a certain level of usage, then there will be demand for that skill in the foreseeable future. Even if the language falls out of favor for new projects, maintenance/patches/upgrades will always be needed.
I know freelance PHP developers who have to turn away work. I know freelance Rails developers who have no problem billing out at $200/hour.
I agree with your premise, but I don't think what the OP is asking is really that unreasonable. If you learned C++ or Java a decade ago, chances are you still have no problems finding work. The problem is, you can't know with certainty what tech will be widely used in 10 years; you can only guess, and hope you made the correct decision.
If I were to make a bet now, I'd bet on Node still being widely used in 10 years, and to a lesser extent Rails and Django as well.
Maybe that's good career advice, but it feels wrong somehow. My own experience is that while design is hard, it's always simpler than dealing with the nitty gritty. The hallmark of good design is that it leads to simplicity in the lower layer (implementation, etc).
Design is different to the nitty gritty but I'd say not necessarily easier or harder. Just as no battle plan survives engagement, no design survives the realities of implementation.
This is what makes waterfall hard and agile.attractive. it is also what makes someone who can shift mental focus from one to the other more useful.
Personally I think of it in terms of field of view. Zooming out to bigger and bigger picture or down to finer and finer detail.
I guess what I'm saying boils down to "increase your range" - if you're a coder you'll be more useful/valuable the more you can look out. (Whether that be in terms of business sense or devops practicalities).
My meta-comment would be to avoid trying to find the-next-big-thing.
If it was easy to guess the next big thing everybody would do it ;-) A 5-10 year horizon is a very long time in computing years. Look back ten years. How many people were accurately guessing the current environment? How many of the big-things now even existed ten years ago?
When I look back at my career I can't point to a single instance of seeing the next-big-thing.
I can point to lots of great things that have happened because I'm continually poking at new ideas, new processes and new bits of tech. So I'm ready to take advantage when one of those does become the next-big-thing.
So yeah. Take a look at JavaScript and the node.js world. Or robotics. Or architecture as code - or whatever. But for god's sake don't bet your career on it in five years time. Explore lots of things. Find stuff you're good at and enjoy. Be ready for when one of those starts turning into the next big thing.
Learn how to learn new things. Learn how not to get stagnated. Learn how not to be afraid to leave the comfortable. Practice these things and you'll be good for the next 50-100 years.
This is what I was going to say. Basically, learn to be intellectually agile, ready to accept new ideas, and be good at getting up to speed quickly with new things.
Want to learn a language? Take a weekend with it, write something that's useful (even if not suitable for production or long term use). Do that often enough and you'll be mentally agile enough to pick up anything when you need to.
For what purpose? Employability, intellectual well-roundedness, zeitgeistiness? Each of these could pull you in a different direction.
My current hunch is that statistics/data science/machine learning will satisfy at least two of the above three, if not all.
I've been learning the basics of data analysis with R, much helped by the awesome RStudio. Initially this was for fun (and a tryout of MOOCs, specifically Coursera's data analysis class) but after only a few weeks I found occasion to use it at work (finding patterns in an application's response times in response to user load throughout the day).
Now I'm getting into stuff that's even more fun, specifically the reactive Web framework Shiny.
This is usually a sure sign of a good match between learner and subject matter: an iterative process where learning and applying, tightly interleaved, form a feedback loop.
While you are learning javascript, learn functional programming. You don't need to learn a new language, but you have access to most of the functional goodies, like higher order functions, closures, and from that interesting patterns like Functional-Reactive-Programming, that is all in rage now ... and maybe even replacing the popular Model-View-Control pattern.
I have to admit, I like to experiment with weirder stuff.
Haskell is awesome. Incomprehensible sometimes, but it is the only language I know of, that implements interfaces for you :D
> What should I learn to stay relevant in the next 5 – 10 years?
Mathematics and algorithms not tied to any particular language. Avoid paying too much attention to the "next big thing", that's counterproductive.
The field of computer science is too fluid right now -- and for the foreseeable future -- to expect to be able to choose a language or environment that has any serious staying power.
For example, 10/20 years from now, everyone will have to learn how to write parallel algorithms to a degree not even imagined today, for lack of appropriate current hardware. That future is virtually certain, but there's no present way to even prepare for it.
> 10/20 years from now, everyone will have to learn how to write parallel algorithms to a degree not even imagined today
So you could learn about low-level code and compilers. Application of graph and set theories. Automated modeling.
As far as I know, there have been developments for more than 10 years that aim towards better parallelising compilers. I believe the current compilers can already use some SIMD instructions when they conclude that the working set is possible to split for parallel execution. (Without programmer hinting, that is!) As the problems become better understood, I expect this trend to continue. Right now it's done by some binary compilers. The next step will likely involve using the same logic in JIT compilers and hence in some language runtimes. After that? I have no idea. Maybe going way beyond map-reduce by applying the same logical solutions to bigger data sets and allowing for more delayed execution. Instead of doing map-reduce by hand, why not have a logical "warehouse compiler" which generates these jobs and their pipelines for you automatically?
My point is that there are fields with known hard problems. As technology and theories evolve, some or perhaps even many of these fields will find new applications outside their current (possibly narrow) scope. Finding interest in them, and tinkering with the problems will expand your own knowledge about the field - as well as the practical applications. From there, applying that knowledge in other fields should become a possibility.
If you're ever-curious, just focus on the fields you are already interested in. (You will discover new ones that overlap.) Find out what's still missing, and then... let there be hacking.
>> 10/20 years from now, everyone will have to learn how to write parallel algorithms to a degree not even imagined today
> So you could learn about low-level code and compilers.
No, you could learn mathematics and algorithms (which I already said). A least-squares curve-fitting regression method works the same in all languages. A Fast Fourier Transform works the same in all languages. Quicksort works the same in all languages. These examples have in common that they are all expressed in universal mathematical notation, and they all carry out the same basic algorithms in the same way, regardless of which language they're expressed in. But all of them would need to be modified to take parallelization into account and exploit it to its fullest.
> As far as I know, there have been developments for more than 10 years that aim towards better parallelising compilers.
That's true, but it's also true that the real challenges of parallelizing algorithms have yet to be addressed in any meaningful way, for lack of suitable hardware. One example is the problem posed by race conditions among independent processes, which is a big argument in favor of immutable variables and functional languages. But these issues have to be examined in light of specific hardware -- they can't be fully worked out in advance of the existence of the target hardware.
C, Java, and JavaScript would have been a good choice 10 or even 20 years, and they're still a good choice today. They'll be around forever, and at the forefront of innovation.
JavaScript didn't exist 20 years ago, so if you chose it 20 years ago you were quite prescient! (First released as LiveScript in 1995.) These things do change more quickly than people realize...
PHP. With the fall of popularity you might think it will bleed to death but the opposite is true. There will be less good PHP programmers but millions of projects running PHP so tightly it is too expensive or of a hassle to rewrite.
PHP is the new Haskell and LISP in terms of legacy. 5 years, when everyone is getting trendy and NodeJS is as mainstream as finding it on free shared hosting, PHP will be powering a massive backlog of web applications which need maintenance.
Lots of suggestions about JS in this thread, which I disagree. I think we have currently very poor visibility how browser tech will evolve. If you look what Facebook is doing with React, it is obvious that the browser rendering pipeline will look very different 5-10 years from now. Also divergence of device UIs is going to continue - think Glass, watches, TV, car control and this will definitely affect web UI technologies too.
I've been a mobile UI developer for over 10 years. World of mobile looked very different 12 years ago. Technologies changes that fast that I wouldn't make career affecting predictions about tech for that long time span.
Learn to ship. It's hard, surprisingly rare skill and doesn't get old.
You should also learn a server side programming language with good performance(Java, C#, Go). I think Java is the best because it is mature, multi platform and you can also use it for Android programming.
Come on, sticking with only one language is never a good idea. Exposing yourself to different paradigms and ways of doing things is almost certain to broaden the way you are able to approach problems in the future.
Learn how to decouple yourself from specific technologies. Underlying all programming languages is the 'pure' logic of programming itself and the theoretical stuff of computer science.
Things like algorithms and data structures are largely independent of language (although there are some 'exotic' things you can do in many of them).
I would however strongly suggest getting a strong background in cross platform C/C++ code. For a very long time this has been the only really practical way to write properly platform agnostic code and it still is... you'll need a bit of Java to glue it into Android, and a little Objective-C might help with iOS and OS X. It also lots of quirks due to being low-level enough and will give you a better understanding of why x is slow or difficult to implement in the general case rather than in just 'language and platform X'
Also, for the web make sure you understand HTML(5), CSS and JavaScript - aside from server side stuff these three things underpin everything on the web.
JavaScript is not the next big thing - its like a 101 requirement for serious web development imo...
I strongly advice against deeply following the next big thing too - check it out see what it is, learn about it a little, but don't go nuts. There is a chance that you will learn nothing of long term value from investigating it thoroughly.
Knowledge of APIs and standard libraries is something Google can provide for you these days... understanding never will be.
Rather strengthen your algorithmic abilities, maybe some more maths and work on something like data science or so, if that's you interest. Languages keep coming and keep going.
Personally I'm preparing to bet on the following group: Haskell, Purescript, Idris - maybe Roy.
As the world realizes that they're relying on software for everything, and that a lot of it is horribly buggy, pure functional programming with typed languages is going to get a lot more popular.
This will likely be reinforced by the current JavaScript era, with some of its type coercion rules making absolutely no sense and object property access that happily accepts accessing nonexistent properties. Add all this talk about its functional parts being the best parts, and the logical progression seems obvious.
Additionally, just immutability by itself will make programming any kind of software much easier in the multicore era.
Regarding types, people will soon realize that these are not your grandmother's (dumb) strongly typed languages. They don't need you to spell out everything for them - they have extremely good type inference - someitmes to the point of feeling almost dynamic, but without sacrificing correctness.
There might be some issues with tooling and foreign-looking terminology at the present moment - but I'm confident they will be sorted out in the next couple of years.
But most importantly, its not just technical merits. People seem to be talking about functional programming a lot lately. Some of it is correct and some isn't, but that doesn't matter - the interest is growing there and I optimistically predict that the trend will continue.
Its probably too early to say whether types will become popular, but I certainly hope so. It sure would help if advocates for types distance themselves from Java and similar languages with little or no type inference. Many people have a lot of ill will accumulated for some of them and tend to blame the types for that. "Inferently typed" seems like a good buzzword for that.
Predictions are often horribly wrong, but they're also so much fun!
I would love it if a Haskell-like language ended up becoming as widely used as Ruby is today, but I don't think it's going to happen. I've met one or two developers in my life whose eyes don't glaze over when I talk about lambda calculus, algebraic data types, or higher order functions that go beyond mapping over an array-like data structure. Trying to explain monads prompts most people to say they left their oven on and flee the room.
These things are very abstract, to a degree where I think many people just aren't comfortable with them. Not that there's anything wrong with that, as I have a hard time with very low levels of abstraction. We've all got our comfort zone.
>I would love it if a Haskell-like language ended up becoming as widely used as Ruby is today, but I don't think it's going to happen. I've met one or two developers in my life whose eyes don't glaze over when I talk about lambda calculus, algebraic data types, or higher order functions that go beyond mapping over an array-like data structure. Trying to explain monads prompts most people to say they left their oven on and flee the room.
You are probably working in the wrong company. I know dozens of colleagues who know what lambda calculus and moands are.
I think that a lot of this is a problem with jargon and explanation rather than with the concepts themselves. For a programmer the difference between abstract and concrete is really just the difference between 'something I don't yet see why I would need to use it' and 'something you've given me a good example for'.
If you want to explain monads to a software developer, call it a 'design pattern that lets you chain actions on wrapped values' rather than "an endofunctor, together with two natural transformations".
I think that most people able to deal with AbstractSingletonProxyFactoryBean will also be able to deal with monads. The jump in abstraction level doesn't seem that high but the complexity seems much lower and code reuse is actually possible, so it would be worth it too. Maybe even for those programmers that never embraced those abstract factories because they simply didn't feel like they'd get enough benefit.
There is just not enough (approachable) material on the subject right now but the amount seems to be growing every day. The percieved "coolness" factor is also rising, and even though in principle we should choose only based on technical merits, us programmers will definitely go through many more obstacles for something that is perceived as cool / fashionable / in demand.
My guess is that most programmers are simply put off by the completely alien terminology rather than the complexity or abstraction level. But this terminology wont remain alien forever - its already entering into more widespread use.
I yearn for a reasonably "right way" to develop software - for a set of solid patterns with truly good characteristics. Not a silver bullet, but at least a set of universal principles that apply to any high quality bullet. The acceleration of the current chaos only reinforces this yearning. There is just too much magic, too many approaches, too many opinions, too much rehashing of the same-old, too much cargo-culting, but not enough facts. I have a hunch that the functional languages of today may be on the verge of being able to offer that "right way". I guess I'll find out soon...
65 comments
[ 3.1 ms ] story [ 68.4 ms ] threadD3, Angular ...
Personally I find Go[1] interesting and it's something I'm hoping to pick up in the coming year. It seems like a fun language, well suited for building web services that handle lots of traffic.
Lua[2] might also be nice to learn. It's used for scripting in a lot of games. For example: in World of Warcraft you can create your own Lua add-ons. Lua can be easily integrated into your own apps / games, since it's just a small C library. It might be a good language to learn if gaming interests you, since lots of games make use of Lua in some way.
And as someone else already mentioned in this thread: functional programming will become bigger in the future. You can use the functional programming style with .NET if you choose to learn the F# language.
---
[0]: http://en.wikipedia.org/wiki/.NET_Framework
[1]: http://en.wikipedia.org/wiki/Go_(programming_language)
[2]: http://en.wikipedia.org/wiki/Lua_(programming_language)
I've found it difficult to find work with Java, Ruby and Python outside of London, however the rest of the country is flush with C# and .NET jobs.
Although mostly in the south east there are well known studios in Scotland, Ireland and the north and midlands. Rockstar, Havok, Ubisoft, Natural Motion, Rebellion and Codemasters come to mind as a few of the bigger names who have studios further from London.
however the tech requirement for AAA is almost exclusively C/C++ (with good hardware and API knowledge strongly preferred for some specialities like audio, rendering, physics, AI, networking...)
Things like C#, Java, Ruby, Python will be limited to internal tools - although there are a lot of smaller companies making HTML5, JavaScript or Unity games or even still flash games which are aimed at the broswer.
Wait, are you talking about JEE?
However, just a decade ago, a large majority of Internet used JS primarily for form validation, which was sad. A lot of web developers were not comfortable leaving their code open for the visitors to see.
I personally believe JS will continue to soar but I also believe that nobody can answer this question perfectly as nobody knows the future.
In any case, if you spend a lot of time learning any language very well, the time required to learning another language after that, decreases substantially.
Learning only programming language (PL) people are limited to scope of that language. Learning paradigms (better in terms of one of PL) you gain knowledges which are "portable" between PLs of the paradigm. You will have a boost when switching PL of the same paradigm: learn PL faster, looking into PL's features and not its basics.
I recommend to check out before you choose what to learn: Lisp dialects like Closure, CL, etc; Ruby; Go / Rust; Java.
Then Node.js and Angular. You should be set for the next 10 years.
Outside enterprise, .NET is sinking into irrelevance. I don't know for Xamarin though.
Edit : fwiw my current job is C# / WPF since 2009. So don't take my comment about .NET irrelevance as mindless Microsoft hatred.
Technologies go through cycles - PHP was hot in 2006, Ruby peaked in 2010, Javascript (and Node.js) is currently hot, and it's quite possible that Go will be hot in 2-3 years.
It's foolish to learn a language under the assumption that it will be relevant for 10 years. If you asked this question in the early 2000s, PHP would be the answer, not Javascript.
The best strategy is to continuously brush up on skills. Experiment and dabble with new languages and frameworks as often as your time allows!
Second, once a language/framework/toolset reaches a certain level of usage, then there will be demand for that skill in the foreseeable future. Even if the language falls out of favor for new projects, maintenance/patches/upgrades will always be needed.
I know freelance PHP developers who have to turn away work. I know freelance Rails developers who have no problem billing out at $200/hour.
[1] http://www.indeed.com/jobanalytics/jobtrends?q=php%2C+ruby%2...
If I were to make a bet now, I'd bet on Node still being widely used in 10 years, and to a lesser extent Rails and Django as well.
If you can turn a design into code, learn to turn a spec into a design.
If you can turn a spec into a design, learn how to understand a problem and produce a spec to solve it.
If you can understand a problem, learn to talk to people and discover the problems they have so you can solve them for them.
If you can do that, learn a million other things and run your own business.
[You can also skip any of these steps if you're happy managing people to fill in the downstream aspects rather than doing it yourself.]
http://en.wikipedia.org/wiki/Peter_Principle
This is what makes waterfall hard and agile.attractive. it is also what makes someone who can shift mental focus from one to the other more useful.
Personally I think of it in terms of field of view. Zooming out to bigger and bigger picture or down to finer and finer detail.
I guess what I'm saying boils down to "increase your range" - if you're a coder you'll be more useful/valuable the more you can look out. (Whether that be in terms of business sense or devops practicalities).
If it was easy to guess the next big thing everybody would do it ;-) A 5-10 year horizon is a very long time in computing years. Look back ten years. How many people were accurately guessing the current environment? How many of the big-things now even existed ten years ago?
When I look back at my career I can't point to a single instance of seeing the next-big-thing.
I can point to lots of great things that have happened because I'm continually poking at new ideas, new processes and new bits of tech. So I'm ready to take advantage when one of those does become the next-big-thing.
So yeah. Take a look at JavaScript and the node.js world. Or robotics. Or architecture as code - or whatever. But for god's sake don't bet your career on it in five years time. Explore lots of things. Find stuff you're good at and enjoy. Be ready for when one of those starts turning into the next big thing.
Want to learn a language? Take a weekend with it, write something that's useful (even if not suitable for production or long term use). Do that often enough and you'll be mentally agile enough to pick up anything when you need to.
My current hunch is that statistics/data science/machine learning will satisfy at least two of the above three, if not all.
I've been learning the basics of data analysis with R, much helped by the awesome RStudio. Initially this was for fun (and a tryout of MOOCs, specifically Coursera's data analysis class) but after only a few weeks I found occasion to use it at work (finding patterns in an application's response times in response to user load throughout the day).
Now I'm getting into stuff that's even more fun, specifically the reactive Web framework Shiny.
This is usually a sure sign of a good match between learner and subject matter: an iterative process where learning and applying, tightly interleaved, form a feedback loop.
I have to admit, I like to experiment with weirder stuff.
Haskell is awesome. Incomprehensible sometimes, but it is the only language I know of, that implements interfaces for you :D
Mathematics and algorithms not tied to any particular language. Avoid paying too much attention to the "next big thing", that's counterproductive.
The field of computer science is too fluid right now -- and for the foreseeable future -- to expect to be able to choose a language or environment that has any serious staying power.
For example, 10/20 years from now, everyone will have to learn how to write parallel algorithms to a degree not even imagined today, for lack of appropriate current hardware. That future is virtually certain, but there's no present way to even prepare for it.
So you could learn about low-level code and compilers. Application of graph and set theories. Automated modeling.
As far as I know, there have been developments for more than 10 years that aim towards better parallelising compilers. I believe the current compilers can already use some SIMD instructions when they conclude that the working set is possible to split for parallel execution. (Without programmer hinting, that is!) As the problems become better understood, I expect this trend to continue. Right now it's done by some binary compilers. The next step will likely involve using the same logic in JIT compilers and hence in some language runtimes. After that? I have no idea. Maybe going way beyond map-reduce by applying the same logical solutions to bigger data sets and allowing for more delayed execution. Instead of doing map-reduce by hand, why not have a logical "warehouse compiler" which generates these jobs and their pipelines for you automatically?
My point is that there are fields with known hard problems. As technology and theories evolve, some or perhaps even many of these fields will find new applications outside their current (possibly narrow) scope. Finding interest in them, and tinkering with the problems will expand your own knowledge about the field - as well as the practical applications. From there, applying that knowledge in other fields should become a possibility.
If you're ever-curious, just focus on the fields you are already interested in. (You will discover new ones that overlap.) Find out what's still missing, and then... let there be hacking.
> So you could learn about low-level code and compilers.
No, you could learn mathematics and algorithms (which I already said). A least-squares curve-fitting regression method works the same in all languages. A Fast Fourier Transform works the same in all languages. Quicksort works the same in all languages. These examples have in common that they are all expressed in universal mathematical notation, and they all carry out the same basic algorithms in the same way, regardless of which language they're expressed in. But all of them would need to be modified to take parallelization into account and exploit it to its fullest.
> As far as I know, there have been developments for more than 10 years that aim towards better parallelising compilers.
That's true, but it's also true that the real challenges of parallelizing algorithms have yet to be addressed in any meaningful way, for lack of suitable hardware. One example is the problem posed by race conditions among independent processes, which is a big argument in favor of immutable variables and functional languages. But these issues have to be examined in light of specific hardware -- they can't be fully worked out in advance of the existence of the target hardware.
PHP is the new Haskell and LISP in terms of legacy. 5 years, when everyone is getting trendy and NodeJS is as mainstream as finding it on free shared hosting, PHP will be powering a massive backlog of web applications which need maintenance.
I've been a mobile UI developer for over 10 years. World of mobile looked very different 12 years ago. Technologies changes that fast that I wouldn't make career affecting predictions about tech for that long time span.
Learn to ship. It's hard, surprisingly rare skill and doesn't get old.
Suppose you're now top 5% iOS developer. 5 years later you'll probably be top 1%. That's cool.
I can see only one hugely improbable risk in doing this. If Apple goes down then Objective-C developers will be as valuable as toilet paper.
Things like algorithms and data structures are largely independent of language (although there are some 'exotic' things you can do in many of them).
I would however strongly suggest getting a strong background in cross platform C/C++ code. For a very long time this has been the only really practical way to write properly platform agnostic code and it still is... you'll need a bit of Java to glue it into Android, and a little Objective-C might help with iOS and OS X. It also lots of quirks due to being low-level enough and will give you a better understanding of why x is slow or difficult to implement in the general case rather than in just 'language and platform X'
Also, for the web make sure you understand HTML(5), CSS and JavaScript - aside from server side stuff these three things underpin everything on the web.
JavaScript is not the next big thing - its like a 101 requirement for serious web development imo...
I strongly advice against deeply following the next big thing too - check it out see what it is, learn about it a little, but don't go nuts. There is a chance that you will learn nothing of long term value from investigating it thoroughly.
Knowledge of APIs and standard libraries is something Google can provide for you these days... understanding never will be.
As the world realizes that they're relying on software for everything, and that a lot of it is horribly buggy, pure functional programming with typed languages is going to get a lot more popular.
This will likely be reinforced by the current JavaScript era, with some of its type coercion rules making absolutely no sense and object property access that happily accepts accessing nonexistent properties. Add all this talk about its functional parts being the best parts, and the logical progression seems obvious.
Additionally, just immutability by itself will make programming any kind of software much easier in the multicore era.
Regarding types, people will soon realize that these are not your grandmother's (dumb) strongly typed languages. They don't need you to spell out everything for them - they have extremely good type inference - someitmes to the point of feeling almost dynamic, but without sacrificing correctness.
There might be some issues with tooling and foreign-looking terminology at the present moment - but I'm confident they will be sorted out in the next couple of years.
But most importantly, its not just technical merits. People seem to be talking about functional programming a lot lately. Some of it is correct and some isn't, but that doesn't matter - the interest is growing there and I optimistically predict that the trend will continue.
Its probably too early to say whether types will become popular, but I certainly hope so. It sure would help if advocates for types distance themselves from Java and similar languages with little or no type inference. Many people have a lot of ill will accumulated for some of them and tend to blame the types for that. "Inferently typed" seems like a good buzzword for that.
Predictions are often horribly wrong, but they're also so much fun!
These things are very abstract, to a degree where I think many people just aren't comfortable with them. Not that there's anything wrong with that, as I have a hard time with very low levels of abstraction. We've all got our comfort zone.
You are probably working in the wrong company. I know dozens of colleagues who know what lambda calculus and moands are.
If you want to explain monads to a software developer, call it a 'design pattern that lets you chain actions on wrapped values' rather than "an endofunctor, together with two natural transformations".
There is just not enough (approachable) material on the subject right now but the amount seems to be growing every day. The percieved "coolness" factor is also rising, and even though in principle we should choose only based on technical merits, us programmers will definitely go through many more obstacles for something that is perceived as cool / fashionable / in demand.
My guess is that most programmers are simply put off by the completely alien terminology rather than the complexity or abstraction level. But this terminology wont remain alien forever - its already entering into more widespread use.
I yearn for a reasonably "right way" to develop software - for a set of solid patterns with truly good characteristics. Not a silver bullet, but at least a set of universal principles that apply to any high quality bullet. The acceleration of the current chaos only reinforces this yearning. There is just too much magic, too many approaches, too many opinions, too much rehashing of the same-old, too much cargo-culting, but not enough facts. I have a hunch that the functional languages of today may be on the verge of being able to offer that "right way". I guess I'll find out soon...