31 ms·

IDEs we had 30 years ago

• DeathArrow 3y ago
  I spent countless hours in Borland Pascal and Borland C as a kid. This brings back nice memories.
• hnbad 3y ago
  I was expecting the author to mention Smalltalk because I distinctly remember people praising Smalltalk for its IDE but I think the IDE I was thinking of is from the late 90s or early 00s.
  • rwmj 3y ago
    I don't think SmallTalk ever had a TUI. Even the very early versions on the Xerox machines used a GUI, and that GUI persisted even when it was all ported to Solaris.
    • zozbot234 3y ago
      Oberon was this weird mix where you had a proper GUI on thr screen but it would basically only show text. You could run commands by selecting text from inside any arbitrary window. The plan9 OS and Acme editor have kept this workflow.
    • xkriva11 3y ago
      Digitalk had Smalltalk TUI for DOS named Methods. https://pbs.twimg.com/media/ET8sPbsXQAAcgpb?format=jpg&name=4096x4096 https://pbs.twimg.com/media/ET8sPbsXQAAcgpb?format=jpg&name=...
    • hnbad 3y ago
      The title of the article doesn't mention TUIs (or UIs at all) but I was thinking of a GUI. Specifically it seems I was likely thinking of Pharo (which is '00s not '90s so off by a decade).
      • igouy 3y ago
        The article subtitle is: "A deep dive into the text mode editors we had and how they compare to today's". The second paragraph says: "This time around, I want to look at the pure text-based IDEs that we had in that era before Windows eclipsed the PC industry."
  • mananaysiempre 3y ago
    An interesting continuation of that evolutionary line is the Open Dylan IDE: https://opendylan.org/history/apple-dylan/screenshots/index.html https://opendylan.org/history/apple-dylan/screenshots/index....; the deconstruction of the object browser / Miller columns seems interesting even as a general UI concept.
  • tcard 3y ago
    I think it's fair to say Smalltalk(s) have had in many aspects the most advanced IDE in existence at every moment since its introduction. Demos for a couple old versions: https://www.youtube.com/watch?v=NqKyHEJe9_w https://www.youtube.com/watch?v=NqKyHEJe9_w Demo for Pharo: https://www.youtube.com/watch?v=baxtyeFVn3w https://www.youtube.com/watch?v=baxtyeFVn3w
    • pjmlp 3y ago
      Not only Smalltalk, all Xerox PARC Workstations Interlisp-D, Mesa (XDE) and Mesa/Cedar, all shared same ideas with Smalltalk, regarding developer tooling. Same on Genera with Lisp Machines.
  • masklinn 3y ago
    > I think the IDE I was thinking of is from the late 90s or early 00s. Smalltalk's from the 70s and 80s, and almost certainly had what you're thinking about given it's where both Microsoft and Apple got their foundational ideas (restricted to significantly less powerful hardware), and later unrelated smalltalks retained a lot of now quirky considerations and behaviours. Self inherited a lot of those and is from the late 80s. So yes, I was also expecting the author to talk about Smalltalk.
    • eschaton 3y ago
      If you actually look at Xerox’s hardware, it’s quite a stretch to call Lisa or Macintosh “less powerful.” It’s kind of amazing what Xerox was able to accomplish on such underpowered systems; they did it largely by having multitasking microcode to handle performance-sensitive I/O, and implementing BitBlt there too.
  • 010101010101 3y ago
    I suspect there are quite a few more niche languages/interfaces that the author didn’t consider when it comes to GUI IDEs. I thought of EiffelStudio immediately, myself, having worked with a group that used it in a past life.
• bayindirh 3y ago
  People still forget Eclipse when it comes to a full-blown yet not bloated IDE. That thing consumes less than a bare bones VSCode install while running 5x the tools. It can handle everything from code to git to CI/CD and remote development since 2013. I'm using it for 20 years and I think it's the unsung hero of the IDE world. This article doesn't mention it either as a modern GUI IDE.
  • RcouF1uZ4gsC 3y ago
    But Eclipse was often laggy and slow. So it felt bloated to the users than VS Code which is snappier even though it is bigger
    • bayindirh 3y ago
      It was, for C++, for a couple of years, 12-13 years ago. It's neither laggy nor slow for the last 8-9 years. I've written my Ph.D. thesis on it, on C++, which was a sizeable high performance code. It never crashed, allowed me to work remotely if required, integrated with Valgrind, allowed me to do all my tests, target many configurations at once, without shutting it down even once. Currently it has a great indexer (which is actually an indexer + LSP + static analyzer and more), LSP support if you wish, and tons of features. It gets a stable release every three months, comes with its own optimized JRE if you don't want to install one on your system, etc. Plus, it has configuration snapshots, reproducible configurability, configuration sync and one click config import for migrating/transforming other installs. That thing is a sleeper.
      • magicalhippo 3y ago
        While Eclipse today is certainly a quite decent IDE, I use it mostly in the form of STM32CubeIDE[1] now, it was servicable at most back in 2005-2006 when I used it for some Java classes. In any case, it's a younger product than the offerings in the article. [1]: https://www.st.com/en/development-tools/stm32cubeide.html https://www.st.com/en/development-tools/stm32cubeide.html
        • 3y ago
• miohtama 3y ago
  For the comparison: Interview with an Emacs enthusiast https://m.youtube.com/watch?v=urcL86UpqZc https://m.youtube.com/watch?v=urcL86UpqZc
  • zozbot234 3y ago
    Emacs actually supports drop-down menus in text mode, with a different key shortcut: https://www.gnu.org/software/emacs/manual/html_node/emacs/Menu-Bar.html https://www.gnu.org/software/emacs/manual/html_node/emacs/Me... There is also a special incantation for proper mouse support in the terminal, because the default is to keep the default handling as copy/paste: https://www.gnu.org/software/emacs/manual/html_node/emacs/Text_002dOnly-Mouse.html https://www.gnu.org/software/emacs/manual/html_node/emacs/Te...
• RcouF1uZ4gsC 3y ago
  One thing these IDEs had was an integrated debugger. It seems Unix/Linux really got a nice integrated debugger with ann IDE and gdb is powerful, it is very cumbersome. Hence, it seems there is a lot more printf debugging on Unix, and less use of debuggers than say on Windows where Visual C++ and Borland Turbo C++ both had very easy to use debugging integrated into the IDE.
  • pjmlp 3y ago
    Commercial UNIXes had nice graphical debuggers like dbx on HP-UX, while Solaris and NeXTSTEP had good IDEs. Linux eventually got DDD. Unknown to most is that gdb has a TUI, and is highly scriptable in Python.
  • lsllc 3y ago
    Agreed, for the most part debugging has gone backwards (aside from Xcode, Visual Studio 20xx) and was always pretty bad on UNIX. Still amazes me that there isn't a really nice, batteries included TUI debugger (e.g Periscope!).
• zozbot234 3y ago
  I do wonder what the easiest, most straightforward path to a full TUI IDE would be today. Perhaps starting from the codebase of a lean graphical IDE like Lapce and adding a TUI-powered backend. (Note that text editors do exist with that kind of interface, the real gap is wrt. the IDE features including LSP and DAP interop.)
  • magicalhippo 3y ago
    One could always use the updated Turbo Vision library[1], which originally was used for the Turbo Pascal/Turbo C++ IDEs mentioned in the article... [1]: https://github.com/magiblot/tvision https://github.com/magiblot/tvision
  • hnlmorg 3y ago
    Vim and emacs do already have plugins for LSP. Probably DAP too. But like everything CLI, it might take a bit of initial set up to get it right.
• iamgopal 3y ago
  Turbo C/C++ was my first IDE, when you know all short cuts, it was quite fast. Then came DJGPP with RHIDE...and for many years, IMHO, Visual Studio 6 was best for kid ( and window user ) like me.
