Site Statistics

These are the statistics for the Vista Smalltalk site for the past month.

----------- July 2006 ----
         Page loads: 6,210
    Unique Visitors: 1,559
First Time Visitors: 1,181
 Returning Visitors: 378

Some impressions from a more detailed analysis:
– very few visitors have the WinFx runtime installed
– a large percentage of visitors are using Firefox or Opera browsers
– there have been visitors from nearly every region of the world.

The release of the WPF/E plugins for the Firefox and Opera browsers will, hopefully, allow Vista Smalltalk to be usable by a much larger percentage of visitors to the site.

Contributed Code Section Added

I have added a contributed code section to the Vista Smalltalk site. The first two contributions have been graciously made by Gal Zsolt.

Launcher
Improved “15 Puzzle”

Vista Smalltalk Page Header

 

Thanks to the assistance of a talented graphic artist, Dimitri Morris, I am starting to improve the appearance of the Vista Smalltalk site.

The page header graphic is inspired by Robert Tinney’s 1981 drawing of the Smalltalk balloon leaving the ivory towers of an academic island.

Twenty-five years later, I wish to continue the story with the Smalltalk balloon arriving in the new world of Web 2.0.

I have given Dimitri some suggestions to add to further drawings:
- a bizarre “Javascript” flying machine is falling towards the sea
- there are some large, slow ships named “C#” and “XAML” lumbering towards the land

Smalltalk is a computer language and a set of implementations, libraries and applications.

But in a real sense, Smalltalk is also a culture. The culture is based on a sense of esthetics – an appreciation of the beauty of simplicity.

For Smalltalk to become the next generation Internet language, it needs a both a logical written narrative and an emotive symbolic narrative.

The written narrative is that simplicity will beat complexity to the marketplace.

The symbolic narrative is the ongoing story of a little balloon that set out from an island a quarter century ago.

Vista Smalltalk Entered in Coding Competition

I have entered Vista Smalltalk in Microsoft’s “Code Master Challenge” competition. The competition closes today, and the 20 finalists will be announced on Sept 15.

Contest rules specify a PowerPoint presentation of not more than 12 pages. Making PowerPoint slides is obviously not one of my strong points, but I hope that I at least explained the basic concepts.

The Vista Smalltalk PowerPoint slides are here: vistasmalltalk.ppt

The History of Vista Smalltalk

Microsoft’s first .Net SDK was released in November 2000. It was very primitive and lacked any of the development tools that we now take for granted. However, with a “Vi” editor and a lot of patience, it was possible to write programs that (sometimes) worked.

My first .Net project was to build an inference engine, similar to the NASA Clips system. I had the RETE engine working by about April of 2001 but I was missing an interpreter for the scripting language. 

I wrote a very simple Lisp interpreter, and then started improving it. By 2003, I had a reasonably working bytecode Lisp interpreter, which I posted on the Internet as “NetLisp 0.7″ - there was no community interest.

In 2004, I used the Antlr parser generator to develop a Smalltalk parser for the interpreter, and released “Vmx Smalltalk” in both .Net and Java versions. Again, very little interest.

There have been two other releases using Antlr generated parsers,  “DotBasic” which was modelled on Microsoft’s VBA, and “Vistascript” which was modelled on the Javascript 2.0 proposal. Neither excited much interest.

However, when IE7 was first released, I found that I could tweak my interpreter to run in the browser. Probably, it will run in any browser or device supporting WPF/E.

So, I revived my Smalltalk parser, and brought out “Vista Smalltalk” primarily as a browser scripting language competing against Javascript/Ajax for rich client applications, and also for Vista desktop scripting solutions.

Microsoft had a scripting solution that they called “VSA” (Visual Studio for Applications) when the .Net project started. This appeared to be their replacement for “VBA” (Visual Basic for Applications) which is a very popular scripting language bundled with many of their current Office products.

Somehow, the VSA initiative was abandoned, and they have not yet announced any other scripting solution for .Net.

On the browser side, the Javascript 2.0 initiative, seems to have been abandoned in about 2003, although there are constant rumors of it being revived any day now.

Now in the second half of 2006, with all the talk of Web 2.0, and with the 8-9 billion dollars of .Net investment reaching the market, the current situation is this:

- Microsoft still doesn’t have a scripting solution for .Net

- the IT industry can’t decide on a replacement for the 1995 version of Javascript

There may be a period over the next 18 months that Vista Smalltalk will be the best solution for writing next generation Internet apps – in fact, in some cases, it may provide the only workable solution.

Smalltalk Networked Application (SNAP) Architecture

I have created the acronym SNAP (”Smalltalk Networked Application”) to describe an architecture for building rich client applications using Vista Smalltalk.

SNAP applications run on the client and have two principle roles:

• create and manage the user interface
• provide the application logic to coordinate remote web services

Other characteristics of SNAP applications are:

