HN Reader

> Visual Basic was the pinnacle of graphics programming

I am still shocked how no tool since has managed to come even close to VB. You could easily develop a moderately complex GUI application that felt snappy in an afternoon. C# with WinForms is the second closest to that. All other iterations since have not been designed with individual developers in mind, sadly.

A powerful developing alternative to this paradigm could be what I’m calling speech/voice driven development (SDD or VDD). It takes some pain of typing so much away - makes interactions with AI feel a bit more natural. Like talking to a colleague. But for it to really work well, AI models will need to become even faster.

I think Emacs still does all of this; the argument the author makes is that it is "arcane", it just uses conventions he is not used to. It is however fully self-documented and interactive.

For me the best textual interface I've ever used remains Magit in Emacs: https://magit.vc/ I wish more of Emacs was like it.

I actually use emacs as my git clients even when I'm using a different IDE for whatever reason.

Things like Borland C and VB/WinForms really do take me to a simpler time. There was joy in being able to write simple programs very fast, in a more intuitive way, without needing to use browsers or frameworks or writing shaders to do the simplest things. Current systems are more powerful and versatile for sure, but for a teenager curious for coding they are a much less welcoming environment in a lot of ways. The ever growing amount of technologies you need to learn now does not help either.

For what it's worth it, I'm still developing and using exclusively my own text-based editor/IDE: https://github.com/alefore/edge

I wrote recently a bit about my conclusions after ten years of developing it: https://github.com/alefore/weblog/blob/master/edge/README.md

In the golden age of DOS you had an array of bytes representing characters and an array representing attributes (background and foreground colors) and the hardware drew out of that. If you wanted to write a ‘A’ to a certain spot you wrote 0x41 to a certain memory address and that was that —- there were some wait states involved but it was way faster than drawing on a 9600 baud terminal with ANSI terminal commands that use up even more bytes.

I first used emacs on terminals that were hooked to Sun workstations and you were either going to use a serial terminal which was very slow, or the terminal emulator on the Sun which was a GUI program that had to do a lot of work to draw the characters into the bitmap. So that’s your reason TUIs went away.

Turbo Pascal was completely amazing. I remember resisting it for a long time, because IIRC it implemented non-standard Pascal. But the competitive tools were less powerful and far more expensive, (e.g. the Microsoft tools). And then I tried it, and was completely blown away. I no longer cared about the non-standard stuff. I had a fast intuitive IDE running on my original IBM PC.

As for modern IDEs, Intellij has been orders of magnitude better than any competition for more than 25 years (I think). I have stayed away from Microsoft products for a very long time, so I can't comment on VSCode and its predecessors. The main competition I remember was Eclipse, which I always found to be sluggish, unintuitive, and buggy. The fact that it wasn't even mentioned in this article is telling.

JetBrains, the company that created Intellij (and then PyCharm, CLion and many others) is one of those extremely rare companies that defined a mission, has stuck to it, and excelled at it for many years, and has not strayed from the path, or compromised, or sold out. It is so impressive to me that they maintain this high level of excellence as they support a vast and ever-growing collection of languages, coding standards and styles, and tools.

(Article is from 2023, so the title should be updated to say "32 years ago", or something)

The biggest loss in TUIs is the latest wave of asynchronous frameworks, which bring the joy of dropped keypresses to the terminal.

In any TUI released before the year 2000, if you press a key when the system wasn't ready, the key would just wait until the system was ready. Many TUIs today still do this, but increasingly frequently (with the modern "web-inspired" TUI frameworks), the system will be ready to take your keypress, and discard it because the async dialog box hasn't registered its event listener yet.

Other than that antipattern, TUIs are doing great these days. As for terminal IDEs, Neovim has never been more featureful, with LSPs and other plugins giving all the features this article discusses. I guess it isn't a mouse-driven TUI, so the author wouldn't be interested, but still.

I used to use a Java-oriented IDE called “Visix Vibe”, at first as an experiment in application development with Java and then as an alternative to Delphi, which was my bread and butter tooling environment for custom application development.

Both of these IDE’s gave me a huge productivity boost, and it used to be a no-brainer to give customers a realizable estimate for getting the UI done, then wiring up logic, and get things ready to ship, etc.

I really miss these IDE’s, because of the integration factor. It was fun to wire up a database table and generate a form and immediately have something that could be used for data input and validation on the project - then spend a few weeks refining the UI to be more robust and cater to the application use case in focus.

These days, it feels like a lot more careful planning is needed to make sure the UI/API/backend realms can play properly together.

It would be nice to see some more progress on this level of tooling. It’s one thing to have an AI generate UI code - but I still think there is room for painting the code and using a UI to build a UI.

(The moment someone produces a properly WYSIWYG tool for JUCE, the glory days will begin again ..)

Ah, Borland’s IDE! An absolute delight. I’ve yet to find anything modern that matches it. Sure, nostalgia turns everything syrupy, but I actively hunt for excuses to use Free Pascal just to fire up that interface. Okay, fine—I like Pascal too. You caught me.

I also use Sam and Acme from Plan 9 (technically from the excellent plan9port), but let’s be honest: those aren’t IDEs. They’re editors. Tools that let me think instead of wrestle.

