Re:Things That Turbo Pascal Is Smaller Than (2011)
by hawkice on Sunday November 15, 2026 @09:14AM
(#50507082)
Given development speed is way up, I'd be interested to see what a from-basic-principles simple and efficient OS and programming system might look like.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by pocketarc on Sunday November 15, 2026 @10:10AM
(#50507458)
This is the thing - when the cost of iterating and grinding compiler warnings drops to virtually 0, what new paradigms might we invent to exploit that? Rust gives us an inkling of an idea of what might be possible, but that still predates LLMs and thus still makes concession for human ergonomics. What are structures, guardrails, and patterns, that our OSs, frameworks, and toolchains can put in place, which would result in whole classes of problems going away completely, at the expense of massively increased (but mechanical, and easily automatable with a prompt) developer effort?
Re:Things That Turbo Pascal Is Smaller Than (2011)
by drfloyd51 on Sunday November 15, 2026 @08:34PM
(#50512964)
I imagine a kind of language which is just a bunch of declarative statements about conditions and what should happen. Basically BDD. Maybe we will just write the “unit tests” in human and AI writes more comprehensive specification to fill in the blank and for us to modify. And then AI makes code that satisfies the spec.
I don’t believe that source code is a spec. Source code has real time manipulation a kind of temporal dependency. Specs are declarative.
The difference is a spec would say: adding two and three should equal five. Code says you have a variable give it the value two. Now add three to it. Return that value. Maybe a unit test to assert it returned 5.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by Isamu on Sunday November 15, 2026 @10:15AM
(#50507497)
>Fundamentally, many inefficiencies were justified for developer productivity, and I'm not sure that makes sense anymore
Having lived through this period, I would disagree, quite the opposite we tended to develop in C and assembly specifically for runtime efficiency because we had to.
For developer productivity you could opt for Lisp or SmallTalk or some such, which ran much slower until high quality compilers for these became available, and even then your target machine might only have a C compiler.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by SoftTalker on Sunday November 15, 2026 @11:32AM
(#50508224)
I read GP's comment differently, that we ended up where we are today (bloated languages, IDEs and runtimes) due to chasing developer productivity at all costs.
Now, developer productivity is becoming less important as developers are factored out entirely.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by hawkice on Sunday November 15, 2026 @12:02PM
(#50508511)
This was my intended meaning -- the clearest advocacy of this was from DHH about Ruby on Rails, although he's changed his mind about big questions lately and suspect he no longer endorses that set of trade-offs (I don't either, _sort of_ -- I think developer productivity means having simple ways to enable large-scale testing and oversight while minimizing context switching costs, although I think we are all figuring out what that means in practice).
Re:Things That Turbo Pascal Is Smaller Than (2011)
by LeFantome on Sunday November 15, 2026 @07:30PM
(#50512505)
We will end up with something that is easier for AI to write, efficient to execute, and possible for people to audit.
Rust is becoming popular as LLM output. The resulting code is very efficient. The compiler helps keep the LLM on track and holds it to a minimum level of quality. Humans can read it if they want to. But it is not great to read.
Python is also a popular target. Easy to audit. LOTS of training data. The “one way to do it” philosophy of Python helps. But the resulting code is not very efficient.
I think we will end up with a new language that balances all these things better.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by drfloyd51 on Sunday November 15, 2026 @08:27PM
(#50512924)
I don’t think we will. Well maybe for a bit. But I think eventually LLMs will produce a kind of byte-code or IL.
Maybe it will have human words inside of it to explain the parts.
Most of the way we organize code is to support our brains. Code reuse via classes and functions. Extensible patterns. Classes.
AI doesn’t need all that stuff. Consider, AI needs what assembly needs. And assembly doesn’t have any of those conveniences.
At some point AI will stop writing code for us to pretend we own and start writing it for itself. I am curious to see what conventions arise to support a programmer whose brain has infinite storage capacity and can figure out what existing code does without having to remember or read documentation.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by jiaaro on Sunday November 15, 2026 @10:12PM
(#50513591)
Not all of that abstraction is solely to help us understand. Much of it is to make iterating on the code over time simpler and more reliable: avoiding unintended side effects, for example.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by robotresearcher on Sunday November 15, 2026 @09:52PM
(#50513439)
I’ve done some work using Python for design iteration with me in the loop, followed by a hands-free reimplementation in C++ with byte-identical testing, then into another fully automated perf loop.
I’ll probably switch to Rust for the automated stages. I read C++ more easily, but maybe I don’t need to much longer.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by majormajor on Sunday November 15, 2026 @11:25PM
(#50514025)
Rust isn't my personal favorite for having agents drive development because the compile time penalties add up fast unless you stay on the agents with prompts/AGENTS.md/etc directives to really keep it from re-running full compile/test suites every iteration.
It can be the difference in a loop that an agent can crank on in Go for 15-30min while I get a coffee vs taking multiple hours in Rust, sometimes.
Anything agent-focused language/ecosystem wise needs to focus on small-blast-radius/fast-iteration.
(Unless/until there's a generational leap in the raw coding ability of these tools to be able to get it "right" (for larger-and-larger definitions of "right") the first time.)
Re:Things That Turbo Pascal Is Smaller Than (2011)
by robotresearcher on Sunday November 15, 2026 @09:45PM
(#50513405)
It’s a polyglot stack to the extreme these days. The dev lives in Claude Code, running TypeScript and JavaScript, and calling into servers likely written in Go and Rust, which call into Python running CUDA.
Dev is likely generating JavaScript, C++, Python, SQL for corporate work, or Kotlin and Swift for mobile.
It’s much more diverse than back in the 90s. Kinda fun.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by hedgehog on Sunday November 15, 2026 @01:26PM
(#50509336)
v8 is pretty complicated, and anything that depends on LLVM is going to be huge, so I think I would start smaller. You could try building around something like NuttX or an L4 + tcc or cproc and see what it takes to get to self-hosting as well as ability to do some job you care about. To me the bigger question is that last bit, you can shrink the platform code quite a lot relative to a typical Linux but what's the situation where that's a good trade vs say cross-compiling from a full C++ or Rust toolchain?
Re:Things That Turbo Pascal Is Smaller Than (2011)
by mike_hearn on Monday November 16, 2026 @04:27AM
(#50515667)
Ahhhhh this is a common misconception and it's dangerous. V8 is not a battle tested sandboxed execution environment, not unless by battle tested you mean battle wasted. V8 is full of sandbox escape vulnerabilities practically "by design", always has been, probably always will be - and the Chrome engineers knew this from the start which is why from day one they invested so heavily in kernel-level sandboxing.
But! Very important! The kernel sandbox is NOT A PART OF V8. It's not even reusable or modular, it's a hard coded part of Chrome's startup sequence and tuned for Chrome's exact needs. If you embed V8 via its API you don't get it.
I've seen this misconception several times now including in quite serious places, where people talk as if V8 on its own has a robust sandbox. It doesn't! This will blow up in people's faces eventually.
If you want a JS engine that's secure by design then the only one I know is GraalJS, as it's written in a memory safe language and uses partial evaluation to create its compiler so you can't get interpreter/JIT mismatches. It also has a proper sandboxing API and can transparently run code out of process. They're adding Landlock support to that now so it actually will get a built in kernel sandbox on Linux.
This issue vexes me enough that I wrote a whole article about it:
Re:Things That Turbo Pascal Is Smaller Than (2011)
by mikestew on Sunday November 15, 2026 @09:53AM
(#50507353)
“Obviously”. Look, if you don’t really know what a development environment is, that’s okay. But a dismissive comment such as this makes it obvious to the rest of us that you don’t know, when I’m confident that isn’t your goal.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by bell-cot on Sunday November 15, 2026 @09:55AM
(#50507369)
Well, yeah. Back in the mid-80's, software needed to be usable on a computer with a single 360KB floppy drive. (No HD, no SSD, no USB, no network, no ...) And even a big budget for RAM - which cost many orders of magnitude more than today - would really not get you around Bill Gates' 640KB DOS memory limit.
Comparing to current-day stuff is kinda like comparing battery-powered bathtub toys to jetskis.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by probably_wrong on Sunday November 15, 2026 @10:13AM
(#50507477)
Those "bathtub toys" built the entire modern infrastructure, parts of which are still chugging along. If anything, I'd put the onus on software developers - like John Carmack said in 2005, "there is something deeply wrong when text editing on a 3.6 ghz processor is anything but instantaneous".
Software in the 80s showed what's possible when you really care about doing it. Software in the last 15 years feels like an exercise on what happens when you don't.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by exe34 on Sunday November 15, 2026 @01:07PM
(#50509151)
I remember Windows 98, where it crashed every few hours and took everything with it, but while it worked, it never missed a keystroke or mouse press. I could type ahead and click where I knew the button would appear in 10 seconds and it still wouldn't lose anything. Nowadays you just finish typing out a thought and then realise half of it never turned up, because something else claimed the focus or whatever.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by MonkeyClub on Sunday November 15, 2026 @10:36AM
(#50507705)
Yet at the same time, one is a pastime for an affluent lifestyle while the other is driving the global economy. Interestingly, or ironically, the former was probably put on the shelves by means of the latter.
If there is any positive progress to be made, the rethinking necessary must go much, much deeper than the superficial flesh of the problem, but there it’s bound to hit upon the sinews and bones of vested interests.
In all, as I’m growing older and see the world trudge along the same lines it did centuries ago, I’m more and more pessimistic about the possibility of people agreeing that the sacrifices necessary will be made.
Short-term stakeholder interests seem to trump any notions of longer-term greater good.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by andsoitis on Sunday November 15, 2026 @10:13AM
(#50507476)
cool. can you drag & drop in files (e.g. screenshots, PDFs, video recordings, text files, etc.) for context when you work on features or bug fixes? Cursor is great at workflows like that.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by badsectoracula on Sunday November 15, 2026 @01:40PM
(#50509455)
Amusingly i also used Turbo Vision to make some agentic harness[0] :-P (though mine is meant to talk with llama-server via its OpenAI compatible endpoint since i'm using local models - the one in the shot is Gemma 4 E4B which i'm using for testing).
That said i never finished that and ended up making another one (using tvchat as a base since it had largely working communication and session management) that acts as a server/daemon inside the container is meant to run in the background and provides a web-based UI instead.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by jbellis on Sunday November 15, 2026 @10:17AM
(#50507510)
Anders Heljsberg GOAT. Turbo Pascal, Delphi, C#, TypeScript, just a phenomenal career marked with better taste than any other language designer I can think of, certainly any designer whose work is so mainstream.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by pjmlp on Sunday November 15, 2026 @01:57PM
(#50509599)
Nope, J++ was on the Microsoft JVM, whereas C# was on top of a full new runtime.
However the language extensions that were the reason for the lawsuit did indeed transition from J++ into C#, with J# being J++ on top of .NET for easing code porting.
The features were events, J/Direct (later P/Invoke on .NET), COM interop (later RCW/CCW on .NET), and Windows Foundation Classes (later Windows Forms on .NET).
Re:Things That Turbo Pascal Is Smaller Than (2011)
by sroerick on Sunday November 15, 2026 @11:05AM
(#50507985)
Why did Pascal basically die completely? It seems like a hugely influential language and was very loved, but there are plenty of other languages which still seem to have a lot of legacy code. Where is Pascal?
Re:Things That Turbo Pascal Is Smaller Than (2011)
by coliveira on Sunday November 15, 2026 @11:13AM
(#50508049)
The main problem with Pascal was not having a standard at a time when having a standard was important for adoption. There were several successful implementations like Borland's, and the version used in the Macintosh, but being closed products they never talked to each other.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by twoodfin on Sunday November 15, 2026 @12:45PM
(#50508945)
Not just having a standard but being able to collectively evolve a standard.
In the absence of that, Pascal’s creators and commercializers invented follow-on languages, including the most successful thread via Hejlsberg as we’re discussing here: Object Pascal -> Delphi -> C#/.NET—with a brief detour to J++, which I don’t know enough about to understand if it belongs in this sequence.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by pjmlp on Sunday November 15, 2026 @01:19PM
(#50509279)
Outside Borland and Apple, people tend to forget that already in 1976, Niklaus Wirth came up with Modula-2, exactly to fix all the shortcomings from a language originally designed for teaching, with one properly designed for systems programing from the start.
As for your sequence, from someone that was around back then, .NET and C++ only exist as you know it thanks to Sun's lawsuit regarding Java language and runtime extensions introduced in J++.
Then an internal research language originally named Cool, became C#, the language extensions in J++ were made into C# features (events, J/Direct, COM interop), Windows Foundation Classes became Windows Forms, and J# was released in .NET 1.0 as transiton technology.
Had it not been for the lawsuit, Ext-VOS (.NET codename) would have been released with J++ instead.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by pjmlp on Monday November 16, 2026 @05:13AM
(#50515956)
Sure, but the point was about how everyone complains about the original Pascal, and the related dialects to fix its shortcomings, while ignoring that shortly thereafter its creator solved all of them, by designed another programming language actually targeted to large scale software development and systems programming from the start.
Given Niklaus Wirth pursue for minimalist systems programming design since Oberon, I doubt he was a big fan of Ada83, let alone Ada2022.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by pjmlp on Sunday November 15, 2026 @01:12PM
(#50509210)
It certainly had a standard, two actually, however no one cared because Turbo Pascal was more relevant, and Modula-2 was designed to fix Pascal's shortcomings, which also has a ISO standard.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by camtarn on Sunday November 15, 2026 @07:26PM
(#50512479)
IEC61131 Structured Text, used to program PLCs and other industrial automation systems, is also based on Pascal. Very niche, but definitely still alive.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by anthk on Sunday November 15, 2026 @11:17AM
(#50508082)
Free Pascal/Lazarus it's rocking nice tools such as Peazip and other stuff like Carte Du Ciel and some RAD tools in the enterprise. On the niche geeky world, there's T3X at https://t3x.org which is semi-Pascal like.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by phba on Sunday November 15, 2026 @03:31PM
(#50510390)
Not sure if you are being sarcastic. Pascal strings are first class citizens, so it's trivial to add null-termination. Delphi actually does this to allow typecasting.
C, for example, doesn't have strings. It has pointers to memory that might contain characters and, if you are lucky and the stars are aligned, a zero to mark the end. I'll never understand how C strings were accepted as a string representation and not the mad source of bugs and insanity that they are.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by tzot on Sunday November 15, 2026 @04:05PM
(#50510745)
> I'll never understand how C strings were accepted as a string representation
1972 was definitely not a good year for C standardization bodies. I blame that guy Ritchie and his audacity to hack a language on a whim. Even his GitHub page is empty (or misattributed).
Re:Things That Turbo Pascal Is Smaller Than (2011)
by regularfry on Sunday November 15, 2026 @12:54PM
(#50509031)
In a way it didn't, the Lazarus project is the current most well-known incarnation. But that itself tells a story: it's for desktop applications, mainly. It never really had a "here's how you do a web app" story around it. Really it could have been go-lang before go-lang and I'm not sure why it wasn't other than that it wouldn't have been controllable by the folks at Google.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by kragen on Sunday November 15, 2026 @05:43PM
(#50511663)
Not in 02002. In 02002 your JS devtools were that the browser crashed when you had a bug in your JS, so you would have to binary-search your recent changes to figure out which line of JS was crashing it, and you could evaluate expressions by typing javascript:(void)alert(f()) in the URL bar. No browser console, no web inspector, and the only portable DOM was image rollovers and form field values. If you wanted to generate document content in JS the only way that was portable to Netscape Navigator 4 was document.write().
I think we didn't even have bookmarklets at that point—the browsers supported them, but we didn't know that.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by regularfry on Sunday November 15, 2026 @06:59PM
(#50512263)
Yes, but I'd say that Lazarus is the standard bearer for Pascal the way Delphi was back in the day. It would be the reason someone would pick up the language a lot of the time.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by drfloyd51 on Sunday November 15, 2026 @08:41PM
(#50513011)
Php stupidly easy to write something half-assed. Incredibly difficult to write something correct.
I am going to swipe at most dynamic type-unsafe languages: most developers think they are easy to write. And they are compared to type-safe. But the overall difficulty of actually maintaining a project over time and over a revolving door of coders far exceeds the difficulty of using a type-safe language to begin with.
The compiler is your friend. All the compile time error messages are runtime errors you don’t have to look for.
I get why PHP was adopted. A bunch of new coders on the web reaching for an “easy tool”. Not experienced enough to feel the slow encroachment of suck embracing them. It’s really kind of sad. We could have had better languages. Pascal in both the back and front end.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by marcle on Monday November 16, 2026 @04:57AM
(#50515853)
I recently ported an old Delphi application to Lazarus (https://github.com/mclements/prevent). As my first experience with Delphi and Pascal, I was impressed with the smooth development experience (expected), the comparative richness of the libraries (unexpected), and the speed of the application (expected).
For a historical perspective, the original Delphi code was written by Jan Barendregt. After his death, I was the only person to have his source code -- where most of the comments are in Dutch:).
Re:Things That Turbo Pascal Is Smaller Than (2011)
by pjmlp on Sunday November 15, 2026 @01:10PM
(#50509188)
It didn't, despite all its management failures, several companies are still buying into Delphi (Object Pascal evolved from Turbo Pascal/Apple's Object Pascal), and there is at least an yearly conference in Germany.
For reference, ZX-Spectrum has 48Kb of RAM out of which 8Kb is video memory, so unusable.
Then you have to load the Pascal compiler into the remaining 40k of RAM. Allocate some RAM for stack and environment variables for the editor where you write your program, plus space for the actual program. Then compile your program into the same 40k of space. And run it, using heap and stack memory from which memory space? You guessed right, same 40k.
To recap, on 40k of RAM you had back then:
- The Pascal compiler
- The Pascal source code in text form
- The Pascal executable form in machine code
- The Pascal data/memory. Of which, recently in a "tech demo" of automated tests, one colleague said "unfortunately we only have a very limited amount of RAM to be able to do basically anything [that's why the product is a mess with no tests]. Only 32Gb per machine".
One of my first programs was a Tetris clone, because ZX-Spectrum BASIC was slow as molasses. All on top of only having tape for storage so if I fucked up a pointer (I don't think Pascal had the concept of access violation back then but I sure discovered it on my own skin), it would take 5 minutes to load the Pascal compiler + some backup copy of my Tetris game, hopefully not from a month ago and hopefully I remember what I changed. Lots to discover and have "fun" with.
About a year later I did find a compiler for BASIC and it turned the unplayable BASIC code for Tetris I wrote in the 9th grade into a totally playable Tetris game, without the need to learn another language and paradigm (pointers!) but the damage was done. Ignoring a year of databases, in 12th grade of computer science class, I got introduced to C and from then on, here I am, 30 years later, doing C++ in finance for an S&P 500 company.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by TacticalCoder on Sunday November 15, 2026 @04:44PM
(#50511150)
> Why did Pascal basically die completely?
It morphed into Delphi. The reason that it's not that successful anymore is that it was deeply tied to Windows (even if there were half-arsed Macintosh ports).
And then the Internet taking off happened.
And suddenly you had gigantic companies built on PHP/JavaScript/Linux (like Facebook), on open-source software (Google) and Pascal/Delphi got also attacked by actually portable stuff, like Java, which some of today's biggest companies were built on (like Amazon).
So on one hand Linux and it's myriad of open-source languages and on the other hand Java (which is what it is but it is portable) and then JavaScript in the browser.
Nowadays tens of billions of devices, including many servers powering the entire world, are running Linux. While Pascal/Delphi was that language you'd run on DOS and half-arsedly ported to Windows: not a winning proposition.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by atombender on Sunday November 15, 2026 @06:48PM
(#50512159)
ObjectPascal's downward spiral was tied to Borland's. When Borland started to struggle, there weren't any other implementations — Borland's was the only viable one.
Evne in its heyday, Borland's Pascal-based products were not that big in the developer tools market. Delphi was a huge hit in Europe, but in the US, they were dwarfed by Microsoft. So Pascal's influence is a bit like that Brian Eno saying (paraphrasing): “Only 30,000 people bought the first Velvet Underground album, but everyone who bought it started a band.”
Part of Borland's fall was betting too much on client/server database stuff at a time when the web was happening. They renamed themselves Inprise and marketed a suite of technologies called MIDAS which nobody remembers anymore. You used Delphi to build database GUIs on top of MIDAS and, say, Oracle. I don't know what they were thinking. They also did a Linux version of Delphi called Kylix which was just using Wine (!).
Even so, I suspect ObjectPascal would have failed eventually. A language tied to a GUI toolkit, without a standard spec, or a cross-platform open source implementation, just couldn't last forever.
I held onto Delphi far after it was evident that it was a dying language. I actually did a ton of my work in the 1990s and early 2000s doing non-GUI stuff in Delphi, including web backends and commercial games, which I suspect was not that common. ObjectPascal actually worked wonderfully as a server-side language. It was a strict, statically typed language, it had modern constructs like classes and threads, it was natively compiled, very fast, had a terrific interactive debugger. In many ways a perfectly fine alternative to C++ at the time, including for game development — I made my own bindings for DirectDraw, DirectSound, and so on.
At the time — say, around 2000 — I didn't find the alternatives compelling. Java was dead slow and didn't offer anything language-wise. Languages like Python were also slow and were not type-safe. But there came a point when Linux had just taken over, and ObjectPascal wasn't a viable option anymore.
Today, the closest thing in spirit to the ObjectPascal language isn't C#, I think, but Go.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by pjmlp on Monday November 16, 2026 @02:50AM
(#50515123)
It really isn't Go, it isn't even as half as rich as Turbo Pascal 7 abilities, let alone everything else Delphi added on top.
They refuse to even have Pascal like enumerations, rather pushing that stupid iota/const boilerplate without any of the nice features that Pascal enumerations had in 1970's.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by atombender on Monday November 16, 2026 @06:21AM
(#50516345)
In spirit, not in abilities. I think Go inherits many of the qualities of ObjectPascal:
• Extremely fast compilation (even if at the cost of throwing away generations of optimizations)
• Strict, somewhat impoverished type system
• Simple but pragmatic module system (Go has packages, OP has units)
• High focus on integrated tooling (e.g. built-in assembler/linker)
• Safe strings and dynamic arrays built into language
• Built-in reflection and a runtime that often makes use of it
I would argue that if you gave ObjectPascal a C-ish syntax and added built-in concurrency and GC, it would look and feel more like Go than anything else.
Yes, OP has enums and ranges and Java-style interfaces, but those are minor details.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by pjmlp on Monday November 16, 2026 @06:40AM
(#50516482)
Object Pascal at the time Apple created it as evolution from Clascal, not as when Borlad took it up.
> Extremely fast compilation...
> Safe strings and dynamic arrays built into language
Even Lisp and PL/I have these ones, we really lost focus with C's adoption.
> I would argue that if you gave ObjectPascal a C-ish syntax and added built-in concurrency and GC, it would look and feel more like Go than anything else.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by pjmlp on Monday November 16, 2026 @07:51AM
(#50517073)
Lisp surely is compiled, since the early 1970's.
I have used all Borland products starting with Turbo BASIC 1.0, moving into Turbo Pascal 3.0 and then all TP versions, Turbo C++ 1.0 all the way up to the last Turbo C++ for Windows 3.1 version.
Delphi up to Delphi 5, and the accompanying C++ Builder releases.
Go is really nothing like Object Pascal, nor in features, nor in spirit.
It is a mix of Limbo with Oberon-2 method syntax, from UNIX folks that were always quite against Pascal, none of the authors is fond of Object Pascal, and it shows.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by atombender on Monday November 16, 2026 @08:16AM
(#50517302)
Again, "in spirit". Go and ObjectPascal are both a pragmatic, engineering-focused, imperative/procedural, strict, simplistic, statically typed languages with mutability and no memory safety — the differences are superficial, and the philosophies are very close. There is a huge conceptual and philosophical distance between them and, say, Lisp or PL/I or indeed C++.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by kristianp on Sunday November 15, 2026 @08:28PM
(#50512934)
From about 1992 C and C++ became hugely popular. Microsoft was promoting their C/C++ compiler for example. In '92, MFC was available for Windows 3.1. Apple got on C/C++ the bandwagon too. Not sure of the timing, but the Mac was originally a Pascal development environment, with the toolbox in assembly.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by nl on Monday November 16, 2026 @03:47AM
(#50515443)
In the 80s Pascal was a serious competitor to C for systems programming as well as applications. Large amounts of the original Mac Finder were in Pascal for example.
The lack of a good web platform has been mentioned but also there wasn't really any Unix heritage and on Windows the .NET platform and C# killed the advantages Delphi had over Visual Basic 6.
I was a Delphi developer for a bit and most of us moved to Java if we wanted to stay if Microsoft platforms.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by gmueckl on Sunday November 15, 2026 @12:35PM
(#50508856)
Is it such a stupid comparison? It's an absolutely trivial amount of data now, but back in the 80s, a few files of that size would fill out a floppy disk. It's also a source file - the input to a compiler.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by Timwi on Monday November 16, 2026 @03:57AM
(#50515504)
I think the issue isn't with the comparison itself, but with the conclusion drawn. Pascal compiler is smaller than `touch`, therefore Pascal compiler was amazingly efficient and `touch` is super bloated.
I think a better conclusion is that the Pascal compiler was very limited and modern `touch` is very feature-rich (many comments in this thread have explained how) and it shows that we've come a long way.
If you actually used that Pascal compiler from the 80s, you'd immediately notice the limitations.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by t43562 on Monday November 16, 2026 @04:19AM
(#50515613)
Turbo pascal was incredibly impactful - it gave lots of people like me an efficient compiler in an IDE with a superb graphics library (BGI) and superb compile speeds and one didn't need to swap floppy disks to compile. It was an amazing learning tool.
Touch, on my 1980s computer, would have been seen as a caricature. It would have been a 200 byte .com file back then, if that. The comparison is about what you can do with what you have if you have no other choice, and how plentiful resources don't automatically create empowering outcomes.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by jll29 on Sunday November 15, 2026 @12:06PM
(#50508542)
While some comparisons may look silly, the fact that the touch command's binary should exceed Turbo Pascal is insane: the command basically creates an empty file or updates the file change date if the file already exists, not more.
There's no reason (other than laziness) why that should take more than 2k.
On the other hand, a lot of boilerplace code is repeated in each and every command. When I first learned as a kid about UNIX commands being ordinary programs, I was intrigued (there is nothing "special" about them, you can also write your own!) but also shocked about the overhead compared to an architecture in which e.g. the shell contained all (at least core) commands compiled into a single binary, which could share all the error handing, startup code, command line parsing code and so on.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by teiferer on Sunday November 15, 2026 @12:29PM
(#50508786)
Agree with everything you wrote, but if you go look for bloat on your storage device, the last thing that will be of any significance is that overhead.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by zahlman on Sunday November 15, 2026 @12:29PM
(#50508795)
> the command basically creates an empty file or updates the file change date if the file already exists, not more.
GNU coreutils touch does a lot more than that. My local copy is about 95k; it allows for choosing from multiple different timestamps to update; suppressing the (default) creation of an empty file if it doesn't already exist; operating on symlinks directly rather than following them (if the system supports it); specifying a custom timestamp rather than "now" (including by parsing a date string), and of course outputting a help message and a version.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by regularfry on Sunday November 15, 2026 @12:50PM
(#50508994)
I was going to suggest that even that logic wouldn't account for a binary size three times the RAM of my first machine, but from the man page:
> DATE STRING
> The --date=STRING is a mostly free format human readable date string such as "Sun, 29 Feb 2004 16:21:42 -0800" or "2004-02-29 16:21:42" or even "next Thursday". A date string may contain items indicating calendar date, time of day, time zone, day of week, relative time, relative date, and numbers. An empty string indicates the beginning of the day. The date string format is more complex than is easily documented here but is fully described in the info documentation.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by Joker_vD on Sunday November 15, 2026 @02:19PM
(#50509778)
You'd think they'd put this bullshit inside some .so where it could be reused by all other coreutils; but no, it's re-included in every GNU tool that deals with parsing dates.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by Joker_vD on Sunday November 15, 2026 @02:55PM
(#50510090)
Yes, it can be. You can run `strings "$(command -v touch)"` yourself and then compare the output with the strings in parse-datetime.y [0]. Look for e.g. "FORTNIGHT", "sixth", and "error: parsing failed, stopped at '%s'", they're all inside the touch's executable.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by collinfunk on Sunday November 15, 2026 @04:56PM
(#50511256)
It is correct. But only 'date' and 'touch' use it, so I am not sure how much benefit there is in making it a shared library.
If size is really a concern, we have supported building a single 'coreutils' binary since 2014, which will be more effective in saving disk space. It can be done with './configure --enable-single-binary'.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by Joker_vD on Sunday November 15, 2026 @05:28PM
(#50511529)
> But only 'date' and 'touch' use it, so I am not sure how much benefit there is in making it a shared library.
There is also the rest of the whole "gnulib" folder inside the coreutils repo. Yes, I know that Gnulib explicitly states in the docs that it's a source code library but it doesn't bother to explain why exactly it chose to be that instead of being a .so à la glibc (beyond some rather unrelated "but supply chain attacks!" segment in the docs — if I cared about that, I'd statically link the relevant parts of glibc as well, in fact, that would be a much higher priority).
Re:Things That Turbo Pascal Is Smaller Than (2011)
by collinfunk on Sunday November 15, 2026 @06:48PM
(#50512161)
Read section 2.2 [1]. Each package that uses Gnulib maintains a list of modules that its program(s) requires. I.e., each package has a different library built as libgnu.a.
Gnulib also doesn't make API stability guarantees like shared libraries do. If a distribution installs Gnulib as a shared (or even static) library, and then links programs to that instead of the vendored sources, they will likely end up with broken programs.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by Joker_vD on Sunday November 15, 2026 @09:14PM
(#50513210)
Yeah, I've read the section of 2.2 in its entirety — nothing you said in your comment is in it.
Also, "Gnulib doesn't make API stability guarantees like shared libraries do" — a) do you mean ABI? b) why not? The gnulib seems like something that's perfectly suited to be a shared library, even more so than the glibc, since it's not a language runtime.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by Joker_vD on Sunday November 15, 2026 @09:30PM
(#50513306)
Well, guess we have to be grateful that Ulrich Drepper never really got around to mess with gnulib, unlike he did with glibc.
And the .so dependency hell is real. You try to build some older version of a certain language runtime, it complains that your libssl/libcrypt lacks the functions it needs (those functions were in 1.0.1f, but 1.0.1k dropped them because that's how semver works), and of course your distro doesn't have the older version of libcrypt packaged for it so you take the package from the previous version of your distro, and it complains that your libc is too new and segfaults. Well, you sure as hell ain't rolling your system's libc to an older version so you try to rebuild libcrypt from the source, but the build with default config/flags still doesn't satisfy this certain language runtime and oh my god why am I even wasting my time on this, "docker pull certain-language:ancient" it is. Yeah, sure, this image has essentially Ubuntu 14.04 inside of it but at this point IDGAF. Why can the same 6.16 kernel run the user space both from today and from ten years before it, but the userspace from today can't run the program from eight years ago?
Re:Things That Turbo Pascal Is Smaller Than (2011)
by unnah on Monday November 16, 2026 @03:25AM
(#50515307)
I would hope that the date formats parsed by GNU touch would still be at a lower level of complexity than the dialect of Pascal supported by Turbo Pascal... but you never know until someone checks.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by II2II on Sunday November 15, 2026 @03:32PM
(#50510410)
And how much of that feature-rich version touch is actual executable code?
I did a quick estimate by disassembling touch with objdump on macOS (163 kB executable), and it was approximately 6 kB (1500 instructions * 4 bytes/instruction). There is a lot more to an executable than executable code.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by agumonkey on Sunday November 15, 2026 @02:42PM
(#50509975)
I'd love to have a graph of gnu [core]utils growth over time. IIRC in Unix days, these simple utils were simple.. until they had to support various flags, and various hosts ..
Re:Things That Turbo Pascal Is Smaller Than (2011)
by raddan on Sunday November 15, 2026 @03:33PM
(#50510415)
If you run `strace` you can get a hint at why `touch` (and any modern, compiled C binary) might be big: it is doing way more than you think it does, and you definitely _want_ a lot of that. For example, any program that uses the C standard library needs to have that code available-- since virtually every C program is going to use it, it will be loaded and mmap'ped into some region of memory. The stack needs to be set up, memory protection bits will be set, a random value is read to be used as a stack canary, etc, etc. I count on the order of 50+ system calls.
Watching `mv` do its thing is even better. About 100 system calls, including playing nice with SELinux in case it happens to be installed, just to issue a single `renameat2` system call.
Don't forget that we're running on a 64-bit machine. MS-DOS in 1986 was a 16-bit machine? The word size on a modern machine is bigger because we have a bigger address space, more registers, and more instructions.
We want speed and security and convenience and pleasant error messages. All of this is put here by the compiler to ensure that we have nice things. It sounds awesome to have such a small Pascal compiler, and it makes the modern state of binaries seem bloated, but all those extra bytes are paying for things that we want. There's probably a little bloat, but really, there is not much bloat.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by zvmaz on Sunday November 15, 2026 @04:43PM
(#50511124)
> There's no reason (other than laziness) why that should take more than 2k.
I presume you know some of the intricacies of coreutils or the touch program. I'll probably go and donate to whomever receives donations for coreutils; it's the least I can do: Show some respect to the developers of these free and open source tools.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by mitxela on Sunday November 15, 2026 @07:43PM
(#50512611)
The minimum size for a program is about 20k due to page alignment and sections. That's one page each for text, data, bss, rodata, and file headers that don't get loaded into memory at all.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by pron on Sunday November 15, 2026 @07:57PM
(#50512728)
By "laziness", do you mean cost? Because there's been a ~30,000x inflation in RAM between 1986 and today, and what's silly is to ignore that 1GB of RAM has about the same impact on the machine as 20kB in 1986. Software back then (and even a decade later) was significantly more bloated than the "lazy" programs of today.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by lelanthran on Monday November 16, 2026 @02:33AM
(#50515033)
> There's no reason (other than laziness) why that should take more than 2k.
Well...
$ touch --help | wc -c
1580
Just the text for the help message compiled into `touch` is over 1.5kB.
It's not just laziness, it's also what the program needs to do, like (for example) print out all the options it supports (1.5kB), then parse those options, execute a different code path depending on what the user wants to do, etc.
If all you want to do is update the date or create a new empty file, I can write a very short program that does that, although the minimum program in C is around 16kB (hello world), so that's the minimum overhead needed to have a C program loaded by Linux.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by lukaslalinsky on Sunday November 15, 2026 @12:08PM
(#50508565)
What I remember the most fondly about Turbo Pascal was its integrated help. It was such a great resource, both the ease of use, but also the contents. I always missed that when I later moved to C on Linux and had to work with man pages.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by tetha on Sunday November 15, 2026 @12:44PM
(#50508941)
It's always an interesting thought that I had meetings about the log aggregation dropping stack traces that would take ~3 3.5" floppies to store. Each.
Zabbix also confuses operators at this point. I recently had to increase a cache. I chose to go from a solid 4MB to a luxurious 256MB.
I know high-performance Java, so just a little jab there, but you don't size JVM parameters like that, except maybe code caches. And before Rust comes in, we also have a Rust application running without good resource control and it wouldn't like those resource constraints.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by oldjohnnylane on Sunday November 15, 2026 @12:52PM
(#50509009)
The wall of defensive, hostile replies to this simple post is expected. Today’s programmers need to feel like they are an elite class above the rabble and programming is their identity. When someone shows them an example of what talented programming really looks like, they have to pile on and dismiss it from a thousand cuts. The guy who wrote Pascal understood the system top to bottom, and understood computer science. There are maybe a few thousand programmers alive today with that kind of skill, and it hurts the egos of the average HN typescript scrum jockey to see something they just don’t comprehend so they lash out at it.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by pron on Sunday November 15, 2026 @07:55PM
(#50512710)
Just keep in mind that the amount of RAM in an average PC in 1986 was about 30,000x smaller than the average amount of RAM in today's laptops, so Turbo Pascal actually consumed much more of the machine's resources than a lot of today's software.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by mbfg on Monday November 16, 2026 @03:24AM
(#50515295)
A much greater proportion of code written in 80s/90s was single user/run-and-done applications, not applications that stood up for weeks or months, used by thousands/millions of people. I believe much of the "bloat" came about because building robust memory stable systems is hard and relying on 3rd party libraries to do so was the rational choice for most.
Re:Things That Turbo Pascal Is Smaller Than (2011)
by t43562 on Monday November 16, 2026 @04:30AM
(#50515681)
There were memory safe operating systems at the time which could probably have worked once the 286/386 were out.
Everything was about compatibility - that's really why we were stuck with int 21 and almost no other help from the OS to insulate us from the hardware. There wasn't a standard C library with millions of features - or anything else - that could add overhead to hello world.
Every program had its own drivers - everything was optimised for that use case and not some general set of cases.
The next few years are going to be fun.
I don’t believe that source code is a spec. Source code has real time manipulation a kind of temporal dependency. Specs are declarative.
The difference is a spec would say: adding two and three should equal five. Code says you have a variable give it the value two. Now add three to it. Return that value. Maybe a unit test to assert it returned 5.
Having lived through this period, I would disagree, quite the opposite we tended to develop in C and assembly specifically for runtime efficiency because we had to.
For developer productivity you could opt for Lisp or SmallTalk or some such, which ran much slower until high quality compilers for these became available, and even then your target machine might only have a C compiler.
Now, developer productivity is becoming less important as developers are factored out entirely.
Rust is becoming popular as LLM output. The resulting code is very efficient. The compiler helps keep the LLM on track and holds it to a minimum level of quality. Humans can read it if they want to. But it is not great to read.
Python is also a popular target. Easy to audit. LOTS of training data. The “one way to do it” philosophy of Python helps. But the resulting code is not very efficient.
I think we will end up with a new language that balances all these things better.
Maybe it will have human words inside of it to explain the parts.
Most of the way we organize code is to support our brains. Code reuse via classes and functions. Extensible patterns. Classes.
AI doesn’t need all that stuff. Consider, AI needs what assembly needs. And assembly doesn’t have any of those conveniences.
At some point AI will stop writing code for us to pretend we own and start writing it for itself. I am curious to see what conventions arise to support a programmer whose brain has infinite storage capacity and can figure out what existing code does without having to remember or read documentation.
Already when coding on cloud environments like Workato and Boomi there is no code output to look at.
I’ll probably switch to Rust for the automated stages. I read C++ more easily, but maybe I don’t need to much longer.
It can be the difference in a loop that an agent can crank on in Go for 15-30min while I get a coffee vs taking multiple hours in Rust, sometimes.
Anything agent-focused language/ecosystem wise needs to focus on small-blast-radius/fast-iteration.
(Unless/until there's a generational leap in the raw coding ability of these tools to be able to get it "right" (for larger-and-larger definitions of "right") the first time.)
Dev is likely generating JavaScript, C++, Python, SQL for corporate work, or Kotlin and Swift for mobile.
It’s much more diverse than back in the 90s. Kinda fun.
It's the lack of clear abstraction boundaries that causes decreased developer productivity.
A code generator will not save you from Conway's law.
UNIX. Seriously. Look at what it could do with 1970s era hardware, that was unmatched even when DOS came out in the early 80s.
During the 1970's, VAX/VMS and Xerox PARC workstation OSes, ML, CLU, were more inspiring for 1970's hardware capabilities.
But! Very important! The kernel sandbox is NOT A PART OF V8. It's not even reusable or modular, it's a hard coded part of Chrome's startup sequence and tuned for Chrome's exact needs. If you embed V8 via its API you don't get it.
I've seen this misconception several times now including in quite serious places, where people talk as if V8 on its own has a robust sandbox. It doesn't! This will blow up in people's faces eventually.
If you want a JS engine that's secure by design then the only one I know is GraalJS, as it's written in a memory safe language and uses partial evaluation to create its compiler so you can't get interpreter/JIT mismatches. It also has a proper sandboxing API and can transparently run code out of process. They're adding Landlock support to that now so it actually will get a built in kernel sandbox on Linux.
This issue vexes me enough that I wrote a whole article about it:
https://medium.com/graalvm/writing-truly-memory-safe-jit-com...
Their comment was entirely on brand.
Comparing to current-day stuff is kinda like comparing battery-powered bathtub toys to jetskis.
Software in the 80s showed what's possible when you really care about doing it. Software in the last 15 years feels like an exercise on what happens when you don't.
If there is any positive progress to be made, the rethinking necessary must go much, much deeper than the superficial flesh of the problem, but there it’s bound to hit upon the sinews and bones of vested interests.
In all, as I’m growing older and see the world trudge along the same lines it did centuries ago, I’m more and more pessimistic about the possibility of people agreeing that the sacrifices necessary will be made.
Short-term stakeholder interests seem to trump any notions of longer-term greater good.
which one is the former and which one is the latter?
IBM’s 640 KB limit, to be fair.
https://www.xtof.info/the-640k-memory-limit-of-ms-dos.html
https://github.com/runvnc/tvclaude
That said i never finished that and ended up making another one (using tvchat as a base since it had largely working communication and session management) that acts as a server/daemon inside the container is meant to run in the background and provides a web-based UI instead.
http://runtimeterror.com/pages/iv/images/25b1d4b43bb3467e392...
However the language extensions that were the reason for the lawsuit did indeed transition from J++ into C#, with J# being J++ on top of .NET for easing code porting.
The features were events, J/Direct (later P/Invoke on .NET), COM interop (later RCW/CCW on .NET), and Windows Foundation Classes (later Windows Forms on .NET).
In the absence of that, Pascal’s creators and commercializers invented follow-on languages, including the most successful thread via Hejlsberg as we’re discussing here: Object Pascal -> Delphi -> C#/.NET—with a brief detour to J++, which I don’t know enough about to understand if it belongs in this sequence.
As for your sequence, from someone that was around back then, .NET and C++ only exist as you know it thanks to Sun's lawsuit regarding Java language and runtime extensions introduced in J++.
Then an internal research language originally named Cool, became C#, the language extensions in J++ were made into C# features (events, J/Direct, COM interop), Windows Foundation Classes became Windows Forms, and J# was released in .NET 1.0 as transiton technology.
Had it not been for the lawsuit, Ext-VOS (.NET codename) would have been released with J++ instead.
https://web.archive.org/web/20190111203733/https://blogs.msd...
Follow the linked paper for Ext-VOS, aka COM+ Runtime, aka .NET.
Microsoft would revisit this COM+ Runtime a decade later with WinRT,
https://arstechnica.com/features/2012/10/windows-8-and-winrt...
Can’t wait to read the VOS paper.
Not Pascal but it comes from that tree.
Given Niklaus Wirth pursue for minimalist systems programming design since Oberon, I doubt he was a big fan of Ada83, let alone Ada2022.
So it wasn't for lack of standard per se.
Though Borland had some commercial success, I remember Pascal mainly as a teaching language.
Ada also was widely used in aerospace/military applications, though not sure it's still used for anything new today.
C, for example, doesn't have strings. It has pointers to memory that might contain characters and, if you are lucky and the stars are aligned, a zero to mark the end. I'll never understand how C strings were accepted as a string representation and not the mad source of bugs and insanity that they are.
1972 was definitely not a good year for C standardization bodies. I blame that guy Ritchie and his audacity to hack a language on a whim. Even his GitHub page is empty (or misattributed).
UNIX and C would never had taken off as they did, had they been sold just like VAX/VMS or MVS.
I think we didn't even have bookmarklets at that point—the browsers supported them, but we didn't know that.
Hem hem,
https://www.freepascal.org/
It's still called RoR though.
I am going to swipe at most dynamic type-unsafe languages: most developers think they are easy to write. And they are compared to type-safe. But the overall difficulty of actually maintaining a project over time and over a revolving door of coders far exceeds the difficulty of using a type-safe language to begin with.
The compiler is your friend. All the compile time error messages are runtime errors you don’t have to look for.
I get why PHP was adopted. A bunch of new coders on the web reaching for an “easy tool”. Not experienced enough to feel the slow encroachment of suck embracing them. It’s really kind of sad. We could have had better languages. Pascal in both the back and front end.
For a historical perspective, the original Delphi code was written by Jan Barendregt. After his death, I was the only person to have his source code -- where most of the comments are in Dutch:).
https://entwickler-konferenz.de/en
Then there is still FreePascal, Mikroe Pascal and RemObjects Pascal to chose from.
And now also Micron, which re-added Pascal features to Oberon (https://github.com/rochus-keller/micron/).
The project is rather cool.
Here's a page from the book I was reading in 1993: https://imgur.com/a/7UWdGgS
For reference, ZX-Spectrum has 48Kb of RAM out of which 8Kb is video memory, so unusable.
Then you have to load the Pascal compiler into the remaining 40k of RAM. Allocate some RAM for stack and environment variables for the editor where you write your program, plus space for the actual program. Then compile your program into the same 40k of space. And run it, using heap and stack memory from which memory space? You guessed right, same 40k.
To recap, on 40k of RAM you had back then: - The Pascal compiler - The Pascal source code in text form - The Pascal executable form in machine code - The Pascal data/memory. Of which, recently in a "tech demo" of automated tests, one colleague said "unfortunately we only have a very limited amount of RAM to be able to do basically anything [that's why the product is a mess with no tests]. Only 32Gb per machine".
One of my first programs was a Tetris clone, because ZX-Spectrum BASIC was slow as molasses. All on top of only having tape for storage so if I fucked up a pointer (I don't think Pascal had the concept of access violation back then but I sure discovered it on my own skin), it would take 5 minutes to load the Pascal compiler + some backup copy of my Tetris game, hopefully not from a month ago and hopefully I remember what I changed. Lots to discover and have "fun" with.
About a year later I did find a compiler for BASIC and it turned the unplayable BASIC code for Tetris I wrote in the 9th grade into a totally playable Tetris game, without the need to learn another language and paradigm (pointers!) but the damage was done. Ignoring a year of databases, in 12th grade of computer science class, I got introduced to C and from then on, here I am, 30 years later, doing C++ in finance for an S&P 500 company.
It morphed into Delphi. The reason that it's not that successful anymore is that it was deeply tied to Windows (even if there were half-arsed Macintosh ports).
And then the Internet taking off happened.
And suddenly you had gigantic companies built on PHP/JavaScript/Linux (like Facebook), on open-source software (Google) and Pascal/Delphi got also attacked by actually portable stuff, like Java, which some of today's biggest companies were built on (like Amazon).
So on one hand Linux and it's myriad of open-source languages and on the other hand Java (which is what it is but it is portable) and then JavaScript in the browser.
Nowadays tens of billions of devices, including many servers powering the entire world, are running Linux. While Pascal/Delphi was that language you'd run on DOS and half-arsedly ported to Windows: not a winning proposition.
Evne in its heyday, Borland's Pascal-based products were not that big in the developer tools market. Delphi was a huge hit in Europe, but in the US, they were dwarfed by Microsoft. So Pascal's influence is a bit like that Brian Eno saying (paraphrasing): “Only 30,000 people bought the first Velvet Underground album, but everyone who bought it started a band.”
Part of Borland's fall was betting too much on client/server database stuff at a time when the web was happening. They renamed themselves Inprise and marketed a suite of technologies called MIDAS which nobody remembers anymore. You used Delphi to build database GUIs on top of MIDAS and, say, Oracle. I don't know what they were thinking. They also did a Linux version of Delphi called Kylix which was just using Wine (!).
Even so, I suspect ObjectPascal would have failed eventually. A language tied to a GUI toolkit, without a standard spec, or a cross-platform open source implementation, just couldn't last forever.
I held onto Delphi far after it was evident that it was a dying language. I actually did a ton of my work in the 1990s and early 2000s doing non-GUI stuff in Delphi, including web backends and commercial games, which I suspect was not that common. ObjectPascal actually worked wonderfully as a server-side language. It was a strict, statically typed language, it had modern constructs like classes and threads, it was natively compiled, very fast, had a terrific interactive debugger. In many ways a perfectly fine alternative to C++ at the time, including for game development — I made my own bindings for DirectDraw, DirectSound, and so on.
At the time — say, around 2000 — I didn't find the alternatives compelling. Java was dead slow and didn't offer anything language-wise. Languages like Python were also slow and were not type-safe. But there came a point when Linux had just taken over, and ObjectPascal wasn't a viable option anymore.
Today, the closest thing in spirit to the ObjectPascal language isn't C#, I think, but Go.
They refuse to even have Pascal like enumerations, rather pushing that stupid iota/const boilerplate without any of the nice features that Pascal enumerations had in 1970's.
Rather take C# when given the option.
• Extremely fast compilation (even if at the cost of throwing away generations of optimizations)
• Strict, somewhat impoverished type system
• Simple but pragmatic module system (Go has packages, OP has units)
• High focus on integrated tooling (e.g. built-in assembler/linker)
• Safe strings and dynamic arrays built into language
• Built-in reflection and a runtime that often makes use of it
I would argue that if you gave ObjectPascal a C-ish syntax and added built-in concurrency and GC, it would look and feel more like Go than anything else.
Yes, OP has enums and ranges and Java-style interfaces, but those are minor details.
> Extremely fast compilation...
> Safe strings and dynamic arrays built into language
Even Lisp and PL/I have these ones, we really lost focus with C's adoption.
> I would argue that if you gave ObjectPascal a C-ish syntax and added built-in concurrency and GC, it would look and feel more like Go than anything else.
That is C++ Builder.
I have used all Borland products starting with Turbo BASIC 1.0, moving into Turbo Pascal 3.0 and then all TP versions, Turbo C++ 1.0 all the way up to the last Turbo C++ for Windows 3.1 version.
Delphi up to Delphi 5, and the accompanying C++ Builder releases.
Go is really nothing like Object Pascal, nor in features, nor in spirit.
It is a mix of Limbo with Oberon-2 method syntax, from UNIX folks that were always quite against Pascal, none of the authors is fond of Object Pascal, and it shows.
https://en.wikipedia.org/wiki/Macintosh_Programmer%27s_Works...
The lack of a good web platform has been mentioned but also there wasn't really any Unix heritage and on Windows the .NET platform and C# killed the advantages Delphi had over Visual Basic 6.
I was a Delphi developer for a bit and most of us moved to Java if we wanted to stay if Microsoft platforms.
Bytes have history, meaning, context of creation, different utilities and different cost associated with creation/transfer/storage/manipulation
We could also use those comparisons to praise how complicated our current world has become and how good we are at managing such complexity
Engineers who complain about accidental complexity need to show that this complexity doesn’t come from the real world
I think a better conclusion is that the Pascal compiler was very limited and modern `touch` is very feature-rich (many comments in this thread have explained how) and it shows that we've come a long way.
If you actually used that Pascal compiler from the 80s, you'd immediately notice the limitations.
Touch, on my 1980s computer, would have been seen as a caricature. It would have been a 200 byte .com file back then, if that. The comparison is about what you can do with what you have if you have no other choice, and how plentiful resources don't automatically create empowering outcomes.
There's no reason (other than laziness) why that should take more than 2k.
On the other hand, a lot of boilerplace code is repeated in each and every command. When I first learned as a kid about UNIX commands being ordinary programs, I was intrigued (there is nothing "special" about them, you can also write your own!) but also shocked about the overhead compared to an architecture in which e.g. the shell contained all (at least core) commands compiled into a single binary, which could share all the error handing, startup code, command line parsing code and so on.
GNU coreutils touch does a lot more than that. My local copy is about 95k; it allows for choosing from multiple different timestamps to update; suppressing the (default) creation of an empty file if it doesn't already exist; operating on symlinks directly rather than following them (if the system supports it); specifying a custom timestamp rather than "now" (including by parsing a date string), and of course outputting a help message and a version.
> DATE STRING
> The --date=STRING is a mostly free format human readable date string such as "Sun, 29 Feb 2004 16:21:42 -0800" or "2004-02-29 16:21:42" or even "next Thursday". A date string may contain items indicating calendar date, time of day, time zone, day of week, relative time, relative date, and numbers. An empty string indicates the beginning of the day. The date string format is more complex than is easily documented here but is fully described in the info documentation.
There it is.
[0] https://github.com/coreutils/gnulib/blob/master/lib/parse-da...
If size is really a concern, we have supported building a single 'coreutils' binary since 2014, which will be more effective in saving disk space. It can be done with './configure --enable-single-binary'.
There is also the rest of the whole "gnulib" folder inside the coreutils repo. Yes, I know that Gnulib explicitly states in the docs that it's a source code library but it doesn't bother to explain why exactly it chose to be that instead of being a .so à la glibc (beyond some rather unrelated "but supply chain attacks!" segment in the docs — if I cared about that, I'd statically link the relevant parts of glibc as well, in fact, that would be a much higher priority).
Gnulib also doesn't make API stability guarantees like shared libraries do. If a distribution installs Gnulib as a shared (or even static) library, and then links programs to that instead of the vendored sources, they will likely end up with broken programs.
[1] https://www.gnu.org/software/gnulib/manual/gnulib.html#Libra...
Also, "Gnulib doesn't make API stability guarantees like shared libraries do" — a) do you mean ABI? b) why not? The gnulib seems like something that's perfectly suited to be a shared library, even more so than the glibc, since it's not a language runtime.
2/5
And the .so dependency hell is real. You try to build some older version of a certain language runtime, it complains that your libssl/libcrypt lacks the functions it needs (those functions were in 1.0.1f, but 1.0.1k dropped them because that's how semver works), and of course your distro doesn't have the older version of libcrypt packaged for it so you take the package from the previous version of your distro, and it complains that your libc is too new and segfaults. Well, you sure as hell ain't rolling your system's libc to an older version so you try to rebuild libcrypt from the source, but the build with default config/flags still doesn't satisfy this certain language runtime and oh my god why am I even wasting my time on this, "docker pull certain-language:ancient" it is. Yeah, sure, this image has essentially Ubuntu 14.04 inside of it but at this point IDGAF. Why can the same 6.16 kernel run the user space both from today and from ten years before it, but the userspace from today can't run the program from eight years ago?
I did a quick estimate by disassembling touch with objdump on macOS (163 kB executable), and it was approximately 6 kB (1500 instructions * 4 bytes/instruction). There is a lot more to an executable than executable code.
Watching `mv` do its thing is even better. About 100 system calls, including playing nice with SELinux in case it happens to be installed, just to issue a single `renameat2` system call.
Don't forget that we're running on a 64-bit machine. MS-DOS in 1986 was a 16-bit machine? The word size on a modern machine is bigger because we have a bigger address space, more registers, and more instructions.
We want speed and security and convenience and pleasant error messages. All of this is put here by the compiler to ensure that we have nice things. It sounds awesome to have such a small Pascal compiler, and it makes the modern state of binaries seem bloated, but all those extra bytes are paying for things that we want. There's probably a little bloat, but really, there is not much bloat.
I presume you know some of the intricacies of coreutils or the touch program. I'll probably go and donate to whomever receives donations for coreutils; it's the least I can do: Show some respect to the developers of these free and open source tools.
1/5
Well...
Just the text for the help message compiled into `touch` is over 1.5kB.It's not just laziness, it's also what the program needs to do, like (for example) print out all the options it supports (1.5kB), then parse those options, execute a different code path depending on what the user wants to do, etc.
If all you want to do is update the date or create a new empty file, I can write a very short program that does that, although the minimum program in C is around 16kB (hello world), so that's the minimum overhead needed to have a C program loaded by Linux.
Zabbix also confuses operators at this point. I recently had to increase a cache. I chose to go from a solid 4MB to a luxurious 256MB.
I know high-performance Java, so just a little jab there, but you don't size JVM parameters like that, except maybe code caches. And before Rust comes in, we also have a Rust application running without good resource control and it wouldn't like those resource constraints.
There is truth to this article.
3/5
Sure, I mean it had a turbo whereas Microsoft only ever had quick things. A shame no one thought of swift back then.
Of course now it would be a trivial job for an AI to make the chart. Finding a authoritative source for byte counts, probably less so.
Everything was about compatibility - that's really why we were stuck with int 21 and almost no other help from the OS to insulate us from the hardware. There wasn't a standard C library with millions of features - or anything else - that could add overhead to hello world.
Every program had its own drivers - everything was optimised for that use case and not some general set of cases.