Slashdot Mirror

True. The naming "zilla" is present in different plants as well as spiders.

If you can get it (there's been trouble in this department, but someone close to the company seems to have recently sorted it), Izware's Mirai is a very good solution for at least your second problem.

This software (in it's previous incarnations as Nichimen's N-World and Symbolics' S-Graphics packages (it's virtually a direct descendant! ain't Lisp great?)), is where most of the current packages are leeching their modelling features from - first Subdivision surfaces modeller on the market, and because of the fact that it uses the Winged-Edge data structure to store geometry, the first with "edge loops."

While these edge loops aren't triangle strips per-se (I actually think it's a horrible idea to force triangle fans and strips at the tools level - leave that for converters and exporters!), they, as an edge control structure, will help form the proper polygon arrangements so you can exploit triangle strips later down the pipeline.

As for shaders, at this time I also thing it's a downright horrible idea - there aren't any implemented standards yet! At least wait for OpenGL 1.4 drivers to come out.

Mirai's next release should be ready for this, since it currently features a versatile materials "domain" editor that lets you painlessly transfer those material and texture properites that you define for the renderer onto OpenGL for previewing (well, everything that the domain permits), and later onto your target console (although the domains are for older systems - Mirai hasn't been updated in a while.), and vice-versa.

Besides that, you get 2d and 3d paint, advanced UV editing tools, rigging controls that will blow your mind (sure, Maya's poweful, until you start watching the time it takes to rig a skeleton fully with IK and FK solvers, and then throw on a couple of more controls to keep the skeleton in place - there's absolutely nothing like Mirai's "pin" joint system out there, and it's the only package where you can use skeletons to actually aid your modelling), the industry's first (despite SoftImage's claims, and IMO still the most useful) non-linear animation system, and a batch of Mo-Cap processing tools from TestaRossa, and a specially designed game-data export framework (Game Exchange). Oh, and did I mention it's all written in Common Lisp? Who needs a plugin interface, when you can run code directly from the Lisp image!

Is it really worth raving so much about? Hell yes.

the last widely-used p-code based system that had static typing was probably USCD Pascal

Considering that Guy Steele, coinventor of the awesome language Scheme, was on the original Java team, perhaps they got some things right which you haven't understood yet.

Lisp manipulation of XML and HTML is something people have been working on for a long time. For example, the Document Style Semantics and Specification Language (DSSSL) was a purely functional, side-effect free variant of Scheme. Even XSL, the apparent replacement to DSSSL, offers the same kind of functionality. It just uses a more CSS-like page model and XML syntax. But, conceptually, it's Scheme inside.

it's not valid to claim that Java+XML is a reinvention of Lisp+S-expressions

We (the intelligent life) are here and not on another planet because this planet is uniquely suited to us.

An elegant statement of the Weak Anthropic principle.

FWIW my current worldview is

• Life "as we know it" is a lot more common in our region than we think. Due to exobiology as per the Hoyle Wickramasinghe hypothesis. Even if the hypothesis is wrong and life requires a clay matrix to develop DNA, and even though the latest news on Martian Meteors looks like they didn't contain fossil bugs, the mechanism for propagating life pretty much anywhere near where it develops is sound. Bacteria are hardy beasts, and can survive in space quite well. With the latest news on the water on Mars, the odds of life there approach certainty.
• That's the good news. The Bad news is that the step from procaryotes to eucaryotes, that is, going from single-cell to multi-celled organisms is a big one, and probably only a fraction of one percent of life origins ever make it.
• But it's worse than that. Technology requires colonies of multicellular organisms. These can be as complex as as the Portugese Man-O-War which although it looks like a jellyfish is actually a colony of 4 different polyps, more like a multi-species anthill or coral reef than anything else. Or they can be as simple as the US Congress, an organism whose intellect is less than any of its constituent members. In any case, some multicellular genusses may remain in pre-school, and never develop anything as complex as an ant farm. The development of such complexity may require a stable double-planet system, rare as hen's teeth. Earth and its moon would be considered a double planet system if we didn't live on one of em.
• It's worse still. The Dinosaurs were terrifically successful for megayears, but had they landed on the Moon, we'd almost certainly know it. So it's possible to have complex organisms, complex societies (herds), but still no technology for Sagans. Closer to home, Dolphins are unlikely to ever develop a technology. You may need to periodocally hit the planetary reset button with a meteor or super-volcano. But not too hard - or you've got to rebuild from procaryotes again. And not too soft, you only have a limited amount of time before the star you're around goes Ploof.
• Finally, there's the "Goldilocks Zone" that's the subject of the original article. Star too close to galactic centre = bad. Star too far out = bad. And then within that torus, star in spiral arm centre = bad. Don't be too near a supernova. So the quicker you can develop a multi-stellar population, the better. Which reduces the odds even further.

