Slashdot Mirror

The e-toys are great fun for school age children. Squeak for the cognoscenti, and Squeakland for Mum, Dad, and the Kids. Heaps of fun. Good books available from Amazon too.

The Cappuccino doesn't have a battery either, does it? I was under the impression that their MiniPC wasn't for mobility so much as portability- taking it places, or having a problem where a very small computer is a good idea, but not the kind of computer that could sit in your pack or your pocket.

Regarding computing environment, another link I forgot to mention is the PDA operating system/environment I'm working on called Dynapad. It is what I currently run on my Jornada 720 and will run on my OQO when I get one. Even now, on my iBook, I do most of what I do on my computer within the Squeak Smalltalk programming environment. The only thing I use Mac OS 9/X for is to browse the web. Squeak includes a pretty simple web browser, but it is insufficient for a lot of web sites. For some web browsing, I simply use Links from within a vt100 terminal app that is native on Squeak. I've written some code on the Squeak side of things to allow me to open Opera windows from within Squeak to automate it, but I imagine that this may be a bit harder on WinXP than it is currently with AppleScript on OS 9/X, but perhaps Windows Scripting Host would be a good replacement.

In all honesty, the only reason I *may* use WinXP on my OQO is for ParaGraph's CalliGrapher HWR software. As I said, Linux doesn't have any real HWR, so for me, it's pretty useless as a PDA or other pen-based platform. Which is why I have a Jornada 720 running WinCE instead of a Zaurus running Qtopia.

At this point, Dynapad wouldn't do quite everything that PocketPC does, but in the coming months and years it will. In about a 6 MB footprint, Dynapad includes:

* PIM applications: Notes, Todo, Names (Contacts), and Dates (Calendar)
* Net apps: Simple web browser, IRC client, email client; and coming soon, a LiveJournal client as well as an app with very similar functionality to Watson/Sherlock 3
* A full Smalltalk development environment using the Morphic GUI toolkit; with the ability to create entirely new apps on the device itself, or modify existing apps to better work with the user's expectations
* An OODB as the "blessed" means of data storage- makes sycing with desktop machines or other Dynapad devices as well as sharing the data via the internet very easy
* Character recognition, rather like Graffiti,but without a dedicated space- write anywhere in a text box
* A GUI builder for rapid application development
* An advanced, extensible, dynamic, reflective architecture that allows end-user programming and scripting

Small, portable, virtual-machine based, simple enough for kids to get started (and excited on) it's powerful enough for 'real stuff'. Check out the FAQ based on a Squeak Swiki.

Oh, and as Logo had Seymor Papert as 'the guy' behind it Squeak had Alan Kay who did lots of early work on 3D graphics, ARPAnet, windowing interfaces, modern oo programming, and inventor of the Dynabook.

StarSqueak has been in the Squeak Smalltalk System's base image for a couple of years. The interface was modelled on StarLogo, and has some mighty impressive demos in the distribution. (Squeak is free to use, and very cross-platform.)

For a fairly wide range of usertypes, the Newton had the potential to be a desktop replacement. This excludes the kind of people who don't think that a laptop is a satisfactory desktop replacement, namely, 3D gamers. I'm not into that. The only reason I sold my Newton, and the only thing I couldn't do on it that I can on my desktop (er, well, it's an iBook) is program in Squeak. However, I can do this on my Jornada 720, at the expense of everything else working as nicely as it did on the Newton. With the proper knowledge of C and graphics work, I could've had Squeak running on the Newton, but even for that noble cause, having to deal with C for a big project didn't interest me.

Unlike the Palm and for the most part, PocketPC, the Newton didn't need to be teathered to the desktop to be useful. I never sync'd with a desktop, and never needed it to get data or applications. I was able to use a browser and FTP client via ethernet for those sorts of things, just like I would on the desktop. Apple's intent wasn't to completely replace the Mac- true, but it does a pretty good job at it. Most of the missing pieces that are in the work habits of other users could easily, in most cases I'd surmise, be solved by having an application or analog of one that just didn't exist on the Newton.

Again, this excludes hardcore 3D gamers- there is an OpenGL subset available on the Newton- but a 162 MHz StrongARM wouldn't cut it for Quake 3. :P

