Howard Abrams

Fish shell's joke tagline is "Finally, a command line shell for the 90s". I believe that the developer experience for all sorts of tooling has improved dramatically over the last 15 years or so, coinciding with GitHub's rise in popularity. e.g. the plugin ecosystem for Vim or Emacs have improved, let alone options like VSCode. Tools like Vagrant made it easier to work with VMs. Containerised workflows have similarly improved some cases. Languages like Go-lang or Rust seem pretty nice in some cases. etc. Shells are also the kind of thing that developers use. I don't believe bash is the best we can practically get. -- Though.. I have heard of other, fancier shells; (or cool ideas like https://ambrevar.xyz/lisp-repl-shell/ or http://howardism.org/Technical/Emacs/literate-devops.html). These haven't caught on.

Oh yeah, I found his http://www.howardism.org/Technical/Emacs/spreadsheet.html about org-mode and spreadsheets, yet another thing that I love about emacs and can't imagine a "modern" IDE doing as well.

This is a good read written by someone who uses multi mode editing for productive reasons: http://howardism.org/Technical/Emacs/literate-devops.html

Yes, there's a great blog post that describes how this functionality is really helpful to manage your life as lots of little spreadsheets [1]. For me that's the true advantage of Org over Markdown. It has timestamps, spreadsheets and links with citations (e.g. a DOI link type). Plus the ability to get programmatic document views using org-agenda. I can manage my whole life in a really minimal and uncomplicated way. Of course, you can develop a really fancy Org setup. But I think a minimal one, with these features and defaults is really good enough. Plus, not hard to learn. [1] http://www.howardism.org/Technical/Emacs/spreadsheet.html

Consider using org-mode [1] as your primary word processor and committing revisions to git. I recommend org-mode because org documents are saved as plain text and therefore can be easily diffed. org-mode can also be exported to many formats [2]. If you are concerned about how the look and feel of writing in plain text might impact your experience authoring a document, there are lots of editor specific tutorials for beautifying the presentation of org documents. Here is one such article on beautifying org documents in emacs [3]. Also, if you choose emacs as your editor and you are uncomfortable using git, then I recommend magit [4] because it makes git functionality highly discoverable. [1] https://orgmode.org/ [2] https://orgmode.org/manual/Exporting.html#Exporting [3] http://www.howardism.org/Technical/Emacs/orgmode-wordprocessor.html [4] https://magit.vc/

emacs' org-mode / org-babel is well suited for it. This blog post [1] has some fantastic examples. The problem, of course, is that it's so closely tied to emacs. 1: http://howardism.org/Technical/Emacs/literate-devops.html

Emacs org-mode supports a lot of languages [1] and you can mix and match within a file. Howard Abrams literate devops is an interesting example of what org-mode code blocks can do. [2][3] Org-mode also allows embedding images or source blocks in languages like LaTeX that resolve to rendered images. [1]: http://orgmode.org/worg/org-contrib/babel/languages.html [2]: http://www.howardism.org/ [3]: https://www.youtube.com/watch?v=dljNabciEGg

it's a SpreadSheet by default, and from old times: https://www.gnu.org/software/emacs/manual/html_mono/ses.html Also: https://howardism.org/Technical/Emacs/spreadsheet.html

You can do literate DevOps: http://howardism.org/Technical/Emacs/literate-devops.html

Yes, see: http://howardism.org/Technical/Emacs/literate-devops.html

That's an ansible task to do something, but it's not the task solved in the article, or in any of the other linked examples. Things that you haven't done before are harder than things you do all the time, and I would've reckoned trying to do them in ansible is much harder than doing it interactively, but I'd be interested in learning. If I find an article like this[1], how do you translate it into the artefact I would want to keep in source control? In org-babel it's this[2], so what would that look like in ansible? [1]: https://www.digitalocean.com/community/tutorials/how-to-set-up-a-firew… [2]: http://www.howardism.org/Technical/Emacs/linux-iptables.org.txt Once you've done it and you've documented it, I can see how you might translate that into ansible (or chef or whatever), but that's a different thing.

I use it more or less exactly how it was described here: http://howardism.org/Technical/Emacs/literate-devops.html The only real additions relate to internal tools which we developed for our work (I do sensor development and integration).

