Windows Palladium, the end of privacy as we know it.

[Phyltre]

I mean about whatever Palladium turned into.

[CaboWaboAddict]

Originally posted by spiderbaby1958
Hey, I'm not making this up. With computers, easy to learn is always a pain in the ass to run. It's always been that way, since the days of the Commodore 64. The simpler a gui interface is, the less flexible and powerful, and the more clicking you have to do to accomplish a task. When you know how to use the command line, you can cut through a lot of gui "red tape".

Have you ever tried to code a flexible but simple GUI? Its a pain in the ass. I wasn't pokeing fun at what you said. I agree wholeheartedly that in many cases a GUI makes it more cumbersome or impossible to do the advanced stuff that is so simple in a command line environment. But the GUI was designed originally for the masses, so they would not have to learn all of those commands.

One system that was a dream to write code for - that I'm sad to have seen die - was the Amiga.

[MegaRock]

No, we don't. Microsoft could not pull off 1% of what is stated in this forum - the closest they could do is make media files have some sort of stamp on them - and consumers would be pissed off by that, plus, there would be a way around it.

MS can do pretty much anything it wants since there is no government entity that has been powerful enough to stop the monster it is. MS has more in the bank than our entire country is in debt for.

And considering how easy it would be to implement this using Automatic Updates should scare the fuck out of anyone running an MS system.

How to stop it? Start using Linux now and stop buying anything sold by Microsoft or it's subsidiaries. Take away their income and you take away their power. With control of 90+ % of the PC market what choice do we have right now. You either use Windows or are part of the less than 10 % who use something else.

Face it, you have no choice. Learn linux or keep funding the fucking beast.

[xzxzzx]

Originally posted by MegaRock
MS can do pretty much anything it wants since there is no government entity that has been powerful enough to stop the monster it is. MS has more in the bank than our entire country is in debt for.

7.7 trillion? Microsoft has more than 7.7 trillion in the bank? In the EU, Microsoft has been forced to remove WMP from its O/S.

Microsoft may be a monster, but it's one on moral grounds far more than legal ones.

Originally posted by MegaRock
And considering how easy it would be to implement this using Automatic Updates should scare the fuck out of anyone running an MS system.

Implement what? Palladium? You need a whole damn hardware overhaul for that. Media files with stamps? That's either been around or requires a hardware update too.

[zootm]

TCPA is interesting - a lot of people think it's a lot worse than it is. It's one of those technologies which can be used for evil, but has huge potential for securing systems too.

[fwgx]

Originally posted by spiderbaby1958
The simpler a gui interface is, the less flexible and powerful, and the more clicking you have to do to accomplish a task. When you know how to use the command line, you can cut through a lot of gui "red tape".

Not so. You only have to look as far as MS products to see that they are the masters of flexable, powerful GUI design. Stating "more clicking" as a bad thing compared with remembering abstract commands off by heart and actually having to type them out exactly, precisly and without error in full sounds a bit scewed. I have yet to see any problem that cannot be implemented well in a GUI, now it may not have been but that's not the point when arguing against GUIs in general. Now I'll hapily argue that Linux is a terrible OS when it comes to it's developers creating decent GUIs. They are badly designed, inconsistent, confusing, non-intuitive and many many many other bad things that anyone that knows anything about GUI design could spot in less than 10 mins of using the system.

Having no GUI means there is no choice on what to use and is a close minded, isolationist and elitist position to take.

[xzxzzx]

Phily, while I agree that it is possible to make a powerful and simple GUI interface, you simply can't match the power of a bash shell (without some fundamental changes to how GUIs operate).

For example, can you explain how to do something like:

1) With case sensitivity, find all files with the word "mouse" in them.
2) In those files, if they have at least 1 instance of the word "elite" in them, change "elite" to "1337", and "owned" to "pwned".

All one really needs to remember here is the name of appropriate commands to do something like this. First, to find the appropriate files, "find". I do "find --help", and get:

code:
legolas root # find --help

Usage: find [path...] [expression]

default path is the current directory; default expression is -print

expression may consist of:

