Slashdot Mirror

Thought VennMaster could do it already:
http://www.informatik.uni-ulm.de/ni/staff/HKestler/vennm/doc.html

I've played Mike Goetz' B03 version of CP/M Adventure (really Crowther & Woods's, with a few additions) on every computer I've owned since my Kaypro 10, thanks to emulation software. The original CP/M files cost nothing but download time (at 300 baud on a SmartModem, measured in hours, IIRC), and I've played them unmodified since 1984. On this repurposed Dell Inspiron 1525 running Jaunty Jackalope, I use the excellent YAZE emulator by Andreas Gerlich. Hilariously, this old text adventure runs an order of magnitude or two faster than it ever did running natively on the Kaypro.

http://www.ifarchive.org/if-archive/games/cpm/cpm-advent-b03.zip
http://www.mathematik.uni-ulm.de/users/ag/yaze-ag/

So, on the Scotch parsimony principle of cost benefit, Time Plaid divided by Cost, this one game is worth about 80 grillion pazools. Probably a universal principle; I've just spent January replaying every Star Ocean game ever released in English, and will move on to Blue Sphere (in Japanese on the GBC) shortly. After that, maybe FF12 again, who knows...? (What's a life for?)

YAML and Ruby play well together. (or perl, or Python)
CSV has a perl DBD driver for it.
http://www.mathematik.uni-ulm.de/help/perl5/doc/DBD/CSV.html

