from Hacker News

Ask HN: Good examples of interactive command-line user experience?

by noshbrinken on 5/23/17, 1:40 PM with 82 comments

What are good examples of interactive TUI/CLI user experience? I'm looking for nice layouts, use of ASCII color, interaction patterns, nicely written help text, etc.

  • by git-pull on 5/23/17, 2:20 PM

    Yes, tmux.

    - tmux counts as a TUI UX. it is backed by ncurses (https://en.wikipedia.org/wiki/Ncurses)

    - colors: it supports 256 colors, 24bit colors landed in 2.2 (but haven't used it)

    - layouts: 1) supports splitting multiple command lines into "panes" which are resizable 2) supports custom layouts and arrangements for panes 3) you can "zoom" in on panes via `C-b z` 4) you can actually run other TUI applications within it

    - interaction: 1) tmux also forks itself into a server in the background so you can de/re-attach your workspace 2) you can create and move between collections of panes, what tmux calls "windows" 3) command-based, so configuration via ~/.tmux.conf uses the same language as scripting 4) tmux can be scripted / remote controlled, you can even send-keys and copy the contents of panes

    - help: the tmux manual is superb (https://www.freebsd.org/cgi/man.cgi?query=tmux)

    Downsides are, I still get glitchy issues when using vim / unicode / colors in tmux panes which are difficult to diagnose. `reset` normally fixes it. It's been this way for years, and I don't want to even begin figuring out what the hell is happening because I'm using too many plugins. Considering starting from scratch. So if you get into tmux/vim/other CLI stuff, the simpler you keep your config, the better off you'll be.

    (P.S. I am the author of The Tao of tmux, a book you can read free online)

  • by neovintage on 5/23/17, 1:59 PM

    I would recommend that you check out the Heroku CLI Style Guide: https://devcenter.heroku.com/articles/cli-style-guide

    There are many different teams within Heroku that need to provide interactions for developers via CLI whether its for dynos or data services. The guide was a way to codify building a consistent interaction that all product managers and engineers could follow. Disclaimer: I work for heroku.

  • by gumby on 5/23/17, 6:04 PM

    The symbolics accept/present system (part of Dynamic Windows). Unfortunately if you haven't used it, all I couldn't find was Gene Ciccarellis' PhD thesis: https://dspace.mit.edu/bitstream/handle/1721.1/6946/AITR-794...

    Basically: Lisp supports idempotent type-based printing (print something in a form that can be read back to identify the same object -- basically unremarkable these days; consider python's __repr__ and __string__) as well as human-friendly printing.

    The presentation system was remarkable in that when you printed an object it printed in the user-friendly form, but when the text was read back the IO system knew what the object was and so acted as if a machine-readable representation had been printed. It also used the type hierarchy to support mouse action in "ordinary" text, thus if you needed a SHAPE object, the mouse would highlight "Square at 4,4" and "Circle centred at 5,5, radius 7" as if it were #<CIRCLE 5,5, r=7>. In fact the "printed" representation need not be textual.

    Also BSD4.1 sh is quite good one !:... and ^...^ etc were added.

    As a side note, IIRC Emacs started out as Ciccarelli's TECO init file around '75/76 or so.

  • by sonofgod on 5/23/17, 2:06 PM

    It's a terrible idea, but an excellent example of experience:

    https://github.com/nvbn/thefuck

    [TL;DR -- typo a command, type 'fuck', will run the command you should have run]

  • by zie on 5/23/17, 2:28 PM

    There was a talk at Pycon 2017 about this [0] that's pretty good. He(amjith) goes through several examples with his favorite being bpython [1] and even covers writing such a thing in python live on stage.

    [0] https://www.youtube.com/watch?v=hJhZhLg3obk [1] https://bpython-interpreter.org/

  • by czak on 5/23/17, 2:42 PM

    I'm constantly impressed by fzf (https://github.com/junegunn/fzf). I use it both from the shell (for files and command history) as well as a fuzzy finder in vim. I greatly enjoy the speed and intuitiveness.

  • by jszymborski on 5/23/17, 6:37 PM

    There's mapscii[0], which was on HN a little while ago. Easily the coolest console experience I've ever had.

    You can check it out by running "telnet mapscii.me"

    [0] https://github.com/rastapasta/mapscii

  • by xiaq on 5/23/17, 4:21 PM

    Shameless plug: Elvish (https://github.com/elves/elvish) is a shell with a rich UI.

    The idea of enriching shell's UI is not new though, zsh and fish are both prior arts.

  • by romdev on 5/24/17, 12:02 AM

    Telemate BBS client was a great example of a windowed TUI in the style of DESQView. You could have a chat window, a DOS terminal and an ANSI terminal all open at the same time. Overlayed dialog boxes were framed, resizable and movable within the window. Scripting was supported in chat and terminal windows to navigate through menus or to type "^H^H^H^Hsexy beast" any time your name comes through the chat. Another favorite of mine, Vern Buerg's List.com, was far better than Norton Commander or the MC clone, in my opinion. As a multi-column file viewer/manager, it maximized the number of files displayed onscreen and allowed simple file operations from a keystroke. By using a hex editor you could change the viewer and external editors. It was also written in 8086 assembly and was very fast.

  • by zeveb on 5/23/17, 3:18 PM

    I think that gnus & magit are pretty good.

    Gnus is a full-featured news, email & RSS reader (and others too maybe?). I've used it for most of my life.

    Magit is a full-featured git UI, good enough that I don't bother using git from the command line anymore.

  • by malkia on 5/23/17, 2:24 PM

    for the TUI - aptitude, midnight commander, back in the days the Turbo Vision was awesome, which I think has some ports for Linux.

    I'm constant midnight commander (linux/osx), FAR commander (windows) user. I'm so glad that it works flawlessly almost anywhere there is terminal support...

  • by gabrielcsapo on 5/23/17, 1:48 PM

    I like npm-check https://github.com/dylang/npm-check it has a really useful and easy to use UI, on of the nicest terminal UI driven applications I have used.

    Edited: to use TUI instead of CLI

  • by niftich on 5/23/17, 3:02 PM

    Midnight Commander and its spiritual predecessors going all the way back to Norton Commander and Volkov Commander are marvellous examples of TUI.

    They're intuitive, interactive, come with embedded help, and use text mode to present a sophisticated, productive interface.

  • by yourapostasy on 5/23/17, 8:47 PM

    Tangentially-related: check out Vermont Views [1], a complete TUI development solution. I wish they open sourced it before they exited the market, or re-entered the market for IOT/embedded developers. I've never found a comparable open source effort, though here's to hoping the Blessed project for node.js takes inspiration from Vermont Views for future directions.

    [1] http://web.archive.org/web/20091011010412/http://www.vtsoft....

  • by odammit on 5/23/17, 1:48 PM

    Serverless (https://serverless.com) has a nice experience. I believe it is built using inquirer.js (https://github.com/SBoudrias/Inquirer.js)

    I've recently built an internal tool with inquirer and it was a really nice development and user experience. I haven't figured out the best way to test the interactions though.

    termUI in go is also nice if you need graphing and viz for a dashboard like command line.

  • by gglitch on 5/23/17, 1:48 PM

    - Emacs' Magit

    - moc (Music on Console)

  • by rdavis on 5/24/17, 3:18 AM

    I highly recommend ranger[0]. It's a very useful console based file manager with great vi key bindings.

    The configuration is also very flexible and includes a python API to write your own commands[1].

    [0] http://ranger.nongnu.org

    [1] https://github.com/ranger/ranger/wiki/Commands

  • by andrewf on 5/24/17, 1:09 AM

    I'd look at old DOS applications - the last mass market (i.e. not just technical users) for non-GUI apps. Although towards they end, they were often just aping Windows GUIs as well as they could (see https://en.wikipedia.org/wiki/IBM_Common_User_Access )

  • by j_s on 5/23/17, 5:51 PM

  • by falcolas on 5/23/17, 2:02 PM

    `parted` is pretty good, in an old-school way.

    The only thing I'd personally ask for is if you offer an interactive interface, make sure you can execute the exact same commands on the plain CLI. Also (yeah, two things) support --help and --version (as well as -h and -v) out of the box.

    Color, layouts (other than those required for readability), and other things just don't really matter as much, IMO.

  • by dduarte on 5/23/17, 8:08 PM

    https://www.youtube.com/watch?v=hJhZhLg3obk "Amjith Ramanujam Awesome Command Line Tools PyCon 2017" goes through some nice examples: mycli, pgcli, fish shell and few others

  • by nicoburns on 5/23/17, 2:22 PM

    The `micro` test editor is fantastic. GUI-standard keyboard shortcuts. Mouse support. Ability to execute commands while editing test.

    https://micro-editor.github.io/

  • by dennyabraham on 5/23/17, 3:03 PM

    The dbcli suite (pgcli, mycli) provide a great user experience on the command line that even some gui database tools don't match up to.

    https://github.com/dbcli

  • by Jaepa on 5/23/17, 2:34 PM

    While it mostly piggy backs on ag, I think tag (https://github.com/aykamko/tag) has one of the best UX workflows I've seen.

  • by odammit on 5/23/17, 2:12 PM

    Oh and don't forget figlet when you need that dope ASCII logo banner.

  • by vram22 on 5/23/17, 5:00 PM

    The FreePascal TUI is good, IMO. So was Turbo Pascal, back in the day. Both are very fast, get out of your way (IMO) and also look(ed) good. Okay, TP not so much :), but not bad either.

  • by winterbe on 5/24/17, 11:25 AM

  • by grovegames on 5/23/17, 1:45 PM

    yeoman is pretty good. It gives the option of interactive or command line. Reasonable use of colour, with some layout formatting. Dynamic options.

  • by TheAceOfHearts on 5/23/17, 4:49 PM

    The first tool that came to mind for me was htop [0] with ncurses. It's a friendly alternative to top.

    I've previously used ncmpcpp [1] without any major complaints, although it's been a few years since then. It's an mpd [2] client written with ncurses.

    On my personal servers I use goaccess [3] to analyze access logs. I remember being able to pick it up pretty quickly on my first try.

    Only tangentially related, but you may find it useful to read the "Utility Conventions" [4] entry of The Open Group Base Specifications. I'd also suggest reading through the relevant entries under the "Program Behavior for All Programs" [5] section of GNU Coding Standards [6]. By following existing conventions (or even being aware they exist) you can sometimes make it easier for others to learn how to use your tool.

    If you know JavaScript, you may consider writing your program with node. The blessed [7] library is a JavaScript reimplementation of ncurses, and there's even a react renderer [8]. This makes building the UI much easier than many of the alternatives I know. When you're ready to release, you can generate an executable [9] for easy deployment or publication. The biggest benefits of taking this approach are that it makes it very easy to achieve cross-platform support, and the barrier of entry is lower than many alternatives. The biggest caveats are that it'll be slower and much larger than if it had been written with C.

    [0] http://hisham.hm/htop/

    [1] http://rybczak.net/ncmpcpp/screenshots/

    [2] https://www.musicpd.org

    [3] https://goaccess.io

    [4] http://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_...

    [5] https://www.gnu.org/prep/standards/html_node/Program-Behavio...

    [6] https://www.gnu.org/prep/standards/html_node/index.html

    [7] https://github.com/chjj/blessed

    [8] https://github.com/Yomguithereal/react-blessed

    [9] https://github.com/zeit/pkg

  • by dbkaplun on 5/24/17, 4:33 AM

    slap[0] (the terminal-based text editor) was designed to emulate Sublime's UX within the terminal. It has a shallower learning curve than other command line editors.

    [0] https://github.com/slap-editor/slap

  • by Grom_PE on 5/23/17, 2:40 PM

    Far Manager is my favorite TUI and is the primary reason I haven't switched over to Linux yet.

  • by txdv on 5/23/17, 2:11 PM

    tig is pretty solid

  • by skocznymroczny on 5/23/17, 3:44 PM

    Turbo Pascal 7.0

  • by type0 on 5/24/17, 1:36 AM

    terminal_velocity

  • by swah on 5/25/17, 11:55 AM

    darcs

  • by type0 on 5/24/17, 2:14 AM

    dockly

  • by souenzzo on 5/23/17, 1:49 PM

    git