The Death of the Full Stack Developer

The other day I was talking with one of my 20-something developers about his career path, and he expressed a desire for working as a full stack developer. What followed was a somewhat heated debate about why he was wrong, I don't think I made a particularly compelling, or necessarily coherent argument that day, so allow me to address that.

History

The term full stack developer originates in the early days of Java EE. In those days Java EE was fairly straight forward. It had an n-tiered architecture, and district technologies to handle each. JSP, or Java Server Pages were used for presentation. A JSP developer was expected to know things like HTML and JSP syntax, as well as be familiar with EL, and JSTL, in short a good JSP developer could build a functional webpage, these were occasionally called front end developers, because they were experts at developing what was, at the time, the only feasible form of customer facing interface for a web application. Down the stack were EJB, or Enterprise Java Beans, which where used for modelling the domain and business logic. An EJB developer was required to understand and use software design patterns and assign different responsibilities to different EJB's and make sure they had high coherency and low coupling and other niceties. At the bottom we had JPA, the Java Persistance API and the RDBMS, often called back end developers because they were the workhorse, that took complicated EJB graphs and stored them persistently, typically in a relational database. Thus the full stack developer was more of a generalist. While he did not have the specialist skills needed to do anything exceptionally, he knew enough about everything to make a competent effort. This was, and as off today still is a sought after resource, someone who can solve most general tasks somewhat competently. But the jack-of-all-trades is a master of none.

Standing on the Shoulders of Giants

As a software developer or computer scientist the most prestigious recognition we can receive is the Turing Award. It is our Nobel Prize. However if we look at some of the more famous recipients, like Edgar Djikstra, who famously wrote an article in Dr. Dobbs Journal about why goto is bad, Alan Kay, who basically invented the object oriented paradigm, and once famously while he was working for Apple, quipped that he didn't think Oberon was object oriented because it didn't "quack like a duck", and Ivan Sutherland, who invented the WIMP (Window, Icon, Menu, Pointer) interface, which Apple would later "borrow" and claim as their own. Now apart from having received a Turing Award for their contributions to computer science, and their gender, none of these three men have much in common. They are not, by any stretch of the definition, generalists. So why would you aspire to be any less than that? Find out what it is about software development you feel passionate about and do that!

Reality is Changing

Now back in the early days of Java EE, being a full stack developer actually was a fairly accurate description. If you knew IBM WebSphere it was a fair assumption that you could also work on JBoss, because while the implementations were different, the standards were still the same. This assumption didn't always hold for various reasons that aren't all that interesting, but it is even worse today. Just do a job search for Java EE. the results are ridiculous. No two are the same, the term Java EE developer has become meaningless. This isn't really helped by the fact that most "modern" Java EE applications, use the Spring Framework, which isn't technically a part of the Java EE specification. Further more almost nobody uses JSP (or its replacement JSF) any more, they use zk, vaadin, gwt, thymeleaf, freemarker, Apache wicket, or any other of more than two dozen mainstream libraries, that use POJO's (Plain Old Java Object) instead of  EJB's.

It Gets Worse

Other languages are no better. PHP has Laravel, Symfony2, CakePHP, CodeIgniter, and so on. C# has WPF, NancyFx, ASP-Net, Razor, LINQ2SQL, Entity Framework, NHibernate, and so on. Python, has django, turbogears, flask, bottle etc. Even what you might consider niche languages like Erlang and Haskell have several pretty good choices. There is even NodeJS, for people who think JavaScript is such a brilliant language, you should write everything in it. Furthermore there is also a fairly bit of grey area. Modern CMS platforms like Wordpress and Microsoft Sharepoint are technically full monolithic stacks, which means that Wordpress and Sharepoint developers are also by definition full stack developers. Now don't get me wrong, I think it's absolutely brilliant that this kind of diversity exists. That if you want to build a website today, you don't have to learn Java EE, or one of its clones, PHP or ASP. You can go with something like Ruby on Rails, and get skilled and inexpensive labour for your start-up. Brilliant. But the consequence is that you can no longer usefully call yourself a full-stack developer, without specifying which stack. PHP and Python developers seem to have grasped this quite well, and are already calling themselves "Symfony2 Developers" or "Django Developers" which works well for these two groups, and they should keep that up. Java EE and .Net Developers however are in a lot worse positions, because they encourage you to build your own stack, that suits your needs, and being a "Wicket-Spring-jOOQ" Developer, or a "Razor-NancyFx-Linq2Sql" Developer just doesn't really roll of the tongue so easily.

We're not Done

The last nail in the coffin of the full stack developer is Service Oriented Architecture, because in a modern service oriented architecture there is no stack, there are only microservices and message queues. So what does a full stack developer do, when faced with the harsh reality of modern software? He adapts. He is no longer a Full Stack Developer, he is a Cloud Developer, Distributed Software Engineer, or simply DevOps, which has recently become synonymous with being the special forces of software development.

Becoming Part of the Elite

So what should a 20-something software developer focus on, if he doesn't want to be replaced with a 200 line bash script in 10 years? Well you need to grow vertically. You should have:

1. a high degree of confidence in at least 1 DSCM, like Git or Mercurial.
2. some experience working with Docker and the Linux operating system.
3. idiomatic expertise in a mainstream programming language, like Java, C#, JavaScript or PHP.
4. a comprehensive understanding of RESTFul web services and what a HTTP resource is.
5. a working understanding of a functional programming language like Haskell or Scala.
6. a working understanding of distributed storage systems (ElasticSearch, Memcached, Riak, HBase, Cassandra)
7. a working understanding of Message Queues (RabbitMQ, ActiveMQ, ZeroMQ, IronMQ, AWS Simple Queue Service)
8. a working understanding of a front end technology (AngularJS, ReactJS, iOS, Android, Windows Phone)
9. a working understranding of build tools (Maven, Gulp/npm, Jenkins, Teamcity)
10. a community to share ideas and receive coaching and counseling (StackExchange, InfoQ, hackernews, slashdot)

As you can see this quickly becomes a fairly comprehensive list, so you need to prioritise. I would argue that the first four on the list are absolutely mandatory, and ideally you should be able to cross off two or three of the others, this way I believe that your skills will be in demand until you reach an age where you can comfortably retire. Around 40. :)