• .Net/WPF classes and methods are mapped to Smalltalk objects
• remote web services are mapped to Smalltalk objects
• the application logic is implemented in Smalltalk on the client
• applications may simultaneously transact with multiple servers
• application code is loaded/modified dynamically
• application code may be loaded from multiple sources
• Smalltalk development/debugging tools are available on the client

The availability of .NET/WPF will allow the development of applications with the best qualities of traditional LAN based client/server solutions and the ease of deployment of Internet based solutions.

Javascript/AJAX scores well for flexibility/deployment but is tied to DHTML and a limited programming model.

Microsoft’s deployment of compiled solutions provides a rich user interface and ease of deployment, but is too rigid a model for highly dynamic solutions.

Server side Smalltalk/Ruby with continuations provide ease of flexibility and deployment, but don’t yet have a model for integrating the rich WPF interface.

As WPF becomes more available over the next several months, I think that multiple solutions for easily deploying rich client applications will be attempted.

I am sure that we will find is that there is not a single optimal solution. The learning curve for WEB 2.0 is still ahead of us.

Dynamic XAML

This demo shows how to dynamically load a WPF object from a XAML string. The XAML can be created using Expression Designer or other XAML editor.

Demos subclass: #XamlDemo
instanceVariableNames: ''
classVariableNames: ''

open
  | s w x |
  w := self topWindowClass new.
  s := File readAllText: 'xaml/test1.xaml'.
  x := XamlUtility xamlFromString: s.
  x isNil ifFalse: [w add: x].
  w width: 550; height: 350; title: 'Xaml Demo'.
  w open

Building a Custom Browser

This demo shows how the .Net “WebBrowser” control can be easily integrated into a Vista Smalltalk solution. Note that the “WebBrowser” control supports Javascript and plugins such as Flash, etc.

Demos subclass: #QuickBrowser
instanceVariableNames: 'browser'
classVariableNames: ''

open
  | bottom dockpanel top w |
  w := self topWindowClass new.
  w title: 'Quick Browser'.
  dockpanel := DockPanel new.
  bottom := self buildBottomPanel.
  dockpanel add: bottom.
  DockPanel setDock: bottom to: Dock bottom.
  top := self buildTopPanel.
  dockpanel add: top.
  w add: dockpanel.
  w open

buildBottomPanel
  | stackpanel |
  stackpanel := StackPanel new.
  stackpanel orientation: Orientation horizontal.
  stackpanel
    add: (Button content: 'Yahoo' callback: [self showYahoo]);
    add: (Button content: 'Dilbert' callback: [self showDilbert]);
    add: (Button content: 'CNN' callback: [self showCnn]);
    add: (Button content: 'Torremolinos' callback: [self showTorremolinos]);
    add: (Button content: 'Google' callback: [self showGoogle]).
  ^ stackpanel

buildTopPanel
  | host |
  browser := WebBrowser new.
  host := WindowsFormsHost new.
  host child: browser.
  browser dock: WfDockStyle fill.
  ^ host

gotoUrl: aUrl
  browser navigate: aUrl

showCnn
  self gotoUrl: 'http://cnn.com'

showDilbert
  self gotoUrl: 'http://dilbert.com'

showGoogle
  self gotoUrl: 'http://google.com'

showTorremolinos
  self gotoUrl: 'http://www.mapquest.com/maps/map.adp?formtype=address&country=ES&addtohistory=&address=&city=torremolinos&zipcode='

showYahoo
  self gotoUrl: 'http://yahoo.com'

Less is More – The Art of Engineering

“The art of engineering is to create what you require using resources that you can obtain.”
– Anonymous

“Less is More”
– Ludwig Mies van der Rohe, Director of Bauhaus

The Vista Smalltalk kernel has now been simplified as far as I am able to do so.

I expect ongoing adjustments to improve robustness and performance, but I don’t anticipate any major architectural changes to the kernel for quite a while.

The major focus going forward will be in building up the Smalltalk tools, and in providing packaging options so that Vista Smalltalk can be easily integrated into larger .Net projects.

“15 Puzzle” in XAML

	;
Smalltalk Solution	XAML/C# Solution

On July 10, I posted a simple “15 Puzzle” game to this blog. The game took about 1 hour to write and consists of 68 lines of Smalltalk. It works on the Vista desktop or in IE7.

Yesterday, I was looking through some WPF examples in Microsoft’s SDK. They have also created a “15 Puzzle” game, but built using XAML.

Their solution has 15 files containing 1384 lines.

To make a more valid comparison between the two solutions, I would need to add some more functionality – say 15-20 lines of Smalltalk. And their solution could be shortened by a few hundred lines that only do graphic effects.

So, maybe a comparison of functionally equivalent solutions would be:
Smalltalk – 85 lines
XAML/C# – 1000 lines

A final point was that the Smalltalk game was built without extenal tools – I just used the ClassBrowser and a Workspace. The XAML/C# solution certainly used Visual Studio and probably used another tool (such as Expression Designer) as well.

Smalltalk can give users the power to write or modify programs in whatever browser or device that they are using. That could be decisive advantage as Web 2.0 evolves.