The screen is indeed big enough. By "big" I am talking physical dimensions, screensize. I could see why some people would like a larger resolution, but I did fine with 480x320.

For those things, I never wished I had a much larger screen. My girlfriend has a webpad with a 10" 1024x768 screen, and it's much too large to be comfortable for me.

I was a Newton user for a while, but I don't think it's fair to just dismiss stories of well it worked as just reality-distortion-tunneling of "Newton die-hards." My handwriting was (and still is) a big mess, and with the Newton, I was able to get 40-45+ WPM and around 99.4% accuracy. Sorry, but the days of Eat up Martha are long ago, and the Newton 2100 is not the Newton of 1993. Newton HWR *learns* as you correct it, so it works fine even with messy handwriting like mine.

The Newton has the size of screen of a legal-pad- obviously, people manage to use the paper version of those, do they not?

I've been using pie menus on Squeak and they're pretty useful. In case anyone is interested, Squeak is a free and open OS and programming environment written in a version of SmallTalk-80.

The simple truth of the matter is that there is plenty of room for closed source solutions without impacting open source at all. Games, Kiosks, and software solutions for major industries are all perfect examples of closed source that no one really minds. For example, the software that allows Visa to authorize and settle transactions probably will remain closed source for the course of my lifetime because there's no real reason to open it.

However, I don't need to be paid for all of the software I create, anymore than I need to be paid for every web page, every peice of advice, and every photo I take. many of them I can give away for free at no loss to myself.

And this is where I actually get wealthy. These contributions come back because I no longer just have access to my little bit, but I have access to everyone else's contributions as well.

When it's over I have a large photo collection, an operating system, a graphics editor, a coding enviroment, and a plethora of other tools.

As Bucky Fuller long alo realized, by giving away the right things to the right people, I can make myself wealthy.

Life is not a zero sum game.

None of these are X11 alternatives on the level of SVGALIB or DirectFB, but a bit higher level. They require a low-level display medium like DirectFB, SDL, or X11 (but you can ignore that option for now).

Squeak Smalltalk: A cool Smalltalk environment. Based on Smalltalk-80, for which first modern WIMP was invented. Has a bunch of little apps, simple web browser, vt100 client, few email clients, web servers, a couple different GUI toolkits and programming paradigms to choose from. Personally, what I use mostly as my OS. I like having my entire environment available to me, to be changed as I like, in a very straightforward way. Rather like Emacs users, I suppose. Except Squeak is more customizable, and has full windowing system. Also can run as the OS, no Linux or X11. DirectFB, SDL, X11, Mac (9/X), Windows, Acorn, WinCE, BeOS and lots of other ports that all run the same binaries.

ETH Oberon: Implementation of the Oberon language - derived from Pascal and Modula, by Nick Wirth. Has it's own entire GUI system, like Squeak does. Can run as an OS, without Linux or X11. Also has a VNC client, so you could still run the X11 app or two that you still needed in a window. :)

PicoGUI: A really cool GUI system especially for PDAs and other embedded applications. Super fast. Bindings for C, Perl, and Python (I think). Linux FB and SDL ports, runs wherever they can. Not much in the way of apps thus far, but it's definitely alive and under pretty active development.

QT/Embedded: You know, like runs on the Zaurus.

GTK+ on Direct FB: Can't say I've used this, but I imagine bindings for regular GTK+ work in this port, which makes for a lot of development options.

MicroWindows/Nano-X: Yet enother embedded GUI option. It's developer seems to be pushing for PDA, set-tops and such. Not many apps, but could be useful especially for custom apps.

Are there any worthwhile just-Java windowing systems out there? There are al ot of Java-OS projects, but none of them seem to have gotten past linking Kaffee with OSKit...

Probably others out there, but this is a good look at some options.

That's not such a big drawback: XFree86 and Squeak both have handwriting software availble for them. For XFree86, you can even get OpenOffice. Why would you want to pay for XP software and struggle with MS Office instead?

Take a look at Jazz. It has a 2D scenegraph and support for animation and zooming.

Also, you might look at Squeak and Morphic.

Ming is not an alternative to the Flash player - it's simply a library of functions with which you can build a Flash movie, typically from PHP. It still requires the Macromedia player to play it.

There was an open source Flash Player that worked on most movies up to version 3, but that project appears to have been discontinued since Macromedia released a Linux player.

