Cincom Smalltalk Stuff

Moving to BlogSpot

2011-05-16T22:36:59-04:00

With Jim Robertson not around to maintain this blog infrastructure any more, I've decided to move it. And to start actually posting stuff again. So you can now find my blog postings at http://alanknightsblog.blogspot.com

iWeb and self-serving blog posts

2009-07-16T17:46:59-04:00

My partner Kirsten is a flute teacher, and has been thinking for a while she needs a web site. She wasn't exactly keen on editing the HTML manually, and has a Mac, so we started playing with Apple's iWeb. It worked out really well. It's quite limited - you get templates, and you can't even edit the templates, so each new page starts with the default header picture on it. But it does a really good job of looking like a WYSIWYG layout tool, hiding the horrors of HTML beneath the surface. The site requirements aren't complicated, but she was able to lay out the whole thing by herself, and she's very picky about things like layout and colours. She did notice that the published site has fonts and colors slightly off from what iWeb shows, even on a Mac in Safari. But it's pretty close. And she did things like overlapping pictures whose underlying HTML has got to be horrific.

Of course the real reason I'm blogging about this is that, even with the site having been up as a placeholder for a few days, our Google overlords don't seem to be aware of its existence. So perhaps putting an external link referring to the site will help with that.

Update: Just looked at the site from Windows, and I'm slightly less impressed with iWeb. The fonts come out a lot more jagged, and some of the spacing is wrong. But getting that all right is tricky to do. Bizarrely, Internet Explorer does a better job than Firefox.

Windows Genuine Disadvantage

2009-04-07T11:08:09-04:00

OK, apparently I only actually blog anything here when I feel like ranting. So, I recently upgraded my quite old desktop Mac (1GHZ G4) and bought a nice new shiny iMac. I got VMWare, and wanted to install Vista under it, if only to see what all the complaining was about. It was fine, I even used it for something useful, but then it had to be activated. It won't. I've got a legitimate product key, everything's in order as far as I can tell, but all I get is an error message whose "more details" is that I got a timeout. Company support tells me that this is normal and to be expected. Try again later. It's been a couple of days now I've been trying later. There's a phone activation option, but it doesn't appear to be enabled in my copy. I even found out how to force it ("slui.exe 4" if you're interested, and it just won't let me pick a country).

Microsoft's been running ads lately about the price premium of Apple, but I've wasted something close to a day of my company's time trying to get legitimate software to run, and at this point I'm probably just going to give up on it. The sad part is that it's part of the company's bulk licensing agreement, so Microsoft's already got there money from it, so why should they care if I can't actually run it.

Oh, and if I go to Microsoft's site, I don't qualify for free support. They want US$59 in order for me to activate the product. I'll take Jim Robertson's advice here, and avoid swearing in a blog post. But I do feel like it.

Commodore 64s, Soccer Playing Robots, and Lots and Lots of Meat

2008-11-21T11:18:44-05:00

I just came back earlier this week from the Smalltalks 2008 conference in Buenos Aires, Argentina. This is just the second year of the conference, and I was very impressed, despite not really understanding very much. Not speaking Spanish is a bit of a handicap when that's the predominant language for the talks. Up here in Canada we don't get Spanish in school - we get French. That's helpful - between French and English, you can guess quite a few Spanish words. But it's not like knowing the language. But what was surprising to me was how much it's possible to get out of a talk where you don't understand either the slides or the talking. Hmmm - now he's making a joke about Microsoft and Web Services... now he's saying this is implemented in Dolphin and too bad that Dolphin's dying...
The SqueakDBX presentation. Even without knowing Spanish, you get the idea. Mariano Peck, Esteban M. Lorenzano and Germán F. Palacios.

And there were some very interesting talks. The prize winner was a very impressive Commodore 64 emulator by Gabriel Honoré. It's technically interesting because it reifies many, many aspects of the underlying hardware (at one point it wasn't working, and it was because he'd forgotten to virtually plug it in - it needed a "powerSupply turnOn"). And it was just really cool to watch the graphics and hear the bleeps and bloops just like a real Commodore 64. I'm told by former C64 owners that when you do a "hardware" reset the screen flickers just the right way you'd expect. And the performance was adequate to run at full speed on a reasonable modern laptop.

But there were a lot of other interesting talks too. I won't go through them all, but some of the ones I particularly enjoyed included some work on medical expert systems, another experiment in reworking the collection hierarchy to use traits, the SqueakDBX database driver project, an "IDE" written in Dolphin to ease the pain of a huge .NET and Web Services project, SqueakNOS (Squeak running directly on the hardware), and a tutorial on soccer playing robots. This last one deserves a bit more explanation. Apparently this is a fairly organized activity, with actual robot soccer leagues (e.g. http://www.fira.net ) Unfortunately, they didn't have real robots here, just simulators. But it was still pretty interesting to watch.

