14 ms·

IDEs we had 30 years ago and lost (2023)

• matt7340 1y ago
  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!
• sph 1y ago
  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.
  • AlexeyBrin 1y ago
    FreePascal has a text mode IDE similar to the old Turbo Pascal 7.0 that you can use in a Terminal. So you can use a modern Pascal compiler from it.
  • coolcoder613 1y ago
    Have you seen tvision[0] and turbo[1]? [0] https://github.com/magiblot/tvision https://github.com/magiblot/tvision [1] https://github.com/magiblot/turbo https://github.com/magiblot/turbo
    • badsectoracula 1y ago
      There is also Free Vision which is part of Free Pascal. I used it sometime ago when i wanted to write a TUI viewer[0] for info files[1], though i never finished it (should pick it up at some point since it is mostly done). [0] https://i.imgur.com/Qvkt3W0.png https://i.imgur.com/Qvkt3W0.png [1] https://www.gnu.org/software/texinfo/manual/texinfo/html_node/Info-Format-Specification.html https://www.gnu.org/software/texinfo/manual/texinfo/html_nod...
    • fithisux 1y ago
      I use it instead of edit on Windows for everything in Windows Terminal, except development where I use helix editor. It works fine with Yori too, not only CMD.
  • Brian_K_White 1y ago
    A hundred years ago I found something called XWPE and managed to build it for sco osr5, and then pretty much never used it for real. (That doesn't imply I went with VS or similar fat ide, just that I didn't end up using xwpe for real. I tried code::blocks for a while but mostly just use geany or a plain editor.)
    • lproven 1y ago
      Try Tilde. https://github.com/gphalkes/tilde https://github.com/gphalkes/tilde
      • Brian_K_White 1y ago
        They commandere the break key to use it for cut & paste? oh hell no. But thank you anyway, I understand the suggestion was well meant and it does look nice.
  • Dwedit 1y ago
    DOS programs ran in Text Mode, and directly interacted with the keyboard hardware. Linux Terminal programs are running in an emulated terminal, and are bound by keyboard input restrictions that DOS programs did not have.
• chris_wot 1y ago
  Is there a TUI that can mimic Borland’s text based UI? Something that integrates with lldb easily…
  • lproven 1y ago
    https://github.com/magiblot/tvision https://github.com/magiblot/tvision https://github.com/cosmos72/twin https://github.com/cosmos72/twin https://github.com/Julien-cpsn/desktop-tui https://github.com/Julien-cpsn/desktop-tui
• api 1y ago
  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.
  • kranke155 1y ago
    What binaries are a good example of this?
  • AlexeyBrin 1y ago
    Mostly because of static linking. C and C++ don't put every library they need in the binary by default. The advantage is that a pure Go or Rust binary just works (most of the time) when copied from one machine to another, you don't have to care about installing other libraries.
    • Onavo 1y ago
      Go especially, on some platforms they go straight to syscalls and bypass libc entirely. They even bring their own network stack. It's the maximalist plan 9 philosophy in action.
      • self_awareness 1y ago
        I don't really like Go as a language, but this decision to skip libc and go directly with syscalls is genius. I wish Rust could do the same. More languages should skip libc. Glibc is the main reason Linux software is binary non-portable between distros (of course not the only reason, but most of the problems come from glibc).
• jfengel 1y ago
  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.
• PaulHoule 1y ago
  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.
  • floam 1y ago
    Damn that actually sounds superior. How did changing the size work?
    • layer8 1y ago
      Unless the program specifically allowed for it, you couldn’t change the size (video mode, really) without exiting and restarting the program after changing modes on the DOS prompt. Remember, the video hardware rendered text mode full-screen, and it had to be reconfigured to change to a different number of lines and columns. Only specific sizes were supported.
    • danparsonson 1y ago
      There were a bunch of predefined modes in the video BIOS, and with a little bit of assembler you'd issue an interrupt (a system call really) which would change the video mode. Then as the parent comment said, you could write to video memory directly and your writes would either be interpreted as ASCII character/attribute pairs in a text mode, or colour palette indices in a graphical mode. Most games at that time used mode 13h which was 320x200 with 8-bits per pixel which therefore indexed into a 256-colour palette (which could itself be redefined on the fly via reading from and writing to a couple of special registers - allowing for easy colour-cycling effects that were popular at that time). Here's a list of the modes: https://www.minuszerodegrees.net/video/bios_video_modes.htm https://www.minuszerodegrees.net/video/bios_video_modes.htm
• anthk 1y ago
  You had WPE and XWPE. And current Emacs works under a TTY with GPM and mice.
  • lproven 1y ago
    Today there's Tilde. https://github.com/gphalkes/tilde https://github.com/gphalkes/tilde