There is also a Flash 3-level player built into Squeak.

Windows wasn't a misuse of Apple's GUI. It was a ripoff of it. "Misuse" implies that MS licensed it, and abused or overstepped their bounds for that license. But that isn't the case.

Apple didn't invent the GUI. Nor was it demonstrated by "some prof." The first GUI was created by Ivan Sutherland in 1963 while he was working on his PhD at MIT. By GUI, I'm talking about the first program with an interactive graphics display.

However, systems like Mac OS and the Windows GUI shell isn't just a GUI. What MS stole from Apple was the WIMP (windows, icons, menus and pointer), which is more than a babystep up for any sort of interactive graphics display.

The WIMP was first invented at XEROX Parc, as an internal research project as part of the development of the Smalltalk programming language. You can see a screenshot of a modern version of Smalltalk's similar environment here. The original looked pretty similar, but it had a BeOS-like tabbed window decoration, and was only in black and white. Incidentally, as a part of the Smalltalk project, OOP (the term, and the way we know it today- Simula had something similar a few years before). This was during the 70s, with the first commercially available WIMP system, Smalltalk-80 in 1980.

Apple didn't steal the WIMP, per se. They aquired engineers that worked on it from Xerox. Xerox didn't see it as commercially viable. It is a common misconception, that Apple stole it from Xerox, while Jobs snuck in covertly.

With them, Apple brought the first generally available commercial computer using a WIMP interface, the Lisa. Couple years later, MS had released Windows 1.0, a pretty substandard copy of Apple's aquired ideas, and what little they knew of Xerox's work.

Interesting, the last time I had looked at Alice it was still at Virginia Tech.

There is a free (as in speech) version of Alice in Squeak Smalltalk which runs not only in Linux, but also Windows, Macs, PDAs and so on.

The above site seems to be having some problems, so check SqueakLand instead.

I'm not sure it is so simple. I belive many cs people at ga tech are pretty strong on collaboration -- or at least that is how I interpret their widespread use of swiki and their very active participation in open source squeak . I wonder if there is more to this story because some of the squeakers are hyperactive open source people.

Squeak can do most of things, plus 3-d graphics, and speech synthesis. www.squeak.org You should seriously take a look at it. Flash is nice, since version 5.0, it's a fully object-oriented programming language, but it can not even compare to Squeak. Macromedia has some smart people, but I don't think they can compare to Alan Kay. Alan Kay is one of the main developer behind Squeak, he is one of the inventors of the Smalltalk programming language and one of the fathers of the idea of Object Oriented Programming. He is the conceiver of the laptop computer and the architect of the modern windowing GUI.

http://www.squeak.org/"

From their web site: "With the Squeak programming system, we have made some delightful and powerful educational applets. If you are a student, parent, or teacher, please jump over to www.squeakland.org, and download some great educational projects."

Stephan

considered squeak?

Check out Squeak, the free, portable Smalltalk machine. Like all Smalltalks, Squeak runs in an "image". The image is your entire language, programming environment, and execution environment, all at once.

The interpreter, programming tools, and even the GUI all exist as long-lived objects in this large (sometimes very, VERY large) memory space. When you aren't using Squeak, the image gets stored as a file on disk.

There are also projects to run Squeak on bare metal--no intermediate operating system like Windows or Linux. Squeak itself becomes the operating system.

This memory technology would be ideal for a Squeak machine. The image would always live in NVRAM. In such a case, there isn't a distinction between the operating system as it exists in static form (files on disk) and executing form (code in memory). There are always just objects in memory. Very elegant.

Smalltalk Squeak offers the ability for rapid prototyping and it is quite fast (more than java in my own opinon).
A commercial solution is Visual Works or Dolphin.
Try Squeak

I'm mentioning squeak because I don't see it in the list yet, not because I think it's the panacea you're looking for. But it's pleasant, smalltalk-ish, and (tautology alert) its adherents like it.

Actually, if you want to play with a persistent programming environment, download a Smalltalk environment. Smalltalk environments are able to serialize themselves to image files. When subsequently re-serialized, the state of all the objects in the system at the time of serialization is restored.

from finding perfect numbers to solving basic algebraic equations--just for fun. However, I only have experience with Java, and BigInteger and BigDecimal suck pretty hard

