Or named arguments to email.send indicating how to interpret the incoming data. At least that’s how it’s usually dealt with already.

I didn’t entirely buy into this the first time I read it, but I’m starting to…

If you look at these languages in order, Java, Perl, Python, you notice an interesting pattern. At least, you notice this pattern if you are a Lisp hacker. Each one is progressively more like Lisp.

Aww heck, let’s do object-oriented pipes.

class ShellPipe
  def initialize(input=$stdin)
    @input = input
  end
  def to_s ; @input.read ; end
  alias inspect to_s
  def method_missing(*args)
    args.map! {|a| a.to_s}
    ( output_reader, output_writer ) = IO::pipe
    if fork
      output_writer.close
      ShellPipe::new(output_reader)
    else
 output_reader.close
      $stdin.reopen(@input)
      $stdout.reopen(output_writer)
      exec *args
      exit 255
    end
  end
end

class Object
  def method_missing(*args)
    ShellPipe::new.send(*args)
  end
end

Example usage from irb:

irb(main):001:0> ls('-lt').grep('\.rb$').head('-8')
=> shellpipe.rb
minihobix.rb
bumpspark.rb
zook.rb
frink.rb
blah.rb
zubmorfa.rb
kronk.rb

...which is equivalent to ls -lt | grep '\.rb$' | head -8 in the Unix shell.

very interesting. I really like the

somefilename.someextension

Another interesting idea would be to add something like distributed lexical scopes a la Obliq. Imagine this from your ruby CLI :

"10.0.0.2".node.user.home.jwatkins.notes.txt.read

or even block migration to compute servers:

node12.compute { ...some heavyweight code... }

Interesting. The syntax is rotated in relation to the shell though: verb obj indirect_obj becomes obj.verb indirect_obj which may feel odd for a shell. It might flow better in the Io language because there are spaces instead of dots between obj and its method.

I think it should be tried to see if it produces something usefully novel. If people see benefit in an Adventure Shell then why not this?

FWIW , my officemate, Bill Wood, likes to use irb for his shell.

Crazy, I was just thinking about this !

What would also be nice, is to use reflection on binaries to get their starting arguments.

Some of this crosses over into Quicksilver: take this, do this to it…

What sounds quite interesting as well is the combination of ‘nix config files & XML (see the ruby-talk link). Some time ago I’ve run across an interesting article on “launchd” (over at www.afp548.com/article.php) that I think already combines ‘nix & XML !

So Microsoft has been touting their new shell called Monad (Hey, better late than never I always say). Now apparently theres a new Ruby-based OOCLI that will be under the GPL … it’s gonna be called…. Gonad.

b’dp ba!

” I imagine metadata will need to accompany strings which are piped.”

Look up “plan9 plumber” on the Googletron sometime.

Someone should mention the wiki

“I imagine metadata will need to accompany strings which are piped.”

The pipe could report what mime-types are available, and allow the data to be read in any applicable format; in this example, email.send would check the mime-types, see that it’s an image, and select the preferred format.