• bluetomcat 3y ago
  Visual Studio and XCode are the closest experiences to “first-class IDEs”, reminiscent of the Borland stuff from the early 1990s. They offer tight integration with the native toolchains and a set of menus that mostly make sense. Environments like VSCode or Emacs are a generic platform for text editing and file manipulation, a lowest common denominator for a variety of languages, workflows and tastes.
  • bayindirh 3y ago
    Try Eclipse, or Geany if you want something very small, yet powerful for its size.
• mihaic 3y ago
  For me, the closest modern successors to the Borland suite are Visual Studio (not VSCode) and the Jetbrains IDEs. The feel like they're the only one with a holistic, batteries included, design that actually focuses on debuggability. I actually feel that the terminal-based focus of modern FAANG-style development actually hindered proper tool development, but I was never able to explain it to anyone that hasn't used Borland C++ or Borland Pascal in the past, except maybe to game developers on Visual Studio.
  • aulin 3y ago
    out of the loop, how is terminal-based development related to FAANG?
    • marcodave 3y ago
      I guess it's caused by the "brogrammer" culture of Silicon Valley, where you would get hazed if you dared using a GUI-based tool. Also, being more focused on open-sourcing their tools (because other companies do not open source them, therefore being un-cool), which begets a "simpler" and "engineeristic" approach to UX, which do not need UI experts and designers.
    • bluetomcat 3y ago
      Except maybe Apple, all the others are service-oriented companies. They run heterogenous pieces of code on their servers and their ideology is “move fast and break things”. It’s a hipster culture that reinforced the use of 1980s “video terminal” editors and CLI tooling because they were supposedly more flexible for their workflows.
    • MonkeyClub 3y ago
      It became sort of a hackerish trend in the past decade, usinga hyper customized (neo)vim in lieu of an IDE.
    • jpollock 3y ago
      Lots of companies end up with their own internal tooling. They have their own build systems, packaging systems, release systems, version control, programming languages, configuration languages, everything. Some even have their own editors. There is a lot of value in picking a transferrable editor and using that. From that point it becomes "what is the best editor that will _always_ be available". Emacs/Vim fit that. Then the muscle memory can begin to grow, and there is one less bit of friction in starting a new job. One of the best pieces of advice I received was "pick an editor and go deep".
• Findecanor 3y ago
  30 years ago, I used Trash'em One on the Amiga. It was a text editor, 68000 assembler, debugger and memory monitor in one. I preferred it over its predecessor Asm One (which had been based on Seka), but I don't remember what feature it was that made me switch. https://www.pouet.net/prod.php?which=92408 https://www.pouet.net/prod.php?which=92408 You can run Asm One in the browser here: https://archive.org/details/ASM-One_v1.02_1991_Gram_Data https://archive.org/details/ASM-One_v1.02_1991_Gram_Data
  • snvzz 3y ago
    Lives on in the form of asmtwo (lightweight, supports 1.3) and asmpro (featureful, needs v37).
• jbverschoor 3y ago
  Ahhh.. Borland TUI. But also Visual C++ was really great. With offline docs!
• aulin 3y ago
  Seems a bit quick to dismiss modern TUI editors. Emacs in terminal mode has feature parity (almost?) with the GUI version. And by the way classic curses like menu bar can be opened in text mode with M-x menu-bar-open which is bound to <f10> by default. You can even use mouse with xterm-mouse-mode. The one he was looking at was text menubar emulation which is pretty powerful too if you take a minute to appreciate it.
  • marcosdumay 3y ago
    He claims they are unintuitive so he didn't bother exploring them. What is completely fair. Emacs in particular is more featureful than VS-Code, but hell, it's hard to make use of all of it.
    • ParetoOptimal 3y ago
      If vertico and context-menu-mode were defaults you might not be able to say that. Or just the menu and toolbar weren't immediately disabled by most.
• dep_b 3y ago
  30 years ago people were using Interface Builder already. Admittedly not that many, but the drag and drop interface is still there integrated into Xcode.
  • pjmlp 3y ago
    They were, and had it not been for Apple's reverse acquisition, it wouldn't be there in Xcode today. My graduation thesis was porting a visualization particles engine from NeXTSTEP/Objective-C/OpenGL into Windows/Visual C++/OpenGL, as the department was seeing the end of NeXT and they wanted to keep the research going on. My supervisor had a NeXT Cube getting dust on the office corner, waiting to be collected.
• microtonal 3y ago
  I loved Turbo Pascal, but to me the high point of Borland's tooling was Delphi (1995). I don't want to sound like old man yells at cloud, but every time someone says that building GUIs with Electron is so easy compared to native apps, I just wished they experienced Delphi in its prime. There are some very short/simple demos on YouTube: https://www.youtube.com/watch?v=m_3K_0vjUhk https://www.youtube.com/watch?v=m_3K_0vjUhk
  • pjmlp 3y ago
    They can still experience it today with the community edition.
    • mikewarot 3y ago
      If you can agree to their very strange terms and conditions. Or, use Lazarus/Free Pascal, which is almost identical, except for the documentation, which needs a massive overhaul, in tooling and content.
      • pjmlp 3y ago
        Not everyone is religious against such agreements. Those can profit from very latest version.
        • mikewarot 3y ago
          If you make gears, for example, and sell more than $5000 of gears, you still have to pay for Delphi under that license... it's really weird.
  • lelanthran 3y ago
    > but every time someone says that building GUIs with Electron is so easy compared to native apps, I just wished they experienced Delphi in its prime. Every time someone says that, I mention Lazarus. I stll get a thrill out of using it (one of my github projects is a C library, and the GUI app is in Lazarus, which calls into the API to do everything). The problem I find with Lazarus is that it seems to be slowly dying; yes, they still work on it, but feature-wise they are very behind what can be done with HTML+CSS and a handful of js utility functions. A wealthy benefactor could very quickly get Lazarus to the point of doing all the eye-candy extras that HTML+CSS let you do (animated elements, for example).
• pjmlp 3y ago
  Those Borland IDEs, a show of hands for Turbo Basic as well, were the main reason why I never liked the UNIX development experience, until a professor showed us XEmacs, at the time much more feature rich than Emacs, and vi was still vi, not vim. Thankfully with KDevelop, Smalltalk, and when Java started to make IDEs more common on UNIX, I no longer needed XEmacs. Ironically for all IDE-haters, even James Gosling, inventor of XEmacs, says people are missing out not using IDEs, he surely moved on from Emacs ecosystem.
  • jdougan 3y ago
    Nit: James Gosling implemented Unipress Emacs aka. Gosmacs, not XEmacs (with a lot of licensing sturm-und-drang). XEmacs was forked from Gnu Emacs at Lucid, by jwz (Jamie Zawinski)
• fiforpg 3y ago
  We used Turbo Pascal and Turbo C++ for my high school classes, and I have very fond memories of both. This must have been on Windows. Borland really had a series of these fantastic products, it's a shame they are no more. The only modern company in this space is JetBrains, it seems, so the niche is small.
  • zozbot234 3y ago
    Turbo Pascal and Turbo C++ are still used to this day in some high schools and even college intro courses. Of course nowadays you need Dosbox to run them on modern computers.
