Why Software Engineering Will Never Die
Written by Nikos Vaggalis   
Tuesday, 10 October 2023
Article Index
Why Software Engineering Will Never Die
Becoming a well-rounded developer
Online Training v Bricks and Mortar Universities

A new published paper, "Preparing Students for the Software Industry New Demands", is ostensibly a study on how graduates can become job ready. However, it also prompts thinking about the extent to which programmer jobs are threatened by low code tools or ai-assisted tools.

It's no secret that educational institutions do not prepare students effectively to join the workforce. There's a mismatch between what is taught at school to what the industry actually requires.

Just have a look at Linkedin job postings to get an idea of what is expected from junior developers. They are required to be novices, but at the same time have the tool belt and experience of a developer already working for years. That means that they must have deep knowledge of specific technical subjects (databases, programming languages, requirements analysis, Web development, mobile development) and the skills to integrate new features in more complex systems.

A paper titled Preparing Students for the Software Industry New Demands from the Polytechnic Institute of Castelo Branco
of Portugal, recently published in the International Jounal of Advances from Software by acknowledges the problem and tries to understand what's necessary to bridge the gap. That is the paper's main purpose, but there's also a hidden secondary intent, when reading it from another perspective. Under that perspective the paper could also do with a subtitle of "Why Software Engineers will not ever be replaced by Low Code tools or AI" as it goes to lengths to answer the pressing question on every one's minds - whether developers will be out of job due the rise of low code tooling or LLMs. As we'll find out while going through the paper, mass redundancy of junior developers is an unlikely or even impossible scenario. 

But first things first. The main issue that the paper found is not that the basic skills required by the industry are not being taught at colleges. Skills like requirements engineering, analysis, design, coding, or validation are on every self-respected curriculum. The problem is combining all that to create something tangible, since integrating all these subjects usually requires experience in developing a complete project.

The paper believes that an active and collaborative learning approach involving academia and industry actors
would be the most optimal in getting there. This approach presented, involved staff from a software company in collaboration with staff from an academic institution. It resulted in a student being involved in an entire software development project which as we'll see, encompasses the whole software development life cycle, the skills and steps involved. Spoiler, as the study found, modern SE developers should be well rounded, soft skills included.

But first, the setting. The work described here was done by a student who attended a computer engineering course's third curricular year (fifth and sixth semesters). In parallel, the student had to attend other curricular units, which are part of the course.
The student was involved in an agile team of faculty and Information Technology (IT) professionals. The Scrum agile framework was followed, and the product was developed using a Low-code development platform.

The application to be build was a Web and Mobile application for household accounting with which the user could scan or upload his invoices, in order to extract valuable information with the aid of cognitive services. Its features allowed the user to:

  • Register invoices automatically
  • Consult their invoices that are due to be paid
  • Visualize spending through a graph organized according to the value and entities of the invoices
  • Process invoices (recognize and extract) data from pdf or an image captured by a smartphone

To build it, the low code platform of OutSystems and integration with Azure cognitive services were employed. The low code tool was used to build the UI and underlying infrastructure, while the Azure backend was used for utilizing machine learning in understanding the contents of the invoice.

At this point the first takeaway is that low code platforms, while allowing for fast learning development processes, enabling a more systemic view of software projects and providing easy integration with other application endpoints, can't escape good Software Engineering, as low code's inherent abstraction requires following good development practices. Software Engineers vs Citizen Developers 1:0.

The second takeaway, is that you don't reinvent the wheel, you don't start from scratch. Nowadays you usually use integration and interconnection between various systems. This aspect makes it increasingly crucial for new IT professionals to know the services available and the mechanisms to integrate them into their applications. This holistic knowledge can be acquired in theory, but nothing is better than consolidating it through developing projects that use this integration and other technologies. In this case, that is incorporating Azure cognitive services.

So knowing and learning how to integrate is deemed a a very valuable skill that a student should posses for him to get into the workforce.

Takeaway number 3 - teach them full stack development. Developers often do not just play a single role in software
development; they must be multifaceted, often taking on the role of designers, coders, and database specialists. Therefore,
having this knowledge and multi-tasking skills is essential. This is also an advantage because it will enable the developer to be more familiar with all stages of the development process, optimizing cooperation inside and outside the team and contributing to reducing software development costs.

Can a LLM do all these tasks in a logically coherent way in building a software product iteratively? Apart from turning designs even printed on handkerchiefs to html code, or  generating code, they can't. Software Engineers vs LLM's 1:0.

Last Updated ( Tuesday, 10 October 2023 )