Slashdot Mirror

actually a tad bit before darwin. Squeak is from Apple and has an very liberal license (well, except for the fonts - but they weren't Apple's).

No. Disney non-supporting Open Source, as it has always been.

No. Disney non-supporting Open Source, as it has always been.

Oh yeah.

I dislike the company, but there are some really cool, nifty, interesting things, technologically, that disney does.

One of my favourite examples - The core development team of Squeak smalltalk is resident at Disney. Smalltalk hackers are a cool bunch. And yes, Squeak is open source.

Anyway, I'm sure there are many cool nerds at Disney.

-Laxitive

Anyway, check it out, maybe that's the beginning of something you dream of. Be sure to get a copy of Squeak to experiment too, it's a whole lot of fun (despite what some C/C++ people might say)

If you don't care too much for native GUI widgets, you can check out Squeak. It's very easy and very fun to build GUI's with Morphic and it's very well integrated

I recently started messing with Squeak and I think that it is the kind of thing programming language should try to mimic: an easy to use, very dynamic environment. Let's take computing to a new level, leave the 90s behind please.

I gave up on a SL-5500 as well. Granted, unlike most Zaurus users who actually like their Zs, I was (un)fortuante enough to have used good PDAs before I got the Z- A Newton 2100, Jornada 720, and an iPAQ 3150. Even though WinCE is worse than PalmOS in a lot of PIM-ish areas, it resembles a "real OS" far more than PalmOS does. It's the little things that make it better for power users- multitasking, being able to allocate more than 64K of RAM in a chunk... :)

Disclaimer: Contrary to the tone of the rest of this post, I feel the need to clarify, less the less intelligent and more 1337 members of our communtiy get confused.

I am not a fan of WinCE. I've used it because it was the only real option for me for the time being. I do not use Windows on the desktop. Or the server. I use Mac OS X and Linux. But I am not shamed to admit that I use WindowsCE. Perhaps I should be embarassed for the sorry state of PDA Linux software.

so it begins...
I've said it on here a 1000 times- I can do just about all of the things Zaurus users boast on any Windows CE PDA. On my Jornada 720 WinCE 3.0 palmtop (aka Handheld PC 2000), I've been able to:
browse the web well (IE is much better than PocketIE for PocketPC 2k and 2k2), do my email and admin via a real 80x24 SSH and telnet terminal (in a readable font, even), run apps remotely using XFree86 for CE and VNC Rdesktop/Windows Terminal Server Client, IRC and IM (AIM, Yahoo, ICQ, MSN and Jabber), play MP3s and OGGs, share files with FTP/FTPD and Samba, go wardriving on my bike, write papers in LaTeX (and compiling and viewing w/ WinDVI), serve with Apache, and lots of other stuff I can't remember now.

Especially snazzy is developing on the PDA. Thanks to the really nice keyboard and the big screen, I've written, compiled, debug and ran quite a bit of code on the WinCE Jornada 720 itself. I've done most of my PDA-coding using: Squeak Smalltalk, Dialect, and Perl (w/ Perl/Tk). However, there are a lot of other options- a number of BASIC implementations, Java (compiling supported too), Python, Ruby, Caml, Scheme, OpenLisp/ISLISP, Common Lisp (GCL), PocketC, and plenty of others.

One thing of note that AFAIK you can do on the Z but can't on a WinCE device- compile and run C. While entirely slow and unwieldy, there is a port of GCC to the Z. IIRC, the GCC StrongARM WinCE port was aborted a while back.

And yes, you can do all of that stuff on the keyboard-less and smaller-screened PocketPC too- they're both WinCE 3.0. Some of it isn't as useful with the smaller screen and real keyboard, but it's just as useful as it'd be if done on the Zaurus.

Sorry for the rant, but I'm sick of the pattern these Zaurus discussions take: "Oooh, cool Zaurus review!" -> "Dude, Zaurus sucks- get a Palm or PocketPC and get a usable PDA!" -> "STFU! I can do all these l33t things that you can't on anything else!" In most cases, that's where the discussion ends; the PalmOS or WinCE users just assume that the Zaurus user is right, regardless of the actual utility of the "l33t thing" in question. That isn't to say there aren't things you can do on the Z you can't do elsewhere, but that's the case with all platforms- there are things you can't do with Linux that you can with CP/M. :)

