Lucid Energize Demo VHS 1993

I also only toyed with Ada. My real work experience with Algol like languages are Turbo Pascal, Delphi and Oberon. Although thanks to my interest into compiler development during my CS degree, I also do have some knowledge of almost all major Wirth influenced languages. Personally, I do prefer some verbosity to lines full of symbols. Ada 2012 is quite good. It is also remarkable that in the 80's Ada 83 as seen as almost impossible to implement and nowadays C++ is way complexer to implement than Ada 2012. Another anecdote, Rational started out in mid-80's as a startup doing Ada workstations[1] (think Ada machines), with IDE capabilities that probably only Lucid C++ had in the 90's [2]. [1] [LINK] [1] [LINK] [2] [VIDEO]

Interactive programming is very developer friendly workflow, something that was already possible at Xerox PARC in their Smalltalk, Interlisp-D and Mesa/CEDAR environments. Actually there was an early attempt to provide C++ repls back in the early 90's with Lucid Energize C++, after they pivoted from Lisp Machines and applied their knowledge to C++. [VIDEO] Also the majority of CERN code is written in a mix of Fortran and C++, and not all teams like to use Python. So they rather use something that provides interactivity to research their algorithms and speed at the same time.

Like Lucid Energize C++ in 1993 ? [VIDEO] Or C++ Builder or C Set++ for OS/2 (might have the name wrong). If it wasn't for tool vendors having switched their focus from C++ to Java and .NET, until LLVM and clang got created showing everyone what was wrong with their approaches, C++ IDEs might have been much more advanced already, in spite of technical issues with language.

The point being that we have seen the future like Bret puts it, and are to certain extent disappointed that the industry keeps doing left turns. Many C++ users are finally enjoying environments like Clion and incremental compilers, well this was a C++ environment in 1993: [VIDEO] Built on top of Lucid Common Lisp infrastructure, as Lucid pivoted their business to C++. IBM had a similar one, that imported C++ into a database, offering a Smalltalk like development experience for C++, called VisualAge C++ Professional 4.0 [LINK] So yeah, we are grey hair dogs disappointed how things evolve.

It existed, but sadly both were too early for the market. The first one was from Lucid, after pivoting away from Lisp Machines. [LINK] Here is a demo on YouTube. [VIDEO] IBM also tried to create a Smalltalk style repository in Visual Age for C++ v4.0, which has quite resource hungry for mid-90's PCs. So we had to wait until the idea of compiler as library to catch on, to get those ideas back.

Here is how Lucid implemented their C++ knowledge repository for Energize C++. "Foundation for a C++ Programming Environment", chapter 7, Protocols [LINK] And how it looked like with their Emacs customization in 1993 on UNIX. [VIDEO]

It would look like Lucid Energize for C++, here a 1993 sales demo: [VIDEO] Or the version 4 of IBM's Visual Age for C++ Visual Age for C++ was quite impressive, the whole program was serialized into a database, an approach similar to Energize, and you could edit C++ code just like in a Smalltalk environment. Sadly not much of it has survived, so save pages like this while they exist [LINK] The problem with those two products was that they were ahead of their time, so with their hardware requirements, ended up being a commercial failure. Then for something more down to earth, there is C++ Builder, the only actual C++ RAD tooling, but their market is only deep pocket corporations. Think VB experience, but using C++ instead. [LINK] Finally there is VC++, which also supports edit-and-continue with incremental compilation and linking, and with C++/CX I thought it could eventually be like C++ Builder but was wrong. Also with the C++/WinRT reboot, the tooling is still playing catch up with C++/CX. However there is also the option to use interpreters like Cling. Then you also have the development experience of Common Lisp, Dylan and Eiffel. All of those have rich IDEs, with interpreter/JIT compilers for development, and then you can also AOT optimize for release builds. Eiffel to this day uses their JIT (oder MELT as they call it) for rapid development, and then relies on a C or C++ compiler for the release builds. Dylan while killed by Apple, had a short commercial life, and you can

Compare Symbolics Genera to a Free Software Common Lisp development environment today (SBCL and SLIME on GNU Emacs). The latter does a lot less and is more bloated. Commercial Common Lisp compilers like Allegro and LispWorks have features and optimizations that Free Software compilers lack (Allegro has really good debugging tools and garbage collection, LispWorks has excellent support for concurrent programming). Intel Fortran compiler and their C++ compiler produce the fastest code. Lucid Energize and IBM VisualAge C++ did incremental compilation and had IDE features not available with Free Software C++ compilers and editors/debuggers. [VIDEO] [LINK]

Rejuvenating that many devs are finally looking into this kind of workflows. For prior work on IDE as database check "Energize/Cadillac & Lucid's Demise", [LINK] You can see it in action on this 1993 marketing video from Lucid, [VIDEO] IBM also tried the same concept on Visual Age for C++, version 4, which was one of the very last versions of the product. [LINK] Both suffered from too heavy hardware requirements for what most companies were willing to pay for, otherwise we could have had Smalltalk like tooling, with incremental compilation and reloading for C++ already during the early 90's.

The video is not bad but as I watched it when it came out I thought that they missed what for me is the most interesting part: how the console/debugger/ui combination is fully hyperlinked: [LINK] There are precedents of that though: from what I’ve seen in videos and read in manuals, the integrated LISP environments like Genera did have that much earlier. That was built by teams of people with way more resources than him. I think Terry Davis was right in that some valuable things have been lost in modern computing systems. BTW, today I watched a demonstration of an IDE from the 1990s linked from another HN discussion which also hyperlinked things like the debugger (gdb) output etc.: [VIDEO] It was the company that made Lucid Emacs (later XEmacs) which they built for this purpose: graphic elements combined with monospace text.