• coldcode 1y ago
  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.
  • elevation 1y ago
    I got a windows 95 66MHz Pentium machine with 16MB ram at a yard sale in 2002. Visual Studio 5 Enterprise worked plenty fast on that with features I still miss (or which don’t perform as well) in modern environments.
  • marstall 1y ago
    totally. so strange that that was the fastest, most flowy dev experience i've ever had. been chasing that ever since. though i must say rails, vite, react fast refresh, etc. are pretty nice in that regard.
  • chadcmulligan 1y ago
    Have you tried Delphi lately, very fast, compiles in less than a second.
  • 1313ed01 1y ago
    Came here to share this mandatory link on this subject, Dadgm's Things That Turbo Pascal is Smaller Than: https://prog21.dadgum.com/116.html https://prog21.dadgum.com/116.html I used Turbo Pascal 2 as late as 1991, if not later, because that was the version we had. It was really fast on a 386 40 MHz or whatever exact type of PC we had then. A bit limiting perhaps that it only came with a library for CGA graphics, but on the other hand it made everything simpler and it was good for learning. A few years ago I wanted to run my old Turbo Pascal games and decided to port to Free Pascal. Sadly Free Pascal turned out to only ship with the graphics library introduced in Turbo Pascal 4, but on the other hand I got a few hours of fun figuring out how to implement the Turbo Pascal 1-3 graphics API using inclined assembler to draw CGA graphics, and then my games worked (not very fun games to be honest; more fun to implement that API).
  • 1y ago
• constantcrying 1y ago
  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.
  • marstall 1y ago
    and yet zed is straight up slower than turbo c++
    • constantcrying 1y ago
      What? "Slower" how? And why would dev experience not matter more? TUIs are bizarre legacy technology, which are full of dirty hacks to somewhat emulate features every other desktop has. Why would any developer use them, when superior alternatives, not based on this legacy technology, exist and freely available?
      • jagged-chisel 1y ago
        Lots of opinions in the thread without any substance to back it up. If you don’t like TUIs and terminals, that’s ok. But if you actually want to argue against them, let’s hear a substantive argument. What specifically is so bad about the TUI?
        • constantcrying 1y ago
          They are built on ancient technology and need an enormous array of hacks to emulate basic features, which are trivial to do in any modern GUI. User experience is inconsistent with features varying wildly between terminals, creating a frustrating user experience. It is also making customization difficult. E.g. in a TUI IDE you can not have font settings. Short cuts are also terminal dependent, an IDE can only use those shortcuts the terminal isn't using itself. Something as basic as color is extremely hard to do right on a terminal. Where in a normal GUI you can give any element a simple RGB color, you can not replicate that across TUIs. The same goes for text styling, the terminal decides what an italic font it wants to use and the IDE can not modify this. They are also very limited in graphical ability. Many features users expect in a GUI can not be replicated or can only be replicated poorly. E.g. modern data science IDEs feature inline graphics, such as plots. This is (almost) not replicable on a Terminal. If you are using profiler you might want to plot, preferably with live data. Why arbitrarily limit what an IDE can do to some character grid? The terminal is just a very poor graphical abstraction. It arbitrarily limits what an IDE can do. Can you tell me why anybody would seriously try to use a terminal as an IDE? Terminals UIs are more complex, because they need to handle the bizarre underlying terminal, they are often less responsive, since they rely on the terminal to be responsive. There might be some very marginal improvement in resource usage, do you think that is even relevant compared to the much increased dev experience of a normal GUI? There absolutely is no real advantage of TUIs. And generally I have found people obsessing over them to be mostly less tech literate and wanting to "show off" how cool their computer skills are. All serious developers I have ever known used graphical dev tools.
• andai 1y ago
  I enjoyed this. Make sure to read the comments too!
• deleted 1y ago
  [deleted]
• codezero 1y ago
  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.
• csmpltn 1y ago
  Crimson Editor.
  • chadcmulligan 1y ago
    It's emerald editor now I think - https://sourceforge.net/projects/emeraldeditor/ https://sourceforge.net/projects/emeraldeditor/. I used to use this because it had integrated ftp and the place I was working wouldn't allow shares so edit in crimson editor and save as ftp. Its a nice editor.
  • cwnyth 1y ago
    A name I haven't heard in nearly 20 years. This was my go-to editor on Windows. Crimson Editor and Dev-C++ were great free tools.