from finding perfect numbers to solving basic algebraic equations--just for fun. However, I only have experience with Java, and BigInteger and BigDecimal suck pretty hard

I know it's been mentioned here before, but I thought I'd jump in...

The Sharp Zaurus runs "Squeak", it's an open source programming language, it is a genuine, complete, compact, efficient Smalltalk-80 environment, you can read their licence here.

Check the
ZauChu homepage for more information on programming for the Zaurus.

Ah, another Mickey Mouse website about to be slashdotted. ;)

Seriously, Squeak is an interesting implementation of Smalltalk-80, reported to be faithful to the original language, though the GUI seemed to be rather outdated last time I tried it on a pentium box--it doesn't seem to do asynchronous screen updates. It's supported by a team at Disney (no kidding!) including famous Smalltalk guru Alan Kay.

The IDE for Pocketsmalltalk, for Palmos is being ported to use Squeak instead of the commercial Dolphin implementation. Squeak itself doesn't run on palmos, however (as far as I know).

this is a site detailing the installation of Squeak on the Zaurus. Squeak is a descendant of Smalltalk-80.

You can find the Squeak Zaurus port and the Squeak IPaq port on http://minnow.cc.gatech.edu/squeak/458

You can find general information about Squeak (a dialect of SmallTalk-80) at http://www.squeak.org

Enjoy!

Stephan

Apple's user interface improved on Smalltalk-80 by making it easier to learn (more user interface functions are represented by explicit graphical elements) and with its graphical design. But I have a hard time coming up with any area in which Apple improved on Smalltalk-80 in terms of functionality or usability for experienced users. Even today, I find the Smalltalk-80 interface better than what you get on the Macintosh. Furthermore, Smalltalk-80 came with a development and debugging environment that puts even the best C++ and Java environments available today to shame.

Like many other people who have been in the computer industry for more than two decades, we can't help but shake the feeling that innovation in software has basically stopped since the 1980's; most of the change that we have experienced has been to make things "bigger" and "faster", but very little seems to have gotten "better".

To all the people who are working on software like Gnome, Java, KDE, etc., my message is: do your homework first. Find and use some of the old user interfaces. There is way too much reinventing the wheel, mostly very poorly.

"Serialization" means you take your object and turn it into a stream of bytes of some sort. Some more introspective languages, like Python, Smalltalk, and Java allow very easy serialization, but in something like C you spend a lot of time figuring out how to do it. Even if it is indirect, most files somehow represent an object that was in memory and can be put back into memory at a later time.

"Orthogonal" means that something is seperate from something else -- or more specifically, that while two aspects of a thing are related, you can work with one without effecting the other. Kind of -- it's a subtle (though very useful) notion.

"Orthogonal Peristence" means that all objects persist indefinitely with no effort from the programmer. "Orthogonal" refers to the fact that the persistence happens without any relation to other aspects of the program -- everything just persists by default. While it may involve serialization, this is hidden from the programmer, as is any other technique that supplies the persistance.

In such a system there wouldn't be any distinction between objects in RAM or on a disk -- often that is then expanded to objects that are also remote (similar to CORBA, but again, the network access is orthogonal and invisible). Anyway, the system moves things to disk as it needs to, and pulls them off as needed.

I brought up the cleanliness issue before, but the other issue is scaling. Particularly something like garbage collection is a bit difficult, because you can't just do a mark-and-sweep every so often, because anything on the entire disk could contain a reference.

EROS has this, Smalltalks have generally had this (you might wish to look at Squeak), and the old Lisp machines also tended to have orthogonal persistence.

The other option is a database with dynamic tables, that would somehow fit the data. I don't know how you are going to manage that, though... can any application make tables that make sense for its problem space? How are those tables partitioned off so that you have some degree of safety, that one application doesn't step on another? How are they then integrated, so information from one application can be used in another?

A non-relational database might make more sense, I believe they are often called Object Databases (not to be confused with an OO RDBMS). That's really just a way of saying "orthogonal persistence", except maybe that they aren't completely orthogonal (they require some extra programming to use).

The problem with orthogonal persistence, that I see, is all the junk that can collect. Having used Squeak, which offers a certain sort of persistence in its images, transient objects can pile up fairly easily and lead to a sort of faux-memory-leak in the system. It's a convenient system, but not stable.

