Talking to Machines: The History and Future of Programming Languages

Since the dawn of computing, we have strived to command machines as efficiently as possible. Over the last century, a myriad of programming languages has emerged, transforming how we converse with silicon. We have tested and implemented new concepts, paradigms, and patterns.

However, it increasingly feels like we are moving in circles, revisiting ideas pioneered in decades past. It is time to pause and reflect on the state of the programmer's primary arsenal.

In this session, we will tackle the hard questions:

- Are we stuck in a loop of reinventing the wheel?
- Are there deep analogies between code and natural languages?
- Why do some languages thrive for decades while others end up in the graveyard of history?
- Why do we get so attached to specific tools while despising alternatives?
- Do we prefer writing yet another CRUD in the latest Java, or sending humans to space using "obsolete" tech?
- Will English become the ultimate programming language in the AI era?

Transcript

1. Piotr Łaskawiec Comsenity Rozmowy z maszynami: Historia i przyszłość języków programowania Zaobserwuj 4Developers i bądź na bieżąco!
2. • Pragmatic Software Architect • Creating software for nearly 20 years • Founder of • Helping companies to deliver real value • Occasional speaker and trainer @piotrl a sk a wiec @piotrl a sk a wiec.bsky.soci a l COMSENITY LET'S CONNECT Who am I COMSENITY
3. No programming languages were harmed in the making of this presentation. I respect all of them. The ones with semicolons, the ones without, the ones that steal my RAM, and the ones still running quietly in a bank basement since 1982. (And to be clear: I respect you whether you use tabs or spaces. I might judge you silently, but I respect you). COMSENITY DISCLAIMER
4. “You live a new life for every language you speak. If you know only one language, you live only once.” COMSENITY
8. 1949 Assembly 1977 Commodore BASIC V2 2024 English (AI) COMSENITY
9. 1949 Assembly 1957 Fortran 1958 ALGOL 1958 LISP 1959 COBOL 1962 APL 1962 Simula 1964 BASIC 1972 C 1972 Smalltalk 1972 Prolog 1974 SQL 1977 Commodore BASIC V2 1980 Ada 1985 C++ 1986 Erlang 1987 Caml 1990 Haskell 1990 Std ML 1991 Python 1995 Java 1995 JavaScript 1995 PHP 1996 OCaml 2000 C# 2003 Groovy 2004 Scala 2007 Clojure 2009 Go 2015 Rust 2024 English (AI) COMSENITY
10. 1949 Assembly 1957 Fortran 1958 ALGOL 1958 LISP 1959 COBOL 1962 APL 1962 Simula 1964 BASIC 1972 C 1972 Smalltalk 1972 Prolog 1974 SQL 1977 Commodore BASIC V2 1980 Ada 1985 C++ 1986 Erlang 1987 Caml 1990 Haskell 1990 Std ML 1991 Python 1995 Java 1995 JavaScript 1995 PHP 1996 OCaml 2000 C# 2003 Groovy 2004 Scala 2007 Clojure 2009 Go 2015 Rust 2024 English (AI) COMSENITY
11. 1949 Assembly 1957 Fortran 1958 ALGOL 1958 LISP 1959 COBOL 1962 APL 1962 Simula 1964 BASIC 1972 C 1972 Smalltalk 1972 Prolog 1974 SQL 1977 Commodore BASIC V2 1980 Ada 1985 C++ 1986 Erlang 1987 Caml 1990 Haskell 1990 Std ML 1991 Python 1995 Java 1995 JavaScript 1995 PHP 1996 OCaml 2000 C# 2003 Groovy 2004 Scala 2007 Clojure 2009 Go 2015 Rust 2024 English (AI) COMSENITY Language Categorization Legend Icon Shape (Execution Model) Imperative (step-by-step) Declarative (goal-oriented) Multi-paradigm (mixed) Color (Paradigm) Procedural Object-Oriented Functional Logic / Relational Multiple paradigms
12. LISP Fortran COBOL ALGOL BASIC ML Prolog BCPL Simula Pascal C Smalltalk Ada SQL OCaml Erlang C++ Python Haskell Rust Go Java JavaScript Algebraic expression syntax Arrays Array indexing Procedural loops Block structure Control flow Lexical scoping Blocks Structured programming Value/Reference passing Strong typing Packages English-like syntax Data records Curly brace syntax Bitwise ops Classes Objects Message passing Classes Virtual functions Coroutines Memory control Pointers Syntax Control flow structures Bitwise operators Syntax basics Pointers Fast compilation Object-oriented paradigm Garbage Collector Actor model concept Message passing C-style syntax Static typing Systems programming Zero-cost abstractions Syntax conventions First-class functions Recursion Symbolic processing Homoiconicity First-class functions Garbage collection Pattern matching Declarative concurrency roots Strong static typing Object integration Algebraic Data Types Type inference Enums (ADTs) Pattern matching Immutability Typeclasses (Traits) Result/Option monads COMSENITY
13. FOUNDATIONS
14. 1957 FORmula TRANslation • Cre a ted a t IBM (le a ded by John B a ckus) • First optimizing compiler! • Autocode, The L a ning a nd Zierler system • A-0 a nd Gr a ce Hopper • Flow control • Oper a tor Precedence P a rsing a nd comments • Still widely used in HPC a re a bounce.f C Bouncing Character in classic FORTRAN IV / 66 INTEGER X, Y, DX, DY, I X = 2 Y = 2 DX = 1 DY = 1 DO 100 I = 1, 50 X = X + DX Y = Y + DY IF (X .LE. 1 .OR. X .GE. 20) DX = -DX IF (Y .LE. 1 .OR. Y .GE. 10) DY = -DY WRITE(6, 200) X, Y 100 CONTINUE 200 FORMAT(1H , 'Pos: ', I2, ',', I2, ' @') STOP END COMSENITY user@comsenity:~/animation$ ./bounce +------------------+ | | | | | | | | | | | | | | | | | | | | +------------------+ * * * * * * @ Pos: 8,8 @
15. 1957 FORmula TRANslation • Cre a ted a t IBM (le a ded by John B a ckus) • First optimizing compiler! • Autocode, The L a ning a nd Zierler system • A-0 a nd Gr a ce Hopper • Flow control • Oper a tor Precedence P a rsing a nd comments • Still widely used in HPC a re a bounce.f C Bouncing Character in classic FORTRAN IV / 66 INTEGER X, Y, DX, DY, I X = 2 Y = 2 DX = 1 DY = 1 DO 100 I = 1, 50 X = X + DX Y = Y + DY IF (X .LE. 1 .OR. X .GE. 20) DX = -DX IF (Y .LE. 1 .OR. Y .GE. 10) DY = -DY WRITE(6, 200) X, Y 100 CONTINUE 200 FORMAT(1H , 'Pos: ', I2, ',', I2, ' @') STOP END COMSENITY
17. 1958 ALGOrithmic Language • Glorious Ide a - open, univers a l l a ngu a ge for describing a lgorithms • Code Blocks / Lexic a l Scope • Dyn a mic t a bles • C a ll by V a lue • Recurrence* • B a ckus-N a ur Form (BNF) not a tion • ALGOL-like l a ngu a ges COMSENITY bounce.alg comment Bouncing Character highlighting Lexical Blocks; begin integer x, y, dx, dy, i; x := 2; y := 2; dx := 1; dy := 1; for i := 1 step 1 until 50 do begin comment Nested block structured execution; x := x + dx; y := y + dy; if x <= 1 or x >= 20 then dx := -dx; if y <= 1 or y >= 10 then dy := -dy; outstring(1, "Pos: "); outinteger(1, x); outinteger(1, y); outstring(1, " @\n"); end end
18. ((((LISP)))) COMSENITY
19. 1958 LISt Processing • Cre a ted by John McC a rthy a t MIT • Lists, lists everywhere • G a rb a ge Collection (M a rk- a nd-Sweep) • Repe a t-Ev a l-Print Loop (REPL) • Spiritu a l successor - Clojure • Homoiconicity a nd The Curse of Lisp bounce.lisp ;; Classic LISP 1.5 style using PROG and GOTO loops (DEFUN BOUNCE () (PROG (X Y DX DY I) (SETQ X 2) (SETQ Y 2) (SETQ DX 1) (SETQ DY 1) (SETQ I 0) LOOP ;; Label declaration for GOTO (COND ((EQUAL I 50) (RETURN NIL))) (SETQ X (+ X DX)) (SETQ Y (+ Y DY)) (COND ((OR (<= X 1) (>= X 20)) (SETQ DX (- DX)))) (COND ((OR (<= Y 1) (>= Y 10)) (SETQ DY (- DY)))) (PRINT (LIST 'POS: X Y '@)) (SETQ I (+ I 1)) (GO LOOP))) COMSENITY or Lots of Irritating Super f luous Parentheses
20. 1959 COmmon Business-Oriented Language • Gr a ce Hopper’s leg a cy (FLOW-MATIC) • Hier a rchic a l d a t a structures • English a nd noise words • D a t a vs logic • Bullet-proof m a th BOUNCE.CBL * Bouncing Character in COBOL (Highlighting Optional Noise Words) IDENTIFICATION DIVISION. PROGRAM-ID. BOUNCE. DATA DIVISION. WORKING-STORAGE SECTION. 01 X-POS PIC S99 VALUE IS 2. 01 Y-POS PIC S99 VALUE IS 2. 01 D-X PIC S99 VALUE IS 1. 01 D-Y PIC S99 VALUE IS 1. 01 I PIC 99 VALUE IS 0. PROCEDURE DIVISION. PERFORM VARYING I FROM 1 BY 1 UNTIL I IS GREATER THAN 50 COMPUTE X-POS EQUAL TO X-POS + D-X COMPUTE Y-POS EQUAL TO Y-POS + D-Y IF X-POS IS LESS THAN OR EQUAL TO 1 OR X-POS IS GREATER THAN OR EQUAL TO 20 THEN COMPUTE D-X EQUAL TO D-X * -1 END-IF IF Y-POS IS LESS THAN OR EQUAL TO 1 OR Y-POS IS GREATER THAN OR EQUAL TO 10 THEN COMPUTE D-Y EQUAL TO D-Y * -1 END-IF DISPLAY "Pos: " X-POS "," Y-POS " @" END-PERFORM. STOP RUN. COMSENITY
21. -13.2%
22. 1962 Simula • OOP a s a key to simul a te complex processes • Cl a sses a nd objects • Polymorphism • Inherit a nce • Coroutines bounce.sim ! Bouncing Character showing Classes in Simula 67 ; Begin Class Bouncer(x, y, dx, dy); Integer x, y, dx, dy; Begin Procedure Move; Begin x := x + dx; y := y + dy; If x <= 1 Or x >= 20 Then dx := -dx; If y <= 1 Or y >= 10 Then dy := -dy; End; End; Ref(Bouncer) b; Integer i; b :- New Bouncer(2, 2, 1, 1); For i := 1 Step 1 Until 50 Do Begin b.Move; ! Calling object method ; OutText("Pos: "); OutInt(b.x, 2); OutInt(b.y, 2); OutText(" @"); OutImage; End; End; COMSENITY
23. 1972 Smalltalk • Xerox PARC, Al a n K a y a nd Dyn a book • More th a n a l a ngu a ge • Pure OOP • Mess a ge p a ssing over methods COMSENITY Bounce.st "Bouncing Character in Pure OOP (Smalltalk-80 style)" | pos vel | pos := 2@2. "@ Creates Point objects" vel := 1@1. 50 timesRepeat: [ pos := pos + vel. (pos x <= 1 or: [pos x >= 20]) ifTrue: [vel := (vel x negated) @ vel y]. (pos y <= 1 or: [pos y >= 10]) ifTrue: [vel := vel x @ (vel y negated)]. Transcript show: 'Pos: ', pos printString, ' @'; cr. ].
24. Squeak
26. life ← {⊃1 ⍵ ∨.∧ 3 4 = +/ +/ ¯1 0 1 ∘.⊖ ¯1 0 1 ⌽¨ ⊂⍵} ! # $ % & ' ( ) * + , - . / 0 COMSENITY
27. COMSENITY hello.bf [ Hello World in Brainfuck ] ++++++++ [>++++[>++>+++>+++>+<<<<-] >+>+>->>+[<]<-] [ Initialize Tape ] >>.>---.+++++++..+++. [ Print 'Hello' ] >>.<-.<.+++.------.--------. [ Print ' World!' ]
28. COMSENITY bounce.i PLEASE NOTE Bouncing Character in INTERCAL DO ,1 <- #50 DO .1 <- #2 PLEASE NOTE Init X DO .2 <- #2 PLEASE NOTE Init Y PLEASE COME FROM (10) DO .1 <- .1 ~ #1 DO .2 <- .2 ~ #1 PLEASE READ OUT .1 PLEASE READ OUT .2 DO ,1 <- ,1 ~ #1 (10) PLEASE IGNORE ,1 PLEASE GIVE UP
29. COMSENITY hello.arnoldc IT'S SHOWTIME HEY CHRISTMAS TREE isReady YOU SET US UP 0 GET TO THE CHOPPER isReady HERE IS MY INVITATION 1 ENOUGH TALK TALK TO THE HAND "HELLO WORLD!" YOU HAVE BEEN TERMINATED
31. in Java New-Old Ideas • L a mbd a s a nd stre a ms • v a r keyword a nd type inference • Records, Se a led Cl a sses, P a ttern M a tching • Modules • Virtu a l Thre a ds COMSENITY -> LISP, Scheme, Sm a llt a lk, APL, H a skell -> ML, H a skell, Sc a l a , Kotlin -> ML, H a skell, Sc a l a , Kotlin -> Mes a , Modul a -2, Ad a , St a nd a rd ML -> Erl a ng, Go
32. TIOBE Index Source: tiobe.com/tiobe-index/
33. COMSENITY Source: devecosystem-2025.jetbr a ins.com/
34. Survival Instinct • Worse is Better • Ecosystem Gr a vity • The Tr a p of Pl a tform Lock-in • The Troj a n Horse Synt a x COMSENITY
35. Digital Tribalism and Language Wars • Self-ful f illing prophecy • S a pir–Whorf hypothesis • „Blub” p a r a dox • Sunk Cost F a ll a cy • Essenti a l vs Accident a l Complexity • CV-driven Development COMSENITY
36. Sad story about Java to Kotlin migration COMSENITY
37. What comes next? COMSENITY
38. COMSENITY
39. „Any problem in computer science can be solved with another layer of abstraction” COMSENITY
40. Levels of Abstraction • Level 0: Physic a l Wiring • Level 1: M a chine Code • Level 2: Assembly L a ngu a ge • Level 3: High-Level Imper a tive • Level 4: M a n a ged Runtimes • Level 5: Synt a ctic Ergonomics • Level 6: Stoch a stic Compilers
41. Brave New World • Intent Provider • We Are All Architects • Code Review a s the Prim a ry Job • Architecture a s Context
42. - Georg Wilhelm Friedrich Hegel „We learn from history that we learn nothing from history.” COMSENITY
43. Thank you
 for your attention. Contact piotr.laskawiec@comsenity.com Social Media @piotrlaskawiec @piotrlaskawiec.bsky.social COMSENITY LET'S CONNECT
44. 4Developers Warszawa, 22.04.2026 www.4developers.org.pl Oceń mój wykład w aplikacji Eventory Dziękuję Wejdź w agendę Kliknij w wybrany wykład Oceń i zostaw komentarz! JOIN US ON EVENTORY! #463540