Slashdot Mirror

Anyone who has spoken with him personally- in person or via email- or read his words, seen his vision knows this. Alan is *the* man.

There's a great XEROX Video we've here at our uni library- "Doing with images makes symbols [videorecording] : communicating with computers," released in 1987 while Kay was a fellow with Apple. For an enthusiastic and engrossing view of what Kay thinks computers *should* be (and I'm 100% with him!) should check it out.

Also, look into Smalltalk. Alan works on Squeak Smalltalk- rather than C++ or Java- and there's a good reason for it. Smalltalk has the tendency to empower both end user and programmer. It's "open source" in a way that most slashdotters have never imagined. It's kind of like having your whole computer run Emacs, but without being stuck with some funky half-GUI half-terminal app with nothing but key commands to drive it. Squeak gives us the power to control our computing environment in a way similar to emacs, although Squeak is a lot closer to a "conventional" GUI environment than Emacs. That said, there are a lot of things about Squeak's GUI toolkit - Morphic- that are highly unconventional, but quite great to have around.

OK, enough early morning rambling from me...

Before people go all gaga over this rash of new features from Apple and Sun, do some research. Transparency, shadows, overlays, desktops on 3D virtual presences, portals, 3D environments, etc. go back years and years, and many researchers have contributed to them. (You can find many of these features demonstrated in Squeak.)

This stuff is being shipped commercially now because you can now run it on PC hardware costing $1000-2000, instead of requiring high-end SGI workstations, as it did just a decade ago.

Apple does have a short-term advantage in this area: as part of their deal with NeXT, they got a Postscript/PDF-based window system, which happens to do these sorts of things already. But they don't have any long-term technical advantage: Microsoft has added similar APIs to Windows, and X11 also is moving towards full support of transparency and blending throughout the entire window system. Whose system will end up being the best long-term choice remains for the market to decide; personally, I think Apple's PDF-based system is the most cumbersome of the bunch.

particularly the GUI-drawing system

From my experience, this is the most commonly sited perk of VB. It's something that you've been able to do for darn near any language for a long time- GUI designers really aren't new, and VB doesn't even have the best one available.

The frequency that I see people cite the GUI designer as the major benefit to VB makes me think that most folks- especially the types of people on /.- seem to be stuck in the past, coding all of their GUIs manually. I know that the development setup is generally some years behind for most Linux developers compared to your average coder on Windows or Mac OS X, and that there are fewer good and polished tools on Linux. But still- there are free GUI designers for GTK+, FLTK, Qt and Motif. And for just about any other toolkit and language. Do people not use these?

That said, tools like VB and RealBasic (with which I've more experience than VB) are RADs for more than just a GUI designer. Using Glade for a C/GTK+ app won't make you as productive as a seasoned VB coder for simple app development, but it will shave off some time spent coding the GUI programatically.

But there are options, and some darn good ones on, for Linux:

Prima: a new GUI toolkit for perl- including a really nice RAD GUI builder- for Linux, OS/2 and Windows.

Squeak Smalltalk: Runs on just about every platform. Uses a seperate GUI toolkit, but affords a huge amount of power and ease of development.

RealBasic: A cross-platform VB clone for Mac OS Classic/X, Windows and Linux. *Really* nice. Costs money, but it's worth it.

RunTime Revolution: Has a HyperTalk-like language and runs almost anywhere. ...and others. But those are some that embody the feeling of a RAD IDE like VB. That is, they do more than just add a GUI designer.

• $ - CLOS is listed as a separate language. The Common Lisp Object System, as it's name implies, is an object-oriented extension to Common Lisp. Why they thought it was a separate programming language is beyond me.
• $ - No ANS Forth. The ANSI Forth specification was ratified in 1994, and is known as ANSI X3.215-1994.
• $ - No Lisp dialects between 1.6 and Common Lisp. This is an incredibly glaring omission. There were a number of widely used, divergent dialects of Lisp after 1.6, the chief two being MIT's MACLISP and BBN/Xerox Interlisp, both of which were used well into the 80s and had a major influence on Common Lisp, among other languages. This is not to mention the other dialects of Lisp left out (the principal ones I can think of are Portable Standard Lisp, EU_LISP, Le Lisp, Lisp Machine Lisp).
• $ - No ISLISP or XLISP. ISLISP became an ISO standard in 1997, and is a subset of Common Lisp with additions from several European Lisp dialects. XLISP, on which AutoLisp is based, became available for PCs in the late 80s, and due to the popularity of AutoCad was for a time the most widely used dialect of Lisp.
• $ - No StarLogo. StarLogo is a parallel version of Logo which was developed at MIT in the late 90s. It's used in a lot of grade-school computer courses.
• * - Haskell has an arrow pointing to CLOS. Not only is CLOS it's own language, apparently it is also a purely functional one. Again, where this was pulled out of remains a mystery.
• $ - No R^3, R^4 Scheme revisions. PHP has a box for every 0.0.x revision. They could have at least acknowledged the major revisions of other languages (and of course Scheme is not the only language this applies to!).
• $ - No Squeak. Squeak is a derivative of Smalltalk started by Alan Kay and Dan Ingalls (among others) in 1994. Today it is the most popular Open Source Smalltalk.

There are also a lot of languages that can be included, like Carl Hewitt's PLANNER (MIT's precursor to Prolog) and ACTORS (a purely message-passing object-oriented formalism that predated Smalltalk, and had several implementations and a lot of influence on other object-oriented languages).

All in all, I think both charts are pretty lame. O'Reilly should have at least solicited public comments before producing such a factually erroneous telling of history. This is altogether more surprising considering that O'Reilly is not a general publisher but instead specializes (in what they claim are) accurate technical manuscripts.

It's quite impressive how it has evolved, and is still one of the most entertaining software environments around.

In our experience learning OOP using Java is very difficult. All right, the bulk of students aren't that bright, but I think they would do a lot better if they learnt Python or SmallTalk using Squeak first. We kill a lot of interest in programming by using Java as the first programming language.

Some implementations of popular dynamic languages (e.g., LISP, Scheme), let you do some type inference and/or some explicit declarations, and will spit out machine code or C that will do the job that much faster. Tweak your algorithm in the slow version of the language and then produce a program that runs ten times faster with an optimizing compiler.

The Squeak VM is a great example of this. The whole thing is written in Squeak itself. Running a Smalltalk VM this way is painfully slow, but a Smalltalk->C translator generates the code that will be compiled and used as the actual, runtime VM (which can support a whole host of things, including raster and vector graphics, sound, MP3 audio and MPEG video!).

Better yet, let's make the whole thing language-independent. At this "high level", it should be possible to shake away this "language" thing, and use whatever language has been implemented on the level below.

Agreed. These days, if the framework is designed right, there's no reason you can't interface with most any language there is. What is designed right? Well, object-oriented seems to work very well.

By the way...fifth generation? I don't think it'll be AI just yet. Maybe that'll sixth or seventh. For fifth, might I suggest an old friend. What's old is new again. (Check out morphs and Croquet.)

People say funny, but I say Squeak. It's exactly what you're talking about, except it's based on smalltalk instead of perl.

SmallTalk was always an intriguing language to me, and mostly because it used some kind of integrated graphic shell, it used glyphs not found in US-ASCII, and there weren't any decent free SmallTalk environments available for the longest time.

Now with Squeak and this quick tutorial, it might be about time to explore SmallTalk.

Besides, I've always wanted a real OO language where I could send the message "to:do:" to the object "1".

like what?

I'm fond of Python, which sports a very clean, readable syntax without giving up flexibility or power. Python is good if you don't want to give up a traditional class/method, loop/imperative style of programming.

There's also Smalltalk, which requires getting one's head around a different model of program design, but can yield very elegant and effective solutions. Squeak is a good place to start for those curious about Smalltalk.

Those are just a couple of suggestions. There are lots more out there. And of course, if you're happy with Java or C#, well, who am I to stand in the way of your joy?

Bander

Georgia Tech and others are working on a product called Squeak which could gain ground in this regard. Some of the players involved are key names from the early years of computer interface/graphics research, including Dr Alan Kay.

Squeak is an open source product with quite a flexible license, and although they are mainly concentrating on educational apps, it is worth noting that in the system itself they have developed an unusual, yet addictive, UI. It is such an easy system to learn, that quite complex tasks can be done within a few hours of learning the basics of the system and going through the tutorials.

They're written in a compatible subset of Smalltalk called "Slang" which is translated to C, which is then compiled and linked to produce a new virtual machine.

The advantage is that you can modify and run the Smalltalk code to simulate the virtual machine in order to test it, and kick out the C code when you're done. There are a few platform-specific files, of course, that are written in pure C.

From their site:

What is Squeak? Squeak is an open, highly-portable Smalltalk-80 implementation whose virtual machine is written entirely in Smalltalk, making it easy to debug, analyze, and change. To achieve practical performance, a translator produces an equivalent C program whose performance is comparable to commercial Smalltalks. Other noteworthy aspects of Squeak include real-time sound and music synthesis written entirely in Smalltalk extensions of BitBlt to handle color of any depth and anti-aliased image rotation and scaling network access support that allows simple construction of servers and other useful facilities it runs bit-identical on many platforms (Windows, Mac, Unix, and others) a compact object format that typically requires only a single word of overhead per object a simple yet efficient incremental garbage collector for 32-bit direct pointers efficient bulk-mutation of objects Squeak is available for free via the Internet, at this and other sites. Each release includes platform-independent support for color, sound, and network access, with complete source code. Originally developed on the Macintosh, members of its user community have since ported it to numerous other platforms including Windows 95 and NT, Windows CE (it runs on the Cassiopeia and the HP320LX), all common flavors of UNIX, Acorn RiscOS, and a bare chip (the Mitsubishi M32R/D).

What it is not

The Squeak Smalltalk system bears no relation to the "Squeak" language designed by Rob Pike and Luca Cardelli in 1985, nor to its successor, "Newsqueak".

What is Cool about Squeak

To quote from Dwight Hughes, a frequent contributor to the Squeak mailing list, "How is Squeak important? Squeak extends the fundamental Smalltalk philosophy of complete openness -- where everything is available to see, understand, modify, and extend for whatever purpose -- to include even the VM. It is a genuine, complete, compact, efficient Smalltalk-80 environment (*not* a toy). It is not specialized for any particular hardware/OS platform. Porting is easy -- you are not fighting entrenched platform/OS dependencies to move to a new system or configuration. It has essentially been put into the public domain - greatly broadening potential interest, and potential applications. The core team behind Squeak includes Dan Ingalls, Alan Kay, Ted Kaehler, John Maloney, and Scott Wallace. All of this has attracted many of the best and most experienced Smalltalk programmers and implementers in the world."

Squeak stands alone as a practical Smalltalk in which a researcher, professor, or motivated student can examine source code for every part of the system, including graphics primitives and the virtual machine itself. One can make changes immediately and without needing to see or deal with any language other than Smalltalk. Squeak runs bit-identical images across its entire portability base, greatly facilitating collaboration in diverse environments. The system, together with an adherance, for better or for worse, to the image model (the entire state of Squeak is manifest in an image file), has yielded a system of extreme portability and sharability. Any image file will run on any interpreter even if it was saved on completely different hardware, with a completely different OS (or no OS at all!).

A Brief History of Squeak

Squeak began, very simply, with the needs of a research group at Apple. We wanted a system as expressive and immediate as Smalltalk to pursue various application goals (prototypical educational software, user interface experiments and (let''s be honest) another run at the Dynabook fence). As you can read in the OOPSLA paper ("Back to the Future") we hit on the idea of writing a Smalltalk interpreter in a subset of Smalltalk, together with a translator from that subset to C.

Philosophy

The current Squeak interpreter combines a classical ST-80 interpreter with a simple yet efficient 32-bit dir

Uh, I haven't read the salon article.

I think it comes down to a matter of discipline. One of the things that made Unix such a success is KISS. Unix is built around the philo that you should focus on one thing and do that one thing well. Tools in Unix don't re-invent the wheel to get stuff done; they rely on other tools.

Another thing that comes to mind is what Apple's VP of hardware engineering Jon Rubenstein said in an interview. He said that engineers get too creative when they do work, and end up engineering things that do not need engineering - the rote work, as he put it. You have to get engineers to be creative in the non-rote work.

IMO, Java is too complicated and easily gets in the way (I'm not going to touch C++ here). At least with C you can start off with a one-line Hello World program. I've seen first-year CS students trying to understand the many lines of code that constitutes a Java Hello World program (there are so many elements to a typical Java HW example; the class declaration, the static main declaration, the exception handler, System.out, etc. Every token except for "Hello, world!" is gobbldygook to newbies). In the case of C, it can go either way. To a well disciplined programmer, C programs can be extremely elegant. On the other hand, you can end up with some really fug-ugly code. However, a Pascal programmer is more likely to use C in an elegant way because Pascal is simple enough to make a programmer focus on the task, restricting the programmer's freedom to do stupid things.

Although many argue that type-safety is incredibly important, that you can get really weird behaviour if you don't have type-safety, and that it's important that languages restrict programmers by being type-safe. Uh, no. Type-safety is like training wheels. If your program is well structured, 'types' in the program are for the most part irrelevant. What matters is what the code is doing, and knowing what the general flow of the program accomplishes. In a well-structured program with a well-defined execution flow, the data that moves around should always be well defined anyway.

Here's another way to look at it (something an old professor brought up). What useful program has no input and produces no output? There is no such thing. Your job as a programmer is to transform your input sources to your desired output products. And the path to get that done should be as simple as possible. Unfortunately, we've got languages with templates, boxing/unboxing, exceptions, RTTI, etc as our main tools, that often provokes us to design systems that are more complicated than they should be.

Really, it's like an artist trying to make a painting, and going out and buying a self-cleaning, featherweight, self-balancing $1K paintbrush. That's way beyond the point, isn't it? An artist needs to envision their artwork and realize it in their medium of choice. Similarly, a programmer needs to understand the problem they need to solve and then efficiently implement it on their target system (be it a PC or an automated toaster oven). Language features don't make programmers write better programs; discipline does. I can't remember the example perfectly, but it's something like, if you give a team 20 tools to do the job, they'll try and use all 20 tools. If you give a team 4 of those tools that they really need, they'll find a solution too - and a more efficient one.

Anyway, KISS. You need to focus on what execution paths your program takes and what affects those execution paths (and note that exceptions throw a wrench into that. I avoid them). Don't get too creative with the language you're using. The best thing for a programmer to do is to learn how to program non-trivial projects in several different languages (Java and C++ don't count as different languages). And then hopefully more programmers will demand cleaner programming environments that aren't just souped-up C++ clones, and programming will stink less. (Take a look at Smalltalk some time).

For people who think there must be something better to write web-based applications than PHP, I invite you all to take a look at Seaside by Avi Bryant, a web framework available for Squeak and, I think, VisualWorks Smalltalk. It uses continuations to make programming a web application basically the same as coding a desktop application. It features many, many things that PHP cannot do.

Java is cool for uber-OO projects. . .

Nah. Java is cool for run of the mill OO projects where everyone else is using Java too, because everyone else is using Java.

If you want to look at something interesting check out Apple's Squeak, an implimentation of Smalltalk-80 where even the VM is written in open source Smalltalk.

Squeak

KFG

Ahoy-

It seems Swiki.net seems to be floundering some lately. It's a place that hosts the wiki. I should find somewhere else to put it. :/ Thanks for the heads up on the Toshiba Dynapad thinkg. I think I've seen a reference to it, though I can't recall the specifics.

Dynapad runs anywhere that Squeak Smalltalk does. As far as PDAs, that means Windows CE (incl PocketPC) and Linux-based PDAs, as well as a number of desktop and server platforms, including Windows 9x/NT/2k/XP, Linux (via framebuffer, DirectFB, SDL, and X11), various Unixes via X11, Mac OS classic and X. Feel free to email me (reic0024 at d.umn.edu) if you've any other questions.

squeak!

I think that the paper degree would be relatively useless. You already have one of those... they show that you know how to apply yourself to a goal, and to learn. If you can learn what you need to through online sources, local user groups, etc., then a manager interviewing you would be stupid not to take someone smart and dedicated enough to be a doctor, and who knows what they want enough to teach themselves software in their free time. I can't keep myself from plugging squeak. It's got a fantastic knowedgeable and friendly community, and a great object-oriented programming environment. Good luck!

These guys have a cool desktop, if you can call it that.

Riccardo Giacconi was using a fairly ordinary CDE on Solaris desktop on a beautiful 24 inch wide-screen monitor the last time I saw it, with some very cool galaxy images from the Chandra Deep Field.

Steven Squyres probably also has an interesting desktop, and I think I saw it on ABC News last week, before they switched to talking about the problems with the rover.

You can see Asia Carrera's desktop in the background, but it's not safe from work. Looks mundane.

I wonder if Pheobe has a cool desktop. Not Alyssa Milano, but her character.

Speaking of fiction, I wonder whether David Kay uses Windows or Mac?

While I like innovators, I'm more interested in users. They at least try to do useful things. That was the problem with Alan Kay. He always has interesting desktops. He showed squeak at a conference a few years ago that just stunned people, but none of us could figure out what we would actually do with it.

The biggest reason you don't see these kind of books these days is because of the languages being used to teachcomputer science and even just plain programming. Even BASIC has evolved into something for grown ups, something people geting paid use to write apps- VisualBasic, REALBasic, and other similar tools.

Which isn't to say that old-school BASICs don't exist anymore, they do. They are plentiful and free. There is no reason that a kid today, or in 10 or 20 years from now couldn't pick up one of those books, start typing and have a good time learning. There are BASIC implementaitons natively for Mac OS, Windows or Linux that emulate classic BASICs like AppleSoft's or Microsoft's GWBASIC/BASICA. There is also the opton of emulating an Apple ][, Commodore, etc.

But perhaps you want something flashier, something more modern.

One system I'd reccomend is Squeak Smalltalk. Unfortunately, one of the things Squeak really lacks is documentation, especially in book-form. This has a lot to do with the way most folks learn Smalltalk (by doing, rather than reading) as well as aspects of the community and other factors. If you download Squeak (see here) and run it, there are a bunch of demos there to be played with, as well as some tutorials. They make for a great start for someone with a little (or even no) programming experience or formal computer science knowledge.

One of the neat features for Squeak (that you get when you download the version with all the libraries) is an implementation of Alice, which is a scriptable 3D environment for world-building and games. A lot of fun to move that bunny around, especially if you're a kid who likes to see a direct correlation between what you type and what goes on on the screen.

In addition to this, Squeak also comes with a scripting environment called eToys. It

For an example of how to use the Squeak eToys scripting system to make a more traditional application, see this Rolodex tutorial. or, for something a little more fun, check this out. introducing yourself to Squeak makes for a great starting point for experienced folks and newbies alike. Of course, there is also tutle graphics, which even I've used in more "grown up" applications, for modelling dynamic system.

Best yet- Squeak is totally Free. It is free down to its core, the system being open in a way that C, C++ and Java have no analogous structure. Smalltalk has been open since the beginning in almost every way you can think of. Even commercial implemtations, you still have the power to see pretty much all of the source, and changing if you so desire. In addition to being open source and free, Squeak Smalltalk runs on more than 20 platforms, including Linux, Mac OS X & Classic, Windows and pretty much every Unix one could imagine. Unlike what people sometimes experience with Java, it truly is write-once, run-everywhere, with your entire app being encapsulated in just two files- the virtual machine and the image. Even if your target platform doesn't have a VM installed already, it's just a matter having it zipped up in your installer or archive- just one extra file, often less than even a MB.

I meant to say a little, but that is a lot to chew in one mouthful!

And then run Squeak! Squeak's Morphic is a fantastic teaching environment!

Squeak Smalltalk

Morphic Tutorial

But rather than read about it, download and run it. It's fantastic!

Morphic is approachable to little kids, assuming that they're old enough to read a bit (or you sit with them to tell then what's what). And Smalltalk is deep and open enough that they can learn as much as they want. Want to understand how the event handler works? Walk through it in the (source level) debugger. Since the entire environment (including the Smalltalk virtual machine) is open source and written in Smalltalk, it's completely open to exploration and experimentation. Very liberating!

To get started, run Squeak, open one of the "worlds" and play around in it. Check out some screenshots.

Consider the Squeak environment. It's an open, highly-portable Smalltalk-80 implementation. It is really friendly place for kids to get started and smalltalk is a good language for kids to start with.

(As long as we're speculating, it should be possible to put a stripped-down Smalltalk kernel on the RCX.)

The teachers at my son's school are looking at it as a way to teach programming. At the same time, they have the students using Moose Crossing a kid-friendly MUD/MOO environment.

Try looking at what they have here: solarpc.

They even have a complete turn-key squeak system (it's at the bottom of the page): here.

I use Squeak instead of PP. By separating subtopics into projects, using large text, graphics and a touch of animation it make a great presentation tool.

OK, this post may be long. I've had a number of iterations of hardware, OS and apps over the years, but I'll give a couple of them to you with some comments.

1st Gen:
The first iteration of my paper-less setup was a Newton MP2100, keyboard, 8 MB flash card, and 3com ethernet card. I owned 3 other PDAs before this (Newton OMP, MP120/OS 1.3, and a VTech Helio running Linux), though none of them were this good. In most ways, this Newton was still the best PDA I've ever had. It was by far the best PDA I had for taking notes. Any PDA has notetaking software that let allow you to sketch the notes rather than only enter text. A decent PDA will have software that allows you to mix text and sketches in the same note. But only the Newton allowed you to write your notes in text or sketches in the same note, and allow some of those sketches to be searchable, just like the text stuff. Naturally, some sketched things aren't recognizable, but there were times where I wanted to enter something in text mode for one reason or another, but still be represented as text if need be.

There is also the convenience of being able to manipulate your text and drawings; the Newton takes input as Text (typed, recognized, Graffiti, etc), Ink Text (treated like text, but your handwriting is retained), Sketches (just drawings), and Shapes (vector graphics). It was normal to enter a graph in Shapes mode, and if I needed to make one axis longer or something, I could easily just pull it out, without warping the rest of the drawing. It's great not to have to use an eraser, but just to select and move, delete, modify your drawings and writings.

Built-in Newton OS Notes all > Built-in PocketPC Notes app > IQNotes for the Zaurus (Unfortunately the best notes app for the Zaurus)

And that's a logarithmic scale. No joke.

I did a little experiment when I first started taking my notes on the Newton- I made my class notes from General Biology I available online. All taken on my Newton.

The Newton was also the most powerful PDA in other ways unrelated to notes. It was a hackers dream- it was a fully object oriented system, and with a debugging/inspecting tool like ViewFrame, you could explore the entire system by taking a trip through Object Wonderland. :) For instance, I used a spreadsheet app called QuickFigure Works. Like any spreadsheet, it has functions; and like any spreadsheet, invarably there are functions I wished I had but didn't. On most platforms, you'd be stuck with defining it in the terms of existing spreadsheet functions, on a desktop system you would have a BASIC scripting language, though. On the Newton you had access to NewtonScript, something far more powerful and elegant. The original authors didn't intend me to do this, but with the power of NewtonScript at my disposal, I simply opened up a view on the QuickFigure Works app, had a look around and found the array of available spreadsheet functions. I then just added a new one, writing the body in NewtonScript. I could make a proper package out of it later if I wanted to, to make the addition permanent, or to share with others.

The beauty of that is that I could do that without having explicit support from the author of the app itself- it was just a feature of an extensively dynamic, consistent, introspective, reflective and just plain cool OO system.

2nd Gen:
Then I went to Windows CE. My girlfriend told me it wouldn't work, but I was determined- while the Newton was powerful (162 MHz StrongARM CPU in the days when the fastest PocketPC was still 206 MHz- and I could upgrade the Newton to 220 if I wanted) and very capable, I wanted to run Squeak Smalltalk, my programming weapon of choice. A port to the NewtonOS would be very hard for a number of reasons. It was tried, but never made it to fruition. So I wanted a WinCE machine, which could run Squeak.

I first bought an iPA

http://squeak.org/ Yes it's its own OS.

Sounds like Squeak, a version of SmallTalk.

I think we're heading to a world where all kernel-space code (on your favorite kernel) is C/C++, and all user-space code is, as you put it, managed code: VM, .NET, or others (e.g., a good open source Smalltalk VM. Hate to give Microsoft credit, but if they succeed in delivering the vision of Longhorn they recently articulated, then Microsoft may push the industry into this model.

Will this situation improve in PalmOS 6?

Yes, I'm somewhat aware of the pains of porting to PalmOS. I code in Squeak Smalltalk, and a lot of Squeak users would like to have it on their PDAs. While a port was done to WinCE, Linux for the PDA and even EPOC32 with relative ease, nothing has surfaced for the PalmOS.

I'm hoping a lot of these issues will be solved in POS 6 so that apps like Squeak- and MAME- can finally be ported. These inadequacies are also why I don't use a Palm device- I demand too much from my PDAs.

No, I haven't found any perfect device yet, although the Newton MP2100 is by far the device which has come closest. My second favorite PDA has been the Jornada 720 Handheld PC, though I would prefer a device that could be converted between "mini-laptop" and "palm" mode, like the Zaurus but with better software. I just got a Sigmarion III, and it's a sweet device. Although, it can't convert between the handheld pc

I never said the Zodiac is perfect. I don't own one, and certainly couldn't make that kind of claim. Things are bound to improve, compatability problems be taken care of, etc etc. Especially with POS6 things should be getting better.

I assume you have them all for testing and such, but if you ever have an old PalmOS device you don't need anymore, drop me a line... I'm looking for one for stealing UI ideas from. Not a copy or anything, but figuring out what would work and what wouldn't. We have an old PalmPro, but it rarely works.

Meh, it was just an example. I don't own a Zodiac or any Palm device at this point (except a barely-working Palm Pro). Lemmings may be a poor example for other reasons- you did a decent job at making it work well on a touch screen, unlike some games. Snood is a game that works better with a mouse or d-pad, IMHO.

I wouldn't be surprised if Lemmings worked on the new ARM-based b/w Zire, but it doesn't mean there aren't better PDAs out there.

BTW- thanks for all the work you did on the Helio. I bought one of those puppies when they first came out with the intention of running Linux. And did for a while using my own app written in Squeak, as none of the Linux GUIs for it were useful at all.

But, until I finished that, I used VTOS, along with some of your apps. Especially great was the GB emu for the Helio, although it was only worth playing a few games because the controls sucked- like they do on most PDAs.

Surely it must be recognized that you are just moving the complexity problem to a different layer with this approach, PLUS losing the ability to gain low level access when needed.

I don't know if that necessarily has to be the case. Back in the old 8 bit CP/M days I got my introduction to Forth through an application named KAMAS, which stood for Knowledge And Mind Amplification System. Lofty sounding name aside, KAMAS was really an outlining tool. A very good one at that. A few years later after the PC and DOS had taken over a whole slew of these outlining tool programs appeared and all claimed the ability to revolutionize the way you worked with information. For the most part, this was all bunk but in a way KAMAS almost stood up to its self-aggrandized promotion.

What made KAMAS different, IMHO, was that it was based on a FORTH like language that was at the core of the product and its author (Adam Trent) left that programmability exposed. Yet, he was able to organize the program in such a way that the average user didn't have to interact with the language at all or even know it was there if they didn't want to. Heck, you didn't even have to use it as an outliner -- if you wanted it could just act as a simple To Do list.

As the owners' manual stated, KAMAS was arranged in rings,like a Venn diagram, with the outliner at the outermost ring. However, if the user wanted they could issue a command that would expose the next inner layer ofr complexity and do simple programming tasks on their outlines. Because of its' Forth heritage, the programming was interactive and could easily be undone? Screw up a word definition? Just tell the interpreter to FORGET it.

For the true geek crowd, another word could be issued (only while inside the programming layer) that would then expose the inner-most layer and open up access to the all the words defined. At this point, the user/prorammer would have access to basically a full Forth programming environment and actually change or extend the outliner tool by rewriting it! At this point, if one wished to devote the time to learning how to program in a stack based threaded interpreted environment, your computer was wide open to you. It was like have the keys to the gates of heaven laid at your feet.

Later on, when I started playing around with Forth proper, I was still impressed with what KAMAS's author (whatever became of Adam Trent anyway?) had done and felt that this managing of complexity was the true power of Forth based systems. However, even I have to admit that Forth is far from ideal given its' RPN and stack based roots -- at least for Joe Everyuser. More time passed and I discovered Smalltalk and Alan Kay and his idedas for Dynabook and lately, Squeak.

Smalltalk, Squeak and OOP share with KAMAS the idea of bringing the power of the computer to leverage the mind to the everyday user. And, as with KAMAS and Forth too, they are able to prevent a useful, simplified environment at the surface, but still making the power and complexity available to those who want to use it.

So, in short, I think you're wrong here. One does not have to lose the ability to gain low level access in order to mask complexity from the average user. What I do question after all these years is how many users will actually want access to the power hidden at the core of systems such as Squeak and KAMAS before it? I mean, come on, I live in a country (US) where a sizeable portion of the population can't identify the Pacific ocean on a map! I think its likely that in the end we'll end up with just about the same mix of truly technical users to clueless lusers that we have now.

As depressing as that may be, and the thought does depress me, I still think it's important to implement Charles Simonyi's ideas (as well as Alan Kay's and Doug Englebart's and Steve Wozniak's and all the others who believe that the computer can serve as a tool to liberate people). If only for the sake of providing a migration path for people to make that crossing from clueless luser to someone who is able to effectively use the computer as a "Knowledge and Mind Amplification Tool."

The REX model my roomate had a touch screen and input capabilities. It was added at least added for the newest model, may have been there longer. I did a quick look at the FAQ at rex6000.org, and there are some questions about how typing on the onscreen kb gets slow after 38 characters. So I know I'm not imaginging it, although I used it a bunch playing around with it and such.

A while back, I hacked together a read only PDA software suite. See, I use my PDA as a computer, not just as a very overpriced day book. My PDA at the time was a Jornada 720, which was my primary computer. My girlfriend didn't like how whenever I had a minute of downtime anywhere I was, I'd whip out the J720 and start coding or reading an ebook... Just efficient time usage to me.

So, to get myself do not do that, but still have all of my information available, I wrote an app in Squeak Smalltalk that was naught more than a PIM data browser. While I could've entered text, the actual app had no input capabilities. The hardware platform was the V-tech Helio and the OS was Linux. As a matter of fact, the Helio was the first PDA you could buy that could run a real Linux kernel. So, I just had this puppy get a new textfile of all of the PIMish data on my other PDA via Xmodem from the desktop and have it all there without such a temptation to read or write code. :P

Sun is really missing the boat. The fact is that they have the best commercial version of UNIX in Solaris the most popular development language in Java and a thriving hardware platform in UltraSparc.

What the hell is the problem?...Perception!!. Through lousy PR, Advertising and Mismanagement Sun is imploding.

Suggest they do the following:

1) Solaris is the only OS they need, release workstation and server versions of Solaris for Sparc and Intel. Work more closely with third party vendors.

2) Rearchitect Java from the ground up and simplify. Java has more wrong with it then right but no one will admit this. As an OOP language, Smalltalk is far better. Sun could take a lesson or two from Squeak Stop trying to make Java all things to all people. It's a waste of time and effort.

3) I love their computers and think they could do more here. They need to realize that they can sell low-end versions of Ultrasparc to the average consumer if their prices are reasonable and they back it up with strong applications, technical support, and marketing. Yes, they can branch out of the server room and onto the desktop.

4) Get a decent Advertising and PR firm for christ's sake!.