There’s a lot we could (and probably should) learn from the old TUIs. For example, it’s perfectly acceptable, even heroic, to spawn a shell from the File menu and run something before returning. Seems people are afraid of losing style points with such grievous actions.

And the keybindings! So many of those classic TUIs adopted WordStar’s sacred keystrokes. They’re burned into my muscle memory so thoroughly that using EMACS feels like trying to type with oven mitts. For years, joe (with the blessed jstar alias) was my editor of choice.

Anyway! Time to boot the Dr. DOS VM, spin the wheel of Advent of Code, and be nostalgically inefficient on purpose.

> “In my house”, we used something called SideKick Plus (1984), which wasn’t really a code editor: it was more of a Personal Information Management (PIM) system with a built-in notepad.

Finally! Someone who still remembers the best software ever written. I looooved Sidekick and we used it throughout our small company. It's so long ago. I remember only parts of it now but it was such a useful tool.

I think these modern TUIs are a testament to the general failure of modern GUIs.

It's not like they're particularly easier to write these.

But since there's no remote GUI option, much less a portable remote GUI option, particularly one that's not just a video of an entire desktop, we're stuck with these.

WHo wants to fire up an entire desktop to get open a simple utility app?

Obviously the Web satisfies much of the demand for this, but clearly not all.

Remote X is, essentially, dead. It's obviously "really hard", since "no one does that any more". Or, folks just don't miss having rootless windows peering into their remote server enclaves.

It's just too bad, full circle, here we are again. "Progress."

Ok, this post is mostly about text-based IDEs, but I think the point mostly stands as well for IDEs in general. I'm thinking about Visual Basic or Delphi.