operators (decreasing precedence; -and is implicit where no others are given):

      ( EXPR ) ! EXPR -not EXPR EXPR1 -a EXPR2 EXPR1 -and EXPR2



      EXPR1 -o EXPR2 EXPR1 -or EXPR2 EXPR1 , EXPR2

options (always true): -daystart -depth -follow --help

      -maxdepth LEVELS -mindepth LEVELS -mount -noleaf --version -xdev

tests (N can be +N or -N or N): -amin N -anewer FILE -atime N -cmin N



      -cnewer FILE -ctime N -empty -false -fstype TYPE -gid N -group NAME

      -ilname PATTERN -iname PATTERN -inum N -ipath PATTERN -iregex PATTERN

      -links N -lname PATTERN -mmin N -mtime N -name PATTERN -newer FILE



      -nouser -nogroup -path PATTERN -perm [+-]MODE -regex PATTERN

      -size N[bckw] -true -type [bcdpfls] -uid N -used N -user NAME

      -xtype [bcdpfls]



actions: -exec COMMAND ; -fprint FILE -fprint0 FILE -fprintf FILE FORMAT

      -ok COMMAND ; -print -print0 -printf FORMAT -prune -ls





Report bugs to <[email protected]>.

Ok, so our command will be something like:

code:
find /tmp/1337/ -name mouse -exec (do something)\;

Now, I need to make sure there is an instance of "elite" in the files. "grep" should fit the bill:

code:
legolas root # grep --help

Usage: grep [OPTION]... PATTERN [FILE] ...

Search for PATTERN in each FILE or standard input.

Example: grep -i 'hello world' menu.h main.c



Regexp selection and interpretation:

  -E, --extended-regexp     PATTERN is an extended regular expression

  -F, --fixed-strings       PATTERN is a set of newline-separated strings

  -G, --basic-regexp        PATTERN is a basic regular expression

  -P, --perl-regexp         PATTERN is a Perl regular expression

  -e, --regexp=PATTERN      use PATTERN as a regular expression

  -f, --file=FILE           obtain PATTERN from FILE

  -i, --ignore-case         ignore case distinctions

  -w, --word-regexp         force PATTERN to match only whole words

  -x, --line-regexp         force PATTERN to match only whole lines

  -z, --null-data           a data line ends in 0 byte, not newline



Miscellaneous:

  -s, --no-messages         suppress error messages

  -v, --invert-match        select non-matching lines

  -V, --version             print version information and exit

      --help                display this help and exit

      --mmap                use memory-mapped input if possible



Output control:

  -m, --max-count=NUM       stop after NUM matches

  -b, --byte-offset         print the byte offset with output lines

  -n, --line-number         print line number with output lines

      --line-buffered       flush output on every line

  -H, --with-filename       print the filename for each match

  -h, --no-filename         suppress the prefixing filename on output

      --label=LABEL         print LABEL as filename for standard input

  -o, --only-matching       show only the part of a line matching PATTERN

  -q, --quiet, --silent     suppress all normal output

      --binary-files=TYPE   assume that binary files are TYPE

                            TYPE is 'binary', 'text', or 'without-match'

  -a, --text                equivalent to --binary-files=text

  -I                        equivalent to --binary-files=without-match

  -d, --directories=ACTION  how to handle directories

                            ACTION is 'read', 'recurse', or 'skip'

  -D, --devices=ACTION      how to handle devices, FIFOs and sockets

                            ACTION is 'read' or 'skip'

  -R, -r, --recursive       equivalent to --directories=recurse

      --include=PATTERN     files that match PATTERN will be examined

      --exclude=PATTERN     files that match PATTERN will be skipped.

      --exclude-from=FILE   files that match PATTERN in FILE will be skipped.

  -L, --files-without-match only print FILE names containing no match

  -l, --files-with-matches  only print FILE names containing matches

  -c, --count               only print a count of matching lines per FILE

  -Z, --null                print 0 byte after FILE name