Though we could start right now with Chimpanzees and Gorillas. They'd be considered primitive but undoubtedly intelligent species if they came from another planet. History will judge us harshly if we don't start granting sub-human rights to sub-humans.

Which means that we'd better get our ethics up to scratch.

Logo was a language invented by Seymour Papert.

No it doesn't. Take a look at Symbolics Genera, which is (was) the operating system of the Symbolics Lisp machines. It deviates massively from the UNIX-notion of files and character streams for everything.

Sure, you can find a Java implementation of a word processor, but will it last as long as Emacs? Is it as flexible? Is it as customizable? Is it as powerful? An Emacs based on Common Lisp (instead of its own crippled Lisp) would be even more of an improvement.

Any Java "word processor" is going to have a hard time beating MS Word at its own game. Emacs, however, thrives by playing another game, the "text editor" game. And it wins.

Lisp has toolkits like Common Lisp Interface Manager (CLIM) which are much more than simple layers to create windows with widgets. I can't even come up with a concise description of how different the Lisp idea is. (Some of this is my lack of practical experience with CLIM. I don't program GUI applications.)

Java is fine for relatively simple, solved problems (like GUI word processors). Lisp is for horrendously complex, hard-to-solve problems like managing logistics for airlines. Or bioinformatics

Or managing information in complex investigations and audits.

You'll notice that all of these are created to solve real-world problems, where it might not be obvious how a computer could help you. Word processing and 3D-shooters are all very securely "inside the box" of what computers are known to do, and have been done many times. Lisp is for taking on the world, forging into new territory, and kicking the world's ass. If you want to stay safe and do "yet another" of the same old thing, maybe Java is all you need.

Way more powerful, a vastly better development platform, etc., etc., etc. Squashed by "Worse is better."

Peace,

(jfb)

Remember that the Xerox movable overlapping windows paradigm appeared at a time when tiled and framed paradigms were widespread (Symbolics, TI Explorer, a whole range of other systems) and quickly became universal because it worked better. It still does.

Sure, there are issues in navigating the stack of windows, particularly if you use desktops as cluttered as I tend to; sure, less sophisticated computer users may find these navigation problems difficult. But focus, visibility, prominence and accessibility are in the hands of the user, and that's where they belong

Remember that the Xerox movable overlapping windows paradigm appeared at a time when tiled and framed paradigms were widespread (Symbolics, TI Explorer, a whole range of other systems) and quickly became universal because it worked better. It still does.

Sure, there are issues in navigating the stack of windows, particularly if you use desktops as cluttered as I tend to; sure, less sophisticated computer users may find these navigation problems difficult. But focus, visibility, prominence and accessibility are in the hands of the user, and that's where they belong

Here is a list of online books and references which I found useful:

• Common Lisp: A Gentle Introduction to Symbolic Computation -- David S. Touretzky
• Successful Lisp: How to Understand and Use Common Lisp -- David B. Lamkins
• CLtL2: Common Lisp the Language, 2nd Edition -- Guy L. Steele
• HyperSpec: The ANSI Standard for Common Lisp -- Kent M. Pitman
• CLOS: Common Lisp Object System -- Daniel G. Bobrow et al
• MOP: The Meta Object Protocol
• CLIM2: Common Lisp Interface Manager 2.0
  The CLIM perspective, user's guide, and specification.

The Coronado C++ tutorial. Taught me the first stuff. I remember it as being great!!!
http://swt-www.informatik.uni-hamburg.de/~strunk/c pp/

Um....no.

There are many high level design languages for chip design, VHDL and simulators for testing designs prior to fab.

Designed chips is very much like programing.

Digital (Compaq) developed an x86 Dynamic Binary Translator running on Alpha called FX!32. FX!32 won Byte Magazine's "Best Technology" award at Fall Comdex '95.

Dynamic in this case means that some code is emulated on the fly, and some is translated. This approach was pioneered for bytecode systems in Smalltalk implementations in the 80's, and of course is now used in Sun's HotSpot and other dynamic adaptive JVMs.

Static binary translators have been around for even longer, and were used (among other things) for running VAX programs on Alpha. A useful overview of this sort of technology appeared in the Digital Technical Journal 4:4 (1992). HP also performed binary translation between the HP3000 and the Precision architecture, but I can't find on-line info on that, just a citation to a paper article (1987). There is also a useful survey article on static and dynamic binary translation.

