Programming in the Middle Ages

the open space, 1005 AD

Inspired from this post Programmers Today are like Scribes in the middle Ages, in the discomfort of realizing the truth, but hoping for a re-lit of Reason.

Sentences for intellectual sorrow

  • The Programming Language doesn’t matter
  • A programming language is just a tool (for the right job)
  • With the right tooling, all programming languages are equal
  • Eventually all programming languages evolve to become the same
  • All programming languages are Touring Complete (sigh!)

And this is not my own reply, but I tend to affiliate well enough with this answer

I wonder how people think all programming languages are equal. Can we think of anything else, where all options are entirely equal? Cars? Houses? Planes? Burgers? Telescopic back scratchers?

Languages do matter, they absolutely matter.

What doesn’t really matter is what language a beginners learns first, any more than it matters what their first car is. So long as it is reasonably safe it basically doesn’t matter. — Some Quora thread reply

The sewing of ARPANET in 1001 AD, and Quora soon after

I do think the choice of programming language matters, for several reasons:

  • happiness of programmers,
  • expressiveness and clarity (communication)
  • shortness of code. (yes LOCs, yes)
  • maintainability (complexity management)

What I think mostly matters is the evolution of Type Systems,

which for me matches the evolution of Mathematics, Philosophy, and Knowledge somehow (in a parallel universe, the IT universe).

Different programming languages have different features and qualities, and yes, some are better than others. Some are absolutely better, but still I don’t deny practical limitations.

An example of a practical limitation is the inter-operability with something pre existing, does that language support it, if so, to what degree?

For example, does it run on the same runtime, or does it require anything “extra”?

Can it re-use shared libraries previously developed for the “legacy” language, does it have the same “tooling” and development environment, or compatible ones?

The famous witch trial of the programming language, using fair jurisdiction

Doubting The Change

  • What are the Costs to introduce this language?
  • What are the Savings after introducing this language?
  • Is this language production ready?
  • Can everyone learn this language?
  • Does this language have any job market?
  • Is this language performant enough?

A Marketing Journey

Many times in my career as a software developer I tried to approach my co-workers showing them a programming language I love, to feel the incessant delusion of not being able to communicate with them well enough, not move them, nor see them appealed or mesmerized at the sheer sight of the advances of knowledge in the field of computer programming.

Why is it so hard to market something good to my co-workers?

A Common Knowledge Ground Dilemma

My blunt perception tells me that it might be some of us don’t really understand the actual differences among programming languages, either because they tried too few, or because they are in a very human and emotional way tied to what they learned to love, with hardship and sweat, and they decided to castle in for good.

Still some of us, don’t have a 2 pennies say of how languages are classified, on what makes one differ from another. Then a dialogue or a convincing argument becomes almost impossible I think, I might as well just say…

Here I believe most of us would need a refresher on the topics in this list, me included, to actually compare programming languages in a less naïve or blatant-talk way, important stuff in bold:

  • declarative languages/style
  • function (math and programming)
  • imperative languages/style
  • machine code (binary, hex, base system rep of numbers)
  • character encoding (ASCII, UTF8, of text streams and files)
  • assembly language
  • heap vs stack memory
  • compilation (compiled language)
  • interpretation (interpreted language)
  • runtime error vs compile time error
  • class
  • object
  • object oriented programming
  • module
  • functional programming
  • type system (what is it?), and what’s a type
  • reference types and value types
  • runtime environment (and garbage collection)
  • strong vs weak typing
  • dynamic vs static typing
  • inheritance
  • interface
  • dynamic polymorphism (runtime method dispatch via inheritance)
  • static polymorphism (static method dispatch with generics in OOP or pattern matching on union types in FP)
  • dependency injection
  • type inference
  • generics
  • automatic type generalization (inference)
  • ADT abstract data types (Sum types, Product types, from category theory)
  • lambda calculus and higher order functions
  • partial application and currying

Advanced/Others

  • monads and monadic computations
  • recursion
  • higher order types (kinds)

Addition to that list, Our Beloved Middle-Ages Craftmanship Design Sermons

It’s important to be able to deal with the past in positive manner

Spoiler, some of what’s listed below acquires kind of less meaning outside of the OOP only languages, so one starts to question..

  • SOLID for OOP
  • TDD (can still do in FP)
  • Unit Test
  • Integration Test
  • Domain Driven Design (DDD, nice in FP too!)
  • GOF Design Patterns for Reusable Software (OOP)
  • Dependency vs Duplication, aka pp mis-interpreting the DRY principle gospels and becoming crusaders of the one line deduplication. Jerusalem Lasagna.

Fear of the Dark (Ages)

Sometimes the game (making the change or trying it out) is worth the candle, and not as painful or risky as it seems in our heads.

Changing or trying out something new makes us feel vulnerable and subject to mistakes, haunted by possible failure, and worried by the length of our journey.

Will water and bread be enough in the desert? shall we eventually find an oasis?

Let’s be serious. Why would you be scared to learn today?

For me this embeds the concept of Dark Age but in 2021.

The standard experienced knight answer on weather a programming language really matters over any other in the tournament of software is:

The language we use doesn’t matter, as long as it gets the job done.

Honestly this sounds like a joke to me. Why?

Our Job is mostly to read thousand and thousand of lines of code of that language — because you “speak it” (from the word tongue), hence you read it, and you write it.

  • Would you rather read 100000 lines of hieroglyphs which get the job done, or 100 lines of beautiful language closer to logical and mathematical reasoning and English, easier to understand, teach and learn.
  • Are you working for complexity or against complexity, mate?

As a human being, I do myself attach feelings to my strive for a better knowledge.

Toth, Egyptian god of knowledge, writing the first program, stuck in Vim forever with no exit commands

For the love of knowledge, learn the beauty of programming languages.

Repeat after me…

The language is NOT a tool,

The medium is the message

McLuhan in da house