Bill Gates is quoted as saying that we tend to overestimate the pace of change over a period of 2 years, but underestimate change over a decade. It’s an astute observation: much of what will matter in 2019 actually looks a lot like what we said will be important in development this year.
But if you look back 10 years, the change in the types of applications and websites we build – as well as how we build them – is astonishing. The web as we understood it in 2008 is almost unrecognisable. Today, we are in the midst of the app and API economy. Notions of surfing the web sound almost as archaic as a dial up tone. Similarly, the JavaScript framework boom now feels old hat – building for browsers just sounds weird…
So, as we move into 2019, progressive web apps, artificial intelligence, and native app development remain at the top of development agenda. But this doesn’t mean these changes are to be ignored as empty hype. If anything, as adoption increases and new tools emerge, we will begin to see more radical shifts in ways of working. The cutting edge will need to sharpen itself elsewhere.
What will it mean to be a web developer in 2019?
But these changes are enforcing wider changes in the industry. Arguably, it’s transforming what it means to be a web developer. As applications become increasingly lightweight (thanks to libraries and frameworks like React and Vue), and data becomes more intensive, thanks to the range of services upon which applications and websites depend, developers need to expand across the stack.
You can see this in some of the latest Packt titles – in Modern JavaScript Web Development Cookbook, for example, you’ll learn microservices and native app development – topics that have typically fallen outside of the strict remit of web development.
The simplification of many aspects of development has, ironically, forced developers to look more closely at how these aspects fit together. As you move further into layers of abstraction, the way things interact and work alongside each other become vital.
For the most part, it’s no longer a case of writing the requisite code to make something run on the specific part of the application you’re working on, it’s rather about understanding how the various pieces – from the backend to the front end – fit together.
This means, in 2019, you need to dive deeper and get to know your software systems inside out. Get comfortable with the backend. Dive into cloud. Start playing with microservices. Rethink and revisit languages you thought you knew.
Get to know your infrastructure: tackling the challenges of API development
It might sound strange, but as the stack shrinks and the responsibilities of developers – web and otherwise – shift, understanding the architectural components within the software their building is essential.
You could blame some of this on DevOps – essentially, it has made developers responsible for how their code runs once it hits production. Because of this important change, the requisite skills and toolchain for the modern developer is also expanding.
There are a range of routes into software architecture, but exploring API design is a good place to begin. Hands on RESTful API Design offers a practical way into the topic.
While REST is the standard for API design, the diverse range of tools and approaches is making managing the client a potentially complex but interesting area. GraphQL, a query language developed by Facebook is said to have killed off REST (although we wouldn’t be so hasty), while Redux and Relay, two libraries for managing data in React applications, have seen a lot of interest over the last 12 months as two key tools for working with APIs.
Want to get started with GraphQL? Try Beginning GraphQL.
Learn Redux with Learning Redux.
Microservices: take responsibility for your infrastructure
The reason that we’re seeing so many tools offering ways of managing APIs is that microservices are becoming the dominant architectural mode. This requires developer attention too. That’s not to say that you need to implement microservices now (in fact, there are probably many reasons not to), but if you want to be building software in 5 years time, getting to grips with the principles behind microservices and the tools that can help you use them.
Perhaps one of the central technologies driving microservices are containers. You could run microservices in a virtual machine, but because they’re harder to scale than containers, you probably wouldn’t be seeing the benefits you’d be expecting from a microservices architecture.
This means getting to grips with core container technologies is vital.
Docker is the obvious place to start. There are varying degrees to which developers need to understand it, but even if you don’t think you’ll be using it immediately it does give you a nice real-world foundation in containers if you don’t already have one.
Watch and learn how to put Docker to work with the Hands on Docker for Microservices video. 
But beyond Docker, Kubernetes is the go to tool that allows you to scale and orchestrate containers. This gives you control over how you scale application services in a way that you probably couldn’t have imagined a decade ago.
Get a grounding in Kubernetes with Getting Started with Kubernetes – Third Edition, or follow a 7 day learning plan with Kubernetes in 7 Days.
If you want to learn how Docker and Kubernetes come together as part of a fully integrated approach to development, check out Hands on Microservices with Node.js.
It’s time for developers to embrace cloud
It should come as no surprise that, if the general trend is towards full stack, where everything is everyone’s problem, that developers simply can’t afford to ignore cloud. And why would you want to – the levels of abstraction it offers, and the various services and integrations that come with the leading cloud services can make many elements of the development process much easier.
Issues surrounding scale, hardware, setup and maintenance almost disappear when you use cloud. That’s not to say that cloud platforms don’t bring their own set of challenges, but they do allow you to focus on more interesting problems.
But more importantly, they open up new opportunities. Serverless becomes a possibility – allowing you to scale incredibly quickly by running everything on your cloud provider, but there are other advantages too.
Want to get started with serverless? Check out some of these titles…
JavaScript Cloud Native Development Cookbook
Hands-on Serverless Architecture with AWS Lambda [Video]
Serverless Computing with Azure [Video]
For example, when you use cloud you can bring advanced features like artificial intelligence into your applications. AWS has a whole suite of machine learning tools – AWS Lex can help you build conversational interfaces, while AWS Polly turns text into speech. Similarly, Azure Cognitive Services has a diverse range of features for vision, speech, language, and search.
What cloud brings you, as a developer, is a way of increasing the complexity of applications and processes, while maintaining agility. Adding in features and optimizations previously might have felt sluggish – maybe even impossible. But by leveraging AWS and Azure (among others), you can do much more than you previously realised.
Back to basics: New languages, and fresh approaches
With all of this ostensible complexity in contemporary software development, you’d be forgiven for thinking that languages simply don’t matter. That’s obviously nonsense. There’s an argument that gaining a deeper understanding of how languages work, what they offer, and where they may be weak, can make you a much more accomplished developer. Be prepared is sage advice for a world where everything is unpredictable – both in the real world and inside our software systems too.
So, you have two options – and both are smart. Either go back to a language you know and explore a new paradigm or learn a new language from scratch.
Learn a new language:
Learning TypeScript 2.x – Second Edition
Explore a new programming paradigm:
Functional Programming in Go [Video]
Mastering Functional Programming
Hands-On Functional Programming in RUST
Hands-On Object-Oriented Programming with Kotlin
2019: the same, but different, basically…
It’s not what you should be saying if you work for a tech publisher, but I’ll be honest: software development in 2019 will look a lot like it has in 2018.
But that doesn’t mean you have time to be complacent. In just a matter of years, much of what feels new or ‘emerging’ today will be the norm. You don’t have to look hard to see the set of skills many full stack developer job postings are asking for – the demands are so diverse that adaptability is clearly immensely valuable both for your immediate projects and future career prospects.
So, as 2019 begins, commit to developing yourself sharpening your skill set.