> (One could think of an even finer grained approach that would track changes in individual functions or classes and thus recompile even less than a file, but I’m not aware of practical implementations of such an approach in industrial languages, and altogether it doesn’t seem necessary.) Lucid Energize did it: [VIDEO] Incomplete source code: [LINK]

autocompletions have been a feature in IDEs since Visual C++ was introduced, and copied by Java IDEs, and naturally Visual Studio for .NET languages as well. Introspection, graphical code navigation has been a thing in Apple MPW, Borland C++ for Windows, Visual Age for C++ (latter CSet++), C++ Builder, Eclipse, Visual Cafe, Visual Studio Enterprise. Live debugging and recompilation, edit-and-continue in Visual Studio, JVM class reload capabilities and JRebel JVM agents. REPLs, available as standard feature in Java since Java 9, prior to that there were IDE features like Eclipse Scrappages. Visual Basic interactive mode (classical VB), and nowadays F#, C# and VB.NET interactive shells on VS, including send-to-repl capability. Lucid Energize C++ tooling from 1993 already enjoyed some of these features: [VIDEO]

Be prepared to be amazed with what Xerox PARC and others were doing, while Bell Labs was busy pushing for UNIX. "Eric Bier Demonstrates Cedar" [LINK] "Emulating a Xerox Star (8010) Information System Running the Xerox Development Environment (XDE) 5.0" [LINK] "Documents as User Interfaces Video Demo" [LINK] "SYMBOLICS S-PACKAGES 3D GRAPHICS AND ANIMATION DEMO" [LINK] "Alto System Project: Dan Ingalls demonstrates Smalltalk" [LINK] "Action!, the worlds first dynamic interface builder - 1988" (Interface Builder percursor, written in Lisp) [LINK] "The Interlisp programming environment" [LINK] And the cherry, how Lucid used Lisp ideas for their Energize C++ IDE, including an image based format for AST storage [VIDEO] [LINK]

It was already possible in the early 90's. [LINK] "Lucid Energize Demo VHS 1993" [VIDEO] VisualAge C++ Version 4.0 [LINK] [LINK] However they were too resource hungry for the hardware of those days, then Java and .NET took over the spotlight, and until clang/LLVM came into the scene, the industry forgot of what was already possible.

And in languages that try to replace C++, better offer nice IDE tooling as well. [LINK] [LINK] With VC++ and Unreal catching up with Lucid Energize[0], others will have to up their game. [0] - [VIDEO]

Nope, there were plenty of VS plugins like Visual Assist, and the first IDE to offer something like LSP was a C++ one actually, Energize C++. Here is the documentation to cadillac, [LINK] , and the respective demo of their XEmacs based environment from 1993. [VIDEO] Refactoring is one feature of IDEs, not the whole package. Still, here is your refactoring rubicon in Visual Age for C++ (1999), [LINK]

Yeah, that's more like it. RPG worked a lot to bring sophisticated Lisp to UNIX systems. He worked on bringing a standard OOP system to Lisp (incl. Lisp Machines, where Lucid (and he personally) collaborated with Xerox PARC and Symbolics to develop CLOS as a part of the ANSI Common Lisp standard). Then he tried to develop and market similar technology in the form of a databased-backed incremental C++ development system for UNIX (called Energize). [VIDEO] He hoped that the market for C++ environments was larger than the shrinking Lisp market and that C++ developers would want an interactive system with integrated code management in an object store. That did not went well.

Julia main focus is scientific computing, and they aren't doing that bad, [LINK] There have been other interactive environments for C++ that predate ROOT, but they were too resource intensive and the market killed them. Namely, Energize C++, which came out from Lucid as they pivoted away from Lisp Machines, applying the same kind of technology to C++, based on XEmacs. [VIDEO] [LINK] And the last version of Visual Age for C++, based on the Smalltalk development experience. [LINK] [LINK]

Back when C++ was becoming famous, my favourite programming language was Object Pascal, in the form of Turbo Pascal, having been introduced to it via TP 5.5 OOP mini booklet. Shortly thereafter Turbo Pascal 6 was released, and I got into Turbo Vision, followed by Turbo Pascal 1.5 for Windows 3.1, the year thereafter. I was a big Borland fan, thus when you got the whole stuff it was Object Pascal/C++, naturally C was there just because all C++ vendors started as C vendors. On Windows and OS/2 land, C++ IDEs shared a lot with Smalltalk and Xerox PARC ideas in developer experience, it wasn't the vi + command line + debuggers are for the weak kind of experience. See Energize C++, as Lucid was pivoting away from Common Lisp, with Cadillac what we would call a LSP nowadays, where you could do incrementatl compilation on method level and hot reload "Lucid Energize Demo VHS 1993" [VIDEO] [LINK] Or the Visual Age for C++ version 4, which introduced a database, image like system for doing C++ in workflows similar to Smalltalk. [LINK] [LINK] Then there is C++ Builder, still going on, even though the way Borland went down spoiled its market mindshare, [LINK] You're right altougth C++ was born on UNIX at Bell Labs there is that point of view, and also a reason why I always had much more fun with C++ across Mac OS, OS/2, Windows, BeOS, and Symbian, with their full stack frameworks and IDE tooling. However with time I moved into managed languages, application languages, where it is enough t

Many of those features were already available in MS-DOS and Windows 3.x IDEs from Borland for Turbo Pascal and C++. Which is why when I got into UNIX development felt like going into the stone age of development tools, thankfully XEmacs was already there. Which by the way, it was born for Energize C++, in 1993! [VIDEO] Also here is what NeXTSTEP development environment looked like, used for Quake tooling development, in a 1991 marketing video. [LINK] Which is why, I usually assert I cannot understand the nostalgia of CLI and TUI, being there at the time, and not being able to use some of these systems, due to the amount of money they required.