• markus_zhang 3y ago
  I found myself lack of energy and time stepping into my 40s and vowed never to waste time “learning” cool editors such as Vim and Emacs. VSCode is now my one stop editor of choice on Linux and VS on Windows. I also use Jetbrain editors for work. I’m done. For people like me, who write SQL and Python for data pipelines, the Jetbrain IDEs are no-brainers. We don’t actually get the time or energy to do a lot of side projects so it doesn’t make sense to learn advanced editors such as Vim and Emacs: 1) These two need a lot of muscle memory just to start using it, but we don’t use it on a daily basis, 2) I’m not smart enough to write code as if I’m writing this reply so fluent coding experience without mouse isn’t useful for me ——- I have to stop and think hard every few minutes anyway.
  • onehair 3y ago
    I'm in my late 30s. So maybe not so far away from the age of lack of energy :P I like JetBrains a lot. Things work seemlessly and easily integrate with external tools that make up the whole experience. But from 2012, I tried to rely as much on shortcuts as possible, for one simple reason, the mouse. There is no problem with using the mouse. But everytime I have to use while focusing and coding, I find that that small gesture to move my hand from the keyboard to the mouse a bit flow breaking. I have to move to the mouse, do a thing or two, then find my way back to the J key notch. I like what NeoVim and emacs bring with regards to the reliance on the mouse. They allow for maintaining the same posture most of the time and focus only on typing. I dislike how brutal they are at learning how to use them to full potential, and that making them into IDEs takes ages of IDE building rather than project coding. I like Helix. Which takes a lot of inspiration from Vim/NeoVim/Emacs. But require no configuration to get you going right away. The documentation is easy to read, as of now there is no plugin system but there is a builtin integration with a lot of LSP servers for most of the popular languages by default. Keys and navigation is easy, it even shows a helper popup to show you which key to use next. My suggestion is, if you ever want to start a new silly project, and you're feeling free to take it slow for 2 days. Try using Helix on said project. PS: Helix isn't fully complete by any means, but it really is capable of doing everything you want in many projects without being a hindrence if you can adapt to the lack of some built-in features like git and file tree. Its annoying but I am less upset about it and use alternatives
• guytv 3y ago
  Ah, this takes me back. Turbo Pascal and Turbo Prolog - those were the days. Borland had the greatest products, and the accompanying books were always well written, used beautiful fonts, and, not less important, smelled nice. If my memory serves me right, Borland even released their Text User Interface (TUI) library for developers to use in their own applications. Fond memories indeed!
• lwhi 3y ago
  Windows was around .. what about GUI based IDEs? Visual basic?
• Aardwolf 3y ago
  At least the programs in the screenshot have actually useful and visible scrollbars. Seriously, scrollbars are super useful and should never be hidden, they both provide information you want to see and actions you want to do, why is everything trying to make them as subtle as possible today, even most Linux UI's which I'd expect are normally made more for usefulness than "design trends"?
  • ryanjshaw 3y ago
    GitHub's Android app doesn't even show scroll bars. And no scroll grab or snapback in apps even when there is a scroll bar. Am I the only person who scrolls back to check something and wants to quickly return to where I was in a document? Even if just FF on Android had this I would be happy. On desktop we can drag scrollbars but I can't imagine what it's like to use modern 4-8px action area scroll bars if you have fine motor control challenges. I just don't understand how we got to this point. Do people not use the apps they write?
    • posix86 3y ago
      This must be a bug though. If you unfold hidden comments, you jumpt to the BOTTOM, where you just WERE, rather than the top. So you scroll up, with no scrollbar, frantically, because you don't know how far you have to go. Until you reach the top - and you drag down ONE MORE TIME, because you're scrolling frantically, so the whole thread reloads, and everything is folded again, and you're back where you started.
  • analog31 3y ago
    Moreover, make the scrollbars big enough for my thumbs on my touch screen. Or at least make it optional.
  • badsectoracula 3y ago
    On Linux this depends on your theme really, all the themes i use have scrollbars - e.g. here is an example with Gtk3 (which IIRC introduced the "autohiding scrollbars" to Linux desktop)[0]. It is "cdetheme-solaris" which i think is from [1]. I might have modified it a bit though. Though normally i use Gtk2 apps with a modified "cleanlooks" theme (a screenshot from Lazarus[2] i made a couple of days ago shows it - including the scrollbars :-P). [0] https://i.imgur.com/CAyu5Ay.png https://i.imgur.com/CAyu5Ay.png [1] https://github.com/josvanr/cde-motif-theme https://github.com/josvanr/cde-motif-theme [2] https://i.imgur.com/Yw1tTcD.png https://i.imgur.com/Yw1tTcD.png
• miki123211 3y ago
  > there are a few things that VSCode doesn’t give us. > The first is that a TUI IDE is excellent for work on remote machines—even better than VSCode. You can SSH into any machine with ease and launch the IDE. Combine it with tmux and you get “full” multitasking. I definitely disagree with this sentiment. At my last job, I had to do most of my work on a remote server (because it had a GPU), and I found VS Code far more pleasant to use than plain old SSH. People recommended using an editor on the server side or freaking around with Win SCP / Cyberduck, but VS Code was just so much better in so many ways. Because of VS Code's web roots, it can easily run its frontend on your own local computer while running its backend somewhere else. This means that most common actions, like moving the cursor or selecting text, can be done locally, without the need for a round trip to the server. The operations that do have to be executed remotely, like saving a file for example, are properly asynchronous and don't interrupt your workflow. Everything is just far snappier, even if you're working from home, through a VPN, on barely working WiFi and an ADSL line. As a bonus, you get fully native behavior and keyboard shortcuts that you'd expect from your platform. Things like text selection and copying just work, even some of your addons are carried over.
  • medo-bear 3y ago
    Using the editor on the server from a remote connection is silly. However VSCode is not unique. On my local Emacs I use ssh via tramp [0] to browse files on the server and then edit localy. HOWEVER I also have physical access to my server. Emacs then gives me the added benefit of being able to run in terminal on the physical server without any window manager installed. [0] https://www.gnu.org/software/tramp/ https://www.gnu.org/software/tramp/
    • benterix 3y ago
      > Using the editor on the server from a remote connection is silly. Why?
      • gtirloni 3y ago
        Constant screen redrawing and input lag.
• andyjohnson0 3y ago
  Thirty years ago is 1993, and I was a junior dev using CodeCenter on SunOS. It was a nice editor/debugger with a C interpreter mode that iirc let you inspect aa variable's history and un-execute lines of code. A few years later I was using SparcWorks on Solaris. When I realised you could pause on a breakpoint and hover the cursor over a variable in the editor to see its value, my brain nearly fell on the floor. A few years after that I moved to PC development using Visual C++, and then Visual Studio 97 on NT4. Drag and drop UI builders for Windows and Web. And 30+ years later I still spend a significant part of my working day in VS.
• Apreche 3y ago
  I love the aesthetic of Borland Turbo TUIs. I went back and tried to use TurboVision some time last year. It was not good, to say the least. Would be pretty cool if VSCode were themable to the extent that WinAmp was, so we could reclaim that old style.
• ytch 3y ago
  In the early 2000s, back in my homeland, high schools were still stuck using Turbo C for programming classes. This was mainly because there weren't many free and lightweight C IDE options available for Windows (I know Turbo C is not a free software technically). While Dev-C emerged as a possible alternative for console programs and programming contests, it wasn't enough for developing native Windows GUI applications without shelling out for Visual Studio. This limitation ultimately led me and some friends to explore development on alternative platforms like OS X and Linux. Ironically, even to this day, none of us mastered the WIN32 API.
• flohofwoe 3y ago
  One nice side effect of modern TUI applications is that they can be distributed via Docker Hub as platform-agnostic applications that just require a compatible color terminal. E.g. here's my C64 emulator running in Docker (it's a real C64 emulator underneath, but only renders the C64 PETSCII buffer via ncurses, e.g. no graphics or audio output): docker run --rm -it flohofwoe/c64 ...code is here: https://github.com/floooh/docker-c64 https://github.com/floooh/docker-c64