5) Linux is not the enemy but another platform, that is all. Those that want to make it more than that are just as bad as the Java zealots.

It will also have all the speed of a glacier advancing upon the Alps. Yes, in a dozen years maybe Java will be fast enough. It's certainly not there yet. The Freenet Project use Java, and their client is so slow as to be unusable. It could have been just as easily made cross-platform in a real language. Heck, last I checked I believe Squeak has a faster VM than Java.

Yes, we don't write in assembler because 'puters are fast enough to write in C now. We shouldn't write in Java because they're not fast enough for that yet--esp. for numeric calculations such as encryption uses. Actually, we shouldn't write in Java because it sucks as a language. Now, the Lisp-family of languages are excellent, and buffer overflows do not AFAIK occur in them. Perhaps a Common Lisp or Scheme implementation would be good.

I know this didn't make it to the front page, but is there really this little interest in embedded Linux, or non-X11 GUI systems?

I for one can't say I've ever really been too excited about MicroWindows or this PIXIL system built on top of it. We've not seen any PDAs that use it, although the Royal Linux PDA was supposed to use PIXIL/MW, it never saw the light of day.

X11 is entrenched. There have been a number of free alternatives for a long time:PicoGUI, MicroWindows (w/ NanoX [X11 API emulation] or PIXIL apps), Qt/Embedded, DirectFB w/ GTK+, Squeak (and on top of it, Dynapad), W Window System, Berlin/Fresco Window System, MGR and others. Many of these have been around for 10 years or more.

