To keep pushing a project from the 70's and keep it current is quite a feat.
Rebuilding from scratch is its own challenge, but to keep maintaing something at this scale and have such quotes be realized by hundreds of people is awe-inspiring.
Even if I rather use IDEs, Emacs was eventually my rescue in the 90's after failing to find anything on UNIX that could somehow resemble the Borland IDEs I enjoyed using.
This were the days when fvwm was considered new.
So even today, if my IDEs aren't around, I get to use my old friend Emacs.
My short-lived experience with Java and Android made me wary of IDEs. It taught me an important lesson: If a language's IDE can autogenerate 90% of the code in "hello world" for you, without knowing anything about the program you are about to write, than that language has far too much boilerplate.
I've never loved IDEs, because they increase the amount of time between having an idea and starting to code it, whereas with emacs, I can just start writing code.
The only IDE that is any good is the Smalltalk IDE, because it's not so much an IDE in the java sense as it is a realtime window into the soul of your application and environment. I mean, if you thought the modern LISP's realtime interaction was good...
But yeah, even then, I start to miss emacs. And I'm not even a serious emacs user. Which is to say, my config can probably fit on only a few pages, and I don't know the 100+ set of basic keyboard shortcuts yet.
I used Emacs for around 10 years, so I do know what it is capable of.
Regarding Lisp many in the FOSS camp that never experienced commercial Common Lisp IDEs should give a try, the REPL is only the tip of the iceberg. Maybe Racket is the closest one can get without paying.
Back in the mid-90's I couldn't even get Emacs to do what Borland got me with their tools or even what I later learned Xerox environments were capable of.
Energize C++ with their custom Emacs was probably the closest thing that one could get, if the company could afford it.
>Regarding Lisp many in the FOSS camp that never experienced commercial Common Lisp IDEs should give a try, the REPL is only the tip of the iceberg.
You've said. However, I am unsure as to whether any Lisp implementation outside of the lisp machine truly allowed for programming inside a live environment, such that there is no distinction between the live environment and the code on disk, where the image IS your environment.
Although being able to serialize your live environment to disk goes a long way. As a schemer, I'm still drooling over that particular feature.
The bigger Lisp IDEs have a different idea. They use the running image as an information system about all the sources it has seen, which means, which it has loaded and/or compiled. Location of source, arguments, who calls who and from where, documentation snippets, ... When you load and compile, this data is continously updated.
It's not as radical as the InterLisp-D system, which is in many ways similar to Smalltalk - when in fact many ideas in Smalltalk are coming from Interlisp and its earlier BBN Lisp, including part of the runtime technology, which enables dumping/restarting images.
'the lisp machine' did not do that. There were different attempts. The MIT Lisp Machine used Lisp code in files, with some tool support.
The Xerox Lisp Machine (different hardware, different Lisp, different OS) used a different approach will full managed source code in the image, with managed files as kind of a way to persist sources.
With android it's not just boilerplate code but the undocumented tooling involved as well. It might be to late for you now, but I broke some of it down into something more understandable a while ago:
Well, yes, there is that. Great article, by the way. But the awful boilerplate had a lot to do with me dropping it. If I build an android app, it will be either PhoneGap/Cordova, React Native, or some other tooling.
There's a different workflow. I always feel like I'm fighting the IDE, the instant I do anything that is even slightly off the beaten path. And they're complicated: everything about the IDEs that I've used seems to be an overcomplicated mess of settings, options, and menus, whereas in emacs, I could just put a single config option into my init.el to do what I want instead of jumping through all those hoops just to get to the setting. This is a problem compounded by the fact that Java, the only language I've used in an IDE, has a complicated development environment and multiple complex build systems, meaning you HAVE to fiddle with things to a fairly large extent.
To further things, it's rare for an IDE to be as programmable and configurable as emacs, or even close. It's considered above and beyond the ordinary to write extensions for most IDEs: the job of an extension is to add some big feature, like support for a new programming language. My first emacs "extension" was a simple function that wrapped around some actions I found myself constantly using in sequence, so I could type one command sequence instead of six. It wasn't something I wanted to dedicate a macro to, I just wanted a command to exist that would do what I wanted.
So I have burnt out and tried sticking to a Scala class on Coursera. But to be honest, the Scala IDEs were not the problem, not the tooling as everyone jokes.
I have run back to ensime and sbt-mode. I have an old Thinkpad but with 8GB memory. The class flipped between IntelliJ or Eclipse depending on platform. I find them exhausting. They consume a ton of resources (as IDEs go, Emacs and piped in tools can be 8 megs and swap all damn day and still cut through them in performance and speed).
There is just too much going, despite having nice auto-complete and error check defaults, they struggled to pick up Scala compiler bin paths, even at defaults, and there are just so many damn menus. What did emacs, and later helm perfect? M-x and search all the damn options. Even every OS on the desktop imitates this stuff now! I know Intellij, to a lesser extent Eclipse can do that, but they are so damn busy with GUI tiles and buttons and UI choices I cannot be bothered to wade through the chunkiness of it all, even if it means I will have the potential for superior coding. I feel it is the lazy way out.
I am slowly eeking my way to intermediate Emacs use, and I keep forcing myself because all the GUIs and lack of consistency cannot make up for the minimalist, trim your own topiary of combined tool bliss that is Emacs for me!
I'd give Intellij another try. It is heavy, but you gain a lot from having your IDE understand your static language. And it's really easy to set it up to look noise-free; I almost never touch the menu.
Double shift (to lookup every project symbol) and meta-shift-a (to lookup every IDE function, like M-x) gets me almost everywhere, aside from navigating along definitions/implementations/usage sites which is the reason to use an IDE. Toggle distraction free mode (via meta-shift-a) to get rid of everything beside the open file.
I think the typical way to set it up is to manage the Scala runtime itself (maybe via SBT? I don't even know off-hand), so having it pick up an existing installation is kind of non-standard. Can't remember when I've ever manually downloaded Scala.
I used it for a Java class. I like to build up instead of strip down. I will stick to Emacs, thanks.
Emacs can do those things, I just have to selectively decide what and how and when. I also do not like dependence on proprietary software. Yes, I know there is a free copy. But when they try cool new UI or feature X and I must suffer through it, I yearn for the consistency of Emacs for three decades for a reason. I have been doing Windows sysadmin for approaching a decade. W10 imposing changes I hate on me was the last straw: at home, open source or nothing. Haha.
Yes, re SBT. I tried both methods (system-level install of SBT and Scala with pacman and ~/.sbt or whatever install), it went so-so.
Just a tiny little thing: Once you have SBT there's no need to actually install Scala. (Though, obviously, you may want to for other reasons if e.g. ENSIME requires a standalone Scala install. I wouldn't know, being a happy IDEA user :))
I started coding using IDEs some years ago, but after the quick Emacs tutorial, I never went back to GUIs for programming. I like the simplicity of working with text (a terminal) to create text (code). I feel like I can automate anything in the world in Emacs.
To keep pushing a project from the 70's and keep it current is quite a feat.
Rebuilding from scratch is its own challenge, but to keep maintaing something at this scale and have such quotes be realized by hundreds of people is awe-inspiring.