• ThinkBeat 3y ago
  I loved TurboPascal. I agree with everything the post argues. I would like to expand a bit on it being before the Internet was a huge thing. The manuals that came with TurboPascal were nearly excellent. It included most of what you would need to get started. When you didn't quite understand something, you had to spend time to figure it out and how to do it well. This could be time consuming, but afterwards you gained important knowledge. Then there were other books to get, there were "coding" magazines, though at the moment I cant remember any TurboPascal specific ones. and if you were lucky you knew one or two other people who were into coding and you could share problems, solutions, hints and tips. and warez. There were also a lot of BBSs out there. Where you could ask questions, help others, etc. These days most people if they face a problem, Google it (maybe now ChatGPT it) find someone posted a solution, cut and paste the crappy code, crosses fingers that it works and off you go. (or pull down libraries without having any idea what in the world it actually does) At the same time things have gotten a lot more complex . In my TurboPascal days I knew most of the stack. The programming language, the operating system, assembler, a lot of how the CPU worked. These days understanding javascript, understanding the runtime / compiler etc, before you even get close to the underlying OS, and certainly not down into assembler amd CPU
  • wwweston 3y ago
    I'm not sure whether the issue is stack complexity / depth, but there is definitely something in the culture where it's common for docs and how-tos and Q/A to tell you what to do, the steps/commands/etc, but to do little to help you build any kind of relevant domain model. This isn't exactly new, there's always been documentation like this, but I think the proportions have changed dramatically since even the early 2000s. One of my vaguely defined theories is that as valuable as automation is, the culture of automation / process has started to diffuse and act as an influence on how we think, in steps & commands rather than models. Possible that we've always been steps-results / input-output beings, but I wonder.
    • Vegenoid 3y ago
      I recently created some documentation for a process at work where I explained the 'why' for most of the steps and commands. Not in great detail, but just a bit of detail. I thought that it was good as a step-by-step recipe, while also giving context that could help someone in the event that something didn't go according to plan. I was asked to remove much of the context that I provided, so as not to confuse the reader, and to make it as direct as possible. This is documentation intended for experienced, technical professionals. I think that the revised documentation is less helpful.
• nunez 3y ago
  I _think_ edit.com still ships with Windows!
  • zozbot234 3y ago
    Not the 64-bit version, surely. They're thinking about shipping a new TUI editor, though.
• nunez 3y ago
  So I've been using vim as my IDE for the last ten years. I've really enjoyed using it, but VSCode is super duper popular. Has anyone like me converted? If so, are you still using Code or did you go back to vim? If so, why?
  • whinvik 3y ago
    I did. I eventually got tired of fiddling with configs, not so great debug experience, copy paste issues etc. Now I just use Vim mode in VSCode. Don't get me wrong, you also need to spend time on Configuring VSCode, but it's so much better.
  • Kamq 3y ago
    I gave VSC a shot. It's the stupidest thing, but I just can't get over how the side bar (not the file explorer, but the little activity bar that you can open the file explorer/plugin menu/etc from) keeps re-appearing every time I open certain things. I know it's petty, but I can't get over it. I was able to, mostly, get things to work the way I wanted in it, but that ended up meaning I turned it into basically my vim setup. I've moved to jetbrains products at work. Same story there, I basically turned it into vim, and hid all the sidebars (but it does let me do this). Mostly I'm using it for the debugger, the jetbrains debugger is legit. Still use (n)vim at home a lot, especially for anything that doesn't have a dedicated jetbrains ide. Other than that, the only thing I've really had problems with is that graphical editors all seem to think in terms of files instead of buffers, and there's no equivalent to vinegar. I think that really throws me the most.
  • tipsytoad 3y ago
    Moved to vscode with the neovim extension (vim mode was slow for me over large files). vsc is super customisable, and you can remove all the tab bars, side panels and anything else you don't use fairly easily. It's also far more stable than the neovim ecosystem, i don't have time to mess with neovim plugins breaking bi-weekly anymore
• JoachimS 3y ago
  Yes, the Borland TUI was pretty good. But nothing came even close to what we had on the Commodore 64 with the X-Ass Dev Kit. You could code in a nice TUI with syntax highlighting. Press a key to assemble in a split second, execute the program, press reset and be back in the TUI exactly where you left off. And this with source file > 64 kByte, creating executables that occupied the complete memory space of the computer. https://csdb.dk/release/?id=27625 https://csdb.dk/release/?id=27625 http://www.fairlight.to/docs/text/xass_docs.htm http://www.fairlight.to/docs/text/xass_docs.htm So productive and easy to use.
  • marcosdumay 3y ago
    Well, I guess we are lacking any LISP or Smaltalk fans to one-up that today :)
• peteri 3y ago
  Interesting mention of Sidekick Plus, there was a complete SDK for it which I don't think ever got released anywhere (I had a copy as I was working for Borland at the time). It allowed multiple documents to be open at the same time.
  • 3x35r22m4u 3y ago
    It allowed to copy text from screen and paste into its editor, had a modem terminal app, contact app and a calculator. It was a joy to use!
• tgv 3y ago
  30 years ago, THINK C for the mac was already nearing discontinuation. It was a great compiler plus plus graphical IDE with debugger for its time. Hard to find info about it, but this site has some screenshots of the various versions: https://winworldpc.com/product/think-c/4x#screenshotPanel https://winworldpc.com/product/think-c/4x#screenshotPanel
  • eludwig 3y ago
    Yes! I absolutely lived in Think C for many years. You’re right though, it was on the way out by then, supplanted by CodeWarrior and MPW, which were both really good too.
  • idlephysicist 3y ago
    This fella has a number of interesting videos of development on System 6 using THINK C! https://jcs.org/2022/03/05/serial https://jcs.org/2022/03/05/serial
• wzdd 3y ago
  How odd to find a mistake in 30-year-old Turbo C++ man pages from a screenshot. printf and vprintf send send formatted output to stdout of course, not stdin.
• zubairq 3y ago
  Somehow those text based IDEs of 30 years ago feel special to me, maybe reminding me of a simpler time when there were not too many things to master
• __s 3y ago
  Language server protocol has really improved things. I use it with neovim. Makes it straightforward to get IDE features in vim for a variety of languages & allows code analysis part to compete. With Go I'm mixing golangci & gopls. In Rust there was a transition from rls to rust-analyzer. & this effort is able to be shared between vim/vscode/emacs/etc so once someone makes a good lsp implementation it doesn't need to be ported everywhere
• bregma 3y ago
  30 years ago I was using vi and the shell on a Wyse 85 terminal. Nowadays I used vim and the shell in one of many terminal windows on one of many workspaces. Every now and then I try an IDE but I always find the loss in productivity and the lack of discoverability to be hampering. I'm there to get work done, not to stare at cartoons and fumble around for wherever the mouse or cursor has disappeared to again.
• marmakoide 3y ago
  I am easily distracted (as in, ADHD-like), I enjoy very sparse work spaces in general. Tools with lots of icons, windows, and other widgets are very uncomfortable to me. I prefer typing commands, I believe a well written command language and a good search function are more comfortable. I will go to great lengths to avoid some tools if it means avoiding a clickodrome : for example, when coding for STM32 devices, I prefer bare metal GCC + makefile over STMCube. To each his own tho, it's nice to have different tools for different peoples.
• jmclnx 3y ago
  Brief by underwear was by far my favorite in the DOS days. It ran great on the 286 I had at the time. IIRC, something like it was ported to Linux in the mid 90s for purchasing. But Linux had vi and Emacs so I do not know how successful that was.
  • scottlilly 3y ago
    I remember a version named "dBrief", for those of us programming dBase/Clipper code. It was a great tool back then.
• ilaksh 3y ago
  I agree with the article. Turbo Pascal was terrific. There is some kind of psychological thing that has me using neovim in a terminal all the time for many years. I guess it's convenient for ssh. But I miss the affordances of Borland IDEs. Even last night I was working on a web application and was tempted to add a menu at the top of the page, remembering how useful they were back in Turbo Pascal and such. I did a Google search and found this https://github.com/skywind3000/vim-quickui https://github.com/skywind3000/vim-quickui