Yet, what does almost everyone use on Linux or Unix? X. Relative to the X11 install base, there is a miniscule minority of folks using Qt/Embedded + Qtopia on their PDAs, but even so it still a crappy solution when you consider how poorly Qt/E is suited to PDAs.

About as many Zaurus users are using Squeak as a windowing system. Perhaps more using Squeak, not sure. They may not use it as a X11 replacement, but they're using it all the same.

PicoGUI is the bomb. Although, it sounds like it may be going dormant for a while. One of the most promising of non-X11 windowing systems out there, but still no one uses it.

When will we have a project like this that really goes somewhere? Anyone have any bets?

Ironic, then, that you wouldn't enclose a LINK to the Squeak page so that we can use our GUIs and our MICE to intuitively CLICK on a link to the inventor of these revolutionary interface devices, rather than retype the text URL like it's 1954 or something. Here it is.

Squeak is worth looking at. So much so, that I've enclosed a hyperlink to it in this post.

• Fully written in Smalltalk, extensions in C if needed
• The entire environment is object oriented, from arithmatic, to the windowing system, to high-level APIs
• Central object database for data storage
• End-user programmability with low temporal, resource, and emotional overhead- no additional hardware required
• Integrated scripting system which applies to all applications without investing a lot of time in explicit support (as is the case with PalmOS, WinCE and Linux PDAs)
• A really cool GUI toolkit well suited to writing flexible PDA applications; widgets and GUI objects are directly manipulatable
• Easy and simple data manipulation and inter-application data exchange facilities

