Classic software engineering was more about the science of programming, with the focus on –
- Best practices in design and development such as OOP, inheritance, etc.
- Art of developing programs that can scale and perform
- Debugging code to find the root cause and “fixing” that as opposed to adding a patch to “conceal” the bug.
- Best practices around the processes that enable gaps/defects to be identified earlier in the development cycle – such as peer reviews, source code management, continuous integration, etc.
However in the last decade or so, with the proliferation of frameworks and tools which claim to automate a lot of these best-practices – the role of a software engineer has diluted.
These frameworks and tools are supposed to manage most of these low level nitty-gritty of software development allowing the software engineer to have to perform just a few mouse-clicks to build a functionality. Undoubtedly this has resulted in the development cycle shrinking significantly; however there is always a complex requirement from the customer coming just around the corner, which is not supported out-of-the-box by the framework / tool; thus needing some tweaks and customization. Here comes the need for a traditional software engineer; Someone who can cut open the framework/tool, understand how the internals of it work, and based on that insight, figure out the best way to fix/enhance/extend it. But more often than not, by this time the “software engineer” on this project, “spoilt” by the level of automation provided by the tool, is so used to only point-and-click mode of operation, that there is often hesitation to go any deeper into the tool.
This in my opinion is the basic problem that IT organizations face today. The crux of software engineering has really not changed. But its more the continued exposure to ready-made code in the formative years of a software engineer that has resulted in him or her failing to step up whenever there is a need.
Another common problem faced by software engineers of today is that there are so many companies looking for people who can just implement a packaged solution for them as opposed to having a custom developed software which would obviously have a significantly larger development cycle.
Due to this increased demand of “product implementers”, the software developers see a “shortcut path” to success by simply having to learn how to implement a COTS product rather than having to go through the details of traditional software engineering.
These COTS packaged solutions have very little scope for customization and hence these product implementers get no experience in core software development. Which was the main objective of going with packaged solution anyways. However in such situations, more often than not, customers end up with a lot of integration needs to make this COTS packaged solution talk with other systems. Here again it is important for someone with a traditional software engineering view point, to weigh in on what the integration touch points should be, what the message payload should look like, which functionalities should be exposed as coarse-grained vs. fine grained services, etc. And all of these can only come with a thorough understanding of the architecture of packaged solutions and how they fit in the larger ecosystem.
Changes in technology trends have been another factor that has had a telling impact on the role of a SE.
- Cloud : Today, every company wants to jump on the cloud band wagon. Although there is nothing stopping an organization from moving all their systems to cloud; but not always it’s a profitable move. Knowing what should be hosted and what makes more sense to leave as on-premise is a whole new subject and there are dedicated cloud architects that need to be consulted when taking such decisions. However, for a software engineer who is developing new apps, needs to be aware as well of this phenomenon and design the system knowing that there is always a possibility either that application or any other application it interfaces with could get potentially be migrated to the cloud.
- Big data : With the advancements in this area, there is always going to be a need in near future for applications to leverage the power of information available in the huge volumes of analytical and historical datastores so as to enable organizations to make more informed decisions. A Software engineer needs to take those aspects into consideration when designing systems.
- Mobility : Cross device support has almost become a norm for every new application being developed today. Trends such as Single Page Applications (SPA), Software Oriented Front End Archietcture (SOFEA) and Service Oriented User Interface (SOUI) are presenting various new paradigms in web application development for a digital platform.
- Integration : The future of software engineering lies in integrating disparate systems to enable them to talk to each other seamlessly through a unified middleware platform that isolates inter system dependencies.
It is imperative to have our Software Engineers of today, be well educated on these trends and the impacts it can have on application development
There is a definitive need of digital-enablement of our software engineers, making them aware of these pit-falls and provide them with a platform for continuous familiarization to various tools and frameworks, upcoming technology trends, etc. – in addition to the traditional content focused on the art and science of programming
References / Links