Serialization provides a certain discipline -- it's like you have a checkpoint in the application when everything gets consolodated into something well-defined and granular.

Now, you don't have to serialize to apply this sort of discipline. But orthogonal persistence just makes it so damn easy to be undisciplined. I feel like there's some major work to be done to find a way to manage such a large collection of interrelated objects with indefinite lifespans.

for a free smalltalk implementation, check out Squeak. But if they know C, throw Java at them. Free tools that work on most any platform, plenty of good books (c.f. Thinking in Java by Bruce Eckel, which you can read online in a variety of formats (scroll down some on that page)), and not a huge syntactic leap to get in the way of the OO concepts, yet enough of one that they can't just code "C in C++". I've always been fascinated by Obj-C but I've had little luck finding good intro material.

HTH :-)

Found it. Squeak has a documentation page which has a bunch of resources (tutorials, papers, etc.) on it.

Thanks for the tip.

Found it. Squeak has a documentation page which has a bunch of resources (tutorials, papers, etc.) on it.

Thanks for the tip.

The ultimate would be a VM written in the same bytecode that it interprets.

If you've really only been programming in Lisp for a week or so then you really haven't had time enough to appreciate what its strengths and weaknesses are. It sounds to me as though you have acquired a disease that is all too common amongst programmers - the desire to want to specialise in one language too early on.

I simply cannot emphasise enough how valuable it is to learn as many programming languages as possible. Even if you don't really like it at first, a language can grow on you in ways you would have never imagined. No language is perfect, so knowing a selection of different languages will give you the opportunity to choose a tool that is appropriate to the job in hand. If the only tool you have is a hammer, then every problem you come across starts to look like a nail.

By keeping your horizons broad, most especially by learning languages that might seem strange, counter-intuitive or even downright annoying at first, I can assure you othat you will become a much, much better programmer in the long run. The ways in which languages differ can often give you an insight into the ways that different programmers might solve the same problem.

FWIW, the presence of closures and eval are not the only things that make Lisp distinctive from other languages. The one truly unique (not to mention incredibly powerful) feature of Lisp is macros. You will not be able to find these in Perl. Also, in Perl the standard way to solve problems is with an iterative, procedural style, where Lisp more often employs recursion and an applicative programming style, both of which are techniques well worth the effort to learn about.

Whether Lisp is better than Perl for AI is debatable. I'd argue in favour of Lisp for the following reasons: one is the fact that Lisp is extremely good at knowledge representation (and the subsequent manipulation of that knowledge), but more important is Lisp's ability to generate code with macros, effectively meaning that you can write programs to write other programs. It's also probably worth noting that Lisp is quite a lot faster than Perl, given a decent enough compiler. See The Programming Language Shootout if you don't believe me. Lisp is also a very mature language, with an ANSI standard, so unlike Perl you can be certain that it won't be pulling any carpets out from underneath your feet any time soon.

If I haven't done a enough good job of convincing you that learning Lisp is worthwhile (and I probably haven't) then try checking out Paul Graham's Beating the Averages. Also, be sure to check out Richard Gabriel's Good News, Bad News and How to Win Big. And have a read of Paradigms of Artificial Intelligence Programming by Peter Norvig for some more specific examples of Lisp as an AI programming language. Particularly relevant might be the section in the preface entitled Why Lisp?.

And when you're done with Lisp, I'd recommend a look at Ocaml, SML, Ruby and Smalltalk (particularly the delightful Squeak)!

This is true in general. It is rare to see a project open source or proprietary that is really innovative and different. That's because it's easy to copy existing ideas than to think up and implement new ones.

But remember that the Web (http, server, browser) were started as open source projects and today Apache is still one of the best web servers there is.

If you look around there are number really cool open source projects that are way ahead of anything the propriatary world is doing. Here are two I like:

Jazz - a Zooming user interface, as discussed in Jef Raskin's book The Humane Interface.

Squeak - a ground up implementation of Smalltalk-80 which is being used in all kinds of explorations. One of the leaders of this project is Alan Kay (you've heard of him, haven't you?).

Innovation can come from unexpected places. If more people get to play with the code, then it's more likely that someone will think of something really cool...

...richie