Second, I wasn't a part per se of the "iPAQ initiative" at UMD. I was a sophmore the year they started required incoming freshment in the CS, IS&T and ECE programs to lease one. That went on for three years; they "initiative" was dismantled and dumped this summer.

However, being a pretty vocal opponent of the initiative and generally interested in (mis)use of technology in education and in PDAs in general, I talked to a lot of people, students and professors, about how they were being used, how effective they were, etc.

From my research, the iPAQs were used mostly for:

1. Scheduling, etc. I've not met a single person that got a PDA as a part of this program that actually took class notes on it. I did take my class notes on an iPAQ 3150 for a while though, before going back to my Newton. (and, again, I may be switching back to the Newton for notes- the C760 sucks for taking notes).

2. An app in embedded Visual Basic was written by a couple students hired by the CS department for use by students and their advisors to tell them what classes they had left to take to finish their major. Handy I imagine, but never got used all that much, and there have been web tools which do this for a while.

3. Aside this, the iPAQs didn't go very used. I know of no classes to which they added something that really made the iPAQs worth it.

4. A handful of students actually used their iPAQs, although mostly for games and web browsing sites like Slashdot during class.

5. I've not met one other person in real life who actually hacks on their PDA. I know a handful of people on IRC which do, and about a dozen who hack Smalltalk on their PDAs. Part of the problem is what language people use; doing real C/C++ on a PDA is pretty much impossible for now, unless you've got swap/tmp space on a 2 GB PCMCIA hard drive or via NFS. Languages like Squeak Smalltalk, Perl/Tk, or Pocket Scheme make good environments for PDA hacking, whereas C/C++ or Java are limited by their resource use.