• dimitar 1y ago
  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/ 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.
  • _2d30 1y ago
    The Magit experience is due to the use of the transient package for its UI. Some other packages also use it. Most notably for my personal usage is the gptel package.
    • dimitar 1y ago
      Indeed! I went back just to mention it owes its incredible UX to the transient package, I am going to look up more uses for it. Do recommend more if you can, please!
    • pkal 1y ago
      Transient is the worst part about Magit IMO (the best parts are how you can prepare a commit to just include the right changes, or the functionality bound inside the transient menus that make complex operations such as fixups or rebases trivial). Transient UIs are consistently uncomfortable to work with, and could usually be replaced by just using a regular special-mode keymap in a custom buffer. The fact that Transient hooks into the MVC and breaks elementary navigation such as using isearch or switching around buffers has irritated me ever since Magit adopted the new interface. The real neat thing about Emacs' text interface is that it is just text that you can consistently manipulate and interact with. It is precisely the fact that I can isearch, use Occur write out a region to a file, diff two buffers, use find-file-at-point, etc. that makes it so interesting to me at least. A far more interesting example than Magit is the compile buffer (from M-x compile): This is just a regular text buffer with a specific major mode that highlights compiler errors so that you can follow them to the referenced files (thereby relegating line-numbers to an implementation detail that you don't have to show the user at all times). But you can also save the buffer, with the output from whatever the command was onto disk. If you then decide to re-open the buffer again at whatever point, it still all looks just as highlighted as before (where the point is not that it just uses color for it's own sake, but to semantically highlight what different parts of the buffer signify) and you can even just press "g" -- the conventional "revert" key -- to run the compile job again, with the same command as you ran the last time. This works because all the state is syntactically present in the file (from the file local variable that indicates the major mode to the error messages that Emacs can recognize), and doesn't have to be stored outside of the file in in-memory data structures that are lost when you close Emacs/reboot your system. The same applies to grepping btw, as M-x grep uses a major mode that inherits the compile-mode.
• auggierose 1y ago
  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.
• mickeyp 1y ago
  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.
  • frou_dh 1y ago
    Also, the set of top-level things in the menu bar is not static. So even if you cannot directly interact with it for some reason, it gives you a hint that new things are possible in particular contexts. (Same goes for the 'tool-bar' that's distinct from the menu-bar)
  • DonHopkins 1y ago
    My cat is named Emacs, so I take those knocks against Emacs personally. Interview with an Emacs Enthusiast [Colorized] https://www.youtube.com/watch?v=urcL86UpqZc https://www.youtube.com/watch?v=urcL86UpqZc
  • rbanffy 1y ago
    I wonder if it's still possible to run Guy Steele's era EMACS.
  • internet_points 1y ago
    Yeah, the menu bar thing just makes no sense. Here's what a completely uncustomized emacs looks like: https://i.imgur.com/0vFsd3p.png https://i.imgur.com/0vFsd3p.png If you for whatever reason absolutely need to run it in the terminal, then you'll have to either learn that F10 toggles the menu bar, but then it still looks like a real menu bar that you can navigate with the arrows and enter: https://i.imgur.com/ETA2Qhs.png https://i.imgur.com/ETA2Qhs.png (or you can `M-x xterm-mouse-mode` to use the mouse in the terminal). (That said, I'm sure the out of the box experience with Borland was quite a bit better back in the day, if you only needed Pascal or C++ support. And emacs really could do with a better default-theme; e.g. simply changing to the built-in modus-vivendi-tinted and it looks like https://i.imgur.com/lRAWzJK.png https://i.imgur.com/lRAWzJK.png instead. Doesn't help with the tool-bar icons from 1999 or whatever though)
• G_o_D 1y ago
  Been setteled on https://scintilla.org/SciTE.html 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
• guerrilla 1y ago
  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.
  • fragmede 1y ago
    The convenience is the point. Instead of having to go and find the file that lists a class's functions, an IDE can list them and you can just click on the one you want. As the author points out, LSPs do that function in the modern era, but the point is, it's useful. Doesn't have to be your cup of tea, but you should at least be able to see the point.
  • ivankelly 1y ago
    I recall CodeWarrior being the official ide for SymbianOS when I started there. And it sucked, but likely more due to the integration. I think sucky custom rarely working IDEs is what pushed me to full time emacs
  • tjpnz 1y ago
    I do like the "quietness" of vim. With a minimal configuration I've replaced most of the conveniences I enjoyed with PyCharm and VSCode, but without the constant notification spam and weird virtualenv configuration issues I previously had switching between projects.
  • tpm 1y ago
    I can't really imagine navigating huge Java codebases with vim or bash. OTOH I used vim to work with Perl (that was not a small codebase either but had a very different structure).
  • raw_anon_1111 1y ago
    As someone who has been doing this either professionally (since 1996) or as a hobbyist programming in assembly and a little Basic (1986-1992), I’m always amazed at the feigned Slashdot style “I haven’t owned a Tv in 40 years why do people still watch them”. Are you really saying that you don’t see any utility in modern IDEs? Even back in 1999 I thought Visual Studio was a breath of fresh air let alone R# with all of the built in refactors in 2008. But going further back, to the Turbo days in college and my first few years working, breakpoints, conditional breakpoints, watches etc were a godsend
• mkovach 1y ago
  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.
  • citbl 1y ago
    What a wonderful write up and I feel the same. I've been working on my free time on a tui code editor in the same vein eventually with make and lldb built in.
  • bombcar 1y ago
    One thing about the "professional" DOS software (and you can see it in things like Emacs - eight modes and constantly shifting) was you were basically expected to live in it - it had the full attention of the computer and the user. You were also expected to learn it; which meant you became "one with the machine" in a way similar to an organ player. I remember watching Fry's Electronics employees fly through their TUI, so fast that they'd walk away while it was still loading screens, and eventually a printout would come out for the cage.
    • esafak 1y ago
      The old TUIs were faster yet I still prefer IntelliJ; it's fast enough and much more powerful.
    • exe34 1y ago
• pragmatic 1y ago
  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)
  • loloquwowndueo 1y ago
    Care to elaborate as to why they suck?
    • bob1029 1y ago
      It's not that TUIs suck in terms of their inherent capabilities. It's that they're generally a miserable tool for the job, especially if it's a big one. TUIs are like shovels. A perfectly rational tool for doing a little bit of digging. Visual Studio 2022 is like Bagger 293.
  • realharo 1y ago
    I think TUIs mostly suck for IDEs, but some tools like k9s or htop are nice.
    • tstenner 1y ago
      Even k9s would profit enormously from detachable dialogs. Just let me do something without losing my current log view.
  • dardeaup 1y ago
    Some do and some don't. Have you ever used any to develop an application? I suppose a lot of it is also relative. When I started with TUIs decades ago, we didn't have too many options. Turbo Pascal 5.5 or 6.0 was extremely nice to use back in the day.
  • 1313ed01 1y ago
    They are undeniably programmer-friendly though, no matter how hated by users. Much easier to do things when you are limited to just a grid of fixed size characters rather than the bizarre complexities of modern GUIs.
• MomsAVoxell 1y ago
  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 ..)
  • dapperdrake 1y ago
    You may laugh, but that is how I use html forms today. Simple. And effective.
    • MomsAVoxell 1y ago
      I wouldn’t laugh at that, but my context is native applications and will be, for a while. Sure, the web is great and all. But native applications still have a part to play - especially in realms requiring custom applications be built, i.e. not for mass-market.
  • spacechild1 1y ago
    > The moment someone produces a properly WYSIWYG tool for JUCE, Side note: Steinberg's vstgui framework not only has a WYSIWYG editor, you can even build/edit the UI while the plugin is running in a DAW. I usually give Steinberg a lot of shit for their arrogance and ignorance, but this I found extremely cool! I have only toyed around with it, so I don't know how viable it is for complex plugin UIs.