• mamcx 3y ago
  TurboPascal and other Borlands IDE were great, but just a lesser version of FoxPro! With FoxPro, you have the features of them, but also, RAD form/menu/table/report builder. Like "Let's add MS Access to your IDE". That is the dream. One of my goals is to built it!
• deleted 3y ago
  [deleted]
• layer8 3y ago
  Screenshots using 80x50 mode would be nice, which I remember using in the early 90s.
• intrasight 3y ago
  30 years ago - and from about 89-94 - my IDE was DataViews. Still all these years later I don't know of any IDE that can create such graphical interfaces.
• schemescape 3y ago
  Is Doom Emacs really 500 MB? How did the author determine that? I use vanilla Emacs and I believe it was closer to 100 MB when I installed it. Related: I’ve spent a lot of time trying to find a development setup that runs on low-end hardware (as a reaction to modern bloat, and also as a way to minimize distractions). It has many flaws, but Emacs with Common Lisp is my current sweet spot of “price” (resource requirements) to “performance” (features+speed).
• pshirshov 3y ago
  I'm not aware of anything so convenient and learler-friendly as Borland IDEs were.
• orsenthil 3y ago
  I remember using Borland Turbo C++. It was the most convenient piece of software to get started with programming. If I had been introduced with anything else, I would have found it much more difficult to cross the initial curve.
• graycat 3y ago
  Did a lot of programming without an IDE. Then some years ago, tried an IDE: Opened a project. Looked at the resulting directory (folder) and saw ~50 files with what I knew nothing -- hadn't even started the work yet. Got rid of the IDE and returned to my favorite tools and the software I was writing. My favorite tools work fine, and in particular in the directory I'm in I actually know what each file there is, what it is for, what is in it, where it came from, etc. In my work, I need to do some programming, that is, software development. So, I do it. Difficulties are nearly all from poor documentation of other software I need to use. The parts of the programming that are really mine are like cooking lunch -- no problems for my part, but if the pepperoni is not good, that's a problem. To me, programming is, define some variables to store the data, have expressions to manipulate the data, If-Then-Else, Do-While, call-return, input, output, and that's about it.
• softirq 3y ago
  Vim is the only tool I've been able to use at every place I've ever worked at, from intern to staff engineer in three FAANG companies. I've watched tool teams spend months integrating the latest GUI editor, only for it to get killed by corporate acquisitions and replaced with N+1 that offers an almost identical feature set. Meanwhile there's always a community of vim and emacs users who build all the internal integrations by themselves. Vim and Emacs aren't editors, they're platforms and communities, and the benefit of using them over VSCode of JB is that you get to be a part of these communities that attract the best talent, give the best troubleshooting advice, and share advanced configurations for everything and anything you could possibly ever want. They are programmable programming environments first and foremost, and that attracts people who are good at programming and like to hack on stuff. Technologists who choose the propriety path of least resistance when it comes to their most important tools I think are ultimately missing out in a lot of ways, least of all is the actual editing experience. A craftsman should understand his tools inside and out, and picking something you can't fully disassemble and doesn't have the breath of knowledge a tried and true open source tool ultimately becomes just as frustrating as the initial learning curve of these older tools.
  • cies 3y ago
    > that attract the best talent I've seen hugely talented folk on vim/emacs/emacs+evil, and on VSCode/JB. I think was the latter tools do, it make some of the advantages of being proficient in vim/emacs/regex available with less learning curve. Currently there are some combinations that simply best-in-class: VSCode+TS, JetBrainsIDEA+Java/Kotlin, VisualStudio+MicrosoftGuiStuff. vim/emacs may come a long way in these areas, but cannot beat the integration level offered in these combinations. Also, you mention "proprietary", but JetBrainsIDEA and VSC are opensource to some extend, which does improve community imho. But, the fact that they are less "open access innovation" projects, and more company owned is clear to everyone. Finally: AI will come to software devt, and I wonder if AI tools will ever be available on true open access innovated IDEs.
    • softirq 3y ago
      > I've seen hugely talented folk on vim/emacs/emacs+evil, and on VSCode/JB. I think was the latter tools do, it make some of the advantages of being proficient in vim/emacs/regex available with less learning curve. Take Reddit and Hacker News as a fitting analogy, a community with a higher barrier to entry/more niche will be smaller, but the quality is vastly improved. There's still going to be people who sit in both communities, and smart people in both, but it's not controversial to say that an initial learning curve tends to attract people who can pass the learning curve and are motivated to do so. Another great example is the linux kernel development process. > Currently there are some combinations that simply best-in-class: VSCode+TS, JetBrainsIDEA+Java/Kotlin, VisualStudio+MicrosoftGuiStuff. vim/emacs may come a long way in these areas, but cannot beat the integration level offered in these combinations. Integration in some ways, in other ways a terminal based tool that adheres to the unix philosophy is more integrated with thousands of tools than an IDE where every tool has to be converted into a bespoke series of menu items. Just look at fzf, git, rg, etc. integrations in Vim. They are only lightly wrapped and so the full power of the tool shines through, and it's easy to customize it to your specific needs, or add more tools. > Finally: AI will come to software devt, and I wonder if AI tools will ever be available on true open access innovated IDEs. In the same vein, AI tools that act as black boxes and are integrated in the same transparent way as git or rg in Vim at least allow the editor to remain full transparent to the end user, and leave the complexity in the LSP or bespoke tool. I really see no difference between how AI tools will relate to editing as LSPs do today.
• petercooper 3y ago
  I forget if it were a MS or Borland thing, but I recall some of these DOS IDEs having an "expert mode" feature in the menus where you'd get, by default, only the most useful features, but could then turn on all the menu features by enabling said expert mode. Anyone remember this? Some tools (VS Code..) could sorely do with this today, I feel.
• rurban 3y ago
  I loved Multiedit Pro and Walter Bright's Symantic C IDE back then, besides emacs. Still with emacs, the others are gone.
• vrnvu 3y ago
  Loved the concluding question. "So the question I want to part with is: have we advanced much in 30 years?" Every time I see all the bloated software we are putting out. Is it really worth it? One program that does it all vs many programs that do one thing really well. Oh, maybe someone should write about this concept, it maybe interesting to ponder :)
• NikkiA 3y ago
  30 Years ago Watcom would be ripping through Borland's assumed monopoly and rapidly becoming the most used C/C++ IDE, only to have Visual Studio do the same to it in 2-3 years time.
• wkat4242 3y ago
  I was always kinda partial to the Borland IDEs. I even used the concept on Linux for a while in the form of "RHIDE". It wasn't bad UX but the software was pretty badly written so in the end I dropped it. I never enjoyed anything as bare bones (or requiring such a learning curve and setup of adding) as vim. Right now I use VS Code. Not a huge fan of it and I really wish it was available as a TUI application but for now it seems to be the best around.
• lumb63 3y ago
  Even if VSCode/other IDE had features that blew Neovim out of the water, I don’t think I’d move over. The customizability, modal aspect, and open-source-ness are huge for me. I can create macros on the fly for repetitive tasks, can navigate without ever having to stall my train of thought to touch my mouse, and customize every single key binding and the code that it runs. I can create custom commands to do every single thing I’ve ever conceived of wanting to do. I can upstream bug fixes and see those others have suggested that haven’t been up streamed yet. I will concede that for some, maybe this is too much work to set up “just a text editor”, but I enjoy it, and I spend most of my day editing or viewing text, so to me, it’s worth it. If there is one thing I’ve learned in my years of software engineering, it’s that everyone prefers different workflows. Let people build their own, however they want, with whatever tools they want, and they will be happier for it.
  • troupo 3y ago
    Almost everything you wrote is available for any modern IDE, and modern IDEs, thankfully, don't assume that your code is text. So they give all the things you mentioned and superior tools to work with code out of the box: anything from refactoring to code analysis to several types of semantic search to...
    • archargelod 3y ago
      Corect me if I'm wrong, but you can't define macros in a couple key strokes or contribute to development of any modern IDE. Nor they were designed to be hackable or customizable. If you open one of the setting sections in VS-Code you are presented with giant, over-engineered control panel with myriad of options you can toggle. Where Vim has a blank canvas you splash with couple dozen lines of code to make it unique and personal. It's almost like you aren't using just vim, but your own hand-made editor built on a great minimal base, that is Vim.
      • troupo 3y ago
        > Corect me if I'm wrong, but you can't define macros in a couple key strokes or contribute to development of any modern IDE. 1. I did say most, not all 2. The main reason for macros I've seen is the lack of useful features in editors like vim. There are not that many repetitive tasks that you need macros that often. I think I used IDEAs macro recording once in the past 10 years > Where Vim has a blank canvas you splash with couple dozen lines of code to make it unique and personal. I: - don't need "unique and personal", I need working out of the box - don't want to "hack on my editor" to get the basic functionality I already usually have :)