I think id Games used to compile on SGIs. I know MS did some development on Xenix/i286 and Xenix/i386 (somewhere, there's an MS quote about how MS-DOS/Win is not suitable for serious development..hah). In fact, the i286 had a memory management unit, but the only OS (that I know of) which took full advantage of it was Xenix. Minix/i286 may have supported it to some extent, as well.
Some emulator pages....mac&ppc, simos (for SGI/IRIX5), DEC 10 and Big Iron, various DEC emulation, Apple Lisa, Z80 sim&development, yaze Z80, Apricot and Amstrad, bochs x86, ... and there's always emulators that run under DOS that you could run under Bochs or QEMU.

Other possibly helpful links:
emulators on freshmeat
OS kernels on freshmeat
OS's on freshmeat
bunches of old OS disk images
CP/M and MP/M
CP/M disks
Lisa Xenix
LisaOS
tandy xenix
elks and uclinux
freevms
freedos
Apple I (not II) development
reactos - winnt clone
MAME stuff and pinball Mame
info about tandy disk images
solaris minix
minix info and version 3
various free (as in beer and/or speech) OS list
The OS list at tunes.org

• Player/Stage http://playerstage.sourceforge.net/
• RobotFlow (also check out Flowdesigner and MARIE) http://robotflow.sourceforge.net/
• CARMEN http://carmen.sourceforge.net/
• ADE http://ade.sourceforge.net/
• MIRO http://smart.informatik.uni-ulm.de/MIRO/
• ARIA http://robots.mobilerobots.com/
• YARP http://eris.liralab.it/yarp/
• Missionlab http://www-static.cc.gatech.edu/ai/robot-lab/resea rch/MissionLab/
• ORCA http://orca-robotics.sourceforge.net/
• GenoM http://softs.laas.fr/openrobots/tools/genom.php
• ROLE http://wurde.sourceforge.net/

If you're doing software development, how about using those spare cycles for random testing? I find lots of bugs this way.

The guy doesn't say specifically, but it sounds to me like he simply stumbled upon it by accident. I don't get the impression at all that he's some super-hax0r looking to exploit a flaw.

Here's his page about it.
Here's a post he made on MacRumors.

That doesn't leave me with the impression of someone intending to do anything bad with it. I could be wrong!

Because this was reported by Heise via Michael Lehm via mac-tv.

Extreme orthagonality makes learning and reading a language easy for the uninitiated, but does naught but limit those already familiar with it.

For example, take tied hashes in Perl. They are certainly not orthagonal by any means, but they provide an unparalleled method for interacting with databases in Perl.

Standard Java requires IEEE floating point, so Java programs run the same everywhere. A community that used Crays (which were renown for their lousy, but fast, floating point) doesn't want their programs to run everywhere with precise but slow mathematics; they want their programs to run on their hardware with the hardware floating point as fast as possible. Do your research. Java's IEEE implementation is incomplete and doesn't offer things like user selectable rounding modes, which are often used to check for numerical stability of HPC codes. Further, Java's floating point error checking is minimal to the point of being not-useful whatsoever. However, as we say, this doens't really mater as we use Fortran, as Fortran is nice (tm).

There's plenty of Linux clustering technologies available. I wonder how does the Red Hat stuff compare.

First, an article about the shape of the universe, quoting a researcher from the University of Ulm. Then the University Lifestyle Manager (ULM).

I wonder if all this is somehow connected to Johann Gambolputty de von Ausfern Schplenden Schlitter Crasscrenbon Fried Digger Dingle Dangle Dongle Dungle Durstein von Knacker Thrasher Apple Banger Horowitz Ticolensic Grander Knotty Spelltinkle Grandlich Grumblemeyer Spelterwasser Kurstlich Himbleeisen Bahnwagen Gutenabend Bitte Ein Nürnburger Bratwustle Gerspurten Mitz Weimache Luber Hundsfut Gumberaber Shönedanker Kalbsfleisch Mittler Aucher von Hautkopft of Ulm...

Here is the original paper.

As I recall, one of the drawbacks to writing shell scripts(**) in the Joy shell was serious awkwardness in redirecting a program's standard error. And redirecting of higher file descriptors was not possible. Although I can't recall every seeing a shell procedure that used this feature.

Rob Mashey wrote a shell for PWB/UNIX (the "Programmer's Workbench UNIX"), which was about the same vintage as version seven UNIX, the version that introduced the Bourne shell. I read a paper he wrote, for a journal called "Software Practice and Experience", called something like, "Using the command line interpreter as a programming tool".

I just did a google search for Mashey, and I came across the man page for the Thompson shell. Interesting.

In his paper Mashey described an experiment the PWB team conducted, in writing a compiler for shell procedures. It was a waste of time. The compiled versions were larger, were unreadable, and they didn't run any faster. Profiling revealed that most of the time the shell took was spent invoking the two system calls fork() and exec(). Back in those days test was a separate binary.

(*) If the Bourne Shell is named after Steve Bourne, and the Korn Shell is named after David Korn, then the C shell should be referred to as the Joy shell, since Bill Joy wrote it.

(**) Actually Steve Bourne doesn't call them "shell scripts". He calls them "Shell Procedures". So that's what I call them. I figure he should know.

DOS wasn't that bad of an OS. That's no bullshit. It has its high points, and has been around *much* longer, and been magnitudes more popular than nearly everything else that rose to compete with it.

And switching from the one-person-one-cpu approach to a really distributed OS will take more than just a distributed scheduler and a sandbox to run foreign code in.

VAX Clusters.

Could someone who is German or who has studied German law please clarify?

XEmacs can be compiled as an Athena or Gtk widget so that it can be embedded into other apps. See this documentation and this screenshot

I wish more apps would use XEmacs as the text editing widget. :)

In fact it also smells a little bit like Oberon.

Agreed.

I'm not a great fan of OO languages (just how much syntax do you really need?), but it would be wonderful if somebody would get rid of the pointless `new' keyword for object construction, add algebraic datatypes and pattern matching, and add closures as first class objects.

But when you use genuinely modern declarative languages (Mercury, OCaml, Haskell, ...) there's no real incentive to go back. It's like good hi-fi.

though I wish I could find official rules somewhere

[snip] that these are controlled by an off-field computer but at least their behavior doesn't seem to be modified by humans at runtime.

It is based on atomically transactions and distributed shared memory.