I loved the conference logo - Knights of the Square Brackets meets Bandoleon (a type of accordion). Here it's shown on the screen during Hernán Wilkinson's introductory talk.

Unfortunately, this was a real lightning trip for me. I arrived Wednesday morning after an overnight flight, with the conference running Tuesday-Saturday, and then I flew back Sunday night. This didn't leave a lot of time to explore Buenos Aires, but I did get some opportunity to walk around the city and some time talking to people at the conference We had a social evening at a restaurant, served the traditional Argentinian dish of Asado - the short summary of that is lots and lots of barbequed meat. The following evening I had dinner (Asado) with the group doing the SqueakDBX project, talking about how to make Glorp use that driver cleanly without interfering with the other, incompatible drivers in Squeak. And on Sunday, the organizers took a few of us out to Tigre, by a river delta north of the city, and we rowed out to an island for a barbeque (guess what). So lots and lots of Asado, although a bit different each time. Overall, it was a great trip, and many thanks to everyone involved. I had a wonderful time throughout, and will definitely try to get back to Argentina again, and make a proper stay of it.
(nearest to furthest) James Foster (Gemstone), Victor Koosh and Leandro Caniglia (Caesar Systems) and Andres Valloud (Cincom) taking us to the airport.

Smalltalk Solutions: no talks on Wednesday

2008-04-09T19:43:02-04:00

I've been asked this twice today, so let me post here in the vain hope that somebody might come across it. While the schedule for Smalltalk Solutions isn't up yet (real soon, I promise), the basic schedule is that the conference talks happen over three days, Thursday through Saturday. That's June 19-21. On June 18th, there'll be registration open, some coding contest activites, and a welcome reception - so basically it's the day before the conference really starts. If you're looking to book travel, you want to arrive on Wednesday. It's not necessary to arrive on Tuesday.

I knew this would be confusing.

Oh, and we've got some really good talks lined up, and I think it's going to be a great conference.

Ruby and Smalltalk Idioms

2007-09-10T10:23:08-04:00

This is a comment on the "Inconceivable" entry in Jim Robertson's blog, which I tried to post on the weekend, but apparently it was too late, so I'm just posting it here. See also the comment by Glenn Vandenburg and the original post Jim refers to.

OK, I think I see more of what you're getting at, and where you see the Smalltalk community doing things differently, although it's always dangerous to generalize about diverse communities.

I think the biggest difference is in the expectations people would have of the source code they're seeing. Smalltalk programmers would generally expect to be able to see the list of instance variables and the methods that access them. If they can't see them, but they exist, they'd find that confusing, and they wouldn't think of the presence of the instance variable and accessor methods to be cluttering up the source code. From your comments, it sounds like Ruby programmers would. Perhaps that's also related to tools, because Smalltalk has tools that help organize the source code. There's also perhaps an encapsulation point that people don't automatically put accessors for all variables.

So in Smalltalk, people wouldn't tend to think of having a method somewhere that declares the existence of a number of instance variable that are related in some way and also two accessors for each. They'd expect to see those things, and would probably prefer to do something like annotate the class definition, or the accessor methods, to distinguish those things that are to-many relationships.

In fact, when you talked about generating code, I assumed you were talking about more complicated methods for managing persistence, and being aware of the fact that the variable is a collection, not just accessor methods. The more complicated methods are the sort of thing that Smalltalk people would think of as cluttering up code, and would be likely to do by reflective mechanisms of one sort or another.

And, as Avi points out, if we did generate code, we probably wouldn't do it in such a way as to throw away the intention of the original annotation. But again, that's a bit confusing. If all we're talking about is accessors and a variable declaration, then there are no additional semantics to be taken into account in the generated code. All we've said is that there's an instance variable, we just haven't said it in the normal spot. The fact that it's a collection is irrelevant to the accessor methods or the declaration. You do say that you have the accessors doing a bunch of additional very nice stuff, so maybe they do take that into account, but then we start to get into details.

As far as how hasMany works in the Glorp Active Record stuff that I did, it's just an annotation, so the reflective code takes it into account. So, if you put in that annotation, it's expected that you have a variable by that name (the accessors are optional). It doesn't generate it for you. Reading, writing, and querying against the object works via API's that know about that annotation and take it into account, but which don't generate any code (unless you count SQL). One reason I wouldn't want to rely on extra code in getters and setters is just it's more complicated to make them work if people get the collection and modify it directly. Glorp works by just remembering what the object's state was previously and seeing what's changed, regardless of the mechanism. Of course, other people have done things differently in different frameworks.

For the meta-tricks in general, I'd agree that many of the tricks are very similar. The kinds of things that Ruby and Rails do with reflection are exactly the sorts of things Smalltalkers do with them, and the idioms are very recognizeable.

Scripting Support

2007-08-01T16:39:35-04:00