6. In addition to students, a lot of faculty and staff got an iPAQ when this initiative started. I'm not sure if they had to pay for it themselves out of pocket, or if it came as a gift from the dept, encouragement to get them to use them in their classes. Anyway, besides two exceptions (but there are more I imagine), the iPAQs simply sit on a lot of staff and faculty desks now. I could name a dozen UMD employees who got an iPAQ with this program and just have it sitting on their computer, charging, but never used; or in a box, opened and played with but that's it. Really annoyed me for a while, especially before I had a bigger/better/faster PDA than the iPAQ 3650.

It may sound like I'm being overly negative, but I interviewed via email and face-to-face a lot

Apple's port of Smalltalk-80 actually does still exist and lives on as Squeak. Alan Kay and his team took Apple Smalltalk and essentially modified and rewrote bits of it until it was released in I believe 1995 or so to the public as Squeak. It is available under a relatively open license, and runs under a large range of platforms. I highly recommend it if you are looking for a high-quality, free, open-source Smalltalk implementation.

Wait till you try Smalltalk.

Go ahead, download Squeak and see for yourself.

Heck, I got my SL-5500 for $180.

And sold it a month later for $170. The SL-5500 is pretty much crap compared to almost any other PDA. I'd rather have a mono Newton or Psion screen than the pitiful excuse for a color screen that is found on the SL-5500. Let's pray to any and all gods that the screen on this MX-7 isn't as bad...