More information can be found at the Plurix Website - but not really up to date :-(

Locus had a particularly clean API for this.

• open Regular UNIX open, except that if you open for writing, you're creating a new file that starts by sharing the file blocks of the original file and has copy-on-write semantics. Only processes sharing the same file descriptor see the new file at this time.
• close Regular UNIX close, except that if you're closing a file open for writing, the new file now replaces the old file for subsequent opens. Thus, close commits changes.
• revert Closes and discards a file open for writing. The file remains in its original state.
• commit Commits the current state of a file currently being written; essentially equivalent to closing and reopening the file.

If a program terminates abnormally (via kill or abort, a system crashes, or communications with a remote file system are lost, the file reverts to its last committed version.

These are nice file semantics to put under UNIX programs. Unmodified programs that work on files as units work fine, and if they crash, files are not corrupted. This covers most UNIX applications. Advanced applications can use commit and revert to manage clean updates to files being actively updated. It's efficient, too, because the new and old versions share unmodified disk blocks. Opening a file, appending some data, and closing the file is both cheap and atomic.

This is a successful, proven concept, but one that hasn't been seen yet in the open source world. Somebody should pick up on this concept.

The lead developer on Locus, Popek, tried a startup, Locus Computing Corporation, in the 1980s, to market the whole Locus system, but it had too much stuff in it that the UNIX community didn't think they needed back then, like heterogeneous clustering, and also had its own networking protocols. Good idea, but about 10-15 years too early.

Interesting points. But I feel that while PHP may be a good language, it has origins that I feel are somewhat suspect and disqualify it from any serious use in my web applications.

What, for example, is the name supposed to imply?

That this language is so far removed from reality that nothing will affect it?
That this language will give you feelings of strength, power, and invulnerability?
That this is a "supercharged" web scripting language that will stop at nothing to achieve whatever delusional whims you set out for it to accomplish?
That this language will put some real "rocket fuel" into your dotcom enterprise, even more so than, say, small investments from an angel? (Which would be "angel dust", no?)

Let me ask you, then - what kind of message does this send to our children? I have a twelve year old daughter who wants to be a webmaster, and she came home from school the other day and asked me about PHP. What am I supposed to tell her? That it's ok to use it professionally, but not recreationally? Only if you're putting up a website? Please -- we all know that that's the long slide towards addiction, a mad quest for the drug, and finally going broke and living under an overpass with a 40 oz. bottle of Old English, begging money from passing strangers and carrying on extensive conversations with crows, pigeons, and skinny, mangy rats.

Somebody needs to take a hard-line stance against this language and make sure that it spreads no further. Why can't people use sensible, wholesome languages such as Perl, Python, ASP, and TCL?

Next time, before you go and create a scripting language with dubious moral intent: think about the children. Please.

One of them is Plurix, which was demonstrated at the CEBIT fair in Hannover a few weeks ago. The main concept is a distributet address space:

When creating distributed, user friendly systems, most of the work is hiding and overlaying the OS concepts with new ones. E. g. using stub objects and transferring the commands and data over the net, where a stub caller accesses the real object. (this way JAVA-RMI and DCOM work). This is overlayed over a local OS, that even builds walls between the applications on the same machine, creating the need for translation and serialization of data, code and requests.
The main reason for this is to protect apps from "bad" apps. Most of the bad apps result from programming errors, very often caused by pointer arithmetics (e. G. off-by-one-errors), Alloc/Free problems and wrong casts. Especially C and C++ are very dangerous in this area.
Most of this could be avoided by using type-safe languages like Oberon or Java with automatic garbage colleciton, and validating the code when linking it into the memory. This way, you can spread one mem-address-space over the network, instead of dividing every machine into several address spaces.

Another project which researches for new security concepts is SPEEDOS.

---

One of them is Plurix, which was demonstrated at the CEBIT fair in Hannover a few weeks ago. The main concept is a distributet address space:

When creating distributed, user friendly systems, most of the work is hiding and overlaying the OS concepts with new ones. E. g. using stub objects and transferring the commands and data over the net, where a stub caller accesses the real object. (this way JAVA-RMI and DCOM work). This is overlayed over a local OS, that even builds walls between the applications on the same machine, creating the need for translation and serialization of data, code and requests.
The main reason for this is to protect apps from "bad" apps. Most of the bad apps result from programming errors, very often caused by pointer arithmetics (e. G. off-by-one-errors), Alloc/Free problems and wrong casts. Especially C and C++ are very dangerous in this area.
Most of this could be avoided by using type-safe languages like Oberon or Java with automatic garbage colleciton, and validating the code when linking it into the memory. This way, you can spread one mem-address-space over the network, instead of dividing every machine into several address spaces.

Another project which researches for new security concepts is SPEEDOS.

---