Looking for a fast, portable, free-as-in-speech, object-oriented language? Try Squeak, a wonderful smalltalk implementation. It's great. I've been playing with it quite a bit myself, and have been very pleased with it.

Squeak is probably the most comprehensive internet-aware Object Oriented development system currently freely available.

The best part is, it uses Smalltalk - the best OO language ever designed.

Yes, this is true. Perhaps I should have said "it's a waste". You need a far more powerful computer today to do the same damned things you did with a computer 20 years ago! Why? It makes no sense.

I think Microsoft is trying to have its cake and eat it too: it's trying to create a powerful extensible architecture while still keeping the end user (commonly abstracted as "Joe User", "Joe Six-Pack" or "my grandma") in his little sandbox.

On the one hand you have power, and on the other you have a drool-proof interface. You can't really have both at the same time. If you want to take advantage of the power, you're going to have to steepen the learning curve a bit. If you want a drool-proof interface, you may as well use a typewriter instead.

Which is not to say that the software needs to be abstruse and inaccessible except by a cabal of experts. I'm saying that the "sit down and start working" modality is an unattainable goal with most sophisticated application software. (No, Office doesn't achieve it either. As someone who's had to train and retrain his mother and sister in Microsoft Word, I know what I'm talking about.) What should be done instead of focusing single-mindedly on asymptotically approaching this holy grail of ease of use is to make the learning process as painless as possible. It may even be fun.

This is where projects like Squeak come into play. Squeak is basically a laboratory for new ideas in application design. I think that it will eventually lead to some commercial-grade applications for various operating systems that offer all users a degree of flexibility and control that wasn't thought possible in the Microsoft/Apple paradigm.

Oh, and Squeak is hella fun to play with, even if you're not a programming superstar. :)

To play devil's advocate..

The only development environment that ever arguably equalled NeXTSTEP for productivity was Smalltalk.

So, what would your opinion of the squeak project be?

There is zero evidence to back up the notion that a Lisp (e.g. CLOS) app would be less maintainable. Of course, there's not a lot of evidence either way, but there's at least a little evidence that it might be more maintainable:

http://www.spr.com/library/0langtbl.htm

This table shows that CLOS requires fewer lines of code (LOC) per function point than Java, in other words a typical CLOS app will require fewer LOC than an equivalent Java app. This data roughly jibes with the LOC results from the NASA/JPL study. This makes CLOS a "higher-level" language than Java.

Anyway, apps written in higher-level languages are easier to maintain than apps written in lower-level languages, simply because there is less code to worry about. Less code to do the same task also usually means that there is less code duplication, which is a common source of bugs. Thus, we would expect that a CLOS app, on average, would probably be easier to maintain than a Java app. (Yes, there are other factors in what makes a language more or less maintainable, but high-levelness is one of the few that is actually measurable.)