• salvesefu 1y ago
  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?"
• cmrdporcupine 1y ago
  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.
• Lapel2742 1y ago
  > “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.
  • SoftTalker 1y ago
    The reason IDEs blossomed on DOS was because there was no multitasking. On unix/linux, even on a "dumb" tty with no GUI, you could hit CRTL-Z and your editor would go into the background and you'd be at a shell where you could run make or gdb or manage files. Then type 'fg' and your editor would be back exactly as you left it. IDEs do all that in one huge program because if you exited your editor to run the compiler or run your program, when you went back to the editor it was starting up cold again. TSR programs like Sidekick avoided some of this but were a poor substutute for real multitasking.
    • burnt-resistor 1y ago
      There are multitasking options using DESQview(/X) or Windows >=3.1. A friend of mine in high school ran a 4 line BBS using DESQview and 4 Courier 28.8K modems. In real mode, it's possible to have a TSR that swaps the entire contents of RAM from disk. As long as such a hypothetical TSR is always loaded into a fixed location, it's possible to save and restore the entire DOS, program, and/or EMS/XMS session.
  • NetMageSCW 1y ago
    The best software ever written was ThinkTank (and next it to it, Memory Mate). Sidekick was great for popularizing the TSR, though.
  • 3x35r22m4u 1y ago
    SideKick had the ability to take "screenshots" of the text shown in other applications. Being a TSR was cool, but stealing text from another program interface was mind blowing!
• RcouF1uZ4gsC 1y ago
  To me VB 6 was the height of RAD IDEs You could throw together a CRUD app in under an hour interactively.
  • rbanffy 1y ago
    VB was the GUI equivalent of Dataflex - you could design the screen and it would automagically create the data structures under it. I also remember, from the same period, Mantis (from Cincom Systems) that did the same for 3270 terminals and IBM mainframes. I often say Deteflex is Ruby on Rails for the VT100.
• geenat 1y ago
  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.
• jmmv 1y ago
  Hey, thanks for sharing this again! FYI, previous discussion from 2 years ago now (wow, time flies...): https://news.ycombinator.com/item?id=38792446 https://news.ycombinator.com/item?id=38792446
  • dang 1y ago
    Thanks! Macroexpanded: IDEs we had 30 years ago - https://news.ycombinator.com/item?id=38792446 https://news.ycombinator.com/item?id=38792446 - Dec 2023 (603 comments)
• greatgib 1y ago
  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...
  • 1313ed01 1y ago
    The nicest thing about programming for DOS (or probably any old home computer or console?) is that you are in full control of inputs and timing. If you only need to update the screen when the user hits a key for instance you can just call a function to wait for the next key-press, handle that, ask for the next... There is no async, no callbacks, no events, no threads. Nothing is easier than just imperative code doing things one line then the next, then the next. You can still have a main loop, but you do not need to, and if some function you call somewhere to handle something wants to wait for a key-press before returning it can do that and you do not have to yield or anything. I'd love to see some modern environment replicate that somehow. Let us pretend everything is simple and synchronous even if it very much isn't.
• markus_zhang 1y ago
  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.
  • bigstrat2003 1y ago
    I think that GUI editors are just plain superior for doing serious work. I'm a Sublime guy myself, but really any GUI editor blows any text based option out of the water. The only good use case for text based editors these days is to quickly edit and save config files while ssh'ed into a server.
    • markus_zhang 1y ago
      I heard people can be pretty productive in Emacs/Vim. My issue is that I’m not a great programmer, so 99% of the time is spent on reading code and figuring out the steps on paper. I’m sure TUI can be great for that purpose too, but GUI IDEs on multiple screens are on par at least.
• Dwedit 1y ago
  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".
• fragmede 1y ago
  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?
• massung 1y ago
  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 https://prog21.dadgum.com/116.html
• astatine 1y ago
  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.
• fithisux 1y ago
  I liked RHide a lot 23 years ago
• fnord77 1y ago
  30 years ago I was using XEmacs version 19 something
• rana763 1y ago
  [dead]
