catenate

He should play nethack, since it does save environmental damage, and there's a pacifist conduct.

You could run the Inferno VM over OSX to use its variant of unixy commands, "os" to run OSX commands, and edit files and run commands from the tiling windows in Acme. That way you'd get the best of both worlds. This works for me in Windows and Linux (only the commands I run with "os" change, the rest of my environment is cross-platform), and I hear it works in OSX.

clapper@utdc:~$ sudo rm -rf /data/*

[sudo] password for clapper: No4thAmd

Using the mouse or keyboard is a rounding error compared to the time and errors I save by keeping the commands I use in per-directory guide files. I type out a command once, then later modify it slightly repeatedly to suit new needs, and highlight it and run it.

I've never found navigating to and selecting text with keyboard commands as fast and forthright and mindless as just moving the mouse and clicking to locate the cursor and select a range of text, and I used Emacs for 11 years. Also, since Acme binds common operations like cut, paste, and execute to mouse chords, I don't leave the mouse to do these things.

I don't dig candy-colored text, so the lack of syntax highlighting is a plus for me.

For a few years I used each of Wily on a Sun box, then Acme SAC on Windows, and now hosted Inferno on Linux. I could use acme from plan9port, but I prefer Inferno because the whole environment gives me other nifty OS stuff like Inferno's shell sh and /env, which I make use of for the build tool I'm writing. The trickiest part of using Inferno is dealing with the different paths to files depending on whether you're running under emu (emu uses /n/local for files under host /, and / for files under host's /usr/inferno), or on the host (host uses / for files under emu's /n/local, and /usr/inferno for files under emu's /).

Acme

> As Brooks put it, software is the most complex thing humans have ever built; perhaps we should find some other term that sets us apart from ordinary engineers and architects.

Peter Naur (of Backus-Naur form) called it "theory-building". https://dl.getdropbox.com/u/502901/naurtf.pdf

I just ordered one from Digi-Key, and intend to try to compile Inferno on it to run in hosted mode. If that works, I'll network it with the Inferno hosted on my home computer, and see if I can get them both to work well with each other. Once I have the two computers up and running, I'll see if I can use the BB Black as my main home computer, and move off my current desktop.

I assure you, its total lack of movement is due to it bein' tired and shagged out following a prolonged squawk.

Seriously, I use Inferno every day, but my job is building software, so I mostly use it to write shell scripts and execute shell commands. It interfaces well with its host (I can thread calls to host commands in Inferno-sh pipelines), and runs over top of Windows, Linux, and MacOSX.

One advantage of using Limbo to play around with systems programming in Inferno is that since it's a VM, you can muck it up as much as you like without affecting your host. Also, with the clean, spare implementation, there's less cruft to learn to work with the OS (also the userland).

To start, there's a few blogs and Google code projects on programming in Inferno, as well as a book.

http://www.ueber.net/who/mjl/inferno/getting-started.html

http://doc.cat-v.org/inferno/books/inferno_programming_with_...

Limbo is also a good way to learn some of the ideas in Go, which also has modules, strong types, IPC over typed channels, automatic garbage collection, and simple abstract data types. (I'd love to see Inferno updated and re-implemented in Go.)

You might consider Limbo or Go as alternative system languages. Limbo is bundled with the Inferno VM OS, which provides Acme, which is roughly a text-only take on the Oberon UI. Go isn't the main systems language of any OS (yet), but is more recent than Limbo.

An open-source version of the Inferno VM, to take the place of both Linux and Java.

Watch is a small script in Inferno sh to date and print differences in an arbitrary command's output, each time the output of that command changes. (Not an original idea.)

https://github.com/catenate/inferno-cat/blob/master/sh-infer...

You could obviously update it to execute an arbitrary command: e.g. (plot watch.out.new.$pid) instead of diff, whenever a data-generating program generates a different set of data.

https://github.com/catenate/inferno-cat/blob/master/sh-infer...

> On top of that convincing a publisher to put up the money for such a risky project would be incredibly difficult.

Sounds like a good use case for Kickstarter.

It's not purely romance, but at least one project apparently models relationships: "Amaranthine uses simple game mechanics to reflect the ebb and flow of relationships, and lets the power of those relationships influence your success or failure now."

http://www.kickstarter.com/projects/machineage/amaranthine-a...

Acme has an idea of guide files in each directory which store commands you commonly use in that directory. Acme maps a mouse button to "send this text to sh", so you can edit a command in the guide file, highlight it with a sweep of the mouse while holding down the left button, then release the left button and middle-click to run it in the context of the current directory. Over the years this mechanism has greatly improved my retention and usage of interesting and powerful shell commands, and decreased to near zero the amount of time it takes to construct the command and the number of errors I make while doing so.

I used Emacs for 11 years, but gave it up in 2004 for wily/acme-sac/acme. Now I use Acme (running in hosted Inferno) to edit all text files, mostly shell scripts and notes. My favorite shell dialect is Inferno's sh. My favorite text stream editor is sed (because I can use it in scripts), followed by the sam-like Edit command in Acme.

I have many favorite languages for different tasks, because I don't try to make one language do everything, and it takes less time and effort to make a language do things for which it was designed.

My favorite functional language is Haskell, my favorite systems language is Go (I should do more Limbo programming in Inferno), and my favorite object-oriented language is Ruby.

My favorite production-dependency-management language is my own build tool credo, followed by Plan 9's mk.

My favorite document language is UTF-8, followed by LaTeX if I actually have to make it look pretty.

Hey, don't get me wrong, I'm as turned off by Rob Pike's dismissal of everything not in his vision as the next 9fan or gonut. It took me forever to really efficiently use Acme, and no generics means no Go for me, since it's ridiculous to not have map, fold, and filter at your disposal once you've used it in other languages like Haskell, Python, even Perl or the shell. But what's great about his tools is that if you do let them creep into you, your daily practice gets much better because the weight of the environment doesn't slow you down so much.

Extra ways to do the same thing is the enemy of simplicity and orthogonality. A major reason Plan 9 and Inferno are so small (the plan9port layer is 51.7MB source, the Inferno VM OS is 51.6MB source), and easier to grasp in one person's mind, is that the old Unix guys ruthlessly stripped out extra ways of getting things done, and made sure they ways that were left played well with each other. I keep a much smaller working set of unixy information in my head, while working daily with Acme and Inferno's userland, than I had to using Solaris or Linux and vi or Emacs.

The way I work in Acme, commands (whether built-in or my own) are presented in front of me for execution, so I edit and highlight and execute them. I don't take time out of thinking about code to think about the magical key combinations that do whatever. So it's more muscle memory to commands on the screen and sight recognition than remembering keystrokes. I do recall that many of my Emacs commands were muscle memory, but the more I wanted to use, the harder it was to remember them all. I lost them quickly when I stopped using emacs. Years from now the commands I used to manipulate files in a given directory will still be there in the guide file, waiting for me to run them without error. (I help this along by directory-specific logging of interesting commands.)

I was especially happy to get away from the hundreds of extra options in the GNU tools userland, which made entire other tools obsolete (e.g., sort -u obsoletes uniq, except when you need to uniq -c or uniq -d). All these options are the enemy of clarity in code, so you can more confidently write portable, straightforward scripts, go back to them later and actually read them.

In my experience (11 years with Emacs, then 8 years with Wily/Acme-SAC/Acme) using the mouse is much more efficient than typing to move the cursor and select text. Acme takes it a step further by binding cut and paste to mouse chords. Guide files are the big win, though, since I edit and reissue commands (highlight and middle-click) instead of retyping them.

For less grody cruft, and as a challenge to up your game, try layering plan9port or the Inferno VM over your *nix.

Inferno's <{} construct dispatches processes in parallel, and gathers output in coherent blocks. I use it in credo to parallelize all the dependencies for a target. I rely on mutual exclusion to avoid building a target twice at the same time, and on cached checksums to avoid rebuilding when there have been no changes. See the sh-inferno scripts map, credeper, and cresum in the project http://github.com/catenate/credo

I'm also writing a redo-inspired build tool, but less devoted to djb's vision, and more intent on taking advantage of some nice features of Inferno/Plan 9. For example, the /env filesystem allows dependencies on environment variables. The <{} syntax allows parallelism while grouping output.

In a nutshell, credo tries to advance the build-tool state of the art, by replacing *ake files with shell-scriptable commands to build a system from bits of library code. More at http://github.com/catenate/credo See especially the first literate test, which has a more complete introduction.

In that family, Inferno is a small complete OS, which runs as a virtual machine on a Windows/Linux/MacOS host. All source code is included, so it's hackable, and it improves (wrt the basics) on the Linux state of the art. Acme, especially with the plumber, is more friendly user interface than the terminal command line. http://www.vitanuova.com/inferno/

Not really interested in Motorola phones since they screwed me over with no Android update for my Photon. I'll be looking to Samsung 4, I think, since my wife has been happy with the III.

I thought sed was already included somewhere in the unixness underlying OSX?

EDIT: Or tr, even.

shrug I use it on a daily basis, over top of Linux, mostly. I've used Wily/Acme-SAC/Acme as my programming and OS interface for the past 10 years (2003-), after 11 years of Emacs (1992-2003). Both systems are completely reprogrammable, and Inferno has the advantage of being an actual OS (as opposed to a kitchen sink). I recommend it because it's a good way to get the feeling that you know the whole system, which you seem to be interested in, like the early home computers. I think the major three OSes are a little too big and bloated to get the same feel. Also, since it's a VM, you can take it around to other machines, and share it with other people, without changing the base OS they use.

Maybe use and hack on Inferno? It's a VM which runs over Windows, Linux, and MacOS, and provides a stripped-down unixy environment evolved from Plan 9. The entire OS and VM is compiled from source, it's a relatively small and efficient codebase, and you learn some newer OS ideas along the way. It's written in the programming language Limbo, which is sort of half-way between C and Go. (There's a book on systems programming in Inferno with Limbo to help you along.) Best of all, when you mess something up, you can just fall back to your host OS, so you can try more. (And don't worry about upgrades, the latest full release was in 2004.;)

Non-starter for me. Can't find this on Google Play, and don't have (or want) a Facebook account to sign in.

I have used inferno every work day for the past several years, either as Acme-SAC on Windows or natively compiled on a Linux machine. I have found that the minimal unix, coupled with the Acme interface, mean I spend a lot more time getting things done, and a lot less time (almost zero) retyping. Since it's a VM with its own shell and systems language, I can port my daily tools easily between whatever machines I'm working on, which has been great at client sites where I can just run my environment from a usb stick on one of their loaner computers.

> years

Decades, if you don't buy all new rulebooks every few years like most of the RPG companies want you to.

I always opt out of both the new booths. Occasionally they ask why. I say I don't trust them, nobody should trust the security apparatus of the state, and they have no real concern for my safety or well-being. I also make a point of saying everyone needs to see my pat-downs, for me to be safe, and to show people how to stand for their limited choice.