
Ask HN: What should I learn to stay relevant in the next 5 – 10 years? - thewarrior
I am currently an iOS developer looking broaden my horizons. I&#x27;m currently learning Javascript as it seems to be the next big thing. What would you suggest ?
======
jbert
Move up the value chain.

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.]

~~~
norswap
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).

~~~
jbert
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).

------
dshankar
This is not a wise strategy.

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!

~~~
callmeed
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.

[1]
[http://www.indeed.com/jobanalytics/jobtrends?q=php%2C+ruby%2...](http://www.indeed.com/jobanalytics/jobtrends?q=php%2C+ruby%2C+javascript&l=)

------
wsc981
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.

\---

[0]:
[http://en.wikipedia.org/wiki/.NET_Framework](http://en.wikipedia.org/wiki/.NET_Framework)

[1]:
[http://en.wikipedia.org/wiki/Go_(programming_language)](http://en.wikipedia.org/wiki/Go_\(programming_language\))

[2]:
[http://en.wikipedia.org/wiki/Lua_(programming_language)](http://en.wikipedia.org/wiki/Lua_\(programming_language\))

~~~
hackerboos
I would suggest to anyone in the UK who wants to work outside of the South
East to learn .NET and MS technologies in general.

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.

~~~
jheriko
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.

------
jheriko
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.

------
Morendil
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.

------
lutusp
> 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.

~~~
bostik
> _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.

~~~
lutusp
>> 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.

------
spion
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!

~~~
actsasbuffoon
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.

~~~
spion
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...

------
bryanlarsen
Peak jobs for a technology happens several years after the technology peak. To
give an example -- Rails is definitely uncool in 2014, yet there are far more
Rails jobs available now than there were while Rails was cool (<2010).

So if you're looking for a job now, stop listening to hipsters and start
looking at want ads.

Any "cool" technology today is going to take 5 years to have a significant
impact on the want ads. You can try and pick one, and if you get lucky you'll
be one of the few to be able to check the "5 years experience" box in 5 years
time and be in a position to choose your own salary.

However, your chances of choosing it are slim -- many more technology choices
wither and die than succeed.

My advice: when you have a problem, solve it with the best stack for the
problem. Winners are chosen because they're good at solving problems.

You chose Javascript. Javascript's a good choice and a bad one. It's hot right
now and shows few signs of diminishing. But there are lots of people who can
write "10 years experience in Javascript" on their resume, and many of those
aren't all that good in Javascript. It doesn't take long to pick up a language
like Javascript, but it takes longer to pick up an entire ecosystem. So
knowledgeable employers will be looking for experience in the ecosystem, not
just Javascript. In Javascript, there are several of those; jQuery, node,
angular, backbone are some of the largest but there are lots more. Some will
be big in 5 years, some will be forgotten.

IMO, the Javascript/HTML ecosystem that's seems most likely to be much larger
in 5 years than it is now is Web Components. It may or may not be polymer.js,
but that's a good place to start. If a competitor to polymer.js "wins" Web
Components, then polymer.js will at least give you a large running head start.
But that's just my opinion, and it's not going to be useful for a while.

If you're going to be job hunting soon, angular may be your best choice. It
appears to have reached "escape velocity", and is starting to be adopted in
places that actually hire people. It may or may not be uncool soon, but demand
should handily outstrip supply for a few years.

------
mehulkar
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.

~~~
petercooper
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.

------
roadster72
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.

------
jmnicolas
From the trends I see, I'd recommend to become a Javascript expert (not just
passing knowledge of jQuery).

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.

------
arms
No one can predict what the landscape will look like in 5 - 10 years. My
advice is to look at the tools being used in a field that interests you, and
learn those. Technologies cycle in and out of popularity so you can never be
sure what the 'next big thing' will be. But, it's never a waste of time if you
learn something that you _want_ to, and you'll be surprised at how often
you'll find use cases for your new knowledge. Plus, from my experience,
learning any new language/technology makes you better at what you already know
- having a new perspective is a very valuable thing.

You're an iOS dev, so you're familiar with OOP. Why not learn a functional
programming language like Erlang or Haskell? There's a lot of momentum behind
FP right now, and both languages can solve problems in different ways than
what you're probably used to.

------
featalion
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.

------
dirtyaura
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.

------
beardyw
I have been doing this stuff for 42 years. My advice - don't worry about the
next big thing too much, it will become clear if you keep your eyes open.
Avoid jumping on brand new bandwagons which might be going nowhere, but at the
same time if something is clearly gaining momentum, get into it in your spare
time.

For example I cut my OO teeth on Smalltalk in the 90s, but Java looked fun, so
some colleagues an I built game applets in our spare time. I moved straight
into a serious commercial Java job. I also played a little with Flash
actionscript- got me nowhere, but fun nonetheless.

Javascript is a good thing thing to have in your kit bag today.

But to stay relevant for the next 42 years, learn how to learn.

------
mattm
Sales and marketing - those skills will never go out of style.

------
a-saleh
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

------
jgreen10
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.

~~~
dave1629
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...

~~~
icebraining
Same with Java, actually (first public release was in 1995 as well).

------
pearjuice
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.

------
gmays
WordPress (PHP, JS, SQL).

WordPress powers over 20% of the internet, is used by over half of the top 100
sites in the world, Fortune 500's use it, and the government uses it (i.e.
[http://www.data.gov](http://www.data.gov)). There are some stats here:
[http://en.wordpress.com/stats/](http://en.wordpress.com/stats/) but these
estimates are low because all sites aren't tracked.

Despite being around for over 10 years now, it's still growing rapidly. It's
widely underestimated and often derided by other developers, but it's the most
popular CMS in the world and evolving into an app framework. In the WordPress
community devs are the minority, as most are designers, bloggers, hobbyists,
or typical users.

Don't follow the stock market strategy of chasing the hot stocks, look at
value. Remember last year when Apple's stock dipped into the $300's? That's
how WordPress is: great fundamentals, massive loyal customers base, and highly
undervalued.

------
jiax
Functional programming is gonna get big with concurrency becoming more popular

~~~
EiZei
Any day now..

~~~
a-saleh
I'd say, that frontend javascript frameworks are quite functional already :D

D3, Angular ...

------
adrianhoward
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.

------
sgallant
IMO, a better question would be "How do set myself up for my ideal working
situation in 5 - 10 years".

I agree with a lot of things said in this thread, but my suggestion would be
to focus on building relationships and seek out great people to work with. In
10 years, you'll have engineering experience AND be surrounded by talented,
like-minded people. One caveat is, you have to be great yourself, because
great people don't want to work with mediocre people. So really dig into
whatever you're working on, try to impress yourself and try to have fun.

+1 for dirtyaura's "Learn to Ship" comment.

------
democracy
Java(j2ee) is well paid and pretty safe for the next 10-20 years. Java will be
the next mainframes. Even if you look at this thread, not many people want to
do it, but there are hundreds of thousands java applications that need
maintanance and updates and more are starting every year. And good java folks
are in a very high demand.

But the irony is noone wants a pure java dev. It is implied you need to be
good at html/css/js, have handson exp with at least 2 popular databases,
different web/app servers, numerous frameworks and also very good admin
skills. Not the shortest path to success.

------
adventured
I don't think it helps a lot to suggest one specific technology, because
nobody actually knows the future (what that next big thing will be).

Stay agile, aware, and receptive. Learn how to learn better. Don't wed
yourself off for life to one technology, and don't grow stubborn. Be prepared
to turn the ship, quickly, when it comes time. Learn JS today? Sure, I'd argue
however that it's far more important that you're ready to alter your
priorities when that Thing comes along and smashes whatever you think is
important today.

------
peterkelly
Look beyond specific programming languages. Learn computer science theory and
the basic concepts that underly everything we do. If you're good with this you
can pick up any new programming language or framework in the order of a few
days.

Look beyond programming. There's many other intellectually and financially
rewarding pursuits that just writing code. A few examples: research, project
management, business development, teaching, and writing. All of these can
build on your experience to date.

------
rickyc091
I think it's impossible to predict the market / the direction of things. For a
while node.js was a big thing, these days I don't hear as much buzz about it.
Then there was the period of buzz around nosql. I say just do what interests
you the most, don't learn what you might think is the next big thing. There's
also nothing wrong with continuing down the path of iOS. You can be mediocre
at a bunch of languages or an evangelist at one.

------
jbeja
Javascript is not going to be the next big thing, is already that and you
should keep learning it as priority. In my case i am learning functional
javascript and as a framework Reactjs because i like it component base system
approach. Also keep in mind that is not about the language or framework is
about what you can do with it. I suggest to learn programming with
mathematics, regular expresions , etc. To be clear learn how to be language
agnostic.

------
callesgg
JavaScript the NEXT big thing :) That's a interesting way of looking at stuff.
Your are not essentially wrong, just that it is not the NEXT one.

If we are talking work and programming php will not diminish, it is great for
most glue stuff.

If we are talking forefront cool stuff programming GOlang.

Just general stuff, I would say the "next" big thing is embedded stuff and
what annoying people like to call "the internet of things".

------
cryptos
Look for the hard things in software development. To learn a new programming
language or framework is not that hard. Software architecture, requirements
engineering or the overall development process are hard.

------
Proleps
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.

------
balladeer
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.

------
techaddict009
Even I am learning Java Script. Plus I am web developer so started learning
Laravel - PHP framework.

~~~
jbeja
Learn PHP first.

------
qwertz_
"the art of programming"

------
NigelTufnel
A slightly paradoxical advice: learn Objective-C. Learning of one thing never
stops.

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.

~~~
collyw
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.

------
znmeb
1\. Empathy 2\. Humility 3\. Sales 4\. Accounting 5\. Spanish 6\. Chinese

------
Goranek
Go, Javascript(angular)

------
fit2rule
Now learn how to make cross-platform mobile apps with Lua.

------
chatman
Learn Java. Java 8 looks exciting.

------
solomatov
It's very hard to predict the future, but I think, there are things which are
and will always be worth learning in software development world (however, they
aren't enough to find a great job):

\- Large scale programming languages(Java, C#, C++) and techniques. JavaScript
is in fashion today, however, as web is replacing desktop apps we will have
more and more capable and large scale applications. It won't be possible to
develop them in JavaScript because of its lack of support for large scale
development. All these languages have compiler to JS (and in future probably
will have compilers to asm.js), and I think, they will replace JS in the
future.

\- Algorithms and data structures (It's very hard to find a person who can
describe well how hash tables work. I interviewed many people who studied this
at university).

\- Programming language theory. It makes you better programmer, since you will
have a better understanding of why languages are implemented the way they are.

\- Mathematics which is relevant to software: discrete math, statistics (data
science is on the rise now), mathematical logic. These skills are timeless

This part is more speculative (however, I personally bet on this stuff):

\- Reactive libraries. They allow you to become so much productive. You can
learn Reactive Extensions
([https://rx.codeplex.com/](https://rx.codeplex.com/)) or one of its port to
other languages. Also I can recommend you the framework which we developed at
JetBrains: [https://github.com/JetBrains/jetpad-
mapper](https://github.com/JetBrains/jetpad-mapper).

\- Web platform. I mean WebGL, WebCL, WebWorkers, and other HTML5 APIs. The
next generation of apps will be based on the web platform, and you need to be
fluent in these APIs to be relevant.

\- Emerging languages: Scala, Kotlin, Rust. Don't learn Go, that language is
defective by design. Also don't learn Haskell, the language isn't widely used
and if we take a language + popular extensions it's more complicated than C++.
Haskell will probably be replaced by one of the dependently typed programming
languages.

\- Dependently typed programming language. Currently, they are mostly academic
languages, however, they give us a promise of writing reliable software by
construction without too much effort. The best language here is Agda. However,
you might want to learn Coq or Idris.

Things you should stay away from:

\- Do not learn dynamic languages unless you have to (for ex. JavaScript, I
hate it, but I have to write code in it from time to time). Modern statically
typed languages are so good now, that they give you almost all advantages of
dynamic language while keeping code correct.

\- Do not learn language which try to make themselves easier at the cost of
correctness: Go (lack of generics) and Dart (optional unsound type system). I
think they won't work out despite the fact that Google backs them.

