:PROPERTIES:
:ID:       3acde895-6fb6-433a-a46c-3ebd0dedcdbe
:END:
#+title: On software programming evolution
#+Author: Yann Esposito
#+Date: [2024-02-10]

- tags :: [[id:a5be1daf-1010-428f-a30f-8faf95c1a42f][blog]]
- source ::

* Software Programming

My first contact with programming occurred when I was about 10 years old.
I was confronted with BASIC on a local computer.
BASIC was the UI you need to use to do anything interesting with your computer.

The hardware interface was, a keyboard, two joysticks with a single button and
an electronic pen.
You could push your pen on the screen and the computer could detect the position
of your pen.

So as a child, to play any game I needed to put a magnetic tape in a recorder
and wait for prompt to show and write something like:

#+begin_src basic
RUN ""
#+end_src

And after a while I saw that you could play with this computer by writing
commands to draw things on the screen.
And quickly I copied from a book a few commands to make a loop that drawed
lines.
And I felt it was incredible. Just drawing a few lines on the computer because,
I could control how these lines were drawn.

It wasn't easy to grasp what and how I could change things. But after a while I
did my first computer program that was really useful.

Of course, if I wanted to draw the same thing again, I needed to write the
program from scratch all over again.

I was lucky enough to also have to play with LOGO, and other programming
languages.
Year passed and I familiarized myself with Pascal.
Then I really started my studies and really learned how to program.
And a program was always something you mostly controlled.

The mysterious part for a long time was the driver interface.
I could write program that did various complex things.
But I wouldn't be able to explain how my program could really write on the
screen, or print something on a printer, etc…
The layer provided by the OS was long a mystery to me.

But mainly you had to accept the "Standard Library" that comes with your compiler.
That can makes commands like `println` to really print a string into your
terminal on your screen.

And I quickly understood that if I wanted to create games or any kind of
graphics you need to adopt an external component. A Graphic Library which
exposed function that, if you used them, somehow, magically did things on the
screen. Or generate some sounds.

But mainly, that was it.

A program has always been, for a very long time something starting with the
standard library provided with the compiler of your programming language (C,
Pascal, Java, etc…), and perhaps, you need to install *ONE* big dependency. Like
QT, or something else. And that was it.
You started mostly from scratch every time.

Then, years passed, and I started to earn money for programming.
And slowly, I witnessed the evolution of programs.
From a single man, a small team work from scratch.
To... a kind of social construction.

In particular, I saw how Silicon Valley startups could use the power of many
open source projects, use many libraries to build more complex programs.
And it really changed the pace of the production of the end product.
But, more and more, people started to forget about this initial art of writing
something from scratch without the help of an external library or framework.

Now, I feel, the situation appear to be a bit ridiculous.
We are not even talking about library but people consider to use paying services
instead of libs to provide and publish an application.
And what is left to software engineer is about how to put these external, paying
tools together.

Of course, there is always a bit of code you need to write, but the objects you
manipulate are already pretty abstract things coming from external libraries.
And somehow, this is so much ingrained in people minds now, that people are
afraid to build something themselves. They prefer the comfort of using a bloated
external code that provide a feature they need. Generally, you introduce a new
dependency that could be quite big just for a small part of the proposed features.
This is not only code, but also, publication of your application that is done
that way.

Instead of executing a binary on your own machine, or a machine you lend.
You kind of package all this in many layers of complex things.
Part of the complexity is justified, but probably a big part is not for most
applications.
This has simply became "best practices" to deploy and publish an application.
You add tons of dependencies, which are pretty huge comparatively to the feature
your app will provide, you deploy them in "the Cloud", or a pretty expensive
lent computers, generally inside a containers with a complex  topology of
machines and services.

To me it looks like an incredible waste of resources for most use case.
But as this is "cheap" nobody really cares.
But, doing things this way kind of removed the magic of feeling in control and
feeling that you really built something you understand top to bottom.