One of the things people have talked about a bunch recently is better support for scripting using Smalltalk. With that in mind, I'd like to point out a bit of work on helping to do that, in the suitably named package "Scripting Support" in the public Store. This includes a number of different things. It's fairly experimental - we want to see if this is what's actually needed/useful. So feedback is definitely appreciated. I note that the term "scripting" is somewhat vague. To clarify what we mean, this doesn't do anything to help you, say, write entire programs in files without having to use "chunk" or XML format. Rather it lets you control the environment from the command line better.

There are already some ways to run code from the command line in VisualWorks, e.g. -doit, -evaluate, but they don't entirely do what you want. So this adds the ability to just run a file from the command line, e.g.

vm scripting.im dostuff.st

or, if you have command line arguments, you can do them before the program, and put a -- option to indicate the program file. The program can also treat the rest of the line after it as arguments, which will show up in a variable named "arguments".

There's also a "-e" option that just runs its (single-line) argument as a doit. You can have several of these. This is a lot like -doit, except that it (and providing a script file) will automatically quit the image after running, and the environment in which they run. (If you're curious, I just looked at what Ruby had for command-line arguments, because I had it installed on the laptop at th time)

All scripts are run in a ScriptRunner which lets them run in a workspace-like environment in which all namespaces are visible by default. Ambiguous names will resolve to using one of the names and continuing, rather than causing an exception. Undeclared variables will be declared in the script runner's namespace. And exceptions will dump a short stack and quit that particular script, but run other commands if there are any.

There's also an interactive console, of sorts. So invoking the image with -i will give you a command-prompt, and you can type Smalltalk expressions to be run as scripts. You can even use \ to continue on to the next line. And to get out of it, you just type ObjectMemory quit. Note that one limitation of this that we have to fix is that while it's waiting for input at the prompt, the VM is blocked. This is a problem if you want to do complicated background processing, but is surprisingly not that noticeable for basic use. We think we have a fix for that, but it requires some validation.

The ScriptRunner also provides a couple of convenience methods for use in scripts.
#include: runs the named script by filing it in
#use: parcelName makes sure that the parcel is loaded.
#print: prints its argument to the output of the script (normally standard out)

Finally, this package adds & as a concatention operator. This is just playing around with possibilities, but a number of the collection operations in Smalltalk are quite awkward to type out in scripts. So this tries to do some of the collection building stuff in more of a Do What I Mean kind of way. So, e.g.

1 & 2 ==> #( 1 2)
#( 1 2 ) & 3 ==> #( 1 2 3)

and other interesting stuff.

Glorp Changes

2007-07-10T15:26:05-04:00

I feel sure somehow that I had written about some of the moderately recent changes in Glorp, but someone asked me about it, and I can't seem to find anything. So here's a very high level description of the possibly interesting changes from 0.3.138 to the present, in no particular order.

Support for proxy actions. You can give a proxy a block that it will execute when it's instantiated.
Some APIs are simplified. For example, read: instead of returningManyOf:. Or you no longer need to implement constructAllClasses, it'll figure out from the descriptor methods if they're there.
GlorpActiveRecord - the ability to have automatic mappings for things that are relatively simple, and to gracefully scale up when they get more complicated. I talked about this in my user conference presentation, and the code is in the public repository.
The ability to have expressions in mappings. This means that you could make a direct mapping that didn't go to a field, but to a function of a field. Or to a subselect. Such mappings would likely have to be read-only, but this is still very valuable.
Support for a variety of trickier mappings in general, including a number of improvements for situations when the primary keys aren't themselves mapped, but are used as part of a relationship mapping.
Better support for generated values of different types, generalizing from just generated primary keys or optimistic locking versions to allowing things like timestamps for last modification and more complex generated values.
Support for reading database metdata using INFORMATION SCHEMA. This lets us avoid putting in the tables ourselves for the GlorpActiveRecord above. Currently works only for Oracle and Postgresql, though it should be fairly easy to adapt. Done in a nicely recursive way. We have descriptors that map from Glorp's objects to the INFORMATION SCHEMA tables.
Glorp now properly handles the case where you delete and re-insert the same object in the same unit of work.
Added the ability to have exclusive relationships. These will delete the target of the relationship when the source is deleted or the reference to the target goes away.
Added some tools (in the GlorpAnalysis package) for performance analysis, keeping track of which sorts of queries were executed, and how long they took.
A lot of improvements to the dictionary mapping. It still doesn't do everything desirable, but, and here is the essential point, it is better than it was.
A DirectToManyMapping for collections of simple types.
A variety of additional functions and things you can do in expressions. This includes the ability to use includes:, select:, intersect:, count:where:, copyFrom:to: to generate substring expressions,.
The ability to specify an encoding and have it used for reading/writing string data.
Efficient queries for horizontal inheritance, reading all of the subclasses in one (really messy) query. See here
Basic support for groupBy:
A lot of fixups related to types, validation and better error messages, generation of values, performance, and others, too small to mention.