by Jason Seminara and Brian Blakely
On 04 August 2021

It’s time to think about thinking

When it comes to training the next generation of developers, lessons must be learned from history. Instead of prioritizing ‘in vogue’ languages and skills, young developers must be taught how to think, apply logic to different technologies and scenarios, and reason through problems. A fresh approach to training could provide the launchpad needed for young developers to grow in confidence, embrace the magic of computer science and, ultimately, build sustainable and fulfilling careers.

As technology evolves, software developers remain the consistent component; one line of code away from defining the next chapter of business innovation. For decades, developers have sat at the epicenter of technological progress, taking a central role in the debates, trends, and areas of flux that occur from one cycle to the next. It has been said that history repeats itself, but software is different. If you have been around long enough to take in a generational view of software development, it becomes increasingly apparent that technology, specifically the software development lifecycle, does not repeat but rather it rhymes.  The regularity with which new technologies ebb, flow, and shift to new languages shouldn’t come as a surprise, but it should serve as an important lesson for those entering the industry, and for those responsible for training them.

Lessons from history

Consider the browser wars of the late ‘90s onward, and the requirement to write separate versions of applications for Netscape, Internet Explorer, and other platforms. Consider the analogs to present-day competition between iOS, Android, and the Web Platform. Java developers in the ‘90s similarly believed that by learning a single, agnostic language that would operate on any platform or processor, their career would be future-proofed, yet this ultimately failed to materialize (on the front-end), thus losing the fight for mindshare and critical mass within the global developer community. Today, the React JavaScript framework for building single-page UIs has gained widespread acceptance within front-end developer communities, but for how long?

If a lesson is to be learned from technology cycles over the decades, it’s that foundational technologies often fail to meet their promise over time. Such an understanding would be a comfort to younger developers experiencing equivalent technology shifts for the first time and feeling overwhelmed. Yet, counterintuitively, there remains a tendency on the part of students, teachers and indeed employers to prioritize “in-vogue” languages or skills. Given that we know the tech cycle will continue to turn, what’s crucial for junior developers is the ability to reason through problems and swap out one language or scenario for another, applying the same underlying logic to different technologies in different situations. This understanding has to inform the training and progression of the next generation, ensuring they are equipped with the approach and adaptability needed to build a sustainable and fulfilling career. For example, in the mid-2010s, React popularized the component pattern for software architecture. As a result, many newer component solutions now exist, and so it is that pattern which developers must hone, as opposed to any library in isolation. This mindset kindles a powerful career trajectory that also benefits our entire industry.

By adopting a generational view of software development, it is clear that the focus must be on how to think, rather than relying on rote learning of specific languages or approaches.

Learning how to think

The magic of computer science lies in the underlying logic, reasoning and potential. The overlying language is simply the expression of these concepts. By adopting a generational view of software development, it is clear that the focus must be on how to think, rather than relying on rote learning of specific languages or approaches. This may not come as a surprise. The philosophy and practice of teaching and learning was transformed by the foresight of Jean Piaget and his theory of constructivism, seeking to enhance students’ logical and conceptual growth, building knowledge and forming meaning based upon personal experiences. He further inspired Seymour Papert, whose opposing theories of constructionist learning championed the idea that cognitive frameworks could be self-constructed, rather than received. Through goal-oriented computer programming and debugging, children could explore and scaffold their own learning, thereby understanding how they learn and acquire new skills (metacognition). These principles offer a new framework for training junior software developers, underpinned by academic insight and accomplishment. A fresh approach could provide the launchpad needed for young developers to grow in confidence and embrace inevitable technology cycles as an opportunity instead of an insurmountable challenge.

The child programs the computer and, in doing so, both acquires a sense of mastery over a piece of the most modern and powerful technology and establishes an intimate contact with some of the deepest ideas from science, from mathematics, and from the art of intellectual model building.

Seymour Papert

Employers and senior developers have an important role to play in shifting the thinking around what constitutes a “good” junior developer by honestly assessing how they are supported, nurtured, and trained. There is a natural impulse for employers to favor discrete skills over education, and while their interests are served by recruiting people who are familiar and confident with the subject matter, this approach sacrifices the potential to better tackle logical problems, as well as reduce on-the-job training at the outset. Young developers are looking for roles where they are granted the benefit of time; to learn from the team around them, walk through problems at their own pace, gain experiences that will build their confidence and knowledge, and ultimately, learn how to think.