What is presumably novel in Transmeta's approach is that their instruction set architecture (ISA) is tuned specifically for dynamic translation (see page 12ff of Transmeta's paper The Technology Behind Crusoe Processors . Some microcode architectures have been designed specifically for general emulation (most have been tuned for a particular macroinstruction ISA), e.g. the early Lisp Machines (1976-81).

Congratulations, you've just reinvented Genera. Or Squeak, if you like "objects" better than "functions", or if you want to run it on top of an existing OS, or if you don't want to be tied to a specific (dead) hardware architecture. And ETH Oberon is yet another OS based on the same ideas. In any case, that you don't see it everywhere doesn't mean it hasn't been invented yet - and that it's (not) popular doesn't mean it's (not) good. (For the first case, see Haskell - "groundbreaking" parametric polymorphism in the late 80s; for the second case, see Windows.)

In any case, it will do you no good to use CORBA as it is today. Instead, use a dynamic, high-level language for user-level functionality, and just let applications people deal with objects in the language's natural idiom, making no syntactic distinction between "local" and "remote" objects.

In any case, have fun, and don't let those Unix weenies tell you that systems research is dead - if it were for the conformists and the naysayers, we'd be rendering polygons with abaci!

But, even worse, worshipping technology in and of itself is stupid. Technology is a tool. Do you worship axes? If you worship computers enough to write a history of an obsolete OS, why not write the history of the axe?

Aaaaaah, the Lisp Machine. The forgotten ideal.

The Lisp Machine. The first personal workstation. Bleeding-edge technology under your fingertips and yours alone. The programmer, the user, the administrator: the master of your system.

The Lisp Machine. From user interface specification all the way down to on-chip microcode, all is Lisp. Everything is an s-expression, always so wonderfully manipulable.

The Lisp Machine. A great vision of software and hardware working together in the perfect harmony of the Tao.

The Lisp Machine. Often envisioned, often imitated, never surpassed.

Apple understands this, and may therefore be the first to create a Unix-stable, xerox-style operating system.

Bzzzttt. What about Genera, the operating system of ages-old LISP Machines?

-- Faré @ TUNES.org

Here are a few people's pages about Lisp Machines, for the curious (Some links are MIA; can anyone find a new valid address for them?):

• Symbolics machines: Peter Paine | Bob Kerns | [MIA] Rainer Joswig | dr. P.M.E. De Bra | Ralf Moeller | PT Withington
• LMI machines: [MIA] Joe Marshall
• There were other LISP Machines: Ti Explorers, Xerox Dandelions, etc... Check the FAQ for comp.lang.lisp, make a Google search, etc.

I imagine you're thinking of the Symbolics Lisp machine. It was/is indeed a very nice machine, running an operating system called Genera.

The user interface was quite special, indeed. It can best be explained as "XMLTerm on speed". It was basically a command line interface, but pretty much everything could be clicked on with a mouse. A status line on the bottom of the screen showed what different mouse button actions would do to the "object" currently pointed at -- very helpful.

Lots of information can be found on the Sy mbolics Lisp Machine Museum.

Oh, and by the way: Symbolics (the company) is currently developing and delivering Open Genera for Alpha-CPUs. :-)

Secondly, I have some of the Demons supplements for AD&D produced by Mayfair games, which were really well done, addressed a need in the community (I was one of the ones who felt TSR really screwed up by attempting to sate the appetite of the Fanatics for Family values by removing demons and devils from their games, when we all know that only the utter destruction of D&D and RPGs in general would ever do that.) and caused Mayfair to promptly get sued by TSR. See this page for information. What irritated me was that TSR and later Hasbro could be in a position to suppress D&D altogether is they had a motivation (eg, fundamentalist boycott) to do so.

For some information as to the chilling and horrifying goings on at TSR in those days, please read:

The Gary Gygax FAQ

As someone who used to be avidly into pen & paper RPGs, I believe a popular, copylefted RPG would be the greatest thing to happen to RPGS since their original invention. I hope this is for real.

>> C will always be the language of choice for platforms.


Why? Is this for technical or social reasons?
Lisp and Smalltalk have been used to implement operating systems,HTTP servers, and database systems and quite efficient and powerful ones at that. What advantage does C have besides being close to the hardware?

examples:
Li sp Machines
CL-HTTP Hypermedia Server
Squeak
Pluggable Webserver and Swiki
MinneStore
GemStone

I run a similar SAMBA system and have found printop to be very useful