• andsoitis 1y ago
  Delphi - fantastic, modern RAD IDE. Borland heritage. Can build native apps for Windows, Linux, macOS, iOS, and Android. https://www.embarcadero.com/products/delphi https://www.embarcadero.com/products/delphi
  • dardeaup 1y ago
    Delphi is still very impressive. However, they missed out on a much greater opportunity. Part of Delphi's crown jewels is VCL which can only be used on Windows. If you use Delphi for an OS other than Windows you have to use FireMonkey/FMX. Lazarus has LCL which is VERY similar to VCL, but LCL on Lazarus is not limited to Windows. One can write a LCL application and it works the same on Windows, macOS, and Linux. If Delphi had extended VCL to macOS and Linux it would have become much more valuable. Just my $0.02.
    • andsoitis 1y ago
      Don’t disagree that VCL across all the platforms would be a game changer. However, the quality and reliability of the Delphi experience together with mobile support overcome the VCL/FMX trade off in my books.
      • nobleach 1y ago
        I had high hopes for Kylix back around the turn of the millennium. At that time my company was looking moving an organization with field agents to a full Linux-based system. Our options were: 1. Keep the existing CA Clipper accounts receivable/accounts payable apps and run on emulated DOS. 2. Attempt to leverage the Harbour language (CA Clipper compatible web based thing). 3. Rewrite the system in Delphi/Kylix. We actually got fairly far with Kylix and I'll always be a fan of Delphi. In the end a pure web-based rewrite won over all those original options. I feel bad for whomever took over that old PHP4 stuff!
    • spwa4 1y ago
      VCL was ported to linux in the "Kylix" product, for both Pascal and C++. It was non-free and didn't see any uptake really.
• alexshendi 1y ago
  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.
• gcanyon 1y ago
  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?
  • layer8 1y ago
    There are no Windows UI screenshots in the article.
    • gcanyon 1y ago
      Fair —- but are you claiming either: 1. The DOS screenshots in the article are in any way reflective of a designer’s input 2. That Windows was a visually pleasing design?
      • layer8 1y ago
        The DOS screenshots are reflective of the PC video hardware of the time. Text mode had a fixed 16-color palette [0] at best, the IBM font including graphics characters was preset, while the aspect ratio of the characters wasn’t fixed (the screenshots in the article are 80x25, but I used 80x40 or 80x50, with correspondingly more quadratic text cells). However, the screenshots aren’t quite representative of how things looked on a CRT monitor, however; it looked more vibrant and organic, if that makes sense. Personally I didn’t find Windows visually pleasing before Windows 95, but much of that can again be attributed to the PC video hardware limitations of the time. [0] https://en.wikipedia.org/wiki/Color_Graphics_Adapter#Color_palette https://en.wikipedia.org/wiki/Color_Graphics_Adapter#Color_p...
        • gcanyon 1y ago
          Thanks for the trip down memory lane! I worked with DOS in… WordPerfect? I don’t remember for sure which word processing application it was. But I honestly don’t remember ever seeing anything remotely “graphic“ in my DOS days.
          • 1y ago
• sys_64738 1y ago
  I first used an IDE back in 1989 with MicroFocus COBOL from 1983. 30 years seems relatively new.
• Surac 1y ago
  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
• dardeaup 1y ago
  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
  • niutech 1y ago
    There is also Open Watcom for FreeDOS.
• justinhj 1y ago
  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.
• cess11 1y ago
  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.
• afc 1y ago
  For what it's worth it, I'm still developing and using exclusively my own text-based editor/IDE: https://github.com/alefore/edge 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 https://github.com/alefore/weblog/blob/master/edge/README.md
  • ivanjermakov 1y ago
    Me too. It took ~4 months of development, but was fun. https://github.com/ivanjermakov/hat https://github.com/ivanjermakov/hat
• 4b11b4 1y ago
  Recent install of Emacs 30 and Doom 3.0 via https://github.com/jimeh/emacs-builds 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
• neuroelectron 1y ago
  I feel like we should go back to ASCII for programming languages. Does your IDE really need emojis? Parsing unicode is intractable.
  • zzo38computer 1y ago
    I agree, and I still do use ASCII for (most) programming languages. I do not use emojis and most programs I wrote do not use Unicode (although often there is a use to go beyond ASCII, but even then, I will use better character sets rather than Unicode).
• JeremyHerrman 1y ago
  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/turbo_c/Turbo_C_Users_Guide_1987.pdf http://bitsavers.informatik.uni-stuttgart.de/pdf/borland/tur...
  • cameldrv 1y ago
    The Turbo Pascal version of this was even better, because you could do a whole block of asm instead of just a single line at a time. As I remember there were annoying limitations in the C version around labels and such. It was incredibly useful when writing performance oriented code at that time because it was very easy to write code that would outperform the compiler.
    • badsectoracula 1y ago
      I'm pretty sure you could do asm blocks in Turbo C using brackets, e.g. asm { ... }, though it might have been a Turbo C++ thing (i never really used plain TC much).
  • miohtama 1y ago
    It was not very common to interleave assembly in MS-DOS IDEs. Assembler and its IDE were separate tools you paid for. But not unheard of. You could "dump" your OBJ file for assembly. Later C compilers got some better inline assembler support but this was towards the 32-bit era already. Also Borland had its own compiler, linker and such as separate binaries you could run with a Makefile but you really never had to, as why would you when you can do that in the IDE in a single keypress.