• bwann 3y ago
  I'm surprised there's no mention of QBasic that shipped with MS-DOS >= 5.0. This was built on top of EDIT.COM, and while it only ran a BASIC interpreter instead of compiling an executable like full-blown QuickBasic. IIRC it had a rather extensive help lookup system for functions, data types, reference tables, error codes, and whatnot. You could step through your program, set debug points, all without exiting to DOS. It was my first ever exposure to an IDE, I thought it was pretty nice for what it was.
  • djur 3y ago
    I loved QBasic. That integrated help system also came with extensive sample code for each function, including some full programs. Copying and modifying those was a huge boost to learning how to program. (The article does mention QBasic, though.)
• owlstuffing 3y ago
  My favorite part of late 80s early 90s C/C++ dev was the shitty auxiliary monitor used as a dedicated debugger screen. I swear I STILL find situations where I want that back.
  • lowbloodsugar 3y ago
    Separate computer talking to SoftICE over serial port.
• owlstuffing 3y ago
  Not mentioned in the article is JetBrains CLion. Best C/C++ IDE to come along in decades. https://www.jetbrains.com/clion/ https://www.jetbrains.com/clion/
• masto 3y ago
  Meanwhile, outside the world of PCs and DOS... https://youtu.be/uknEhXyZgsg?si=nx7IEAC9RZDwEeWY&t=3251 https://youtu.be/uknEhXyZgsg?si=nx7IEAC9RZDwEeWY&t=3251
• 123sereusername 3y ago
  Sorry, gotta call bullshit on this post. There were several _good_ IDE GUIs 30 years ago.
• anon-sre-srm 3y ago
  Borland C/C++ 3.1 came in the largest by volume and by weight shrink wrapped box ever due to inclusion of printed library and API references for DOS and Windows and other tools. Borland-branded products were the pro versions compared to the Turbo-branded ones.
• SomeHacker44 3y ago
  Did not see mention of Symbolics Genera, a vastly better IDE than any of the ones pictured in this article. And it was quite mature 30 years ago.
• btbuildem 3y ago
  The Borland IDEs really were the swiss army machine guns of their time. Turbo Pascal was one of the first languages I learned -- never really used it again, but looking back, it was an excellent beginner language.
