Forgot your password?
typodupeerror
Windows Operating Systems Software Programming IT Technology

Microsoft Releases A New Monad Command Shell Beta 126

Posted by timothy
from the sneer-or-consider dept.
Watercooler Warrior writes "Slashdot originally broke the news that a new Microsoft command shell was in the works when a reader noticed a suspicious job posting by Microsoft India. Today Microsoft released the first really usable version of the shell (codenamed Monad) to beta testers - and anyone who carefully reads the WinHEC slides about Monad will find how to join the beta and get a peek at it. The shell looks like a bunch of old-school Unix and Perl hackers were given free rein to do what they wanted with the .NET framework, and from what is known about the backgrounds of the Monad developers this is probably pretty close to the truth."
This discussion has been archived. No new comments can be posted.

Microsoft Releases A New Monad Command Shell Beta

Comments Filter:
  • Google (Score:5, Funny)

    by kajoob (62237) on Monday September 20, 2004 @10:34PM (#10304595)
    Google has a new command shell coming out as well; the name? Gonad.
  • It's about time (Score:3, Interesting)

    by JPyObjC Dude (772176) on Monday September 20, 2004 @10:40PM (#10304612)
    Because I unfortunately have to hack on a windoze box, I would love to see an improved command shell.

    The current command shell just plain sucks when compared to OSX's or KDE's shells.

    I can't wait to install.

    truth={ moz: "sweet" }
    • What? Why not just use bash under cygwin?
      • Why not just use bash under cygwin?

        I do, but as most would agree the current command prompt UI totally sucks. I'm hoping that this new distrib will include a better UI.

        I have no interest in any M$ languages except to have some M$ winAPI extensions that I can shell from my python or bash scripts running in cygwin.

    • Re:It's about time (Score:5, Insightful)

      by MBCook (132727) <foobarsoft@foobarsoft.com> on Monday September 20, 2004 @11:09PM (#10304789) Homepage
      Both of those are BASH (OSX used to use csh or maybe tsh but they switched it). Personally I LOVE BASH. After messing with Linux for a few years, the Windows shell drives me nuts. It's just so primitive feeling.

      This is one of those situations where I think MS is doing a serious NIH (Not Invented Here) for no good reason. I can understand the reason to make Direct X instead of use OpenGL (for controll) and other such decisions. But I don't think having their own shell (instead of an implementaion of BASH) does them any good. I don't think it helps them sell more software. I don't think it helps them controll the market more. They should have taken BASH, and extended it with their .NET stuff.

      I can use BASH on Linux, BSD, BeOS, OSX, and many many others. Why should I have to learn a new shell for Windows? Why can't they just accept it for once. It doens't cost them anything. If anything it would make porting apps over to Windows from other platforms EASIER.

      At least make it so I can replace my shell easily (like you can change your default shell on other platforms)? That would be enough for me.

      It's not exactly MS's fault that their current shell isn't very good. They've been going pure GUI and trying to keep people there. They've said DOS is dead and no one should ever have to use a CLI. So they've had no reason (based on that) to improve the shell since it's last incarnation, DOS 6.22. Of course now they are making a new CLI and making a big deal over it. Everything old is new again, eh?

      • Say it with me.. G...P...L...
      • If you glance at the presentation when they are doing the schematic they are showing how everythng fits together and they have an "Other Hosts" block on the same level as Monad. So maybe you will see something, though most likely it will be sort of half supported and not very popular (sort of like the ability to plug other scripting languages into WSH.)
      • Cygwin with bash on rxvt works very sweetly on WinXP.
      • "Everything old is new again, eh?"

        You betcha! Just look at Apple and OSX. I can't really claim this idea as my own (I think someone talked about it in MacWorld), but it is true. The author said how the older Mac OS didn't even have a command line. The big feature of the Mac was that you didn't need commands and could use a menu driven interface. Now one of the big selling points of OS X (for me anyway) is that it has a UNIX base and I can use all the *nix commands and apps that are pretty standard for
      • It's not like conventional shell. Monad is engineered to transfer/transform not just text data, but .NET objects. For instance monadgrep text test.xml | monadcat > new.xml (just an idea).
        So it's quite different.
        I didn't actually try it, because I don't want to sign up for beta etc, but when it's out, I'll definitely give it a shot.
    • All i want in a windows shell is crtl-ins to copy and shift-ins to paste. It's a pain to grab the mouse, right click on the title bar -> edit -> paste where as putty (nearly every app) handles those key combos fine. I couldn't believe that these basic commands were still missing from cmd when work upgraded me to an XP box.
      • Re:It's about time (Score:1, Informative)

        by Anonymous Coward
        title bar -> properties -> Quick edit mode.

        Select + Enter = copy
        Right Click = paste

      • All i want in a windows shell is crtl-ins to copy and shift-ins to paste. It's a pain to grab the mouse, right click on the title bar -> edit -> paste

        Well there is no ctrl-ins or shift-ins but there is a better way to copy & paste using the mouse. Select text using the left mouse button, right click to stop selecting & copy the text into the buffer and then finally right click to paste.

      • Well, unfortunately then, the current MSH preview (drop 3) still uses the exact same cut-copy-paste model as the existing cmd.exe. So it's mark, copy, paste with right-click or the control box, or Quick Edit mode from the Properties dialog as before.

        OTOH, stuff like

        MSH>foreach ($name in get-childitem | sort-object ){if( $name -like "*.xml"){write-host $name}}

        has the potential to be a lot more versatile than clunky old DOS shell commands, even if this particular example is basically just another way o

    • Have you tried 4NT [jpsoft.com]

      Page-up/down for directory history is worth it alone.

      --
      Tobacco represents a huge tax base for the government. The government is as addicted to the revenue from smokers as the smokers are to the cigarettes.
      - WetKarma (plastic.com)
    • Re:It's about time (Score:2, Insightful)

      by jonadab (583620)
      > I would love to see an improved command shell.

      So would all geeks who use Windows. WinFS gets a lot of hype, but it is Monad
      that will drive the next batch of upgrades for Microsoft, especially in server
      space. A good command shell is a killer feature.

      I remember an online poll in about 1999 or 2000, asking what effect Linux would
      have on Microsoft. "Force them to change radically" was the option I voted
      for. Monad is the sort of thing I meant. A good command shell is one of the
      strengths of most POSIX
    • While I can see where this would be handy, I would personally prefer a decent SNMP server in Windows. Take what you can get I guess.
  • by Prien715 (251944) <agnosticpope@noSpAm.gmail.com> on Monday September 20, 2004 @10:49PM (#10304658) Journal
    And I can't say I'm that impressed yet. I'd like to see man pages or something actually implemented. man currently does stuff but man doesn't work for any command I've tried (thus there don't seem to be *any* options). There's a lot of aliases built-in to emulate Unix (e.g. ls, ps) but the lack of grep makes piping seem...well pointless. The actual versions of commands seem entirely too object oriented and thus too verbose. "get-directory" is not something I want to type (I can't remember off the top of my head, but some of them are really absurd). "ps" is ps for a reason. No frequently used command should be more than 4 letters, or require you to use aliases so you don't end up writing a novel.

    Your milaage may vary. I don't care about a scripting language. I have Perl (for Win32). As far as an interactive shell, it still has a lot of rough edges. Personally, I'd rather just use Cygwin/Bash and get a real shell.

    (Though I talked to one of the guys personally and he seems pretty cool.)
    • by bersl2 (689221) on Tuesday September 21, 2004 @12:00AM (#10305115) Journal
      The actual versions of commands seem entirely too object oriented and thus too verbose.

      I can't imagine anybody who has ever used a CLI object-orienting it. Did some marketing drone get a say in the design.

      The command line is more likely to be used for quick-and-dirty jobs, but the language involved (Bourne, C shell, etc...) can scale up to a larger, more maintainable project. The same can't be said about most object-oriented languages in the downward direction. Of course, maybe I just haven't seen the right ones.
    • In drop 3, man appears to be set up as an alias to get-help, just as ls is an alias to get-childitem.

      So if you do man ls, or get-help ls, or man get-childitem, or get-help get-childitem, you now get a reasonably detailed result of which the following (cut down to keep the lameness filter happy) is a rough synopsis

      MSH>man ls

      NAME
      get-childitem

      SYNOPSIS
      {snipped for lameness filter}

      SHORT DESCRIPTION

      Retrieves the child items of the specified location(s) in a drive.
      When -Relationship is sp

  • Not bad... (Score:3, Funny)

    by zulux (112259) on Monday September 20, 2004 @10:52PM (#10304674) Homepage Journal

    The way it handles pipes is good - but FOR THE LOVE OF ALL THAT IS HOLLY! GET. RID. OF. THE. PAPERCLIP!

    (it looks like your writing a shell script)

  • by arkham6 (24514) on Monday September 20, 2004 @10:54PM (#10304691)
    ...what the HELL were old school hackers doing working for microsoft in the first place. ;)
  • by Plake (568139) <rlclark@gmail.com> on Monday September 20, 2004 @11:03PM (#10304755) Homepage
    Go to http://beta.microsoft.com [microsoft.com], login with your passport account.

    The guest id is mshPDC.

    Go nuts. :)
    • Go to http://beta.microsoft.com, login with your passport account.

      ...and if that particular dusty corner of our souls hasn't been sold to the beast yet, and we don't have passport accounts, then... that's it? Can't sign in?

      Oh well, scratch that.

      • Then you go sign up for a hotmail account and use that. Hotmail accounts pass as passports, so you could just grab one email account specifically FOR the beta.
        • That doesn't get around the problem of not wanting to sign up for big brother's Passport account. Ever. And especially not for a crappy Hotmail account. If they can't provide this demo software without demanding an onerous registration in exchange, then the software just isn't worth it to me. And no, using fake information on the signup doesn't get around the problem either. It's not that Microsoft would then know exactly who I am -- or who I pretended to be -- but that they would now have one concrete wa
          • Tracking you? They could already do that via IP address or normal email address. If you're running XP, you don't *have* to associate a passport with your user account to use it.
            • by babbage (61057)
              I've never given Microsoft my address, so I'm not sure how it would have ended up in their database. And yes they can track my IP, but only with a registration system like Passport can they say that any activity I make from home, work, and elsewhere is all coming from the same person. As for XP, well, that's just yet another reason that I'm glad to be using a Mac instead of Windows... :-)
  • .. with human body parts.. monad.. go---.. ;-0
  • What's the Point? (Score:4, Insightful)

    by max born (739948) on Monday September 20, 2004 @11:17PM (#10304842)


    There's already a plethora of shells out there, -- korn, bash, csh, zsh, and way more. And combined with ultilies like find, sed, grep, awk and with the added availablity of languages like perl, python, 'c' and all the lexical mulitude of routines that go with, ... what problem is Microsoft proposing to sovle here?

    Microsoft should consider cooperating and improving what's already out there instead going it alone and reinventing the wheel. Unless, of course, all those old school Unix developers were really all wrong and now Microsoft's is taking the opportunity to show us how it's really done.

    • You just named four different unix platform scripting languages, and then complained about _Microsoft_ reinventing the wheel.

      Anyway, what's the problem? It's not written in stone anywhere that thou shalt use the one true scripting method, and who knows if there's a better way unless people try different things? Even if it sucks we have Cygwin already, so people can use any Unix shell that makes them more productive.
  • Flame Bait (Score:1, Funny)

    by Anonymous Coward
    [sub] http://developers.slashdot.org/article.
    pl?sid=04/09/21/0153251&tid=201&tid=156&ti d=8
    [sub] sweet
    [sub] urrr, down with Microsoft
    [sub] =)
    [geek] cute (re /. link)
    [geek] so they're now inventing stuff that's been around how many
    decades?
    [sub] alphageek: wait, they're going to patent everything
    [sub] !!!!
    [geek] should be fun to watch
    [sub] yeap, recreate UNIX, patent it as they go, use said
    patents against Linux
    [sub] sounds like a business plan made in Redmond
    [sub] even better, claim it
  • by Anonymous Coward
    I can't seem to find any.

    ~~~

  • by Earlybird (56426) <slashdotNO@SPAMpurefiction.net> on Tuesday September 21, 2004 @12:48AM (#10305352) Homepage
    Microsoft is doing something interesting and innovating. The Unix world could use this.

    Basically, Monad formalizes in .NET the pipe interface between shell programs. A pipe participant is just something that implements the appropriate "commandlet" interface: it receives some input, produces some output, maybe some errors.

    However, in the case of Monad the input and output can be anything, not just text. So in the example:

    • get-process | where "handlecount -gt 400" | sort handlecount | out-chart processname,handlecount
    The get-process command produces a sequence of processes; where filters it based on an attribute; sort sorts on an attribute, and out-chart produces a textual table of the filtered output.

    It's important that the input and output of these processes are structures (actually, objects, but I don't want to tickle anyone's prejudices about OOP). .NET knows at runtime about the attributes these structures can have, so you can write apps that manipulate a wide variety of object types: files, metadata-annotated documents, log entries, whatever.

    Naturally input/output can be pure text, allowing all the traditional Unix commands such as grep.

    Immediate benefit? If you have the right translator, there's no need to munge text output using awkward tools like tr, cut, awk and so on, just to get at the process ID column of ps or the URL column of the Apache log file.

    This is better than Unix shells.

    • by 0x0d0a (568518)
      Yes, everything's dandy, until you happen to be using two programs that don't export and import data in compatible formats.

      In the *IX world, stuff moves around in simple text formats. You can glue *any* two programs together, even if the original author didn't intend that you do so.

      In the Microsoft world (well, the new Microsoft world), you can glue together programs that are designed to be glued together.

      Note that Plan 9 did some similar stuff to this (IIRC there was a project called xmlterm that deal
      • Oops, I lied. xmlterm [sourceforge.net] is a FOSS project on SourceForge, but I don't believe it was part of Plan 9.
      • by Earlybird (56426) <slashdotNO@SPAMpurefiction.net> on Tuesday September 21, 2004 @03:00AM (#10305868) Homepage
        • Yes, everything's dandy, until you happen to be using two programs that don't export and import data in compatible formats.
        You missed the part about the type system, then. Any program can access the data, because the data is packed in nice structured .NET types -- arrays, lists, instances, etc. You use reflection to inspect even types your program doesn't understand.

        For example, if something wants to sort objects on an attribute "name", it doesn't need to know the type of the input: it just asks for the value of the name properties. Obviously a sorter needs to know how to compare values against each other: it needs, in short, to be able to turn anything into a string. Those things are solved using formal interfaces: if your "name" attribute is not a string object, it needs to support an interface that allows it to be turned into a string on command (just like Python's __str__(), Java's toString(), etc.). With .NET's type system and automatic boxing/unboxing you already have a rich set of types to interact with.

        The challenge here is agreeing on a set of interfaces that make programs able to interact beyond the basic .NET primitives. For example, let's say the output of my program consists of image bitmaps. Something like a class with an (x, y) extent and a vector of RGB objects. All you need to share such objects is to specify the appropriate interface for clients to use. The client certainly doesn't need any of the originator program's code, just the interface.

        If you think about it, such interfaces already exist in daily usage in a different format: JPEG. GIF. PNG. They're standards need for interoperability. In the same way, programs need to standardize their exchange mechanisms, and if you're saying that the solution is for "everything to be just text" (or more precisely, octet streams) then you're just moving the problem somewhere else. Ultimate, at some point that text/those octets need to become something else.

        (By the way, I'm not a .NET developer.)

        • Eh? (Score:2, Informative)

          Obviously a sorter needs to know how to compare values against each other: it needs, in short, to be able to turn anything into a string.

          I'm sorry, but those are not equivalent statements at all. In most (decent) languages, you implement a sort order simply by providing an arbitrary function (or class, or object, or closure, or whatever) that compares two objects. Hardly ever do you need to convert them to strings.

          Not to mention that even string sorting is done this way-- you don't sort strings in the

        • by 0x0d0a (568518) on Tuesday September 21, 2004 @05:32AM (#10306367) Journal
          You missed the part about the type system, then. Any program can access the data, because the data is packed in nice structured .NET types -- arrays, lists, instances, etc.

          Sure, but all data structures in C are made of C primitives. That doesn't ensure that two programs can interoperate. The Windows Registry contains structured data. UNIX config files contain text. I can read almost every UNIX config file with little trouble (though I might need to look up what an option is to get precise data about it). The text files are intended to be read by people -- the config format is thus self-documenting. The Windows Registry is intended for programs to talk to programs. The interface *might* be human-readable but often devolves into cryptic encodings jammed into strings that aren't documented anywhere -- the interface is not self-documenting.

          The same thing goes for *IX programs. You have a mass of programs that spit out human-readable text output. A self-documenting format, one intended to be read by humans. Now, depending on how benevolent the .NET application author is feeling, an application *might* be able to spit out data that can be understood by a human. It also might just expose data that can't be used worth a damn except by another program.

          Now, I agree that the idea of data pipelines of more complex data can be useful. Frankly, I like the idea of even-more-powerful graph programming languages, as certain data-processing environments sometimes use -- image-processing, audio-processing. However, I've rather more dubious when it comes to general-purpose pipelines.

          Also, think about the social issues. *IX world -- do the bare minimum to be usable by a human, and your program is interfaced with. Microsoft world -- you need to go above and beyond.

          And the roles that data pipeline programs play. *IX world -- data pipelines are generally quick 'n dirty tools. They let you write custom and personal tools in a snap. If you want to interface functionality, you use full-blown libraries, with an API that isn't limited by the structure of a pipeline. Microsoft world -- new program structure for introducing a limited interface between programs, intended for more serious programming.
        • programs need to standardize their exchange mechanisms, and if you're saying that the solution is for "everything to be just text" (or more precisely, octet streams) then you're just moving the problem somewhere else. Ultimate, at some point that text/those octets need to become something else.

          Moving the problem somewhere else is often a very useful technique. In this case, it has worked reasonably well for thirty years.

      • by Chris_Jefferson (581445) on Tuesday September 21, 2004 @07:05AM (#10306626) Homepage
        Just because all your programs input / output ASCII, that doesn't make them "compatable formats".

        I've got bitten more than once by filenames with spaces in, and always thought it would be nice if there was more structure to the input and outputs. Once I got badly bitten by some joker who decided to make a file called "-rf" (yes, you can make such a file). This kind of system with more structure makes it much easier to seperate filenames, switches, etc. in a clean and safe manner. I'm quite looking forward to it myself.

        • [shrug] I use two scripts:

          #!/bin/gawk -f
          # bashescape.awk
          {
          gsub(/\\/, "\\\\");
          gsub(/ /, "\\ ");
          gsub(/!/, "\\!");
          gsub(/"/, "\\\"");
          gsub(/'/, "\\'");
          gsub(/:/, "\\:");
          gsub(/;/, "\\;");
          gsub(/=/, "\\=");
          gsub(/?/, "\\?");
          gsub(/@/, "\\@");
          gsub(/\^/, "\\^");
          gsub(/{/, "\\{");
          gsub(/}/, "\\}");
          print;
          }

          #!/bin/bash
          # myxargs
          bashescape.awk|xargs "$@"


          The problem is that xargs isn't a shell builtin, so it doesn't really know what the characters you need
      • Yes, everything's dandy, until you happen to be using two programs that don't export and import data in compatible formats.

        In which case, you'd probably use one of their generic tools to remap attributes, or you could always whip up a quick .NET class and insert it into the pipeline to do more advanced translation.

        Certainly in some cases a plain text pipe is more convenient, but being able to pass structured objects around in a pipeline has the capability to deliver even more; and, especially with regar
    • Right, anyone care to build an XSTL processor into Bash (or zsh)... it's already quite bloated according to some people ;-)
    • It's important that the input and output of these processes are structures (actually, objects, but I don't want to tickle anyone's prejudices about OOP).

      Sounds like you need to look into XMLStarlet [sourceforge.net] or one of the other XML-grokking command-line filter tools.

      Structured pipe data has been around for a while, and XML's a natural format for that. I certainly don't see a need to drop in a .Net dependency where XML will do. (Note that I would welcome an XML output mode from ps, though ;)

      Also, re: piping bi

    • I actually feel its kinda complementary to the Unix shell environment. This looks more like VBA on steroids, the .NETized version probably. Passing around structures has been done in MS world for a long-time - excel sheet processing, macro viruses etc.

      I think similar results can be achieved using DCOP/KDE or the GNOME equivalent, probably KDE , GNOME hackers can comment on that.
    • Microsoft is doing something interesting and innovating. ...like copying Unix

      The Unix world could use this

      What? Copying Windows? I thought we already were...
        • ...like copying Unix

        Copying and improving. They are evolving an existing design, a design that hasn't changed in 20 or 30 years. That design hasn't been frozen for so long because it's perfect, but because it's "just good enough" for people to consider and rethink.

        • What? Copying Windows? I thought we already were...

        Yep. Everyone [gnome.org] is [kde.org] copying [microsoft.com] everyone [apple.com] else [xerox.com]. It's the nature of design: for the next generation, always combine the best bits of everything else.

    • It's important that the input and output of these processes are structures (actually, objects, but I don't want to tickle anyone's prejudices about OOP). .NET knows at runtime about the attributes these structures can have, so you can write apps that manipulate a wide variety of object types: files, metadata-annotated documents, log entries, whatever.

      Naturally input/output can be pure text, allowing all the traditional Unix commands such as grep.

      Immediate benefit? If you have the right translator, there's
  • I must confess my ignorance: Does perl have a .net interface yet?
  • by Anonymous Coward on Tuesday September 21, 2004 @06:59AM (#10306612)
    Illustrated here. [slashdot.org]

    Reminds me of the "Magical Microsoft Moments" story:

    I've been attending the USENIX NT and LISA NT (Large Installation Systems Administration for NT) conference in downtown Seattle this week.

    One of those magical Microsoft moments(tm) happened yesterday and I thought that I'd share. Non-geeks may not find this funny at all, but those in geekdom (particularly UNIX geekdom) will appreciate it.

    Greg Sullivan, a Microsoft product manager (henceforth MPM), was holding forth on a forthcoming product that will provide Unix style scripting and shell services on NT for compatibility and to leverage UNIX expertise that moves to the NT platform. The product suite includes the MKS (Mortise Kern Systems) windowing Korn shell, a windowing PERL, and lots of goodies like awk, sed and grep. It actually fills a nice niche for which other products (like the MKS suite) have either been too highly priced or not well enough integrated.

    An older man, probably mid-50s, stands up in the back of the room and asserts that Microsoft could have done better with their choice of Korn shell. He asks if they had considered others that are more compatible with existing UNIX versions of KSH.

    The MPM said that the MKS shell was pretty compatible and should be able to run all UNIX scripts.

    The questioner again asserted that the MKS shell was not very compatible and didn't do a lot of things right that are defined in the KSH language spec.

    The MPM asserted again that the shell was pretty compatible and shouldwork quite well.

    This assertion and counter assertion went back and forth for a bit, when another fellow member of the audience announced to the MPM that the questioner was, in fact David Korn of AT&T (now Lucent) Bell Labs--the author of the Korn shell.

    Uproarious laughter burst forth from the audience, and it was one of the only times that I have seen a (by then pink cheeked) MPM lost for words or momentarily lacking the usual unflappable confidence.
  • Msh misses the point (Score:4, Interesting)

    by Zo0ok (209803) on Tuesday September 21, 2004 @07:05AM (#10306625) Homepage
    The fine thing with a shell is that when you have issued the same series of commands numerous times you can simply put them in a script - automation done!

    However MSH seems (with its OO-influenced design) to be a bit too complex for ordinary work. If people dont use it for ordinary work, they cant write scripts "for free".

    The problem today isnt that Windows cant be scripted - it can via VBScript.

    UNIX shells are constructed the way they are because users should BOTH use them for scripting, and for every other task. M$ compromises with simplicity (with its OO-design), so MSH will never be as productive as, for example tcsh.
  • Is it just me... (Score:4, Interesting)

    by brunes69 (86786) <slashdot AT keirstead DOT org> on Tuesday September 21, 2004 @07:29AM (#10306716) Homepage
    ..or is this indicative of a wider trend, where Windows and Linux are coming together from a technology perspective?

    Think about it. Over the past few years, the windowing environments in Linux have grown more and more advanced. With the newer XOrg releases and upcoming KDE4 and Gnome 3, I expect amazing things from the Linux desktop.

    Meanwhile, while Linux has been addressing it's core weakness, Microsoft already has a firm foothold on the desktop. Instead, the past few years they have been integrating more and more sysadmin-friendly technologies - such as integrating scripting into the OS, improving their command shell (and replacing it - hence Monad), improving remote administration.

    Windows has WinFS, Linux has Reiser4 + plugins.

    In the next few years, I doubt a layman will be able to tell Windows and Linux apart from a purely features / technology perspective. What *ill*be important, is he thing that is the most important - who do you trust with the source code to your OS? A private company or a group of hackers.
    • No it is not just you that thinks this. From my observation Microsoft is reinventing UNIX and Linux is a clone of UNIX that is reinventing itself as Windows. It also seems to me that we will as you say not be able to tell the two apart in the future.

      "What *ill*be important, is he thing that is the most important - who do you trust with the source code to your OS? A private company or a group of hackers."

      Well only time will tell with that. But one thing is for sure, the operating system will become
    • Windows has WinFS

      Um, no it doesn't [eweek.com].

  • so what's the release name, TEL.NET?

    (old joke, felt the need to revive it!)
  • My computer experience started with MS-DOS 3.3. I became pretty good at writing batch files.

    I loved DOS and resisted Windows at first. As we all have since learned, resistance is futile and I was assimilated.

    Then, I discovered *nix and I saw the light... a powerful operating system with a command line. I've never looked back.

    My colleagues and friends all think I'm fully Anti-Microsoft, but I just prefer to seek alternatives to Microsoft's overpriced products.

    If this command shell becomes a truly

  • It's great that they're trying to do something at a higher structural level. The Unix command line data structure is essentially just a sequence of '\n'-terminated lines. But while it looks like each filter command is doing its own thing (where, sort, group, etc.), they're really just doing the equivalent of an SQL 'SELECT'. I wonder why they are forcing the Unix-style pipeline syntax instead of a syntax that maps well to the relational model.

    • Mod this parent up--

      this was a really good point. But then, few languages really handle relations well.
    • The problem with SQL is that you have everything built into the one program. Pipelines allow you to bolt functions together in an unanticipated order to create complete program concepts without writing any glue code.

      You might want to read the art of unix programming for details on why pipelining is so good.
      • The problem with SQL is that you have everything built into the one program. Pipelines allow you to bolt functions together in an unanticipated order to create complete program concepts without writing any glue code.

        Pipelines aren't the only way to pass data between separate programs. Sometimes the linear nature of pipelines makes some tasks less straightforward than it could be. The functional programming people have no problem combining the primitive operators to perform complicated operations (a

  • With the .Net runtime installed, is it possible to utilize Monad with Windows 2000 Pro?
  • I wonder how Iron Python might use what these folks are doing? I can see that this shell may have some slick features-but I don't see a compelling innovation here. What I see is a lot of investment in doing some basic stuff to make windows work that should have been done long ago. If it it done vaguely correctly I suspect some better tools will take advantage of the groundwork being laid here.

Any sufficiently advanced technology is indistinguishable from a rigged demo. - Andy Finkel, computer guy

Working...