I now have a Zaurus C760- it's a great platform for running Squeak Smalltalk and Dynapad, especially with its 640x480 screen, but as a PDA, the entire Zaurus line is exteremely lacking.

Anyone know how fast this particular CPU is compared to a 206 MHz StrongARM? If it's any slower than the 206 MHz StrongARM SA-1100 (or the 400 MHz PXA250 XScale, which is about the same speed), it'll suck to run Qtopia and its apps on it. Qtopia is *slow*, especially on PDAs with the 400 MHz PXA250 XScale (SL-5600, SL-C700) or 206 MHz StrongARM (SL-5000D, SL-5500), but it's still kind of sad on the fast 400 MHz XScale PXA255 CPUs in the SL-C750 and SL-C760. You'd think you were using OS X 10.1 on a 400 MHz G3 sometimes...

Hey, read the article- CF (as well as bluetooth and a camera) will be an option. Yeah, more money spent, but at least there is the potential.

The Smalltalk philosophy and community is an interesting beast. Smalltalk has been about being open since before the copyleft, before the FSF or GNU- right about the time RMS was first being hired at the MIT AI lab.

Unlike most of the rest of the software world, Smalltalk is open to its core. I think of it as sort of psycholinguists for programming languages. Due to way Smalltalk works, the community grew into a culture of openness that C/C++ programmers don't know, even with licenses like the GPL.