• reaperducer 1y ago
  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.jpg/200px-Forth64-audiogenic.jpg 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
  • somat 1y ago
    I do want to point out that the 2600 was at it's heart a slightly generalized pong machine, to the degree that I don't find it surprising that you can make pong in 6 lines of 2600 basic. The 2600 graphics were centered around 5 sprites dedicated to two players, two missiles, and a ball. Completely understandable, they were trying to make a toy computer affordable enough for everyone in 1975. but their design process was basically "what is the bare minimum video hardware required to make the games "combat" and "pong". Every single game found on the 2600 that is not a combat or pong clone is probably a masterwork example of making the hardware do something it was not intended for. https://en.wikipedia.org/wiki/Television_Interface_Adaptor https://en.wikipedia.org/wiki/Television_Interface_Adaptor Footnote: yes I know it was released in 1977, but it was designed in 1975.
• rajkhare05 1y ago
  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!
• bvan 1y ago
  Back when you could focus on the code you wrote and not worry about the overly cluttered distractions of the likes of VSCode.
• CGamesPlay 1y ago
  (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.
  • a3w 1y ago
    Rough quote: "in 1984 we had at my house", so even 41 years seems to be in the scope. I was expecting - early projects that ended in Visual Studio 1.0 or NetBeans soon after, (2 to 9 years too early for them) not - "vim (1991) was not out yet" (not-a-quote, but my feeiling upon looking at ncurses instead of floating windows)
    • projektfu 1y ago
      I snickered a little because I know Visual Studio didn't have a version 1.0. Wikipedia identifies the first version as Visual Studio 97, which was at version 5.0. I remember before that there was "Microsoft Developer Studio 4.0" which came out around Windows 95, and could run on 95 or on NT 3.51. There was a Visual C++ 1.0 and a Visual Basic 1.0 released at different times. Meanwhile there were also the workhorses, Microsoft C and MASM. In those days, Borland and Watcom were real competitors to Microsoft for C and C++.
    • roryirvine 1y ago
      Yeah, by 1995, Visual Basic / C++, Delphi / Borland C++, and Symantec C++ were all-conquering. A few years before, it was very different - VisualAge and Rational Application Developer were the big names in the early 90s in "professional" IDEs. Interface Builder for university spin-outs or funky startups (and SunWorks / Forte Studio for the less-funky ones). CodeWarrior on the Mac (perhaps with THINK! hanging on too). I think Softbench was popular for scientific software, but I never actually saw it myself. And then just a few years later, the rise of Java turned things upside down again and we got Jbuilder, Visual Cafe, & NetBeans as the beginning of yet another new wave. The Visual Studio suite really began to take off around then, too. In short, the 90s were a time of huge change and the author seems to have missed most of it!
• username223 1y ago
  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 https://www.gnu.org/fun/jokes/ed-msg.txt
• buescher 1y ago
  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.
• Sophira 1y ago
  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.
• nhatcher 1y ago
  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 https://github.com/microsoft/edit [2]: https://news.ycombinator.com/item?id=44031529 https://news.ycombinator.com/item?id=44031529
  • self_awareness 1y ago
    I wouldn't learn from it, since it uses unsafe code even for basic stuff, like hash calculation. It's also a complete reimplementation, it shares only the name with original edit.com.
    • nhatcher 1y ago
      Well, you wouldn't learn as is let's learn Rust from it. But I think it has many interesting bits not found in most open source projects out there. and true that, there is a lot of unsafe code, uses nightly builds, its own allocator, crazy stuff. I did learn a lot from it :) And yeah, it is a reimplemantion. But it is a TUI and very minimal. Keepining it minimal, with no dependendecies and software bloat seems to be one of the guidelines. So very much something adding to the article at case. But yeah, you are right on both counts.
• anarticle 1y ago
  "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 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
• fred_is_fred 1y ago
  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.
• ttul 1y ago
  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.
• chuckadams 1y ago
  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.
• haolez 1y ago
  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 :)
• duanhjlt 1y ago
  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.
  • dualogy 1y ago
    TextAdept, the most criminally-underhyped high-quality text editor that I know of, has supported LSP for quite some time now IIRC, and has (not just GUI versions but also) a first-class TUI version.
    • jasperry 1y ago
      TextAdept and its possibilities have intrigued me for a while now; a fast Qt GUI and Lua-based configuration sounds like a sweet spot for me. But I've never fully taken the plunge to configure it for development. I'm open to reading more propaganda for it if you can point me to any :)
• shermantanktop 1y ago
  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.
• skopje 1y ago
  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.
  • andai 1y ago
    Coders considered harmful.
    • webdevver 1y ago
      truth nuke
• newswasboring 1y ago
  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?
• deleted 1y ago
  [deleted]
• burnt-resistor 1y ago
  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.
• p0w3n3d 1y ago
  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
• shadowgovt 1y ago
  Oh, this reminds me: I should turn off the menu bar in emacs. Not like I ever use it.
• JoshTriplett 1y ago
  I still remember https://en.wikipedia.org/wiki/Brief_(text_editor) https://en.wikipedia.org/wiki/Brief_(text_editor) , which I used extensively in DOS; it was my first "programmer's editor".
