After more than 35 years being a software/firmware developer, one thing that did not improve in this line of work, is the complexity of the developing environments.
It become worse, not better.
If you are not a software developer, stop to read here :) Boring stuff ahead.
Before to start ...
Ok, in this article I'm using some concepts.Here a brief explanation :
- development system
The "machine" used to develop software mainly defined by a specific operating system.
So typically a x86 based computer using an available OS, like Linux, MacOs, Windows, DOS, etc. - development environment
The set of tools used to create and test programs.
In today world is often an IDE (Integrated Development Environment).
In the glorius days there were a set of different tools. - language
A specific programming language, to be used in a development environment running in a development system, capable to create code to be executed in a target.
Example of language ... assembly, C, C++, C#, Swift, Java, Javascript, Kotlin, Python, Ada, etc. - target
A target is a computer (in a very broad term) capable to execute a code prepared in a development system. Depending the type of the development the target can be the development system itself.
What is the problem ?
As a software developer I did use a lot of languages and environments, and is really a time consuming task to set up a development environment for a project.When I did start years ago things were little bit better because there were far less environments to play with.
History perspective
Let start to see how things were in the past.When I did start to work, mostly talking about embedded development, we had less choices than today.
Not many OS for the development systems, mainly DOS or some Unix stations and later Windows.
You were spending few months learning a specific environment (system and development) and then you were able to reuse it for different projects.
The C language was the main choice, simplifying also the learning curve of the language.
There were different environments available but mostly they were easy to understand once you learned one.
Every environment had basically the same set of libraries and they were a kind of standard.
Basically you had to learn a language, C, and one specific development environment under DOS or Unix.
Once did that you were ready to work on your projects for long time.
Today
How the situation is today ?Well, let start to say we have to start to choose what main OS to use for our development machines.
Windows, Linux/Unix or MacOS and each of them with different versions, that can bring different set of problems/limits.
Each of these choices bring different tools and way to proceed.
Some development environments for a specific language are available for all these systems, BUT it does not means they are really the same.
Each system has it's quirks, from installation, to use and sharing projects.
Even worse, depending what you have to do, you HAVE TO choose a specific environment !
For example if you need to develop code for an iPhone, then you HAVE TO use a Mac with MacOs and some forms of the development environment from Apple : XCode.
Then the languages to use are a lot more than in the past.
C. C++, C#, Java, Javascript, Kotlin, Python, Ada, ecc.
Each language then can have multiple and different development environments also called "frameworks".
Oh yeah, another annoying thing of our "modern" development world is that many languages and environments re-invent terminology to describe the same things !
So if you use Arduino you will actually create "sketches", not programs.
If you use Java for Android you create apps, if you use C you create a program, if you use Kotlin you work with packages, in C++ libraries and so on.
Every language/environment uses different terms to describe the same thing.
For many languages then, there are multiple versions with different way to operate and of course incompatibilities.
Typical for example Python and Java.
Different version of the language are often not compatible among themselves!
That increase the complexity of developing something by a tenfold, not only you need to learn about a specific development system, a specific development environment but also a specific version of a language !
To sum up :
- for every project you need to choose/learn a development system (OS like Linux/Mac OS/Windows) and you need to be aware about differences between versions of the same OS
- you need to choose a development environment capable to work on the chosen development system supporting the required language
- you need to be aware about characteristics/specifications of the environment regarding the version of language used
- if, as now more and more happens, you work with different customers and type of problems, you end up dealing with different environments that basically every few months change !
Just to give some ideas, Visual Studio installed can take up to 50 Gbyte !
A full fledged Android environment can easily reach 25 Gbyte and if you use git or other versioning software (another nightmare to handle) every project can end up to use from 2 Gbyte to 30 Gbyte.
Xamarin (an environment capable to develop code from a source for both iOS and Android) can pass easily 30 Gbyte and so on.
If you need to have all these environments because you need to be able to work on different projects, you can easily have up to 200 Gbyte ONLY in development tools !
And what about the embedded ecosystem we have today ?
RISC, CISC, different architecture, processors of any kind with a plethora of peripherals.
Honestly I don't think there are many developers that KNOW what they are using, because many development environments hide the target hardware and capabilities in layers of libraries and packages somebody else prepared.
In the glorious old day you had to know every processor/MCU in details in order to use them.
Today you just hope that exists some library capable to support a function offered by the hardware because simply there is no time even to study a component, even less to develop a library to use it.
So you just hope that whoever did a library to support a function knew what he/she was doing.
To all this mess (I omitted so many details ... the list of things to know can be just endless) add the need to know what you are supposed to do and of course NO TIME to do it.
Spending time to set up a development environment is often not considered time allowed to be spent.
A developer is supposed to develop, be involved with the specific project and related problems, but without a working development environment is not possible to really work.
Is a kind of catch 22 situation.
I always loved my job, developing software is not just "what I do", is what I am.
Too bad in the last 20 years things become more complicated, more "useless" complicated, taking away so much energy in secondary details.
No comments:
Post a Comment