• malkia 3y ago
  The two most indispensable programs for me are "midnight manager" for Linux/OSX and the like, and "Far Manager" on Windows (and mc there too under wsl2). I'm lost with Far Manager at work. I've stopped using Explorer long time ago (and use it only to verify some reported workflow from other users, or some obscure thing not possible in Far Manager). Other tools: tig (pager), emacs, mg (mini-emacs) - I wish that was available on Windows too without needing msys2/cygwin, and few others. Back in the DOS days - it was Norton/Volkov Commander, PC Tools, but also Turbo/Borland Pascal 3, 4, 5; the most awesome E3 editor (from this series - https://en.wikipedia.org/wiki/E_(PC_DOS) https://en.wikipedia.org/wiki/E_(PC_DOS) ) - and many more
• charlieyu1 3y ago
  15 year old me could use the Turbo Pascal debugger well because it was so intuitive. Now I’m just not comfortable with using debuggers at all and I keep spamming prints in my code.
• TheCapeGreek 3y ago
  Does anyone here feel kind of trapped by their IDE now? PHPStorm + Laravel Idea + the laravel-ide-helper package provides such a great PHP/Laravel development experience that I haven't been able to replicate in VS Code or Sublime. But chowing as much RAM as it does, it feels sluggish. Or at least, not as snappy as the alternatives. But I just haven't been able to find a middle ground with the lighter alternatives. Running the IDE as a thin client with Jetbrains Gateway sounds like a decent solution, if your backend server is close enough for latency to feel okay. From a ~4GB PHPStorm usage, PHPStorm-via-Gateway on GitPod was 1.2GB max.
  • Throw839 3y ago
    Perhaps consider better hardware, not some cheap chromebook. 4GB RAM is very little usage for advanced IDE.
    • TheCapeGreek 3y ago
      M1 MBP. At the lower tier with the 8GB RAM, it's the most affordable device that will outlast power cuts that are frequent where I am - cheaper than getting a backup power solution. Getting more RAM is a ridiculous cash grab by Apple. It's a rock and a hard place. >4GB RAM is very little usage for advanced IDE Java is awful with RAM in general. Decent text editor plugin setups can get close to the Jetbrains suite for what I do, but it's just a few small UX & plugin papercuts that make the difference. And I heavily doubt that those tools I prefer are that heavy compared to other editors.
      • Throw839 3y ago
        That is some Stockholm syndrome... 8 GB RAM is very little. It will limit you as a developer, you will never get into containers, virtualization, AI... If you are in Cape Town, get Linux laptop or minipc with external monitor. It all takes 19 volts, and you can power it from a car battery with simple voltage regulator. I have 8 core Ryzen with 4 TB SSD and 64GB RAM, it was less than 1000 USD. M1 is nice, but has several limits. If it gets broken, it will be very difficult to service in South Africa...
• dvh 3y ago
  Installer for Delphi 1 looked like this: https://delphicodemonkey.blogspot.com/2012/06/delphi-10-installer-was-awesome.html https://delphicodemonkey.blogspot.com/2012/06/delphi-10-inst...
• Trixter 3y ago
  The article covers some good points, but misses a few extra things that the Turbo Pascal 7.0 IDE included that made it a true powerhouse: - A full OOP tree to determine parents/traits of descendant objects - The ability to edit, assemble, and trace through both inline and external assembler code - A registers window that showed all registers and flags at any stage of runtime ...all while able to run on the first 4.77 MHz 8088 IBM PC, which was long in the tooth by the time TP 7.0 came out. (The OOP tree required a 286 as they only added it to the protected mode IDE.) This made the TP 7.0 IDE a complete development and debugging environment for assembler as well as Pascal.
  • badsectoracula 3y ago
    > ...all while able to run on the first 4.77 MHz 8088 IBM PC Eh, more like it walked rather than ran :-P.
    • Trixter 3y ago
      I still use it on that hardware for hobby projects, and while I have to wait 60-120 seconds for a compile, it's still more convenient for me than cross-compiling on Windows and then copying the code over. It's not how well the bear dances, but that the bear dances at all. That said, EMS and a solid-state hard drived do help a little.
      • badsectoracula 3y ago
        TBH for an original IBM PC i'd use at most TP5.5 as it is faster and you do not lose much in terms of functionality (IIRC the biggest loss is the inline assembler).
  • qingcharles 3y ago
    I never tested it on an XT, but it ran like a dream on my 286. I wouldn't be where I am now without Turbo C++/Turbo Assembler.
• fred256 3y ago
  > MS-DOS shipped with a TUI text editor since version 5 (1981) MS-DOS 5 came out in 1991, not 1981.
• novok 3y ago
  IMO the real loss in IDE tech is the speed that visual basic 6 gave you to make desktop guis. Web and mobile development (which I have done all 3) are significantly slower than what you could do with VB6. It's really strange why we haven't gotten back to it.
  • OOPMan 3y ago
    I dunno, I worked with Qt5 and Qt6 recently and creating a UI felt pretty fast and smooth to me (Much more so than the last time I did frontend web work anyway) That said, I've never used VB6 so maybe I'm missing something...
  • hk1337 3y ago
    Would this be similar to the .NET Webforms? That could be done in C# or VB.
    • wombarly 3y ago
      The equivalent would be WinForms
  • haddr 3y ago
    Or even better one: Delphi (if you were into pascal)
    • dkersten 3y ago
      I’ve often heard people mention that Delphi was a superior RAD GUI experience than Visual Basic, but as someone who’s never used it, what is it that made it so great compared to VB or other GUI builder type tools (eg Qt Designer)?
      • gardnr 3y ago
        The pascal language requires things to be declared in a certain order. It's a bit awkward some of the time bit it enables the compiler to work in a single pass. This meant that running an application was extremely fast by any standards and this really made it stand out compared to other development tools out there. VB created applications that had to ship with a shared runtime library. Windows wasn't great at versioning these libraries so developers often shipped their own VB runtime with their executable. The executable was small and the runtime was comparatively huge which had a negative impact on user perception when downloading the installers. Before moving on to Microsoft in 1996, Anders Heilsberg was the Chief Engineer at Borland that oversaw the development and release of Delphi 1.0. For years, VB felt like an application that could make deployable versions of itself. Delphi felt like a programming environment that compiled code into applications. After Heilsberg moved to MS, a lot of improvements were made in VB that utlimately made Delphi less attractive, especially during Borland's strategic waffling known as "The Inprise Years": https://en.wikipedia.org/wiki/Borland#Inprise_Corporation_Era https://en.wikipedia.org/wiki/Borland#Inprise_Corporation_Er... If you want to get a feel for what it was like then check out the FOSS clone "Lazarus".
• purplejacket 3y ago
  XY-Write anyone?
• lowbloodsugar 3y ago
  SlickEdit was around back then, in TUI form. Fantastic.
• shagie 3y ago
  Twenty nine years ago, Metrowerks Code Warrior was released https://en.wikipedia.org/wiki/Metrowerks https://en.wikipedia.org/wiki/Metrowerks I had the shirt ( https://www.rustyzipper.com/shop.cfm?viewpartnum=282427-M55830 https://www.rustyzipper.com/shop.cfm?viewpartnum=282427-M558... ) and wore it for many years... wish I knew where it was (if its still in one of my boxes somewhere). The IDE was no where near as clunky as a text only DOS screen. https://www.macintoshrepository.org/577-codewarrior-pro-6 https://www.macintoshrepository.org/577-codewarrior-pro-6
  • khazhoux 3y ago
    The entire System 7 UI was really a thing of beauty.
  • destitude 3y ago
    The alternative was MPW which was awful! Long Live Code Warrior! Its debugging was probably a decade ahead of its time.
    • com 3y ago
      I still miss the simplicity and power of the Lightspeed/THINK IDEs for Pascal and C. For me Metrowerks was a big step back in terms of complexity, speed and affordances. The thing that I loved about MPW was MPW Shell and Commando, brilliant if you compare it to the state of the UNIX art at the time, probably tcsh, and still to this day feeling just a bit like the future.
• shultays 3y ago
  30 years ago late 1980s / early 1990s Yeah, no
• LoulouMonkey 3y ago
  Fantastic article, thanks for sharing.
• redandblack 3y ago
  Borland Turbo C and it's debugger helped me implement my 1st scheduling optimization algorithm, get into production and got me a promotion. Ported it over to IBM mainframe with the help of a colleague which reduced run time to few minutes compared couple of hours on DOS/486 It looked so clunky compared to what my colleagues used in their DEC and SGI (6 processors I think) workstations had, but got the job done
• tiberius_p 3y ago
  I'm not a fan of any IDE brand or company. I'm a fan of features. Any respectable IDE must have the following features: - jump to declaration - autocomplete of fields and methods of an object - autocomplete or tool tips for function arguments - code templates - find all the usages of a variable, type or function - rename variables, function, types etc. all over the code base(and do it correctly not blindly like with sed) - select a piece of code and extract it into a function - select multiple fields and methods and extract them into a separate class - highlight pairs of parentheses, brakets, curly braces and be able to jump between them - highlight searches - show line numbers - search/replace text in current file or over multiple files(aka grep and sed but integrated into the UI) - be able to open a terminal in a pane - search for a type all over the code base - search for a global function or variable all over the code base - display tree of included files(for languages that allow including other source files like C++) - display tree of subtypes/supertypes of a specific type - display a list of all overrides of a method and be able to jump to them - semantic checks(e.g. check that the types of the arguments in a function call match those from the function declaration - of course for languages that have a type system) - display syntax/semantic errors as I type - a file explorer should always be easily accessible - automatically select the current file in the file explorer; be able to turn this behavior on or off - Copy the full path of the current file to clipboard - Copy the name of the current file to clipboard - Autoformat the code - Autoindent - Syntax highlight - debugger integration - build system integration - display an outline tree of the source code ine current file - have a local history of all the changes to a file - version control integration - diff between current and previous version of the current file - search files by name in the entire code base - when many editor tabs/buffers are opened, search through them by file name - spell checking in comments, be able to turn it on/off - generate documentation from comments - fold/unfold code blocks - replace tabs with spaces - show special characters - block editing - place coursor in multple places and perform the same editing changes in multiple places at once(like in sublime) - jump over paragraphs - jump to beginning/end of file - open documentation of function/class/type/etc. under the coursor - set bookmarks in code - have a history of searches and be able to redo older searches - list all TODOs/FIXMEs from all over the code base - split panes vertically/horizontally - textual autocomplete (meaning autocomplete if identifier is already present in current file) - linter integration - UML diagram generation - erase the current line with a single key binding - move current line up/down with a single key binding - display object instance tree - and possibly many others that I just can't remember right now... Now I don't care if it's vim, emacs, vscode, eclipse or jetbrains offering these features. From experience I learned these features make me most productive...coupled with command line tools it gets even better. So if these features/tools are available in an IDE/tool suite then I'm a happy programmer and I will use them. I don't have time to be a fan of this editor or that editor...even though I do like to enable vim key bindings if they're available once in a while.
• larodi 3y ago
  Here’s another very potent one from 40years ago that was popular and widely used for asm/c dev Since the simple MS-DOS editors (which are not IDEs really) are listed, this one is a must have in the list. https://en.m.wikipedia.org/wiki/Personal_Editor https://en.m.wikipedia.org/wiki/Personal_Editor
• forrestthewoods 3y ago
  There’s a ton of editors that are all roughly equivalent for writing C++ code. Vim, EMacs, VSCode, 10x, whatever. But Visual Studio is still hands down the best C++ debugger. And nothing else even comes close. Which is a real travesty. RemedyBG is making progress. But it needs a NatVis equivalent and it needs to be way more reliable. It fails on major projects with obnoxious regularity.
• jussij 3y ago
  Back then BRIEF was also an amazing development environment. Now it was not so much an IDE and more of a programming editor, but it was still amazingly good for software development.
• ralphc 3y ago
  If you look at his screenshots you might think you were limited to 80x25 but with EGA and VGA you could pick a different screen size and get more vertical lines.
  • Narishma 3y ago
    At the expense of vertically squished fonts, which I hated the look of. I would have been more likely to use it if it had a similar increase in the number of columns to keep the font at the correct aspect ratio.
• bluedino 3y ago
  No mention of the Microsoft C and Pascal IDE. They were somewhat similar to the QBASIC editor. Not as popular as the Borland counterparts
• deleted 3y ago
  [deleted]
• 3x35r22m4u 3y ago
  If any dev out there is looking for a challenge/cool thing to do, here it is: a TUI DE following the practices of TurboC/TurboPascal, CUA visuals and keybindings from edit.com and support for multiple languages and LSPs.
• mannyv 3y ago
  ObjectMaster by ACI was pretty much the best OO IDE at the time. Pretty much everything on the Mac kicked the shit out of these pathetic and crappy DOS/commander interfaces that are linked in the article. Unfortunately, there don't seem to be any screenshots of it online anymore due to link rot.
• deleted 3y ago
  [deleted]
• phendrenad2 3y ago
  I recently started building a little desktop app using C# .NET WinForms, and it was a tiny bit clunky at times, but strongly reminded me of building VB4 apps.
• breadwinner 3y ago
  NeXT had a terrific IDE 30 years ago, called Interface Builder. More info: https://arstechnica.com/gadgets/2012/12/the-legacy-of-next-lives-on-in-os-x/2/ https://arstechnica.com/gadgets/2012/12/the-legacy-of-next-l...
  • jshier 3y ago
    The IDE was Project Builder, Interface Builder was a separate, as the name implies, builder for interfaces that could then be connected to Obj-C code in Project Builder. They continued as separate apps even after Apple bought NeXT and shipped Mac OS X, until they unified the two into Xcode.
• firemelt 3y ago
  so neovim is the sota of vim now?
• nxobject 3y ago
  On the Mac side, THINK/Lightspeed Pascal had all of the same unmmatched mod cons of Turbo Pascal: lighting fast compile times, unmatched symbolic debugger that understood record types and Macintosh handles with a variable watch/execute statement window, auto formatting. It was sad that the Mac world slowly converted to C/C++ as the "flag carrier" programming language. No TUIs, ever. God forbid.
• pkphilip 3y ago
  I hope someone from Embarcadero is paying attention to this thread. They have had some great IDEs but their primary attraction was the price point and the ease of use of the products. Please make Delphi affordable again. Considering that Delphi can be used for Android, IOS and Linux development as well, it would be a great tool - if it weren't for the insane pricing.
  • boznz 3y ago
    Coming up for retirement and I have made a nice business using Delphi; it's been the right tool for the right job and that is developing Windows programs. I understand why Embarcadero did it, but for the dozen people who actually use Delphi for any OS other than Windows, and any CPU other than x86, they really should not have bothered.
• lisper 3y ago
  This article completely ignores the Macintosh and the greatest IDE ever, which came out in in the mid-80s: Coral Common Lisp. It ran on a Mac Plus with 1MB of RAM and it was fucking awesome. It included a drag-and-drop interface builder that let you build a complete app in literally a matter of minutes. Nothing I've seen has come close since.
  • tymscar 3y ago
    That sounds like something I would enjoy playing with? But I can’t find much about it online.
    • lisper 3y ago
      The descendant of CCL runs on modern Intel Macs. (It also runs on Linux and Windows but without the IDE.) The modern IDE is quite a bit different from the original. In particular, it no longer has the interface builder. But it's still pretty good. It is now called Clozure Common Lisp (so the acronym is still CCL) and you can find it here: https://ccl.clozure.com/ https://ccl.clozure.com/ If you want to run the original that is a bit of a challenge, but still possible. The original was never ported directly to OS X so you have to run it either on old hardware or an emulator running some version of the original MacOS, or on an older Mac running Rosetta 1. In the latter case you will want to look for something called RMCL. Also be aware that Coral Common Lisp was renamed Macintosh Common Lisp (i.e. MCL) before it became Clozure Common Lisp (CCL again). This looks like it might be a promising place to start: https://github.com/binghe/mcl https://github.com/binghe/mcl If you need more help try this mailing list: https://lists.clozure.com/mailman/listinfo/openmcl-devel https://lists.clozure.com/mailman/listinfo/openmcl-devel Good luck!
• einpoklum 3y ago
  I was a TA in an "Intro to Compute Science" class in the naughts, and using Borland C was quite popular among students who were on Windows. I never heard a single student complain about the IDE, even though most of them were used to GUI apps only. It was very intuitive and convenient to use. I wish we had nicer TUI tools today - I often miss them when I work remotely over a thin connection passing through a couple of proxies/gateways/etc which have trouble with X or VNC traffic.
• ForOldHack 3y ago
  In 1989, I got a IBM AT, with VGA. I flipped from a Herc card, with 25 lines, leaped past EGA 43-line mode into VGA 50-line mode. Turbo Pascal, and SideKick ( or psychic ) all ran perfectly. Paradise VGA w/ 512k. Sony 15" Trinitron, very sharp. Why don't other people program in this? Wideprint had a 132 column mode for Lotus 1-2-3, and again, SideKick jumped in perfectly.
• liendolucas 3y ago
  Fond memories learning both Pascal and C when at high school with 486 Compaq machines and the Turbo compilers. Not long ago I configured DOSemu with Turbo C to do some bare bones graphics development but I just couldn't get used to it. Does anyone know or recommend a setup where coding takes place outside DOSemu but yet the compiling/execution takes place in DOSemu? (I mean calling all the build chain outside DOSEmu). I've seen in an older HN post that someone setup a retro IDE with VSCode but I'd like something more Vim like instead of this behemoth.
• Blackstrat 3y ago
  A discussion of editors/IDEs from 30 years ago and the author doesn't mention Brief?
• stuaxo 3y ago
  Agree with all of this - I had exactly the same feeling going from DOS to Linux in the 90s and wondering where the proper TUI apps were.
• deadbabe 3y ago
  30 years ago there was Vim. 30 years from now there will still be Vim.
• renegade-otter 3y ago
  I fondly remember Borland C++ builder - it allowed me to write shareware apps for Windows without having to learn the low-level MFC API. I was a hobbyist, and it scared me :)