Context control:

  -B, --before-context=NUM  print NUM lines of leading context

  -A, --after-context=NUM   print NUM lines of trailing context

  -C, --context=NUM         print NUM lines of output context

  -NUM                      same as --context=NUM

      --color[=WHEN],

      --colour[=WHEN]       use markers to distinguish the matching string

                            WHEN may be `always', `never' or `auto'.

  -U, --binary              do not strip CR characters at EOL (MSDOS)

  -u, --unix-byte-offsets   report offsets as if CRs were not there (MSDOS)



`egrep' means `grep -E'.  `fgrep' means `grep -F'.

With no FILE, or when FILE is -, read standard input.  If less than

two FILEs given, assume -h.  Exit status is 0 if match, 1 if no match,

and 2 if trouble.



Report bugs to <[email protected]>.

So:

code:
find /tmp/1337/ -name mouse -exec grep elite {} \; 

Now for the replace. I'll use sed (this one you just have to know, though it's easily found with a Google search):

code:
find /tmp/1337/ -name mouse -exec grep elite {} \; 

-exec sed 's/elite/1337/g' {}\; -exec sed 's/owned/pwned/g' {}\;

(broken into two lines for the forum's sake)

Yes, this is more cryptic than using a GUI, but you'd just be opening the second file in Windows when I hit "enter", assuming I didn't know the syntax offhand anyway (which, for this simple of a command, I do). The point is that while a GUI becomes slightly more powerful over use via familiarity, a command line becomes vastly, vastly more powerful.

Can you envision a GUI producing this kind of flexibility and power? I can't. Not without some sort of major shift in GUI style. What's really missing is stdin and stdout. Different GUI pieces don't fit together.

I don't, however, particularly disagree with you on any point you made Phily, as when considering the average user, this would be totally unworkable, and you're right, linux GUIs have a long way to go (I'm pretty familiar with GUI design myself - I've read GUI design books for fun ).

[zootm]

GUI interfaces can be made modular and powerful, but yes, text-based ones are very good for combining. The reason for this is simple - streaming. They're text interfaces, they take in and give out text. It's simple to make them parse things because of this. It's just completely pointless for the average user.

Incidentally, although I know a few GUI-based tools that it's possible to do your task in, it would require the use of text-based tools, which kinda defies the point. For the sake of finding a quick GUI-based solution, though, using the tool jEdit you could make a GUI-based solution, the only part of which where text-based stuff is needed is a BeanShell macro to close all buffers not containing "elite". It wouldn't be any more complex than using the text tools.

The point is, though, for 99% of uses of computers, this sort of nonsense is completely unnecessary. And it's not like bash and these tools aren't available for every modern computer platform (I used to code on Linux exclusively, but since I started using Cygwin there's no actual difference).

[fwgx]

Depending on how many files you're expecting to change I would use the "find in files" option in something like EmEdit to get a list of files and then click on the file in the list to open it and then use the replace command. Simple.

Although I see your point, I don't think people in general spend their days editing pure text files. Heck, I do and I extremely rarely come up against anything I can't do in a GUI or with a recorded macro in VS6. And more often than not it is quicker to do it all manually instead of read the help file for one command, try and find out a crypticly named utility that does what you want. Learn to use it, pipe it into something else and, yadda yadda yadda.

I can see GUIs doing just that kind of thing very well. You just have to create a workflow program that groups all programs into categories such as text editing, graphics etc. You drag and drop programs onto the workbench, connect up flow lines, add some filters and conditional logic and you're done.

[zootm]

See, that's an interesting concept, Phily, I was wondering if that would work. The main problem is that all the different programs have non-homogeneous modes of dispatch, so it'd be hard (without command-line switches for said GUI tools ).

[xzxzzx]

Originally posted by Phily Baby
I can see GUIs doing just that kind of thing very well. You just have to create a workflow program that groups all programs into categories such as text editing, graphics etc. You drag and drop programs onto the workbench, connect up flow lines, add some filters and conditional logic and you're done.

This is the kind of thought I was trying to stimulate.

Still, while my example may be artificial, it is an example that could be far more easily accomplished with a text interface. Regexes are my best friends. Recently, I had to handle a mail server that was misconfigured and acting as an open relay - I decided that I'd get rid of the email that was in the outgoing queue that had come from the relatively few other servers on the net that had discovered this one.

It was easily done with a find command:

code:
find /var/qmail/queue/mess/ -exec grep "^Received:.*(spammer's ip)" {} \;

-print -exec ~/mymessagedeletescript.sh \;

I'm sure there are GUI-based tools available that would perform something like this, but I doubt there are any that would easily allow me to tweak my command. For example:

code:
find /var/qmail/queue/mess/ -exec grep "^Received:.*(spammer's ip)" {} \; -or

-exec grep "^Subject: WANT A BIG PEN[I1]S. CL[I1]CK HERE" {} \;

-print -exec ~/mymessagedeletescript.sh \;

etc...

While I understand your point about cryptic commands, Phily, you should see a competent Unix administrator who's been using those commands for a while. It's fucking magic.

Plus, it looks really good to your boss who has no idea what those strange things on your screen are, and is amazed at your fingers flying over the keyboard and your comprehension speed as you use auto-complete and are only reading the one relevant piece of data from a list of 50 .

Efficiency brings on a whole new meaning. Want the PID/image name for the program that's listening on port 80?

code:
legolas root # netstat -tlnp | grep ":80"

tcp        0      0 0.0.0.0:80              

0.0.0.0:*               LISTEN      2661/apache2

How many lines of code are in my project's .txt files, anyway?

code:
legolas source # find -name "*.txt" -print0 | xargs -0 cat | wc -l

2961

Hmm, that seems high. What if I don't count blank lines?

code:
legolas source # find -name "*.txt" -print0 | \

xargs -0 cat | grep --invert-match "^ *$" | wc -l

2863

That's better. By the way, if the file names didn't include spaces or wierd symbols (like a file named "bl*ah.txt"), the commands would be more like:

code:
find -name "*.txt" | xargs cat | wc -l

and if you didn't have too many .txt files to overwhelm your shell (253?), you could do:

code:
wc -l `find -name "*.txt"`

As for:

Originally posted by Phily Baby
And more often than not it is quicker to do it all manually instead of read the help file for one command, try and find out a crypticly named utility that does what you want. Learn to use it, pipe it into something else and, yadda yadda yadda.

You're right, it's often faster the first time, and the second time, and even maybe the third time, but there eventually comes a point where you're less productive than if you'd lost the time learning. And it's not like these commands have exactly precise applications - once you've learnt how to use grep, or find (not to mention sed or awk)...

I used to view unix commands as I believe you do, that they're cryptic commands with limited use, and that it takes huge investments of time before you get any use at all out of them. It's not true, though - learning just a few commands, you have amazing power at your fingertips. It's not a mistake, these commands have been around for a very very long time in the Unix world.

[zootm]

The thing about UNIX commands is that they fit in with the UNIX paradigm - everything's a file, files are usually text. It works so well by design. The reason they're useful is because people decided to design things so that tools like that would be useful, if that makes sense.

The commands tend to be less useful on Windows because configuration and so on simply isn't stored as plaintext, and the "everything's a file" paradigm isn't used (since it has less meaning in a GUI setting). It's just design choices.

[whiteflip]

Originally posted by zootm
The thing about UNIX commands is that they fit in with the UNIX paradigm - everything's a file, files are usually text. It works so well by design. The reason they're useful is because people decided to design things so that tools like that would be useful, if that makes sense.

The commands tend to be less useful on Windows because configuration and so on simply isn't stored as plaintext, and the "everything's a file" paradigm isn't used (since it has less meaning in a GUI setting). It's just design choices.

Damn Regsitry. Whats so wrong with ini files anyway?

[zootm]

What's wrong with the registry? It's as organised as .ini files are... The only real problem is cross-platform compatibility.

I used to be convinced by the "single point of failure" angle, but then I realised that ~/.* is basically the same as the single-user registry. I believe GNOME has its own registry-like construct now?

[fwgx]

There's no reason that the registry can't be distributed and simply backed up to a remote domain server or something. I like the registry as an idea, it's much more preferable to flat files imho. I do LOVE the idea of a SQL based OS though. Now with that you get power, simplicity and security. I so hope MS get it to work mmmmmmm.