You see, in a Smalltalk environment, the entire system is available to you, at your fingertips. It's all there, and it's all in Smalltalk. If I want to change the way the plus (+) operator works, I can. Since everything is an object in Smalltalk, and every operation a method, it's just a matter of having a look at the + method on the class Number. In Smalltalk, we notate that as Number>>#+. Which incidentally is also legitamate code- it returns a CompiledMethod object, which contains the compiled bytecode for that method. Or, if I wanted to change the way the Smalltalk system managed windows, I could just pop into the Window class. Nothing is hidden, nothing is kept from you, the developer/user- even on "proprietary" and commercial Smalltalks like VisualAge for Smalltalk and VisualWorks. The ability to change the way anything works, getting the source code for everything is something you don't get with most industrial-strength commercial systems. Definately cool, IMHO.

One exception is the virtual machine, which is often written in C and makes up a pretty small percentage of the Smalltalk system. Java tends to have a lot of what we think of as the "java system" in the VM or a VM extension, but most Smalltalk VMs are small.

Squeak takes this to the next level- Squeak's VM is written in Smalltalk, and then translated to C, and them compiled by gcc, etc. You can make modifications to the way you want your virtual machine to work, and the Squeak system manages the translation to C and compiling it to something your computer can understand.

While I'm very happy to see Slashdot giving my favorite language a little publicity, I can't see what is new about this.