• robertgraham 3y ago
  Nobody (yet) has mentioned Microsoft PWB - Microsoft's Programmers Workbench for their C compiler, around 1990. It's what all the Microsoft engineers themselves used when writing code for Windows, WinNT, OS/2, etc. It was essentially perfect for its time.
• jules22 3y ago
  The glaring omission in the article is Visual Basic for DOS. It had a visual TUI designer in DOS. https://www.youtube.com/watch?v=-vDpzoYgNd0 https://www.youtube.com/watch?v=-vDpzoYgNd0
• dfawcus 3y ago
  Oddly enough, I never used them at the time. It was the CLI compilers, and makefiles. Possibly because most of the work I was doing was cross compilation for embedded systems, not targeting DOS nor Windows. However it was often using Borland/Turbo C and/or Metaware High C, both as DOS based compilers. Occasional y some assembly, or (DOS based) cross compilers for other CPUs (8051, Z80, etc). Possibly the experience was different for folks not predominantly doing cross system development. So the editor was usually BRIEF, which could be set up with per file type "compile", rules. Being a multi-file editor, one could "compile" the makefile, hence build the complete system. This would then run the compiler, and jump to the first error; plus commands available to jump to the next error in sequence. On the occasions I needed something better for search and replace, I'd use a DOS version of vi. When working on a local (DOS based) tool, one would occasionally have a TSR version of a help manual available, but generally the printed manuals the products came with were preferable. As to a retrograde step when switching to unix/linux/bsd based development, not really. The combination of Job Control to switch between suspending the editor and running the compiler, together with virtual terminals where one could have man pages open covered most bases.
• geon 3y ago
  In the late 90s I used notepad. Mostly writing plain html. Then in the early, 2k I wrote php in Crimson. http://www.crimsoneditor.com/ http://www.crimsoneditor.com/ When switching to mac in 2009, I used Smultron. https://www.peterborgapps.com/smultron/ https://www.peterborgapps.com/smultron/ Followed by sublime text. Then when I started writing typescript in 2016 or so, I switched to vscode.