I hope the screen on the SL-5600 is better than that on the SL-5500, which was absolutely horrible. While the Zaurus has *no* real handwriting recognition or decent notetaking apps (no, IQNotes or DrawPad don't do the job), at least the character recognition got less sucky (read: faster, no longer taking .5 seconds+ to recognize a character!) in the new 5500 ROM and on the 5600.

All of that said, I will be getting a C760 soon. Even though I think most of the software for the Z is incredibly immature, I am getting it for the development of a new PDA platform called Dynapad. The C760 is an incredi

Interestingly, Apple's relationship with Smalltalk didn't end with the well known adoption of the mouse, windows, and so forth.

Squeak is a modern Smalltalk-like environment created by a research team at Apple. Disney took up the mantle when Apple decided they didn't want to develop it further. And now the project is on its own. But it's an interesting footnote to the relation of Apple and Smalltalk that not many people know about.

Hmm... most of what he talks about has been available in proper languages for decades! I'll even try, as a public service, not to mention LISP :]

Smalltalk has this:

(3/5) class methodDictionary at: #+

which will give you the + method for the Fraction class. From that object (the CompiledMethod) you can get the original source code (if it's available), or a parse tree. The parse tree will give you indices into the original source, in case you should need to do a GUI for your IDE :)

Say you're writing a debugger (which you can actually do, unlike in Java, where the debugger needs to run externally).. the MethodContext knowns at what opcode execution stopped, the parse tree knows which part of the source that represents. This means you can step operator by operator through an exression... no "line numbers".

You can *fake* some of these things in java, but it's not pretty - something like IntelliJ has to use its own special compiler and huge amounts of support code, and it's just plain impossible in Java for a system to debug itself.

Go play: free-as-in-beer-for-personal-use and nice / free, cute, fluffy and sluggish

</preach>

The problem is not with GUI-based languages; it's with tools that hide their inner workings from you. VB is like that but so is VC and MFC.

Smalltalk, on the other hand, is also purely GUI-based but it's also completely transparent. The entire system--including the GUI (usually)--is written in Smalltalk and you can browse it and modify it just like any other part of the system.

(A good open-source Smalltalk system is Squeak if you're interested.)

I get the impression from looking at M$-ware that they have divided the world into rulers and peons with their developers in the ruling class and the customers as the peons. When this extends into their development tools it's either "this is too hard for you to understand" (in the case of VB and the like) or "you don't need to know this--just read the API documentation" for VC. Whether or not a GUI is involved is relevant only in that MS seems to be trying to get rid of the CLI.

If I were teaching a programming course, I would avoid MS tools (and those that try to emulate them) like the plague.

Squeak smalltalk is a briliant language for smalls. Runs on all small computers under your o/s of choice. Your work will be completely shareable because the Virtual Machine is identical on all hardware platforms. It leads on to the the most productive language ever created.

Squeak smalltalk for kids

Squeak smalltalk for grownups

Smalltalk for business

Smalltalk for engineers - Very fast.

There are many others, have a look through The Smalltalk Portal.

Just remember that with 30 years of developemnt it just works!

Just FYI- it's Squeak at Squeak.org There are a few newish Squeak books out, I've heard the book yuo mentioned is great.

OO doesn't mean a scary IDE. OO doesn't mean VB.NET or any other language on the .NET object model.

Smalltalk has been used for teaching kids for 30 years, and with a good amount of success.

Part of the reason kids can learn Smalltalk well is that there is no need to learn and use OO off the bat. You can do a fair amount of stuff in Smalltalk just by using Object-Based Programming, rather than OOP. Object-based means *using* objects, creating them, but without a full dose of creating classes, etc.

Now a days, we have Squeak, which takes it to the next level. Kids can get a big return on their investment of time, creating moving, colorful things, while writing a very small amount of code. Unlike some environments for beginners, it scales up, being useful for creating big and scary applications with a lot of code. :) Kids end up learning OO by manipulating actual objects, in the form of graphical "Morphs," giving them functionality, changing their properties... until the day it clicks, and they decide they want a totally new "kind" of Morph.

Check out the demos- it's open source, and runs on just about every platform worth runnning, including Mac OS Classic/X, Windows > 3.1 (incl WinCE), and all modern Unices under X11 (or DirectFB, Linux FB, SDL).

Squeak is a cross-platform implementation of smalltalk that has developed quite the little community of educators and students around it. It allows budding programmers to start on a very basic level - something reminiscent of hypercard - but underneath it all is a real language that allows all the power and syntax you might want. As soon as you're ready, the power is there.

The scheme environment bundled with How To Design Programs has a similar goal of allowing the student to gradually ramp up the complexity of the language, but I find their rigid levels confining. Also, the programs a beginning programmer is able to put together are nowhere near as satisfying visually as what a new squeak user can build. (These kids today - in my day, we had either text or 40 by 40 graphics and we liked it.) That said, the htdp scheme environment may be more appropriate for a structured classroom environment with a series of lessons.

My only complaint about squeak is the license (despite claims on squeak.org, it's not really an open source license because of the fonts it includes); however, it is free-as-in-beer and has been already been used in elementary and middle school classrooms for both teacher- and student-created projects. (See squeakland)

That's why scripting and other languages were invented. Easy to write, easy to debug, easy to change. Build up a global library and pull what you need, customize accordingly. And has anyone figured out how much NIH actually costs worldwide? "Fun" can be costly, both monetarily and other metrics (lives lost due to buggy code)

I agree with Squeak one can teach some powerful ideas even to kids (which is one of Alan Kay's goals). You can just like Java run applets in your browser.

Have a look at Squeak.
It's a Smalltalk virtual machine with easily programmable 2D and 3D graphics, audio support, runs on just about anything.

Squeak
Squeakland

"You'll wonder why anybody uses Java at all."


Yes I sometimes wonder.

Python certainly isn't the first semi-mainstream language to provide higher-order features. Smalltalk has been around in one form or another for 30 years. Smalltalk may not be the flavor-of-the-day like Python, but it's a proven, mature system which probably has been used for more 'mission-critical' systems at businesses than Python. As Python mature and Smalltalk evolves into something else, this is bound to change.

Anywho, Perl has more users than Python, has been around for longer and boasts the same higher order techniques and advanced types that support FP well.

Not that I'm telling you to switch to Perl or Smalltalk- everyone has their preference.

I stumbled on to Python 6 years ago and was seriously impressed. A year and a half or two after that I found Squeak Smalltalk and was utterly blown away. Contained all of the stuff I liked about Python, but had more of it! Utter simplicity and total consistency. A hacker's dream- you can change anything about the Smalltalk system within the system itself. Want to experiment with changing the way the language works? No need to drop down to C as you would with Python.

If you like Python or Ruby and have an open mind, it's definately worth checking out Smalltalk. If you'd like to try out an implementation that has good Unix integration, check out GNU Smalltalk; if you'd like to try an implementation that takes computing to the next level with a truly innovative GUI toolkit, check out Squeak. Both are open source, naturally.

I suggest the open mind because Smalltalk isn't Java. It isn't C++. Even Python can look like legacy compared to Smalltalk sometimes. Just like an old C hacker or C++ fan needs an open mind to be able to look at Python without immediately dismissing it because it doesn't look like C/C++/Java, a Python or Ruby user must keep her mind open when looking at Smalltalk for the same reason.

For those interested in trying out an open source Smalltalk that has access to all the .NET libraries and compiles to IL, check out #Smalltalk. And no, nothing was sacrificed to run Smalltalk on .NET as is done with some .NET languages. The #S developers implemented what the CLR didn't support, and made sure it still worked sensibly with .NET. A good example of how new languages on the .NET CLR don't have to just be "syntax skins."

"I invented the term Object-Oriented, and I can tell you I did not have C++ in mind." --Alan Kay :)

I don't mind C++ (or Java) that much but spend enough time on the Squeak ML and you get an idea just how much the other OO languages have been playing "catch-up" to Smalltalk, from a power standpoint.

Strangely enough, Disney has been an open source supporter for a while.

The squeak dialect of smalltalk was created at Apple, but run by Alan Kay and his team while they were Disney imagineers. (I never did get an answer if the squeaking mouse was an homage to Apple's mouse or Mickey.)

Their internet group created a set of open source tools used on their webpages called Tea, released it themselves, and now make it available through sourceforge.

Strangely enough, Disney has been an open source supporter for a while.

The squeak dialect of smalltalk was created at Apple, but run by Alan Kay and his team while they were Disney imagineers. (I never did get an answer if the squeaking mouse was an homage to Apple's mouse or Mickey.)

Their internet group created a set of open source tools used on their webpages called Tea, released it themselves, and now make it available through sourceforge.

I agree with your overall point, but not everything you said. If we are speaking purely about innovation, then I think that open-source can be quite innovative. EROS works towards an orthagonally-persistant server operating system. Squeak is doing a tremendous amount of multimedia work and research on how to make programming literally simple enough for kids. HURD actually does a very nice job improving on the whole idea of Unix, if you study how it would be used in an ideal world. ReiserFS 4 could be a true revolution in file-system design by assigning no penalty to having millions of extremely small files. Although all of these projects leverage existing technologies, all of them want to take those technologies to what, at least in my opinion, are clearly innovative directions. Perhaps they are not always revolutions, but they are certainly radical evolution.

The problem is that there is that the open-source community never quite manages to turn any of these ideas into actual, practical products. Most people haven't heard of EROS or Squeak. HURD sits perpetually half-finished on a horrible microkernel that it should have left years ago, and efforts to move it to L4 have stalled. When ReiserFS gets here, it will likely be years, if ever, before Linux actually takes advantage of its filesystem approach and obsoletes a million text files. Open-source frequently even has trouble matching truly innovative ideas that do make it main-stream elsewhere. There is, as far as I know, no real open-source equivalent to the QuickTime multimedia architecture (not talking about the movie format; I'm talking about the API) (Mac System 7), Quartz (OS X) or QuickDraw GX (Sytem 7.5), OpenDoc (OS/2 Warp), V-Twin content searching (Mac OS 8.1), live queries (BeOS), register-based virtual machines (Tao Group; in open-source defense, Parrot is indeed a register-based virtual machine, although still lightyears behind Tao's 1993 design)... I could go on, but you get the point.

There are, I think, two reasons for these shortcomings. First, open-source seems incredibly forcused on replacing existing solutions. If that's going to be your focus, then you don't have room to be innovative; compatibility is all that matters, and compatibility inherently means that your innovation options are limited. You can't throw out X11, Unix permissions and configuration files, and classic GUI programming if you want to replace a Sun box verbaitim. That requires gusto and the confidence to say, "I'm going to do that very differently, but this way is better." So why doesn't the open-source community do that? Because it's hard to get a large number of developers willing to spend time on something so radical when they don't have any marketing. Getting out a new paradigm is hard. People get set in their ways. Selling someone on the idea that applications are an obsolete metaphor, or that instead of using a database package, they should use the filesystem directly, can take years, and because open-source developers work as a hobby, they figure that if no one will use their idea anyway, there's never any incentive to polish off those innovative ideas to the point where they're usable. Hence a chicken-and-egg problem built into the system. The best you can hope for are minor improvements on existing ideas, ad nauseum.

Open-source can be innovative. It's just implementing those ideas that trips things up.

It's Microsoft that has been (ab)using the word "innovation" for the last couple of years as a differention, and indeed, as defense for their criminal actions. The Open Source, and particularly the Linux movement has never been, and has never claimed, to be about "innovation" in the choice of technologies used.

The true "innovation" in Open Source is the distribution license and the culture that has risen around it.

However, if you'd like to see real innovation in the Open Source community, see what Alan Kay's doing with Squeak.

While we're celebrating, let's not forget the language that XEROX Parc wrote to help them program the Alto - the language that was used for the demo that Steve Jobs saw when he popped in for a visit...

Smalltalk

If you want to see where Kay's latest thinking is taking him, you can see the evolution of Squeak into a more experimental phase of collaborative computing, Croquet. See also the manual.

I'm not sure whether you are trying to troll or if you're just a little igonorant about the history of the computer.

Back in the early 1970s, GUIs were not a natural evolution for computers. They only appear so in retrospect because Steve Jobs happened to get a tour of Xerox PARC and decided that GUIs should be the next step in the evolution of computers. I daresay that Jobs (and Woz's) experiences growing up playing (and later writing) video games influenced the decision to base the Lisa and then the Mac's OS around a GUI but had Jobs not had his little tour about PARC it's arguable that the PC revolution would never have happened and the CLI would still be dominant today.

Alan Kay and his fellow researchers at Xerox PARC and preceeded by Doug Englebart at SRI are the real thing - true visionaries. It's easy to knock their accomplishments 35+ years out (Englebart et. al. developed NLS in 1967! ) because we've had that long for their ideas to percolate into mass culture. Yeah, I know, the Mac has only been with us since 1984 but really, Englebart and later Kay were subtly but powerfully through their work and demonstrations preparing the way for the dominance of the GUI. Also, as I made allusion to before, don't forget the powerful role that video games had in preparing the kids of the 70s and 80s in ways that would make GUIs seem second nature.

So yeah, I've got to agree, this interview was pretty weak. However, if you want to see where Kay really envisioned that we'd be right now, take a look at the copious information out there regarding Dynabook, Smalltalk and his work at Xerox PARC. Then take a swing by squeak.org, download a copy and play around with it for a while. It's hard not to be impressed. As far as where we go next, that's up to all of us, including you. Personally, I'd like to start working in some strong AI and humaniform robots, but that's my hangup. Perhaps you have a different destination in mind.

Note: I'm not sure of Steve Jobs actual role at Xerox PARC. I've read differing accounts ranging from the tourist picture I paint above to his actually being a researcher there. Can anybody clarify?

Yo-

One of the things I use a PDA for is just this. Believe it or not, it is one of the bigger reasons I got a PDA, and at the time, the Newton 2100, which could be programmed in its native language NewtonScript on the device itself. You can produce the same full applications as you could using the desktop NewtonScript tools.

I maintain a page about PDA-hosted development envrionments here. It is mostly concerned with WinCE and the Newton OS, but there is a link to a similar page for Palm OS info.

If you want to do C development, on the road, there really aren't many options. To my knowledge, there is no WinCE port of gcc. There are many programming systems available for WinCE and PocketPC machines, some compiled to machine code, some compiled to bytecode, and some interpreted.

To my knowledge, other than getting something like a Toshiba Liberetto (a 'real' PC, more than $400, and with > 2 hr battery life), the only option for doing C development on a small, PDA-class device is on the various Zaurus PDAs. You can install GCC, etc, on the Zaurus. Modern C development takes, relatively, a lot of storage space, compared to other options. You should be able to get external keyboards for the Zaurus SL-5x00 models. I doubt the wee thumbboard would be much more efficient than just using a decent character recognizer. Battery life may not be quite 8-hours, but that's what you get, I guess.

The newer JP only Zaurus has a built in keyboard, but it is quite small- a lot smaller than you'd find on the Jornada 720. Nothing touch typeable. But perhaps it is all you need?

If you were willing to go low-tek, you could get an older, DOS-based handheld PC like the HP OmniGo. You could probably run Turbo C on them. Or Watcom, etc. Those can he had pretty cheaply, and I believe get good battery life. Probably approaching 8 hours. They may use a non-rechargable battery (AAs or something), which could be good if youl'll be in the middle of nowhere for long stints. You could still use rechargable NiMH AAs even, just carry a bagfull of them. :P

Yet another option would be to install Linux on a Jornada 720. It would be able to run run GCC like the Zaurus, and have the added benefit of having a keyboard, 75% of fullsize. After a few days, I got quite used to it, and can type almost as fast as I can on a fullsize keyboard- and I have some pretty big and stubby fingers. I am using one right now for typing up this post, although under WinCE. (I use it for programming in Squeak Smalltalk. With the Jornada, you could get the optional 24-hour battery if long life is what you need. Under Linux, that battery could probably get you at least 8 hours, but a lot less than 24 hours. (poor or non-existant power management in Linux for the J720) I'm not sure about your environmental conditions, but the J720's screen isn't very readable in sunlight- TFT screen isn't reflective. Unreadable in direct and full summer or spring sunlight. Aside from that, it's a great device, and almost has replaced my poor iBook. ;P I have a 2 GB PCMCIA drive for it.

I use it for development (in Squeak and Dialect [a Python-like RAD language]), write papers in TeX (and render and read them), record data in Excel, browse the web in IE (much more full featured than the IE in PocketPC), listening to MP3s, SSH for email and sysadminage, read eBooks in uBook and Acrobat... Like I said, it is like a full computer. :)

Under CE, the Jornada 720 gets 6-8 hours of battery life.

When discussing the Zaurus in relation to WinCE, a lot of people go on about features they see as novel to a Linux PDA.

I'm a big PDA nerd. I'm working on my own PDA OS/computing environment. And I've done a lot of comparisons between WinCE, Palm OS, Newton OS, and Linux.

Linux on the PDA can do a lot of slick things- run Apache, Emacs, Vi, Perl, Python, SSH, VNC and X11. WinCE can do that as well. There is an XFree port, multiple SSH clients (Free, free and commercial), etc. You can tunnel X11 over SSH on a WinCE machine. You can use a serial cable to adminster router with a terminal emulator. Some of these things are of questionable usefulness for some people, but it is possible all the same.

I've heard way too many people go on and on about how their Linux PDAs can do these things as an advantage over WinCE PDAs. Linux PDAs may have their advantages (moral advantage?), but running a handful of useful Unix-ey tools isn't one of them.

Check out Rainer's page for a lot of useful WinCE ports.

I cannot say the same for Palm OS, however. PalmOS is relatively primitive (internally) compared to WinCE and Linux/PDA, which are both full-blown, relatively modern operating systems that run on PDAs. Some of these things work on Palm OS devices, SSH for instance, but X11, Emacs most likely do not.

I'm *really* tempted to buy this Zaurus- seems like a good deal. But the same thing as ever is holding me back- Linux PDAs have no real handwriting recognition system, like the HWR on the Newton OS or CalliGrapher for Windows CE. I use it quite a bit for taking notes- taking bitmap notes doesn't compare in their usefulness to real text notes. The thumboard wouldn't cut it for taking college lecture notes for me, and the character recognition wouldn't either.

Other than HWR, I have still stuck to using WinCE and the Newton OS as my PDA platforms. The available software for WinCE is generally of a higher quality than you can get for Linux PDAs. Like on desktop Windows, there is a lot of trashy software, however, but the good stuff is pretty good, better than most of what you can get for Linux PDAs, commercial or not.

That isn't to say that all Linux PDA software sucks, or that you can't get a decent package here or there- on the contrary. The Hancom Office apps are pretty nice. However, Linux PDA apps are all too often like their desktop Linux apps- messy UI wise. Especially the Free and free apps. The commercial QTopia shops put a bit more thought into their apps, which is good.

If you like what is available enough, and think the moral advantage of Linux instead of WinCE

I've wanted a Linux PDA for quite some time. I did something similar to you, I bought a Helio for running Linux. Similar specs as an Agenda (75 MHz MIPS, 2 MB Flash ROM, 8 MB RAM, serial, 160x160 B&W screen). Linux was ported, so was PicoGUI, but in the end, it does just about as much as an Agenda does. Maybe a little more- the open-source default VT-OS is still pretty useful. After that, I got an iPAQ 3100 for developing Dynapad, and tried running Familiar and then QTopia on it during a couple months in the summer. Went back to WinCE after that,

I also run Squeak on it, and can use it for programming. But generally, it's a toy compared to my Newton 2100 or my Jornada 720.

That said, use whatever you like. I'm not a "WinCE evangelist," but thus far, I've preferred using it over Linux on a PDA. I don't even use Windows on the desktop (or server), but I'm a big proponent of using the best tool for the job.

When I was talking about late-bound VMs, it was largely the ideal case VM, in which all the functions and data are nicely boxed and type-checking is done at every reference. This is of course not the case, especially for Common Lisp (but from what I know of the original Smalltalk VMs and Squeak they come pretty close to the ideal - if you know someone who knows Smalltalk, it would be interesting to see how well this attack will work against the latter).

Strictly speaking, there is really no Common Lisp implementation entirely contained inside a VM (mostly for speed reasons, but Clisp does come close - it's memory footprint is less than 2mb, and I think it also makes a good candidate to see how well this exploit works against late-bound VMs). Most implementations are native-code compilers - so this exploit certainly applies here, especially since the compilers inline heavily and will make use of optional type specifiers and inference.

Besides the reliance on native code by the VM and the inlining, I think there are two areas where this exploit might work. First is the way dynamic type information is encoded. I don't think anyone uses a whole extra word for that anymore. There are two popular strategies, one being the BIBOP (Big Bag of Pages) scheme, where certain pages are reserved for specific types, and the other is to encode the type information in the upper bits of a word (Clisp does this), and I've heard that the two are used in together in some combination. Second, conservative GCs make passes fairly often - I suspect there may be a small chance to exploit the garbage collector.

So it is entirely possible to exploit late-binding VMs with your method of attack, but I am guessing the success rate will be much lower. This may depend on how much external code is used and other factors (it would be interesting to see how well Python stands up compared to the JVM). This is really starting to pique my curiosity. Maybe if I have some time this summer I will perform a similar experiment on one of the CL systems.

I think the site is a Wiki. Probably a Swiki actually. Notice the 'edit' button at the top of the page. Save is password protected. I guess somebody guessed/hacked the password.

I didn't find anything on the downloads page. Disappointing. This could be interesting. Squeak itself seems like fun. I've tinkered a little but I don't know enough Smalltalk to have done anything useful yet. There's a Squeak browser plugin available from Squeakland and lots of Squeak goodness at Squeak, including ports of the virtual machine to most platforms and lots of docs and tutorials.

An interesting alternative to Java if you have a yen to write cross platform code that runs in a lumbering, slow, resource hogging virtual machine. And it has the little mouse thing. I like the little mouse thing.

If it's Alan Kay, my guess is that it uses the Squeak License, except that it might have been a special case because they took Squeak from Apple. So I guess what I'm saying is that I have no idea.

The point is simply: there are other approaches to building GUIs than the huge and inflexible C/C++ systems people are building now. And if customizability and user-level programming aren't reasons enough, simply the long release cycles and the fact that UI experts can't fix the software themselves are reason enough to look for different approaches.

Contrast that with systems like Squeak, in which every object that is displayed can be inspected, cloned, and modified by the user. While Squeak itself may not be the future (it's a messy research system), it shows that really the line between "configurability" and "programmability" can be blurred, and probably should be blurred.

At the heart of the limitations of systems like KDE and Gnome is the underlying choice of programming language and toolkit. By essentially aping Microsoft Windows and Motif, both systems have painted themselves into the same corner. This is software design for the past, not the future.

In fact, if anything, KDE and Gnome represent regression rather than progress compared to traditional X11 toolkits: X11 toolkits did have simple, general-purpose tools for opening up applications and changing properties, behaviors, and event-handling on the fly (e.g., editres). Traditional X11 toolkits also handled preferences better when applications ran on multiple hosts; these "new" X11 desktops basically just drop the ball on that, giving you the wrong preferences and generally having their inter-application communication fall apart.

In the long term, I expect that the lines between configurability and programming disappear, as GUIs will people give simple, natural capabilities of connecting and customizing applications. What the underlying software technology will be like remains to be seen, but I guarantee you that it won't be based on monster C++ libraries. More likely, it will be something like X11 with X11 properties and a mix of clear-text scripting and XML.

I rely on the bus (in addition to my feet and bike- no car) to get everywhere around town. Carrying around paper schedules was a pain, and sometimes they'd go out of date without you knowing.

Luckily, my city has all the bus schedules on line. For me, it was a simple matter of downloading the PDFs of the schedules and putting them on my PDA, which is usually a Newton 2100, but also a Jornada 720 (for research).

I've been meaning to write a small app in Squeak for Dynapad that does something similar to this hardware solution. It has all the data for the all the bus routes in town (as well as the Greyhound route I take to my parents house), and gives you available bus times out of a given location. Creating a multi-route iternerary would be pretty easy as well.

Unfortunately, I've not gotten around to this yet. The code side of it would be pretty straightforward and IMO fun to write. But the Duluth Transit Authority has opted to only have the schedules online in paper form or as PDF- which would mean I'd have to do some serious PIA data entry. It would be a pain to maintain, looking over a lot of numbers to find a couple of minor changes in bus schedule.

So, I figured I could dick aroudn with pdf2txt or pdf2html converters, parsing from there. But parsing never is fun to me, in any language, so I've kind of not bothered, just dealing with the plain old PDFs for now.

Check out Squeak [squeak.org]. It's Smalltalk and a bunch of OS type tools within a virtual machine.

I urge you all to stick with Smalltalk and not some bastardization of object-oriented paradigms such as Java or C++.

Java is slow, as annoying to program as Microsoft's C# language, and just plain impractical.

C++ is a bastardized object-oriented programming language that's basically the octupus known as C with a bunch of "legs" such as OO, platform compatibility, etc. tacked onto the language.

The homepage for Smalltalk is located at this address. I urge you to read more about it before wasting any more of your precious work hours trying make Java actually work for you and your company.

Cheers.

So what do you suggest to make programming more accessible to kids? Replace Windows with a BASIC shell on all new PCs?

Give them a smalltalk environment. Squeak smalltalk is an excellent implementation of an environment that was designed for teaching kids how to program, while still being a great environment in which adults can program.

I am probably not qualified to spout a hundred words on the topic but I can tell you that the comparison you are asking for may not be an apples to apples comparison in the context of a discussion on Struts.

Morphic is a "direct-manipulation User Interface (UI) construction kit" (scroll down to see relevant section) for Squeak. Squeak is "an open, highly-portable Smalltalk-80 implementation"

MVC as it relates to Smalltalk is slightly different than the MVC Pattern talked about in this context. MVC in Smalltalk terms is the name of the actual GUI, as well as a the paradigm behind it. Morphic may be a replacement for MVC in a Smalltalk/Squeak discussion, however in the MVC as pattern discussion, Morphic is not at odds with MVC, it is an implementation of the MVC pattern.

A discussion of Morphic vs. Struts would be in order if Morhpic ran in a Java environment, or if Struts worked in Smalltalk.

I am probably not qualified to spout a hundred words on the topic but I can tell you that the comparison you are asking for may not be an apples to apples comparison in the context of a discussion on Struts.

Morphic is a "direct-manipulation User Interface (UI) construction kit" (scroll down to see relevant section) for Squeak. Squeak is "an open, highly-portable Smalltalk-80 implementation"

MVC as it relates to Smalltalk is slightly different than the MVC Pattern talked about in this context. MVC in Smalltalk terms is the name of the actual GUI, as well as a the paradigm behind it. Morphic may be a replacement for MVC in a Smalltalk/Squeak discussion, however in the MVC as pattern discussion, Morphic is not at odds with MVC, it is an implementation of the MVC pattern.

A discussion of Morphic vs. Struts would be in order if Morhpic ran in a Java environment, or if Struts worked in Smalltalk.

Your requirements will not change drastically

You are wrong with this assumption. Refactoring (like other XP practices) are for software whose requirements changes constanly.

Your code will be needed for a long time

You don't need the code for a long time because if you never refactor your design (not only your code), the system, with a lot of patches, becomes a Big Ball Of Mud, and then you need to throw away your code.

The point isn't only about "Refactoring", is about the evolutionary code (refactoring is only a small technique for to allow future evolution in parts of the code, cleaning the code to allow more drastic design changes).

The best example about software evolution is Smalltalk (note that the book "Refactoring" is based on ideas taken from Kent Beck's book "Smalltalk Best Practices Pattern").

The base code of Smalltalk comes from the 70's. And the recent version of comercial Smalltalks (with support for all the buzz tech like XML, WebServices..) still uses a lot of objects who evolve from the original implementation.

(offtopic - Talking about Smalltalk, I don't know why any company doesn't made an object based OS, based in the concepts of Smalltalk, for example Squeak is a good example of an Smalltalk Enviroment -or Object Enviroment- that can be used as a complete OS desktop).

It made me think about Squeak/Smalltalk except that in Squeak it is called flaps and when expanded they look like the standard kicker ie it takes all the width when the flap was attached to the bottom or top of the screen.

The card idea is great !

Huh, no. Smalltalk 80 was implemented on a VM (probably still is. The bytecode is documented in a book about Smalltalk 80, but keep in mind Smalltalk started in 1972 - and one of its author said it got the Object idea from a engineer long ago, who wanted to download the code at the same time as the data for planes. Sounds like VM and applets. Nowadays, try Squeak.

When you get a system that supports annotation, and lets you consider the object code and symbol tables as part of a dynamic system linked with the source code, then you'll really get to play.

I don't know anything about the PDP series, or how they utilized their non-power-of-2-size bytes, but some systems used such "non-standard" byte sizes to tag types. For example, if you have a 36 bit word, you can store a 32 bit value plus 4 bits to specify the type of that data. You can then check very quickly if a certain memory word is an integer, or float, or a pointer to a list (or whatever).

The Symbolics Lisp machines used such a system. I haven't followed Squeak's development for a while, but I remember its 32 bit virtual machine used tagged types, and unfortunately that meant that they had to use 30 bit numerical and reference types. Several other languages/virtual machines use this feature.

I put "non-standard" in quotes because in the past not everyone used (uses?) 8 bits. That's why if you read older RFCs, you'll find the term "octet" used where you'd normally expect to see "byte."

I think Alan Kay's Squeak implementation of Smalltalk pretty much fits those criteria. I've spent some time playing with it and have to admit to being awfully impressed. It still has quite a way to go, but when it gets there it should be pretty amazing.

And many functions of pen computers don't require handwriting recognition at all (ink notes, browsing, e-books, etc.)--just getting rid of that bulky keyboard alone when it's not needed would be worth the pen computer.

Nooface also might be a useful resource. If you do change your mind and decide to wade through code, check out Squeak, a Smalltalk VM/environment with a really consistent and fast GUI.

Myself, I prefer a monochrome display quite a bit over a color.

For a few years, I used a Newton 2000u, a kick ass machine. For various reasons, I sold my rad Newton setup and bought an iPAQ 3150 (darned cheap, at $150 with a CF sleeve!). The 3100 line is B&W. I was a bit weary of getting an iPAQ, because from the reviews of the 36xx and talking with friends, as the battery life of the color iPAQs is horrible. 3 hours. Or less. That's appaling. Luckily, the B&W iPAQ gets a good 20 hours of battery life, by virtue of its very readable monochrome screen.

But... one of the things that really bothered me about the iPAQ is the fact that the screen is tiny. So I sold the iPAQ and got a Jornada 720, hoping that the twice-as-large 640x240 screen would help ease the pain of leaving the Newton. And it does, a little, as long as you're inside a room with no natural light coming in. If you're outside, it's unreadable. As a biologist who has a fetish for doing quick analysis in the field as the data is entered, it makes the Jornada 720 worthless for too much of what I need it for.

Of course, there are some PDAs with reflective screens that can be read outside. The iPAQ 3600 series, for example. However, you still have the horrible battery life. Do most modern PocketPCs (PPC2k2) and color Palm OS devices have a similar reflective screen? Or do most have the unreadable ones?

Color sells to consumers though. They want flasher units rather than useful ones. It's a fact of life, but it still blows. :P Color screens just aren't practical for me. I imagine that most color PalmOS units get slightly better battery life than the PPC color units, but you're still stuck with the PalmOS and all of it's limitations. Yeah, I know, POS 5- but it ain't out yet, so it's not part of the picture.

I guess if you're the kind of person that likes to stay inside and watch TV, your PDA tethered to the wall with an AC adapter and the windows shut, color screens would be fine.