I thought perhaps this was something new from IBM- a new package or a new license for a non-commercial version of VAST. Perhaps that is there long term intent, but I just downloaded and installed it, and lo and behold the start-up splash screen informs me that this is an evaluation version. IBM has had evaluation versions available for download from their site (or a CD from IBM, free) for a long time. Looks like the same license and the same stuff.

That said, I hope it doesn't discourage anyone frmo trying it out- or possible trying out a free Smalltalk like Squeak. :)

As others have mentioned, check out Squeak Smalltalk. Squeak doesn't have the same goals as a product like VAST or VisualWorks, but it is a free Smalltalk with a very active user community, and is open source- it's Free, of course. :) It's been available since 1996, and is always moving forward. Check it out!

• Squeak
  
• GNU Smalltalk for one.
  
• VisualWorks
  
• Smalltalk/X
  

There are two major open source implementations of Smalltalk commonly available today: GNU/Smalltalk and Squeak. GNU/Smalltalk is more server-oriented, and does not support Smalltalk's traditional MVC GUI, espousing a new system based off Tk. It is fairly fast, and somewhat lighter weight than Squeak, making it a better choice for headless applications like application servers. Squeak is, at the moment, mind-blowingly huge, but it provides both the venerable MVC GUI and Morphic, which is derived from Sun Microsystems' Self programming language. It also has been ported to many non-Unix platforms, like Win32, WinCe, MacOS 9, etc.

I too need to write GUI apps that just work on a number of platforms- Mac OS X, Mac OS Classic, Windows, Linux, IRIX and Solaris, and have it work with a simple ./configure; make.

Luckily, I don't have to use Xlib, although the display system for X11 probably uses Xlib. I use Squeak Smalltalk, and can distribute my application with the virtual machine for the specific platform, or as Unix source for somebody to compile if they're on a more obscure platform. This can be easily included with my tarball- no need to download stuff seperately. It is also a small addition to my own code, so it's not like you're adding a big download or hassle.

GTK+, Qt and the desktop libraries that accompany them, on the otherhand, *are* a big hassle. Most Linux systems have a version (or two!) of one or both of those libraries, but often enough when deploying, you still have to have them install the version you wrote your app against- and you better believe it's not quick and easy!