Granted, the SPR languages table is rather coarse-grained... apparently a lot of the levels for languages were extrapolated from other languages based on language features. (e.g. I think Java probably deserves a slightly higher language-level rating than C++, but then again Java lacks some things like genericity which might partly offset its LOC gains from automatic memory management/etc versus C++. Same goes for Scheme deserving a higher level.) But still, the table seems to be roughly accurate from my experience with programming various languages, and it's the best data we've got. It would be great if better and more detailed studies could be done comparing languages for developing (and maintaining!) larger, real-world apps, but this type of research is difficult and expensive, so it never seems to get done. :-(

Regarding complaints about the NASA study again... same goes for tiny apps versus huge apps. The jury is still out on whether statically-typed (Java/C++/Fortran) or dynamically-typed (Lisp/Smalltalk/Python/Ruby) languages scale better to huge apps. My personal feeling is that dynamically-typed languages scale better, but I don't think there's any real data proving either case. (Something like CLOS in particular with its powerful meta-programming capabilities I think would start to seriously crush Java in terms of maintainability for enormous apps.)

(By the way, I'm mostly a big Smalltalk fan, but I have a lot of respect for Lisp and its variants. I do work with Java too, but I don't find it particularly inspiring. ;-) See http://squeak.org for a cool, free, open-source (including the VM!) Smalltalk that runs on most any platform.)

As for a prediction of where Java will be in 30 years... my guess is it'll probably be around quite awhile, having a life-cycle similar to COBOL. Java and COBOL are similar in a lot of ways... neither language is revolutionary in terms of fundamental language features (as opposed to Lisp or Smalltalk), but both had good support for development of business-related apps, and gained a lot of momentum as a "standard"...

Its been around in one form or another since the 1970s. I'm talking about the best language ever invented, which includes a kernel mostly written in itself, and which can run as your OS on an 86platform: Smalltalk.

Free implementation can be downloaded from squeak.org

And what will Disney do with all three of them?

PDA's powered by squeak perhaps? (Squeak is an independent project under the aegis of Disney's IT department ... I don't think even they know why)

It is an ultra cool geek language. You can program and see results immediately. The syntax is ultra-clean. It's WORA. And the whole system is under an extremely liberal license.

Python is missing:

Native HTTPS support.

Good widget set (small, portable, and simple - preferably built in too).

Native compiler (bytecode is great...but for some things it's too slow. Gimme a binary).

Powerful graphics primitives.

Easier stack manipulation (hacked pushing and popping isn't a real stack, guys)

Some of these shortcomings are present in other languages, like REBOL and Java, and of course the incredible Squeak (add your own primitives and customize the entire VM in a subset of the language itself)!

But overall, Python is still my favourite language, and I know a few (Squeak/Smalltalk, C, tons of Basic variants, Java, Shell, and a bit of Perl)....but it WOULD be nice if the Python team addressed the concerns above.

There is already open source competition for .NET, and it's darn fine competition at that. It's called Squeak and it has a lot of neat features that .NET won't be able to emulate very easily.

.NET looks messy and slow comparitively (Yes, I have been following the pre-release notes and technical notices regarding .NET, so I do know a lot about it).

Computer Science is not about the language being used. Computer Science is about the problems being solved. Yes, sometimes solving the problem involves writing a new language. As much as I dislike Java and C++ as languages, they can still be used to teach basic CS concepts without incident.

Computer Science is not about being as close to the machine as possible. That's largely branched off into Electrical and Computer Engineering. You can learn about the theoretic basis of CS using assembly, but it won't really get you anything over other languages other than a headache and a better understanding of ECE. It's still CS, but not magically "more" CS because you're working closer to machine level.

I learned the basics of Computer Science (not just "programming") in college using C and C++. I really don't like to actually have to use C, even though I think it's a nice language theoretically. I abhor C++. Java is annoying as hell, but I'd much rather do app-level coding in it any day over C++.

You can learn linked lists, hash tables, recursion, and everything else is almost any language. It makes a lot more sense and can be easier to teach CS concepts in some languages, but you can do OO, procedural or functional programming in most any language, it just may be a lot more work.

I haven't had a lot of experience with it, but SmallTalk is a great language for learning object-oriented principles, because it is purely object oriented; everything in the language is an object, from integers to windows to text and all methods act on an object. In that respect, it's a bit closer to "human thinking" than most programming languages.

I did not study SmallTalk until my Programming Languages Concepts in my junior year here at Penn State, but I wish I had studied it earlier. My initial reaction to the language was it would make a perfect "introduction to programming" language, particulary object-oriented programming. Squeak is a great implementation of SmallTalk, very intuative design and easy to examine classes, objects, and methods.

I agree with the notion of Smalltalk, but if the original poster is hesitant to spend $1000 or so for Delphi/Kylix (judging from the article, price does seem to be an issue), don't you think he might faint at the price for VA or VW? :-) Squeak might be an acceptable alternative, although I don't know how well it really supports typical RAD type applications. I don't know of any other inexpensive cross-platform Smalltalks, though.

(As an aside, if the original poster is ever interested in a different Windows-only tool, he might check out Dolphin Smalltalk. Once you get used to just about anything except VB, though, it's incredible how much it will annoy you if you're ever forced to use it again. :-)

Don't forget Squeak which is open-source Smalltalk. A steeper learning curve than VAST or VW, but in a lot of ways much more interesting.

Another tool along that line would be Squeak Smalltalk. Yeah, it's a bit, uhm, eccentric, but it has some cool animation stuff that works out of the box (comes with a demo Energizer bunny that you can do fun Ren & Stimpy things with) and takes little contextual knowledge of Smalltalk or computing in general. And Smalltalk was designed for kids to learn with few syntactic oddities and layers of rules to learn.