• mcshicks 1y ago
  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) https://en.wikipedia.org/wiki/Brief_(text_editor)
  • youngtaff 1y ago
    Brief was fantastic was my day-to-day editor in the late 80s / early 90s
  • moffkalast 1y ago
    A brief mention. Ba dum tss.
  • socalgal2 1y ago
    brief by underware I don't remember Borland buying it
• mrbonner 1y ago
  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.
• geophile 1y ago
  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.
  • prmoustache 1y ago
    Except for resource usage. I chose it becaue I don't have access to neovim on my cloud desktop and ideavim is a superior solution to any vim like plugins for vscode. It is struggling with 4 cores and 16GB of ram with only a few projects open at a time. Some of it is due to being win11 with the amount of security malware installed by my company but still vscode doesn't seem to make it suffer that much.
  • int_19h 1y ago
    Visual Studio still supports WinForms including the graphical form designer, which is very close to the OG Delphi experience in late 90s (esp. since WinForms is such a blatant rip off VCL).
    • pjmlp 1y ago
      You are missing a step there, before Windows Forms there was WFC, Windows Foudation Classes (not to mix with the other WFC from .NET), used in J++, one of the reasons for Sun's lawsuit. Alongside events, and J/Direct the percursor to P/Invoke. https://news.microsoft.com/source/1998/03/10/microsoft-visual-j-6-0-combines-productivity-of-java-language-with-power-of-windows/ https://news.microsoft.com/source/1998/03/10/microsoft-visua... It was WFC that was the rip off, WinForms is basically WFC redone in C#.
• tangotaylor 1y ago
  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.
• manithree 1y ago
  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.
• tern 1y ago
  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.
• a-dub 1y ago
  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!
• ataru 1y ago
  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.
• joe91 1y ago
  No love for MultiEdit? :(
  • alexott 1y ago
    I’m also was wondering that it wasn’t mentioned. At some point I did all programming in it, compiling via command line, switching to Borland IDEs only for debugging….
• bibiver 1y ago
  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.
  • nxor 1y ago
    Is this not an overstatement? How does a person understand code if they write so much of it with AI?
    • FpUser 1y ago
      Because I tell AI exactly what and very often how to write the code to avoid sub-optimal solutions AI so keen to propose if not properly directed. As for autocompletion, not sure about every tool but CLion and other IDEs I have from JetBrains are genius. Yes they can autocomplete multiple lines of code with a single keystrokes and no I do not really want to write it myself as it mostly boilerplate code I've written many times and autocompletion just predicts it.
      • nxor 1y ago
        How can you recognize optimal / suboptimal solutions if you need to use AI in the first place? As for boilerplate, I thought there were ways to automate this without AI, but I guess that makes sense to me. Not trying to sound accusatory, just jarred by the AI hype generally
        • 1y ago
• James_K 1y ago
  Of course, Emacs can do everything listed in this article, even edit remote files over SSH while in graphical mode.
• trashface 1y ago
  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.
• submeta 1y ago
  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.
• foofoo12 1y ago
  Could we or do we have anything like that for the modern web?
• mikewarot 1y ago
  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.
  • neonsunset 1y ago
    [dead]
• whartung 1y ago
  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."
  • pjmlp 1y ago
    Failure of Linux Desktop you mean. RDP works great and GUI tooling for Windows and macOS is quite comparable to using VB, Delphi, Smalltalk like experiences.
    • f1shy 1y ago
      X could do that before RDP was even a project. I think OP is meaning something different.
      • pjmlp 1y ago
        Of course it could, it is essentially dead, because hardly anyone still does X remoting, and Wayland doesn't support it.
        • int_19h 1y ago
          Ironically these days the built-in "remote desktop" feature in Gnome is literally RDP.
          • lproven 1y ago
            Not really ironic. The GNOME team are mostly paid by the same company as the Wayland team (and the Flatpak team and the OStree team and the systemd team) and that team wants to replace X.org with its own new tool.
• majormajor 1y ago
  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.
  • Narishma 1y ago
    The mouse worked fine in the Turbo IDEs.
• inetknght 1y ago
  > 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"
  • oblio 1y ago
    I haven't checked in Win 11, but all standard Windows apps used to be fully navigable by keyboard only. Notepad, Wordpad, etc.
• SomeHacker44 1y ago
  We had Symbolics Genera, not mentioned, and way better than anything else mentioned here, IMO.
• deleted 1y ago
  [deleted]
• jmyeet 1y ago
  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.
• qingcharles 1y ago
  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)
• timpera 1y ago
  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…
• 29athrowaway 1y ago
  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
• shevy-java 1y ago
  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.
• qiller 1y ago
  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.
  • lproven 1y ago
    As other commenters have noted, the name for the Ctrl+Kx UI is the WordStar keystrokes.
• exceldrawing 1y ago
  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).
• jbverschoor 1y ago
  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.
• twism 1y ago
  He touched on Emacs and it reminded me of the Blub Paradox https://wiki.c2.com/?BlubParadox https://wiki.c2.com/?BlubParadox
• immibis 1y ago
  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?
