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 ?
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).
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.
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.
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.
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.
> 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.
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 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...
>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".
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.
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.
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.
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.
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.
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.
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.
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
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.
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). There are some stats here: 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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/) 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.
- 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.
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.]