And literate programming with org-babel! (http://www.howardism.org/Technical/Emacs/literate-devops.html)

All these workarounds sound like a reason to use start using tramp more (apropos, https://www.youtube.com/watch?v=dljNabciEGg / http://www.howardism.org/Technical/Emacs/literate-devops.html is a pretty neat demo of combining org-babel and tramp). ----- There is also emamux, which seems to be able to copy from tmux: https://github.com/syohex/emacs-emamux/#emamuxyank-from-list-buffers

I use org-mode for work actually. Kind of similar to this but less devops: http://www.howardism.org/Technical/Emacs/literate-devops.html

Url changed from http://www.howardism.org/Technical/Clojure/origin-of-car-and-cdr.html, which points to this, which is far more informative. The link in that previous article is a little weird, since the text says "lost in the mists of time". That of course isn't true; if you read through to Steve Russell's explanation the mists clear up quickly.

Gary Schwartz[0] and Howard Abrams[1][2] both have nice explainers about org-mode which explain the advantages and how to get started. There's also a nice discussion on the Emacs Reddit page[3] about "Why Org-Mode?" [0] https://harryrschwartz.com/2016/04/29/getting-started-with-org-mode.ht… [1] http://www.howardism.org/Technical/Emacs/learning-org-mode.html [2] http://www.howardism.org/Technical/Emacs/journaling-org.html [3] https://www.reddit.com/r/emacs/comments/3nvmvr/why_orgmode/

No need for a separate preprocessor. org-mode offers org-babel which enables you to practice "literate programming" to create your init file, where you interleave text and code. Here's are couple of examples: https://github.com/howardabrams/dot-files/blob/master/emacs.org https://raw.githubusercontent.com/sachac/.emacs.d/gh-pages/Sacha.org Also see: http://howardism.org/Technical/Emacs/literate-programming-tutorial.htm…

And its benefits can go way beyond note taking, e.g.: http://www.howardism.org/Technical/Emacs/literate-devops.html I used parts of that approach for sharing notes with the peers and boss, besides my own notes.

The OP's author actually uses Emacs as a windows manager: http://www.howardism.org/Technical/Emacs/new-window-manager.html

If there are examples you'd like to see written up, I'd be interested in helping out. I used to try complicated examples, which led to pages such as http://taeric.github.io/Sudoku.html. I'm now much more into writeups such as http://www.howardism.org/Technical/Emacs/literate-devops.html. (Note, I did not write the second one.)

As a complement on how to use Org mode for ops: - http://www.howardism.org/Technical/Emacs/literate-devops.html (Literate DevOps) - https://vincent.bernat.im/en/blog/2017-netops-org-mode ("same" for NetOps, I am the author of this one)

There's also always this, which I found pretty cool and somewhat functional as well, though it goes beyong the bare "emacs on a kernel" concept: http://www.howardism.org/Technical/Emacs/new-window-manager.html I one had a VM at a workplace where all I had were outdated hardware specs and outdated versions of Windows with few administrative privileges. It helped to retain some sanity. For some time.

I think the down vote is that we see your comment as: "vim & emacs are glorified notepads". At least that is what went thru my head. But they are so much more than a way to type text, with emacs (which I don't grok) I manage my emails archive via gnus/mu/Maildir. Or do "Literal DevOps", check this out for something that still blows my mind with awesomeness: http://howardism.org/Technical/Emacs/literate-devops.html

Actually you can - http://www.howardism.org/Technical/Emacs/new-window-manager.html All you need to do is to set up a couple of hotkeys for things that Emacs cannot do (yet), like (start-process "" nil "xdg-open" "http://some.flashy.javascript.website")

StumpWM sort of gets you a dynamic interface. Use the Scheme(ish) shell (http://scsh.net/) and you can get ...kind of dynamic. Then there's the obligatory mention of this guy who took it to the next level http://www.howardism.org/Technical/Emacs/new-window-manager.html Plan9 + ACME had an interesting 'editor/OS' integration, especially for the time, where you could highlight text, invoke a mouse click action, which would send it to a shell, and return the result on a new-line within your editor. Having everything exist as a file with an addressable file descriptor really made the platform powerful (too bad the licensing was horrible until recently). It's not homoiconic as a proper LISP-1 would be but still an interesting approach.

Another Emacs-based window manager (http://www.howardism.org/Technical/Emacs/new-window-manager.html) was featured on HN about 6 months ago: https://news.ycombinator.com/item?id=8922359

For the particle cross section of - outliner org-tangle/org-babel, literate programming and/or http://www.howardism.org/Technical/Emacs/literate-devops.html broadly exportable format calendar/todo/personal information management etc etc I'm not aware of anything else that covers that territory. However Xiki and IPython (Jupyter now) do have some of the aspects of the "computational document" that I think of in this broader context.

> I can stage and unstage individual hunks, do complex interactive rebases, squash commits, break apart commits, etc. much faster in Magit than I can in other Git GUIs. I can do all that pretty fast in GitUp, too. Since most of the commands there have quick keyboard shortcuts. My most common workflow besides staging anything is (to make sure history is clean): - split up a commit (add/remove files or hunks if the commit contains stuff that should go into another commit) - move new commit up/down the branch (doesn't require interactive rebase in GitUp) - squash up/down (undo/redo from time to time) As far as I understand, Magit doesn't offer anything in that regard except the good old interactive rebase [1]. In GitUp moving commits is (u)p/(d)own and (s)quash with parent > Maybe you're hung up on the "G" part; perhaps I should have just said "UI" rather than "GUI". The distinction doesn't matter. The keyword in both GUI and UI is User. As a user I found GitUp to be a much better tool than Magit. Though Magit does probably allow for more very advanced usage most people don't do. [2] However, actual useful usage like I described above? Ooh boy, no one does it except GitUp for some reason. [1] I only have this blog post to confirm https://www.howardism.org/Technical/Emacs/magit-squashing.html [2] There's another downside to GitUp: it's very slow on repos with huge histories. Probably due to the git library it's using.

I think overall its a mistake to try to over automate this process. It's brittle and the requirements are simply not the same as a server environment that needs to be simple to replicate X versions quickly, repeatedly and frequently. Automation needs fairly constant attention in the order of little tweaks week over week to fight the inevitable mismatch between the automation and the software networks that it interfaces with. Do you reinstall your workstation once a week? Unlikely and probably would be an unproductive use of your time. The way I approach it instead - The first thing I do is list everything I need for a workstation in an orgmode text file. For why orgmode really works well for this - http://howardism.org/Technical/Emacs/literate-devops.html I aim to make a "computational document" that I can execute a bit at a time as I review/check each piece on installs and upgrades of the system. To me it's really critical that there are links to the webpages and text notes about these configurations alongside the code I'm using. I check this and the needed config files into a single git repository. As the workstations (I use the same document for workstation,laptop, studiopc, homeserver, android) age I'm inevitably adding and upgrading bits of the git repository. I make sure that I work from the orgmode document whenever I touch any configuration. I use Linux and Emacs (which means a big part of my software environment is in a git controlled .emacs.d) so the…