• albertzeyer 1y ago
  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/ 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.
  • jmmv 1y ago
    > 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. Exactly. I recently recorded a video of me creating a toy app with VB3 on Windows 3.11 and the corresponding tweet went “viral” for similar reasons as this article. It’s not really about the TUI: it’s about the integrated experience as you say!
  • cookiengineer 1y ago
    To me, Lazarus is the golden standard of IDEs, because Lazarus is built in Lazarus and the author really knows how to dogfeed his own product. So many examples and tutorials, it's really awesome for teaching kids how to make programs. I mean, it's really an IDE similar to what we were used to later with Microsoft Visual Studio, when it had integrated tagging, search, help, API docs, widget examples and libraries etc. Every time someone tries to tell me what an IDE is, I say nope, that's not an IDE because nothing is integrated there. Xcode could be argued is an IDE (still) but it's a painful one in comparison with Lazarus. But what do I know, I am so stubborn that I build my own UI frontend framework in Go for the last 6 months because I refuse to go back to the JS world. Hopefully at some point I can make an IDE with that, but who knows how much timd I need for that...
• garganzol 1y ago
  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).
• prmoustache 1y ago
  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?
• sheepscreek 1y ago
  > 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.
  • ranger_danger 1y ago
    I find Qt Creator to be quite comparable to the experience I remember with e.g. VB6. Have you tried it?
    • EasyMark 1y ago
      Yeah if you know c++ decently, you can whip up a basic app pretty quickly.
      • ChromaticPanic 1y ago
        Works with python too, you can build a desktop UI for your app in an hour
  • p3rls 1y ago
    [dead]
  • int_19h 1y ago
    Delphi was superior to VB even back in the day, and is still around, as is Lazarus. C# WinForms is actually closest to that, not to VB - and is also still around.
    • throw-the-towel 1y ago
• rednafi 1y ago
  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.
• dusted 1y ago
  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 ?
• zzo38computer 1y ago
  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).
• rimmontrieu 1y ago
  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.
• ranger_danger 1y ago
  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 https://github.com/istoph/editor
  • int_19h 1y ago
    If you like mcedit check out https://github.com/elfmz/far2l https://github.com/elfmz/far2l (`-e` starts it in editor mode).
  • lproven 1y ago
    As above -- also Tilde which in my testing is much superior to either mcedit or eFTE. https://github.com/gphalkes/tilde https://github.com/gphalkes/tilde
• anonymousiam 1y ago
  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.
• ta12653421 1y ago
  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
• LaGrange 1y ago
  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.
• PeterStuer 1y ago
  The Think Pascal IDE was on another level for it's time.
• carra 1y ago
  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.
  • christophilus 1y ago
    VB6 was a revelation to me, coming from C and C++ at the time. It was so much easier and still plenty performant for the kinds of little business applications I was building at the time.
  • niutech 1y ago
    You can still run Visual Basic 6 in Windows 11 and compile programs like in '99. Windows is incredibly backwards-compatible.
  • supportengineer 1y ago
    Another aspect of the sheer number of technologies that you have to use is that you can’t do very much as a solo developer. It introduces a social aspect. You must work as part of a team. Especially when you have a public facing website or large scale. So the field is less appealing for someone who is a typical introvert. The types of personalities are completely different compared to those from the mid-90s or before.
    • aadhavans 1y ago
      I was talking about this with a friend earlier this week. The people who work in software these days seem much more extroverted and outgoing than the 'introverted nerd' stereotype from the 90s.
      • 4gotunameagain 1y ago
        This is also due to the popularisation of computers, the internet and internet culture. Everyone and their aunts now are into computers, and one in x is a software "engineer". Back in the day, it was only the hardcore nerds that were attracted to these things :)
• kristianp 1y ago
  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.
  • titzer 1y ago
    IntelliJ was already awesome in the early 2000s.
  • lmz 1y ago
    I recall using Eclipse 2.x in the mid 2000s and it was good, although not fast.
  • elric 1y ago
    That sounds unlikely. AFAIK both Eclipse and Netbeans have had pretty good debuggers since the early days, probably around 2002ish.
    • kristianp 1y ago
      The 2nd year students I interacted with weren't aware of those and they weren't available in the PC labs at the university. I think there was something called BlueJ IDE as a learning tool. https://en.wikipedia.org/wiki/BlueJ https://en.wikipedia.org/wiki/BlueJ
      • elric 1y ago
        That sounds like a teaching problem instead of a tooling problem. Snark aside, I think there's value in teaching the basics first (e.g. compiling stuff with javac) before moving on to using magic to hide the complexity.
• biql 1y ago
  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.
• KronisLV 1y ago
  > 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 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.
• Chinjut 1y ago
  The title needs to be updated. These are IDEs we had 32 years ago.
  • ej_campbell 1y ago
    32 years ago was 1993. Those IDE's were from the 80's.
    • Narishma 1y ago
      They were still very popular in 1993.
  • Chinjut 1y ago
    This was titled "The IDEs we had 30 years ago..." in 2023. It is now 2025.
• never_inline 1y ago
  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.
• geldedus 1y ago
  "Old man yelling at modern IDEs"
• msephton 1y ago
  Needs Macintosh System 7 IDE representation.
• OCTAGRAM 1y ago
  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.
• random29ah 1y ago
  It's sad that no one has commented about Ultimate++ ( https://www.ultimatepp.org 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.
• paradox460 1y ago
  I wish NeWS had taken off. Don Hopkins' videos on it and psiber are amazing.