Learning a programming language is just part of becoming a software developer. These days, writing software involves an ecosystem of tools, from the programs that developers use to write their code to the cloud computing services that execute it. Choosing your tools is part of the job.

Front-end developers, i.e., those who write code that runs in your browser, have traditionally had fewer choices than their back-end peers, who write the code that runs on servers. Browsers primarily run the JavaScript programming language, while back-end developers must pick from a dizzying number of programming languages and related tools.

That’s changing amid an explosion in tools designed to make life easier for front-end developers. The new tools are a mixed blessing: More choice is good, but tools can fall in and out of favor quickly.

Developers now rely heavily on application frameworks—bundles of reusable parts and an overall structure for building software. In early 2015, the most widely downloaded JavaScript framework was Backbone, according to data gathered by NPM, which makes tools for managing packages of JavaScript code. By the end of that year, it had been passed by Facebook’s then-new React library. Now, less than four years later, Backbone has fallen to fifth place, behind newer frameworks like the upstart Vue, which has surged in usage over the past two years, according to data NPM presented last month.

This turbulence creates challenges both for developers and employers. Like many programmers, Joe Previte, a front-end engineer at a consulting firm in Scottsdale, Arizona, tries to keep up with the latest technologies by working on side projects in his spare time. But he often worries that he’s focusing on the wrong things or that he might spread himself too thin. “The goal in any career is to become an expert in that skill,” he says. “Working in JavaScript, having all these new libraries and frameworks come up, we could dive deeply into React, and then switch to something else entirely for the next project and have to spend six months learning that instead of developing deep expertise in one technology.”

It’s also a challenge for employers that need to attract developers and ensure that the tools used to build their software are supported for years to come. “It’s like looking into a crystal ball,” says Matt Tucker, CEO and cofounder of Koan, which makes team-management software. “You’re making bets on what’s going to still be around years from now, balancing technical considerations with community considerations.”

Why Is It So Complicated?

Jose Aguinaga, the CTO of cryptocurrency company MyBit, captured the disorienting nature of modern JavaScript development in a widely shared 2016 article. In it, he depicted a fictional conversation between a developer who hadn’t paid attention to JavaScript in a few years and someone who was up to speed on the latest trends. The less-current developer wants to fetch some data from a server and display it on a web page, and grows increasingly frustrated as his colleague suggests using new-fangled tools with names like Grunt, Gulp, and Broccoli.

A portion of Jose Aguinaga’s 2016 fictional dialog between two JavaScript developers.

Jose Aguinaga

The article was satirical, but the tools mentioned are real. The suggestions by Aguinaga’s fictional hipster are probably overkill, but many of the justifications for using those tools would make sense in larger projects. “The tools are getting more complicated because the software we’re building is more complicated,” Tucker says.

That’s a relatively new phenomenon in front-end work, says Quincy Larson, founder of the educational site FreeCodeCamp. Historically, JavaScript was used primarily to make web pages interactive. Developers might write code that walked a user through filling out a form or let them flip through a digital photo album, and the programmer could often forget about it afterward, until the page was redesigned. But today developers are increasingly asked to build desktop-style software that runs on the browser—programs like Koan, the project management app Trello, or the workplace chat app Slack.

These more complicated applications require teams of developers to collaborate on code, update it as users discover bugs, and add new features over time. The growing stable of JavaScript tools aims to make life easier for programmers by freeing them from re-creating common features from scratch, making it easier for others to understand and modify their code, or making it easier to find bugs in large code bases.

Developers have been building tools like this for back-end programming since the mid-1990s, but front-end developers are essentially playing catch-up. The rise and fall of JavaScript tools could be mimicking the rise and fall of their back-end predecessors on a compressed timeline.

The turbulence may be exacerbated by other programming trends. Koan CTO Arend Naylor points to the growing popularity of “functional programming,” which essentially makes it harder for code in one part of a program to mess up code in another part of the same program. Facebook’s React is among the tools that offer support for functional programming, which is becoming more common as software becomes more complex.

Learning Skills for the Future

That instability dissuades some managers from using tools created by outsiders. Brian Leroux, CTO of the cloud-computing startup Begin, says the company tries to avoid relying on JavaScript frameworks or other third party tools as much as possible. That’s not to say Begin doesn’t ever use these tools, but Leroux says the possibility that a new version of a library will break old code can create more work in the long run for developers, even if it helps build a product more quickly.

Nonetheless, libraries like React are becoming the norm, and there’s some agreement that they can save effort. Naylor says the Koan team won’t use libraries if they can easily reproduce their functionality in-house, but the team relies on React and related tools. CTOs and developers alike say that when choosing technologies, they look at the size of the community behind a project. A high-quality tool with only one developer who could be hit by a bus makes it hard to bet on a project.

To manage the unpredictability, practically everyone agrees that front-end developers should focus on building strong programming basics, especially in JavaScript. “Once you master the fundamentals, all of this is just different brand names,” Leroux says. Previte, for example, was able to land a job working with React even though his initial experience was with Vue.

But Aguinaga argues that just being versed in the fundamentals isn’t enough. He wants developers conversant with modern tools that require a different way of thinking, such as React. “I’ve ended up not hiring people who looked good on paper because they hadn’t touched React,” he says. “I need people who can be productive [using React] from day one.”

Even when hiring managers aren’t as strict as Aguinaga, developers can’t expect to rely on the same set of skills forever. The good news is that most developers won’t find themselves out of a job overnight. There are still lots of companies that have software built on Backbone, for example, and those companies will need developers to maintain that software for years. That provides time for developers to hone their skills in other tools.

The bad news is that developers typically must learn new things on their own time. “I don’t have many friends who are developers, and they don’t understand why I spend so much time at home learning on my own,” says Eleftheria Batsou, a front-end programmer in Thessaloniki, Greece.

“At first I wished there weren’t so many new things,” she says. But the constant change is part of what keeps the job interesting. “I like that things are evolving. Yes, it’s hard, but I really like it.”


More Great WIRED Stories

This article was syndicated from wired.com

LEAVE A REPLY

Please enter your comment!
Please enter your name here