I think such a IDE for Python would really be helpful for beginners. Not text-based, but more like Visual Basic. But everything integrated, everything easily discoverable (that's very important!). Maybe also with such a GUI builder as in VB. And a built-in debugger. I think for the code editor, as long as it has some syntax highlighting and tab auto-complete, that would already be enough. But some easy code navigation would also be good. E.g. when you place some button on your window, and double click that button in the GUI editor, you get to the call handler code of that button.

Some time ago, a small group of people (me included) (I think from some similar HN post?) got together and we brainstormed a bit on how to implement this. But we got lost in the discussion around what GUI framework to base this on. I already forgot the options. I think we discussed about PySide, Dear PyGui, or similar. Or maybe also web-based. We couldn't really decide. And then we got distracted, and the discussion died off.

Note, Free Pascal was mentioned here. But then you should also mention Lazarus (https://www.lazarus-ide.org/), which is the same as Free Pascal but cloning Delphi. Lazarus is really great. And it is actively developed. But Object Pascal is too little known nowadays, maybe also a bit outdated.

Recent install of Emacs 30 and Doom 3.0 via https://github.com/jimeh/emacs-builds (MacOS) is feeling very nice.

Emacs actually is friendly! apropos and all of the describe commands make it /discoverable/.

Literate configs and tangling?! I finally feel the end game.

Yes, you probably should read a book at the same time on the side to give you a higher perspective on fundamentals. Sure, some other tools are simpler to get started.

If I could drop everything I'd make a simple emacs config for kids with like a turtles mode and maybe a sound sequencer, then teach them functional programming first. Hah

I used Borland Turbo Pascal in 1984. It was amazing to work with something so fast on a PC that was really so slow. No IDE/Compiler since then matched the speed. Today's code is massively more sophisticated and complex, so there is no way to match that performance today despite the speed of computers today.

"the IDE had to be discoverable right away (which it was) and self-contained to offer you a complete development experience"

This right here was the key to super flow state. Lightning fast help (F1), very terse and straightforward manuals. I have tried to replicate this with things like Dash (https://kapeli.com/dash), to some degree of success.

The closest thing I had to this in windows was probably Visual Studio 6 before the MSDN added everything that wasn't C/C++ to the help docs. After that, the docs got much harder to use due to their not being single purpose anymore. The IDE was a little more complex, but you at least felt like you got something for it. After that, too many languages, too many features, overall not great experience.

The keybindings were so simple and fast, Borland IDE on DOS was a very nice tool. Yes, easier than vim and emacs. The reason is because of mouse in TUI so things like complex selection/blocks/text manipulation are not keybindings in the same way so the key combos are more "programming meta"(build, debug, etc) rather than "text meta".

EDIT: also, I feel like this needs to be mentioned: compilers were not free (as in beer) at that time!

In order to develop on my own machine as a teen, I had to sneakily copy the floppy disks the teacher used to install this on the school computers so I could have more than 1h using it at home! COPY THAT FLOPPY

Hey, thanks for sharing this again! FYI, previous discussion from 2 years ago now (wow, time flies...): https://news.ycombinator.com/item?id=38792446

I'm interested in how these old IDEs were used during the transition from assembly to high level languages. It seems especially topical given the LLM integration into today's IDEs.

Back then was it common to have a split or interleaved view of high level and assembly at the same time?

I'm aware that you could do something like the following, but did IDEs help visualize in a unified UI?:

    $ cc -S program.c
    $ cat program.s    # look at the assembly
    $ vi program.c     # edit the C code

A quick search shows that Borland Turbo C (1987) had in-line assembly:

    myfunc ()
    {
        int i;
        int x;
        if (i > 0)
            asm mov x,4
        else
            i = 7;
    }

From the 1987 Borland Turbo C User's Guide [0] "This construct is a valid C if statement. Note that no semicolon was needed after the mov x, 4 instruction. asm statements are the only statements in C which depend upon the occurrence of a newline. OK, so this is not in keeping with the rest of the C language, but this is the convention adopted by several UNIX-based compilers."

[0]: http://bitsavers.informatik.uni-stuttgart.de/pdf/borland/tur...

Nostalgia aside, those classic TUIs nailed responsiveness and cohesion. Modern setups can match features, but rarely that instant, synchronous feel. Emacs + Magit shows the power of text-first integration, yet JetBrains-style debuggers and glue still win for many. It’d be great to see a modern, fast, Borland‑like TUI with solid LSP and LLDB integration.

I think what people miss about bloat, and about what's changed with software over the years, is that a vast variety of niche use-cases are now supported. Software runs on dozens of different systems, every aspect is customizable and programmable, and thousands of different programming languages and approaches are supported.

To give a random example, I use Neovim with SuperCollider, and music programming language. This involves launching a runtime, sending text to the runtime, which in turn sends commands to a server. The server generates a log, which is piped back into a Neovim buffer. There are all sorts of quirks to getting this functional, and it's a somewhat different workflow from any traditional programming model.

I'm not sure there's an easy solution to keeping things simple while also supporting the unimaginable variety of personalities, skill-levels, environments, and tasks people get up to. I do, however, think it's worth continued imagination and effort.

One I used to love back in the 80s/90s was GFA Basic on the Atari ST. In a similar category of TUI (mostly, it did have mouse control and menu bars, but you didn't have to reach for them) with great auto-indentation and code folding (features not common in mainstream editors at the time) and instant compilation and error checking.

It took many decades for me to get that kind of flow back for mainstream programming languages on modern computers. And modern IDEs still have higher latency than they should.

I used most of these and they weren't worth it. They didn't do enough to justify being locked in to the tool. The debuggers were too, uh, buggy. Command line tools were more flexible.

They finally got good enough in the late 90s. I think it helped that computers finally had enough memory to run both the editor and the program itself.

I learned to code with Turbo Pascal 6 without the internet by trial-and-error and the debugger. When in real mode, a program crash would often reboot the system or occasionally lead to some other unexpected behavior/semi-silent corruption.

Borland C++ 3.1 & Application Frameworks for DOS and Windows 3.1 came with an entire library of paper books. It was probably the heaviest and largest boxed retail software package ever because 4.0 skimped on paper books and didn't include real mode versions of the IDE for DOS.

The Pascal almost equivalent was Borland Pascal 7.0 with Objects.

It was possible to link assembly, C++, and Pascal in the same executable assuming the memory model and function calling convention were set correctly.

Worth mentioning a version of ms Edit is now opensource. Not only that, it is extraordinary code to learn from:

[1]: https://github.com/microsoft/edit [2]: https://news.ycombinator.com/item?id=44031529

He touched on Emacs and it reminded me of the Blub Paradox https://wiki.c2.com/?BlubParadox

I'm going to get punished for saying this, but I don't really see the point of IDEs when you have things like vim, Makefiles and bash. It just seems like more things to go wrong. I used Eclipse while I was doing Java development for a while and it had some conveniences but for the most part I just see it as one more thing that can go wrong and get in my way.

Anyway, does anyone remember Metrowerks CodeWarrior? I see it still exists, but I mean back from the 90s. I got a T-shirt from them at MacWorld '99 and still had it until not too long ago. High quality merch.

I agree with emacs. It is a fantastic operating system but it lacks a good text editor. I remember using the Borland ide and miss there clear design language. Fighting with ide, gui and language is no fun. I miss the ide I could just start up over a rs232 connection and use it

Good article.

I'm more of a GUI guy who is contend with VSCode. I'm intrigued to learn Emacs but don't have the time for it.

Back in the 90s, however, Borland TUI was indeed the pinnacle. I remember I played with Turbo C for a while but did not learn anything, but it was fun just to use the IDE.

The Turbo Pascal “IDE” was my very first dive into programming, and it’s still the best experience I’ve ever had! Maybe it’s just because it was my first, but wow, it already had tons of cool features back then, like syntax highlighting, step debugging with breakpoints, and a quick peek at variable values.

Do you think there’s anything like that out there today? The only ones I can think of that are closed are nano and micro editors, but I wouldn’t really call them IDEs.

Thirty years ago was 1995. TUI programming environments were closer to obsolete than obsolescent. We had 32-bit versions of Visual C++. We had Delphi and the Borland C++ stuff for Windows. We had Codewarrior. On the lighter end of RAD, Visual Basic was four years old, HyperCard was eight years old, and LabView was nine years old. The future was very unevenly distributed back then. I see now the article is from 2023, well, adjust appropriately.

When I use an editor, I don't want eight extra KILOBYTES of worthless help screens and cursor positioning code! I just want an EDitor!! Not a "viitor". Not a "emacsitor". Those aren't even WORDS!!!! ED! ED! ED IS THE STANDARD!!!

TEXT EDITOR.

-- https://www.gnu.org/fun/jokes/ed-msg.txt

Learned to code with Borland Turbo C++

Moved to Dev-C++

Nowadays just any editor and using GCC directly

Eternally greatful for open source, Microsoft charged thousands for Visual C++ back then.

A little bit later, there was visual editors for gui app like Delphi and Visual Basic and co.

Despite VB to be a little bit shitty, I think that a big loss happened in the GUI software development world since web apps became the norm.

Not many remember this world where you could easily graphically create your UIs by placing components and that reactive interface were a given without effort.

I really miss the original Delphi before things went DotNet shitty...

I struggle to understand what the author actually wants, aside from nostalgia about a specific look and feel that he imprinted on. And perhaps the simplicity of having few features.

I would have appreciated a breakdown of what specific individual features those crummy old ides are offering.

I suspect the one the author wants most is a time machine to go be 12yo again, but software can’t do that. Yet.

Of course, Emacs can do everything listed in this article, even edit remote files over SSH while in graphical mode.

I don't know, all of those are pretty similar to me.

I'd like to be able to develop in other languages the way I do when I dabble in Pharo, i.e. mostly windows and widgets and dialogs that abstract away boilerplate, file and directory management, and allows me to relatively easily extend the environment when I feel like it.

Instead I tend to complement the editor or IDE with a rather large set of Linux and Unix programs in terminal emulators. It's not nice or easy to teach, but nicer than trying to figure out whatever module protocol used by the editor. Perhaps I could have stayed with Emacs and been content, but when I arrived at this methodology Emacs was still single threaded and quite sluggish in comparison.

I'm hoping Glamorous Toolkit might be the thing that eventually grows into what I'd like to have.

> Each program was its own island because its interface was unique to the program. However, they were all so similar in how they looked like—80x25 characters didn’t leave much room for uniqueness—and how they worked that the differences didn’t really get in the way of usability and discoverability. Once you learned that the Alt key opened the menus and that Tab moved across input fields and buttons, you could navigate almost any program with ease.

This is the biggest thing I miss in modern GUIs, especially Windows, macOS, or mobile.

Tabbing across every single possible inputs, with alt or control keys for quick access is insanely powerful compared to "click here, scroll this, click click"

Surprised there was no mention of brief. That was my favorite editor for programming for a while.

https://en.wikipedia.org/wiki/Brief_(text_editor)

Been setteled on https://scintilla.org/SciTE.html It has simplicity + extensible for any language, you can create your own linter + highlighter

Its nothing bloated, its not embedded ide like vscode and all

Rather scite is just gui frontend for cli based binaries, it uses programming environments you have installed on your os

Just like old time on cmd or sh, we used compilers eg javac or cpp

Now scite just make it easy, its exactly same as borland turbo, you add path to your compiler binaries in scite and done you click compile or run,

Plus its lightweight and portable, carry it in usb and run on any computer by just setting paths to compiler and executor binaries

1. coders will use every available resource, and

2. there is no limit on resources.

The consequences can be left to the reader (re: the article in this thread), but these two postulates are the source of all ills in commodity and open-source software today.

Having TUIs available for remote administration is an excellent point. I frequently spin up nmtui on machines with NetworkManager because I’m used to Ubuntu’s network settings GUI and I haven’t bothered to learn enough nmcli.

(“real” deployments would use systemd-networkd and config files but for simple things…who cares)

No matter how good computers and networking get, text-based tools always seem to win for remote administration. I’ve tried forwarding X servers, mounting remote file systems with sshfs, vscode’s remote features, VNC, RDP, but I always seem to revert back to just tmux and TUI tools.

The very first image in the article is not edit.com, it is the Windows 95 edit.exe which replaced it.

The actual "edit.com" is a tiny stub that launches QBasic in edit mode, equivalent to "qbasic /edit".

The amazing thing about Turbo Pascal was that my memory was better, my focus was better, I could stay up much longer and my right knee didn’t hurt.

Edit: I think there is a lot of “do it because we can do it not because we benefit from it” in modern software. But fetishizing the past gets a bit silly. I do still remember getting plenty of useless documentation in old TP. And blasting through an interface that lags behind your typing is how you end up doing something completely unpredictable because one keystroke was a bit off.

I learned on Turbo Pascal many years ago. It was amazing. There's another aspect beyond the TUI though: compiler speed. Turbo Pascal was designed for compilation speed. It was significantly faster than, say, Turbo C++ for an equivalent program.

But this brings up something I think about every now and again: resource bloat.

When Turbo Pascal was currently it'd be common for PCs to have 1MB of RAM. In fact with the DOS memory model you had to do weird stuff to use more memory than that (IIRC it was called "large mode").

Obviously running in a graphical environment is going to use more memory but we had pretty capable Windows environments with Win 95/98/SE/NT3.5/NT4/XP with not much RAM (256MB to 1GB depending on year).

Now with modern windowing systems we have capabilities that didn't exist in early windowing OSs like scalable rather than bitmapped fonts, UI scaling, etc. But we've had those things for 20+ years now and the resource requirements still keep going up.

Yes we have Javascript UIs running in a browser now and that will never be as cheap as native apps but we've also had those for ~20 years now (GMail is ~20 years old).

In the 90s we had graphical X Windows systems on Linux with 4-16MB of RAM. I know. I ran them.

Why do resource requirements keep going up? Is there demand for a low resource OS that could be user-facing? I know hardware is particularly cheap with Raspberry Pis and similar. We have ARM CPUs for a few dollars now that would've cost millions in the 1990s. So maybe that's why there's no demand.

But this is really something I expected to top out at some point and it just hasn't.

The author notes that he programmed back in the 1980's, but the article only focuses on the mid-90's IDEs.

I'd like to see a companion article about the IDEs from the 80's.

I remember 64FORTH had a multi-pane IDE, but I could only find this low-res picture of it: https://www.c64-wiki.de/images/thumb/2/24/Forth64-audiogenic...

There were others, though, including one I remember that was all text at the bottom half of the screen, and then graphic output at the top.

And, of course, the most famous one of all: the Atari 2600 BASIC Programming IDE which fit in just 4K.

Today's ragebait bloggers like to say how awful it was, but if you're patient and thoughtful, the way people were when it came out, you can do quite a lot.

An entire Pong game in six lines, from Wikipedia:

  1 Hor2←2+Key
  2 IfVer1>90ThenVer1←88
  3 IfHitThenVer1←9
  4 Ver1←Ver1+IfVer1Mod2Then8Else92
  5 Hor1←Hor1+7
  6 Goto1

The interfaces look like they wanted to be graphical, as they have windows and drop down menus, and they wanted to have multi-tasking, as they implemented the overlay tools in Borland Sidekick. They wanted those things but they were limited to staying in text mode because widespread adoption of any real graphical interface was slow.

It seems a little humorous now that professionals were stuck for several years doing their day to day word processing, spreadsheets and databases in text mode, where getting different sized text or different fonts was almost impossible. This also wasn't just in the 80s, it was still somewhat true in the early 90s, not very long before the beginning of the internet as we know it.

Still, I wonder if things are really any better now, as we're all using software interfaces built on something else that's not really appropriate for the job. HTML.

I learned the C language from K&, and the C API by right-clicking on all the things in Turbo C on a 286. Learned a fair bit of lisp from emacs using C-h f. I do love the navigation capabilities modern IDEs have, but unless a library's author has gone off the deep end writing doc comments, they don't have the same discoverability.

I saw this and was like, what?

> have we advanced much in 30 years?

IDEs have changed a lot, specially with AI-assisted ones. The author kind of acknowledges it, but imho it's a paradigm shift. Not just "a major difference".

> The only major difference that we are starting to see might be AI-assisted coding, but this is a feature mostly provided by a remote service, not even by the installed code!

Then I realized it’s a post from 2023. IDEs have changed a lot since then. Autocompletion has evolved from merely suggesting function names to completing 20 lines of code in the blink of an eye. It's great for productivity, but it also makes you lazy, to the point where you can't live without it.

In my opinion, software engineers should “disable the autopilot” from time to time, just like airline pilots must occasionally land without it. Otherwise, you end up becoming too dependent on it.

What amazes me every day is that I'm using literally the exact same GUI to build apps that I was over 30 years ago, with Visual Studio.

You could sit someone down from 1991 (Visual Basic 1.0) in front of Visual Studio 2026 and they would immediately know where everything is. (it still has BASIC in there too)

The arguments for using TUI IDEs are just very poor. Developers should not be relying on something as loaded with legacy bloat like the terminal, to do development.

Zed has remote editing support and is open source. Resource consumption is a bizarre proposition, considering what abstractions the terminal has to be forced into to behave something like a normal window.

Really, TUIs are not very good. I get it, I use the terminal all the time and I will edit files with vim in it, but it is a pointless exercise to try to turn the terminal into something it was never meant to be and try to have it emulate something which would be trivial on a normal OS window. To be honest it makes me cringe when people talk about how much they perform tasks in the terminal, which would be much easier done in a graphical environment with proper tools.

It's funny that students in the early 90s would use a pirated copy of turbo C or pascal, but in the early 2000s when Java took over curriculums, students couldn't access a decent IDE. Many never saw a debugger in action, and executed javac in a dos window.

I still remember https://en.wikipedia.org/wiki/Brief_(text_editor) , which I used extensively in DOS; it was my first "programmer's editor".

I love reading about and occasionally tinkering with older text editors like vim, emacs, ed, acme, ex, nedit, and as such.

For actual work, though, I’ve been using VS Code exclusively since its inception. Electron might be a bloated mess, but spending time on alternatives doesn’t feel worth it. Maybe that’s because I didn’t grow up in the golden era of computing and can’t make the vim workflow stick no matter how hard I try.

I’m pretty sure twenty years from now, this generation of developers will get blurry-eyed reminiscing about how fast and feature-packed VS Code was, and how Microsoft built the best GUI text editor of its time.

As for TUI editors, I love micro because it has mouse support and doesn’t make you memorize a spellbook just to move around.

By this point in college 30 years ago I had switched to mostly emacs, and was struggling with it - our program was unix based (solaris) with gcc. But a few years before that I was using turbo pascal, which was indeed a very fast ide, partially by virtue of how low latency hardware was back then.

I like these programs, mostly for that sweet low latency which is just gone today, but I wouldn't romanticize them as dev experiences. To experience it you can download free pascal today and use theirs which is just like turbo pascal (may even based on turbo pascal?). Its pretty clunky compared to what you get today, although, the debugger works which is more than what you can say for the majority of languages today.

We had Symbolics Genera, not mentioned, and way better than anything else mentioned here, IMO.

Speaking of bloat: why are binaries from Rust or (much worse) Go so damn huge? This is in release mode with debug off.

It’s weird because memory use for the same sorts of programs is not much worse than other languages. In Rust memory use seems comparable to C++. In Go there’s a bit more overhead but it’s still smaller than the binary. So all this is not being loaded.

I get the sense devs just don’t put a lot of effort into stripping dead code and data since “storage is cheap” but it shows next to C or even C++ programs that are a fraction of the size.

I see nothing about Rust’s safety or type system that should result in chonky binaries. All that gets turned into LLVM IR just like C or C++.

Go ships a runtime so that explains some, but not all, of its bloat.

I read this earlier today. I agree 100% with the author's opinion that Turbo Pascal had the best IDE ever. I had been using it on the CP/M platform (Z-80 only), and it was so much better than everything else in that era that it was like magic.

Delphi - fantastic, modern RAD IDE. Borland heritage.

Can build native apps for Windows, Linux, macOS, iOS, and Android.

https://www.embarcadero.com/products/delphi

To me VB 6 was the height of RAD IDEs

You could throw together a CRUD app in under an hour interactively.

Great nostalgia! I fondly remember QuickBasic, and how excited I was to compile my BASIC code. And the rarely mentioned gem I thought was amazing at the time: Visual Basic for DOS!

These dos style TUIs are live and well in commercial and industrial settings. Most often you see them in fast food order trackers where their simple clarity stands out.

Far Manager on Windows, and Midnight Commander on Unix, work wonders for terminal-based development nowadays. Not only they allow you to have OS commands at the tips of your fingers, but also they allow you to navigate freely in the file system structure of a project while viewing/editing files with built-in or external editors.

UI/UX of those tools is pretty close to Borland IDEs, they have steep learning curve (at least 10x easier than vi/emacs).

My favourite is Texas Instruments PC-Scheme. Complete with Emacs-like editor. You could compile and evaluate regions in the editor. It is amazing what you can do in 2MB or even 640K.

I learned programming in turbo C++ - not because I grew up in 1990s, but because Indian education system is stuck in 1990s.

> So the question I want to part with is: have we advanced much in 30 years? Modern IDEs have some better refactoring tools, better features, and support more languages, but fundamentally… they haven’t changed much.

I can't give up any of: intellisense, type checking as I type, semantically meaningful navigation.

> Both Free Pascal and QB64 are maintained and under relatively-active development, with their most recent releases in 2021… but they are mostly ignored because they expose arcane languages that most people have no interest in these days.

Touché. Personally I think Pascal (the FPC/Lazarus variety) was pretty cool, straight up one of the best ways to easily do cross platform GUI apps, something of that old RAD fame: https://www.lazarus-ide.org/index.php

I wish someone would prove me wrong, what are the best modern cross-platform options for native GUI?

At the same time, for everything else in similar circumstances (statically compiled executables, relatively safe to code and use), Go has replaced it for me, in great part due to both the ergonomics of the language, but also just how batteries included the standard library is.

Oh wow. Slightly surprised about the emotions these pictures evoke! Not that I would want to program with that today, but I sure had fun with it back then.

No mention of Visual Studio, as distinct from Visual Studio Code. No mention of JetBrains, PyCharm. The author didn't mention that Borland cost $99.95 in 1987, back in the day. Now, Visual Studio costs $499.92/mo. Yeah, the free versions aren't as fully featured or as well integrated as the thing you paid for, what else is new?

I remember using Borland Turbo for C/C++ classes in my school and college days. In fact, it is still being used in most of the colleges in India even now. What nostalgia!

No love for MultiEdit? :(

Loved Borland IDE at the time. I still miss Ctrl-KB/KK (IIRC?) style selections from time to time.

These days Far Manager (via far2l) or MC kind of scratch the itch for quick TUI edits.

I grew up on the borland Turbo series. Learned C then C++ on it. Such nostalgia.

I was wondering, is there a way to get VS code to look like this? Maybe neoVim?

We haven't lost. The best functionality of IDE is navigation (find implementations, calls etc) and refactor. Other functions are merely enhanced notepad.exe functionality

good memories of the borland stuff! (especially super duper high resolution 43 line mode!), it was where i actually cut my teeth on c/c++ before moving to coherent then linux!

Needs Macintosh System 7 IDE representation.

Substack needs to stop blocking VPN and data center IP addresses. I can't read the article because I'm on a train's WiFi…

Could we or do we have anything like that for the modern web?

Back when you could focus on the code you wrote and not worry about the overly cluttered distractions of the likes of VSCode.

I liked RHide a lot 23 years ago

I wish NeWS had taken off. Don Hopkins' videos on it and psiber are amazing.

Visual Cafe (I know they got a bad rep after Symantec bought them but I felt the bugs weren't major enough to make stop using it back then).

Such recallings are incomplete without fake TUIs. TUI that are seemingly text, but in graphics mode. Norton Utilities were running in text mode with altered fonts and had nice UI elements. Acronis OS Selector 5 could run in multitude of different modes: ordinary text mode with pseudographics; Norton Utilities-alike text mode with altered fonts; VGA graphics mode; SVGA graphics mode. But whatever mode, it was drawing UI in a grid. Mouse cursor was the only thing not bound to grind, but when windows were dragged by mouse, they were jumping by discrete steps, staying grid aligned at all times. I was digging in. They are Watcom C++ binaries, and Watcom can remote debug them over COM port. No sources, of course, but I can trace CPU and watch memory. So far I know that it indeed has a concept of text buffer, and each cell is 4 bytes. These bytes encode background glyphs and colors. Text can be over window title, so window title skin is encoded in background glyph. Text can be over tab title. Text can be over button. And there are icons of operating systems in the list. And there are icons on toolbar buttons.

Acronis OS Selector 5 features not much UI. There is FDISK, advanced enough for its time. It can resize FAT partitions, and there is UI for adjusting size and other stuff. There is HTML-based help system with hyperlinks. And there is some editor for AUTOEXEC.BAT and CONFIG.SYS. Acronis OS Selector 5 is about switching OSes, and specific DOS or Windows 9x boot configurations are also "OSes", so editing of boot files is helpful. But apart from that there is almost nothing to do in this OS Selector.

I wish something more daily would be coded in such UI, but nope. And Acronis dropped that style. I don't know what happened with Selector 6 and 7, but it's like 8 is coming right after 5, and 8 UI is not grid-aligned anymore.

Looking at Windows UIs from the '80s -- did Microsoft just not know the phone numbers of any graphic designers? Or did they make it ugly on purpose?

The issues mentioned in the article is generally applicable. While modern software does manage to make life marginally easier and simpler in some very specific ways, they generally manage to do so while also looking like absolute garbage, consuming hundreds of megabytes of memory to do tasks requiring kilobytes while burning through multiple orders of magnitude the amount of instructions actually needed to do the work.

Yes, Visual Basic was indeed the pinnacle, and today, it is QT, for what it's worth. But no, let's go write HTML and CSS, and when the Stockholm syndrome gets us bad enough, why not some React or Angular to get the party of pain going again ?

Fun fact not mentioned in the article is that nano descends from pico which emerged from being the default editor in the email client pine.

The experiences so far that have been left behind:

- A RAD TUI like Microsoft Visual Basic 1.0 for MS-DOS

- DolDoc from TempleOS, with diagrams and sprites

- Clipper, DBase, FoxPro, etc

"Old man yelling at modern IDEs"

Now that CLI tools are in fashion again... has nobody thought to recreate a modern version of Turbo C++/Pascal?

I know there's Emacs and vim, but they're far too programmable and bloated compared to the elegance of TC++, which did one job, and one job only, very well. Also, despite being an Emacs power user at this point, it's never going to be as ergonomic and well thought out with its arcane chords, while TC++ conveniently shows all possible keybinds throughout its UI.

I enjoyed this. Make sure to read the comments too!

I honestly don't understand why we lose IDEs and editors.

I understand that software requires people maintaining it, but my point is more that I still don't understand the why.

We have some functionality, a lot of which could be re-used in editors and IDEs. But people rarely share stuff. They like to re-implement things. Again and again and again. This is not logical to me.

I'd like to have one editor that does EVERYTHING, but in a modular way so people decide what that editor can do. People could then just maintain one cohesive, feature-rich code base rather than each one duplicating what is already available in another IDE/editor.

The article itself is a nice look at the state of editors and IDEs compared to those of yesteryear... but the site itself restyles my scroll bar to be thinner and less usable, which kind of spoils the experience.

I hate it when sites do this. I don't want my window decorations to be restyled in the name of aesthetics. I need them to be usable.

Great post. I feel obligated to reply with a similar post a friend wrote a while ago that’s probably made the rounds here as well: https://prog21.dadgum.com/116.html

30 years ago I was using XEmacs version 19 something

TUIs sucked and they still suck.

Programmers are trying to bring them back bc nostalgia I guess?

I floated the idea of TUIs to our data engineering team and got very negative responses. (My nostalgia for undergrad turbo pascal TUI I guess lol)

Schoolaged 1995 coder self with a fpuless Mac would like a word about what we lost/gained (no available c compilers at the time).

The need for tui argument is vague outside of muscle memory. Lots of beautiful poetry though.

That age of computing the author is romanticizing was expensive and corporate fed stupid (RIP Mr Bollenbach my hs cs teacher who gave us weekly insider tech reports).

I feel like tui folk need their stack/os/integrated environment...oh wait. Nevermind.

"Is FreeDos the Moderate Libertarian TempleOS?"

I feel like we should go back to ASCII for programming languages. Does your IDE really need emojis? Parsing unicode is intractable.

The title needs to be updated. These are IDEs we had 32 years ago.

Crimson Editor.

The Think Pascal IDE was on another level for it's time.

My view of the PC dev era was through the lens of a kid growing up in the 1980s with a dad who programmed for a living. My dad was a big fan of the Borland IDEs starting with Turbo Pascal and then moving on to the world of C and C++ by the late-1980s. As a kid, my friend and I spent hundreds of hours in Quick Basic’s TUI - always trying to remake Super Mario Bros but never coming close to succeeding.

These early IDEs were fantastic at their job and worked so well given the constraints of the DOS environment of the time. It’s a shame that Borland the company eventually faded to black in 2015, but that’s how these things go. I wonder where all the geniuses behind the Borland IDEs ended up.

Nostalgic! Turbo C was my preferred IDE over many years in the late 80s to mid 90s. What an amazing tool! Those key bindings, used in so many other IDEs since, are burned into muscle memory. Even after decades of not using them, they bring a smile back. CodeWarrior, the debugger, helped me understand what happens when you run a program more than literally anything else I read or was taught.

Thank for the article, this brings back so much good memories and nostalgias. Turbo Pascal was my first programming language a couple decades ago, at that time it felt like super power when you could tell the computer what to do by learning the language and just hit the Compile button.

The IDE was also so clean and intuitive, which was perfect for new programmers.

It's sad that no one has commented about Ultimate++ ( https://www.ultimatepp.org ).

I believe it's the easiest way (at least for me) to quickly create GUI programs.

But of course, nothing beats Borland's interface from the DOS era.

A few others not mentioned:

DOS: FoxPro 2.x, dBASE III Plus, dBASE IV, Turbo Pascal 5.5/6.0 was probably the pinnacle for me

OS/2: Watcom VX-REXX - extremely powerful and productive

Windows: Delphi before .NET

ha, he even lists RHIDE!! :-D

The only free solution back then in which you could have a free 32bit protected mode DPMI built-in. And a VESA linear frame buffer!!!

Good ol days :-D

Ahh, memories. I started hacking in Emacs on my Amiga 2000 in 1988. And later in Turbo Pascal in 1991ish.

When I saw Visual Studio years later, or Visual Basic, these IDEs were doing so much more, but I‘d lose the ability to fully control the bare text. These MS tools wouldn’t allow me to write my code in my favourite text editor and version it. So they were nice and a curse at the same time.

The Borland Turbos had a much bigger market impact, but I was blown away by the Zortech C++ IDE in 1988. I don't remember why any more, but I was very dismissive of other TUI IDEs of the day after using Zortech. Even in the early 1990's when I was professionally using PWB (Programmer's Waste Basket) I still felt Zortech's IDE was superior.

The knocks against Emacs feel unwarranted. It has plenty of colour; it has mouse support, even in the terminal, but not all terminals support it, so it's optional. It also runs in a GUI with, you know, image support and whatnot.

You can rail against its defaults, but do not make misleading claims.

I had to use Borland when studying but never really liked it. Later I tried Notepad+ with console for the first time and everything clicked. There is a console for compiling and running and there is a text editor for editing. It was the flow that made sense.

Oh, this reminds me: I should turn off the menu bar in emacs. Not like I ever use it.

We didn't lose all of them though. I know at least mcedit and eFTE are still kicking. And there's some new ones that pay tribute to the interface style such as https://github.com/istoph/editor

There's a recurring pattern that everything is worse now. There's a happy medium - the really old stuff is too basic, while the really new stuff is also basic. But why is the new stuff worse than the moderately old stuff?

I wrote my first program using Borland Turbo Pascal probably around 1993 at my high school. I think those systems ran DOS 3.0 or maybe 5.0? It was all trivial stuff but I found it to be very helpful to debug issues.

MegaZeux was originally a DOS program, but now has emulated PC text mode (with some enhancements, such as SMZX and unbound sprites) and continues to use a TUI, although it is not as good as Microsoft and Borland (e.g. it does not have ALT+letters in a menu to select with different colour letters, etc).

You had WPE and XWPE. And current Emacs works under a TTY with GPM and mice.

Lotta focus on TurboPascal vs Emacs or whatnot at the console level, but you couldn't give TurboPascal to a complete newbie any more than you could give them IntelliJ. The mouse is an advantage here, not a disadvantage.

I first used an IDE back in 1989 with MicroFocus COBOL from 1983. 30 years seems relatively new.

Is there a TUI that can mimic Borland’s text based UI? Something that integrates with lldb easily…

author seems to be mistaking text editors and IDE. I wouldn't put Emacs in any of these categories, it is like an operating system without the kernel part but I am not exactly sure how to call it?

30 years ago we had visual C++, with an amazing debugger. Visual J++, Visual Basic. Normal Basic. All with amazing debuggers and / or “REPL”s and compilers times of 0 or next to nothing.

I was expecting to see the most productive IDEs of all time, Visual Basic 6 and/or Borland Delphi, but we're just ahead of those in this article.

While it was truly amazing that Borland managed to stuff a full text editor into a TSR under MS-DOS, and every new version of Turbo Pascal was faster and had more features, it all culminated somewhere around Delphi for me, and Visual Basic 6 for almost everyone else.

Then the world ended... Anders Hejlsberg was lost to Microsoft, and everyone went collectively crazy in at least two orthogonal ways.

First there was the obsession with C++ as "higher level" than Pascal and the view that it was for "adults", which was delusional. C++ generated a f*ckton more boilerplate and was brittle for the same functionality, at least when generating a GUI program.

Then there was Microsoft's obsession with .NET, which they never recovered from. They crammed all the bloat of an interpreter into everything imaginable, even the operating system. You were always having to get the latest .NET libraries to make things work. They destroyed Visual Basic over this, and it never recovered.

The fun thing is that, if something like Claude Code can be competitive with modern IDEs, these ancient IDEs could become competitive as well with some kind of integration with AI workflows :)