Exploring objects

I’m following @jarober (James A. Robertson) in Twitter, Cincom Smalltalk Product Evangelist. He post links about news and resources about Smalltalk, and Cincom Smalltalk in particular. He writes a blog:

http://www.cincomsmalltalk.com/blog/View.ssp

powered by Smalltalk. If you visit his blog, there are many entries about Smalltalk. Recently, Robertson posted:

Smalltalk Daily: Exploring Objects

There is the video:

Robertson wrote:

Many times, you want to do something, know that it can be done – but just aren’t sure how to construct the code to do it. If you have an object, you can usually solve that problem by drilling into it with the inspector and looking at it. Today we learn how to programmatically change workspace page text by drilling into a workspace.

It’s refreshing to see such interaction with objects, so “Smalltalk-way” of interaction.

I should work on my Smalltalk VM (interpreter) AjTalk, to have support of visual interaction. My idea is to wire the current VM with .NET framework, WinForms. In this way, I could leverage the built-in GUI support in the framework. In these day, every language should take advantage of a class framework: .NET and Java are the obvious choice (see Clojure as a “modern” example of this strategy)

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

AjSharp programming language: a C#-like dynamic language

During the creation of AjGenesis, my code generation project, I defined an interpreted language, named AjBasic, used to write templates and tasks for code generation process. Last year, I began to separate AjBasic implementation of AjGenesis core, and as a proof of concept, I wrote AjSharp, another interpreted language but with more C#-like syntax, using the same core interpreter that I wrote for AjBasic. The core machine was AjInterpreter. More info at:

AjSharp- a C Sharp-like interpreter, work in progress

Now, this year, I started a clean implementation, inside my AjCodeKatas Google Code. The core interpreter is now AjLanguage, and AjSharp is the language with a parser that relies on the core “virtual machine” to build and execute an abstract tree:

Current source code (under development) can be downloaded from:

http://code.google.com/p/ajcodekatas/source/browse/#svn/trunk/AjLanguage

Variables, expressions and commands

Variables are untyped, and are automatically declared when they are used:

a = 1;

b = 2;

These variables contain integer values, but they can be assigned to values of other types:

a = “one”;

b = “two”;

The common commands are supported:

if (k>0)

 return;

for (k=1; k<=10;

k++)

 sum = k+sum;

while

(j<10)

 DoProcess(j);

foreach (element in

elements)

 AddElement(element);

Conditional expressions can be any expression, not only boolean ones. See above, False value explanation.

Functions and Subroutines

This is the sintax to write down a factorial function:

function Factorial(n)

{

 if

(n<=1)

 return

1;

 return n * Factorial(n-1);

}

The word “sub” can be used to define subroutines.

Functions and subroutines are like any other values. They can be defined without name and assigned to variables:

Add1 = function (n) { return n+1; }

two = Add1(1);

function Apply(func,values)

{

 list = new

List();

 foreach (value in

values)

list.Add(func(value));

 return list;

}

numbers = new

List();

numbers.Add(1);

numbers.Add(2);

numbers.Add(3);

function Square(n) { return n*n; }

squared = Apply(Square, numbers);

squared2 = Apply(function (n) { return

n*n; }, numbers);

Native .NET objects

One of the design goals of AjLanguage core is to have access to .NET objects. They can be created using the new keyword:

ds = new System.Data.DataSet();

dinfo = new System.IO.DirectoryInfo(“.”);

foreach (fi in dinfo.GetFiles()) {

PrintLine(fi.FullName);

}

Dynamic objects

Dynamic objects can be created using the new keyword. A dynamic object accepts new members (variables and methods):

dynobj = new DynamicObject();

dynobj.FirstName = “Adam”;

dynobj.LastName = "Genesis”;

dynobj.Age =

800;

dynobj.FullName = function() { return FirstName + “ “ + LastName; }

Another notation:

dynobj = new { Name = “Adam”, Age = 800 };

Another notation:

dynobj = new { var FirstName = “Adam”; var LastName = “Genesis”; function

FullName() { return FirstName + “ “ + LastName; }

Dynamic objects are defined automatically, setting theirs properties:

Project.Database.Provider = “…”;

Project.Database.ConnectionString =

“…”;

creates Project dynamic object, with a Database property pointing to another dynamic object. It’s equivalent to:

Project = new DynamicObject();

Project.Database = new

DynamicObject();

Project.Database.Provider =

“…”;

Project.Database.ConnectionString = “…”;

An experiment: lists are defined automatically using Add method:

Project.Entities.Add(new { Name = “Customer”, Table = “dbo.Customers” });

it’s equivalent to:

Project = new DynamicObject();

Project.Entities = new

List();

Project.Entities.Add(new { Name = “Customer”, Table = “dbo.Customers”

});

Dynamic classes

A class can be defined using this sintax:

class Person {

 var FirstName;

 var

LastName;

 var Age;

 function

FullName {

 return FirstName + “ “ +

LastName;

 }

}

A new instance can be created as usual:

adam = new Person() { FirstName = “Adam”, LastName = “Genesis”, Age = 800 };

The instance is dynamic: new members can be attached to it, and methods could be redefined:

adam.FullName = function() { return “The “ + FirstName; };

You can create class as values:

Person = new DynamicClass();

but the interface to add members is still in flux.

Defined Classes

There are some predefined classes:

dynobj = new DynamicObject();

list = new List(); // implementing 

IList

dict= new Dictionary(); // implementing IDictionary

Primitive Functions

A few functions and subroutines are predefined:

Print(“Hello”);

PrintLine(“Hello World”);

There three predefined functions to execute and evaluate dinamic code:

Include("program.ajs");

Evaluate("k+1");

Execute("k=1;");

Include execute the commands in a file. Evaluate parses and evaluate an expression. And Execute compile and execute commands.

False value

Anything that is false, null, zero or empty string, is evaluated as false in conditional expression:

if (k)

 PrintLine(“true”);

else

PrintLine(“false”);

The above command prints “false” on execution, if k is zero or undefined. If a variable is undefined, any access to its member returns null, instead of a null exception:

if (Project.Database.ConnectionString)

PrintLine(“true”);

else

 PrintLine(“false”);

This command prints “false” again, if variable Project is undefined.

Arrays, List and Dictionaries

Native arrays can be defined with length:

firstprimes = new int[10];

or with values:

firstprimes = new int[] { 1, 2, 3, 5, 7, 9 };

A list is created if you need a dynamic array:

numbers[0] = “zero”;

numbers[1] = “one”;

numbers[2] =

“two”;

numbers[3] = “three”;

A dictionary is automatically created if the subindices are not numeric:

numbers[“one”] = 1;

numbers[“two”] = 2;

numbers[“three”] = 3;

If you need more feature, remember, you can use the native .NET framework.

Console interface

The project AjSharp.Console is a console application, where you can enter and execute AjSharp commands (not expressions):

No command to exit, yet. Just control+c in Windows.

Next steps

There are so many features I want to add. Partial list:

- AjBasic as another language over AjLanguage

- Generics support

- Template support (as in AjGenesis)

- Integrate to AjGenesis code generation

- Compile AST to Dynamic Language Runtime

Angel “Java” Lopez

http://www.ajlopez.com

http://twitter.com/ajlopez

Lord of the REPLs (Read Eval Print Loops) and CodePad

These days, I’m implementing interpreted language. My first interest is Clojure, my work is an implementation using C#, written from scratch, you can see the progress at:

http://code.google.com/p/ajlisp/source/browse#svn/trunk/AjSharpure

Last year I wrote a Lisp interpreter AjLisp- a Lisp interpreter in .NET, that I should improve, but past weeks, I started to write an Scheme-like language:

http://code.google.com/p/ajlisp/source/browse#svn/trunk/AjScheme

With so much activity on Lispy languages, I did research about many implementations. My discoveries were collected, as usual, in my delicious:

http://delicious.com/ajlopez/lisp
http://delicious.com/ajlopez/clojure
http://delicious.com/ajlopez/scheme

One of the gems I discovered, is this Google App Engine tool:

http://code.google.com/p/lotrepls/

LotREPLs is a multi-lingual read-eval-print-loop in your browser powered by Google App Engine and the Java runtime. It’s a technical demo, not something to do serious work with. The following languages are supported:

• BeanShell
• Clojure
• JavaScript
• Python
• Ruby
• Scala
• Scheme

You can try it a:

http://lotrepls.appspot.com/

You can enter your command, and see the result of evaluation, without installing nothing in your machine.

Another discovery, supporting C, C++, D, Haskell, Lua, Ocaml, PHP, Perl, Python, Ruby, Scheme, Tcl, is:

http://codepad.org/

codepad.org is an online compiler/interpreter, and a simple collaboration tool.
Paste your code below, and codepad will run it and give you a short URL you can use to share it in chat or email.

The code you enter and run, can be referenced by an URL, to share with other developers:

Some day, all our tools will be in the browser…

Angel “Java” Lopez
http://www.ajlopez.com
http://twitter.com/ajlopez

Remember Clipper

These days, I’m working in a reimplementation of a full health systems, originally written in the venerable programming language Clipper. It’s a big project, with many use cases, including administration, pharmacy, stock, diets, health management.

I met DBase II at early 80s. It ran in many operating systems, as an interpreter. At late 80s, I met Clipper from Nantucket, for DOS. Some of you remember Fox, adquired by Microsoft years later.

I found some info about Clipper. Those interested in the language, can visit:

CA-Clipper 5.3 . Guide To CA-Clipper – Menu

Clipper (programming language) – Wikipedia, the free encyclopedia

Code examples at:

The Oasis Clipper Source. Over 300,000,000,000 bytes served!

Frequent asked questions about Clipper and related stuff:

Frequently Asked Questions (FAQ 2.31) about CA-Clipper and CA-Visual Objects

One of the member of the development team, commented that while Clipper was from Nantucket, it kept updated, but when it was bought by Computer Associates, it entered in a shadow, full of pitfalls, so it was surpassed by other options.

If you still have Fox, Clipper, DBase files in your disk, you can check the products from:

CodeBase Products Overview

It seems an interesting open source project, with SQL Server support, running in many plataforms, implementing a Clipper to C compiler:

Harbour Project

As language, Clipper had its quirks, as:

- The use/abuse of SET, as in SET EXACT OFF, SET EXACT ON, that modifies the behaviour of the application
- The concept of work areas
- Thinks like MEMVARS, that I still to understand)

I’m having fun, writing an interpreter, AjClipper in C#:

I have two simple programs running using my interpreter:

? "Hello World"

y

? "This is a test"

foo := "Hello"

bar := "World"

? foo, " ", bar

You can run them using

AjClipper.Console HelloWorld.prg SimpleTest.prg

It’s not a “killer application”, but it´s taking form. You can see my advances in my AjCodeKatas trunk:

http://code.google.com/p/ajcodekatas/source/browse/#svn/trunk/AjClipper

Están escritos los tests (dando verde, por ahora):

Good Code Coverage:

 

I´m adding any interesting link about Clipper under http://delicious.com/ajlopez/clipper

I could write an interpreter for Visual Fox dialect? I should study http://delicious.com/ajlopez/visualfox

Angel “Java” Lopez

http://www.ajlopez.com/en

http://twitter.com/ajlopez

Presenting AjCat

Some weeks ago, I was working on an interpreter of the Cat language:

The Cat Programming Language

Cat is a functional stack-based programming language inspired by the Joy programming language. The primary differences is that Cat provides a static type system with type inferencing (like ML or Haskell), and a term rewriting macro language extension language called MetaCat.

Cat is a high-level intermediate language translation that can also be used as a stand alone language for simple application development. In this way it occupies a similar niche to PostScript. Cat is also an appropriate language for teaching of basic programming concepts.

If you are not familiar with Cat language, you can learn more at:

Cat Tutorial
Cat Specification
Cat Primitives

I published the code as part of my Code Katas Google code project. It’s named AjCat:

http://code.google.com/p/ajcodekatas/source/browse/#svn/trunk/AjCat

The solution contains three projects:

The implementation is not complete. It’s only support integers, no .NET object support yet, and no graphics primitives.

Running the console program, you can enter and evaluate expressions:

This code is dedicated to Rodolfo Finocchieti (@rodolfof in Twitter) who pointed me to Cat language, a fascinanting idea.

Tests are green:

And good code coverage

Angel “Java” Lopez
http://www.ajlopez.com/
http://twitter.com/ajlopez

TDD and Code Kata: Writing a Lexer for AjRuby

Usually, I write programs as code katas, to train me in some software development topics. During last months, I wrote many mini interpreters, using TDD-like approach, code coverage, and C#. Past week, I was working in the kickoff of yet another one, AjRuby. The starting point: the lexer.

A lexer is a program that analizes a source code text, and returns the tokens, the "words" that compose the program. In the case of AjRuby, I wrote a lexer that follows the Ruby language grammar. It’s not complete yet, but it’s working.

You can see my progress at my code katas Google code project:

http://code.google.com/p/ajcodekatas/source/browse#svn/trunk/AjRuby

The solution has a library project, and a test project:

It has a Token class, that represents each token:

    public class Token
    {
        public string Value { get; set; }

        public TokenType TokenType { get; set; }
    }

The TokenType is an enum:

    public enum TokenType
    {
        Name,
        Integer,
        Real,
        Boolean,
        String,
        Operator,
        Separator
    }

There is a LexerTest.cs class, containing tests like:

        [TestMethod]
        public void ShouldProcessName()
        {
            Lexer lexer = new Lexer("name");

            Token token;

            token = lexer.NextToken();

            Assert.IsNotNull(token);
            Assert.AreEqual(TokenType.Name, token.TokenType);
            Assert.AreEqual("name", token.Value);

            token = lexer.NextToken();

            Assert.IsNull(token);
        }

There is a test for every kind of token to be processed. Other example:

        [TestMethod]
        public void ShouldProcessNameWithInitialUnderscore()
        {
            Lexer lexer = new Lexer("_name");

            Token token;

            token = lexer.NextToken();

            Assert.IsNotNull(token);
            Assert.AreEqual(TokenType.Name, token.TokenType);
            Assert.AreEqual("_name", token.Value);

            token = lexer.NextToken();

            Assert.IsNull(token);
        }

I wrote the tests using TDD ideas: write the test, compile with error, fix the compiler issues, run the tests in red, fix them, get green status. I skipped most of the refactor steps. I guess the tested code could be improved, but by now, I’m trying to get a working lexer. The tests are in green state, good!

My goal is to have > 80% of code coverage, at any time during the project development:

It’s good to write something only for fun and learning. For me, it’s part of the continuous improvement every software developer should pursuit.

Angel "Java" Lopez

http://www.ajlopez.com/en

http://twitter.com/ajlopez

Presenting AjLambda: Lambda calculus implementation in C#

I was working on my “code kate” AjLambda, a Lambda Calculus implementation, written using C#:

http://code.google.com/p/ajcodekatas/source/browse/#svn/trunk/AjLambda

(If you are new to Lambda Calculus notation, there are tutorial links at the end of this post)

Yes! It’s the geeky project I wrote this year…;-).. The solution is simple, it contains three projects:

It has a core library, AjLambda, a test project AjLambda.Tests and an AjLambda.Console program to run. The core library has few main classes:

Expression is the base abstract class. .Reduce is the method that implements the reduction of an expression. .Replaces is used to change a variable by other. Sometimes, it’s needed to choose a new name for a variable, that it doesn’t collides with another free variable name. .FreeVariables is the method to obtain the list of free variables in an expression. For example, in the lambda expression:

\x.xy

x and y are variables, but y is a free variable, and x is a bound parameter.

Variable express the variable (a lower-case letter in this implementation). Lambda is the lamba (parameter plus body). The lambda is entered using:

\x.x

The short version with multiple parameters is supported:

\xy.yx

This is the .Reduce implementation for Pair (a pair of expression, left and right): 

        public override Expression Reduce()
        {
            if (this.left is Lambda)
                return ((Lambda)this.left).Apply(this.right);

            Expression newLeft = this.left.Reduce();

            if (newLeft != this.left)
                return new Pair(newLeft, this.right);

            Expression newRight = this.right.Reduce();

            if (newRight == this.right)
                return this;

            return new Pair(newLeft, newRight);
        }

Running AjLamnda.Console with a parameter:

AjLambda.Console Boot.l

loads the auxiliary file Boot.l, where I defined some predefined functions:

; True
T = \xy.x
; False
F = \xy.y
; And
AND = \ab.abF
; If Then Else
IFTHENELSE = \x.x
; Natural numbers
0 = \fx.x
1 = \fx.fx
2 = \fx.f(fx)
3 = \fx.f(f(fx))
; Succesor
SUCC = \nfx.f(nfx)
; Add
ADD = \nmfx.nf(mfx)
; Multiply
MULT = \nmf.n(mf)
; Is Zero
ISZERO = \nxy.n(\z.y)x
; Predecessor
PRED = \nfx.n(\gh.h(gf))(\u.x)(\u.u)
; Pair Functions
PAIR = \xyf.fxy
FIRST = \p.pT
SECOND = \p.pF
NIL = \x.T
NULL = \p.p(\xy.F)
; Fixed Point
A = \xy.y(xxy)
Y = A A
; Factorial
FACT = Y (\f.\n.IFTHENELSE (ISZERO n) (1) (MULT n (f (PRED n)))))

You can ask about the predefined names. I defined the first natural numbers, including zero:

Names are words that begin with upper case letter. Variable names are lower letter (from ‘a’ thru ‘z’, only one letter per variable).

As usual, I defined SUCC and PRED (succesor and predecessor functions):

Each reduction step is printed, until no more reduce is possible.

You can define new functions using Name = <expression>:

More information about Lambda Calculus at:

Lecture Notes on the Lambda Calculus (pdf) (excellent paper to learn Lambda Calculus)

Peter Selinger- Papers

Lambda calculus – Wikipedia, the free encyclopedia

A Tutorial Introduction to the Lambda Calculus

http://delicious.com/ajlopez/lambda

Lambda Calculus implementation from Fred’s Page

Angel “Java” Lopez
http://www.ajlopez.com/
http://twitter.com/ajlopez

Dynamic Expressions Example

Yesterday, I was preparing a presentation for today, explaining lambda calculus, its history, and lambda application in languages. At the end of presentation, I’ll discuss lambda ideas in .NET: delegates, lambda notation, and lambda expression.

During a quick research, I found a really cool implementation of dynamic expression parsing, in the example:

DynamicLinq.cs

That code points as source the “the Gu” blog post:

Dynamic LINQ (Part 1- Using the LINQ Dynamic Query Library)

The code is included in the DynamicQuery directory in:

C# Dynamic Query Library (included in the -LinqSamples-DynamicQuery directory)

My initial idea was to write a formula graph winform app, using System.Linq.Expressions. But the above implementation has a notable feature: instead of buildin an expression tree composing a expressions, it takes an string (!!!) and parse on the fly, converting to a compiled version.

OK, this trick is used by many Linq query implementations, but I didn’t know that the code samples from Microsoft include this code.

Using the DynamicLinq.cs, I was able to create a Win Form app:

Note that you can use classes from .NET. “x” is the parameter I use to calculate the formula.

This is a key code in the Calculator.cs file:

 

        public Delegate CompileFormula(string formula)
        {
            ParameterExpression x = Expression.Parameter(typeof(double), "x");
            LambdaExpression e = DynamicExpression.ParseLambda(new ParameterExpression[] { x }, null, formula);
            return e.Compile();
        }

The compiled Delegate, can be invoked, provided the “x” parameter value:

 

        public double[] Calculate(Delegate formula, double from, double to, double step)
        {
            List<double> values = new List<double>();

            for (double x = from; x <= to; x += step)
                values.Add((double) formula.DynamicInvoke(x));

            return values.ToArray();
        }

You can download this sample code from:

http://code.google.com/p/ajcodekatas/source/browse#svn/trunk/DynamicExpressionsExample

Another dynamic implementation:

To Bind or Not To Bind – Dynamic Expression Trees – Part 3 – B# .NET Blog
To Bind or Not To Bind – Dynamic Expression Trees – Part 2 – B# .NET Blog
To Bind or Not To Bind – Dynamic Expression Trees – Part 1 – B# .NET Blog

Some ideas:

- Extend the example to 3D (I could use the F#/DirectX visualization demo as a base code)

- Send a formula as text, to be processed in a distributed application, grid, or HPC cluster.

- Code kata writing a .Parse and .Compile to any of my scripting languages

If you need more power, the next level of dynamic languages and their compilation, using .NET, is the Microsoft.Scripting namespace in IronPython source code:

http://www.codeplex.com/IronPython/SourceControl

Introductions to IronPython, DLR initiative:

CLR Inside Out- IronPython and the Dynamic Language Runtime
CLR Inside Out- Dynamic Languages and Silverlight
InfoQ- Microsoft Surpasses Java’s Dynamic Language Support-
CLR Inside Out – IronPython

Related links about lambda, Dynamic Language Runtime, and dynamic languages in general:

http://delicious.com/ajlopez/lambda
http://delicious.com/ajlopez/dlr
http://delicious.com/ajlopez/dynamiclanguages

Angel “Java” Lopez
http://www.ajlopez.com/en
http://twitter.com/ajlopez

AjBasic: an open source Basic-like interpreter

My code generation project AjGenesis uses a interpreted language to execute tasks and expand templates. The language was named AjBasic. It’s used in all the examples I wrote with AjGenesis (more info at AjGenesis posts). Years ago, I had separated the interpreter code from the mother project. This weekend, I was refactoring the code. The result is now published at:

http://code.google.com/p/ajbasic/

In my opinion, Google Code is easy to manage. Contrary to SourceForge and CodePlex, they are using Subversion as code repository. I use the Tortoise SVN client to checking the changes. Google people are gentle: I can create many projects, until now:

http://code.google.com/p/ajlisp (it’s in good form, I guess)
http://code.google.com/p/ajtalk (it’s still in its infancy)

More info in previous posts:

AjLisp- a Lisp interpreter in .NET
AjTalk- a Smalltalk-like interpreter

The Solution

The solution AjBasicWithTests is composed by the projects:

AjBasic: It implements the compiler and tokenizer. The tokenizer separates the incoming text in tokens. The compiler makes abstract trees from such input.

AjInterpreter: A new project, not present in AjGenesis. It contains all the support for the abstract tree, its nodes, the environment for values, and an evaluator of programs. The management of .NET objects, and dynamic objects, are in this project, too. My intention is to continue to use this project to support other interpreted languages.

AjBasic.Console: A simple console to test the interpreter.

AjBasic.GUI: A simple (and ugly) WinForm to test the interpreter.

AjBasic.Test: Some test fixtures, using NUnit (there is another solution AjBasic that not includes the tests)

All the projects are written using Visual Basic .NET. The solution was compiled using Visual Studio 2005. The console and GUI project could be used as a base that explains how to use the interpreter from your own application.

There are many points to discuss about the implementation: they would deserve future posts. By now, let’s explore some of the main features of the project, at its current status. Then, I’ll write down some ideas to explore in future versions.

As I mentioned, the language was born to support code generation inside AjGenesis. I designed it to manage native .NET objects, as dynamic object. But, what is a dynamic object? Its an object that has no class, but that can be expanded with new properties (the nearest example I could think now, are the Javascript objects).

So, you can write code like this:

a.FirstName = “Adam“ a.LastName = “Doe“ a.Age = 800

You don’t have to declare the variable. You can create the object and add the property FirstName in one command (this automatic creation of object is not supported in AjGenesis, yet).

You can test the existence of a property:

if a.LastName then ‘ it has a LastName not nothing else … end if

If the variable a has no assigned value, or if it has no LastName property, the above condition is evaluated to false. You can test something like foo.bar.anything and no exception is raised. The result value would be a nothing, what is evaluated as a false in a condition.

The Tests

The solution was not developed using TDD (Test-driven development). Instead, I wrote the tests after the code, only to be sure the core functionality were well implemented, according to my expectations. I didn’t use descriptive names, but they were useful when I refactored the full solution:

You can try the language from the console AjBasic.Console:

and from the WinForm AjBasic.GUI

None of the above is the “ultimate app”, but they work…

Next Steps

There are many ideas flying near my remaining neuron, and I have to put order on them. Some points, for the record:

- Now the interpreter core is separated from compiler, I could write AjSharp, an interpreter with C# syntax. Then, it could be added to AjGenesis, to write templates in a language more palatable to die-hard C# programmers.

- Add support to dynamic classes and prototypes.

- Refactor the tests

- Write down a minimal manual, explaining the language and its features

- Extend the language to support delayed values and delayed evaluation

- The internal form of this interpreter could be rewritten in Java

- The option to write an AST related to DLR support doesn’t attract me, it could be a lot of work. But it could be interesting to learn more about .NET DLR.

- Use the language as the basis for programming distributed agents (an ambitious point, that deserves more evaluation).

As usual, I had fun written this software.

Angel “Java” Lopez
http://www.ajlopez.com/en

New Smalltalk Site: ClubSmalltalk.org

These days, this new site dedicated to Smalltalk was launched:

http://www.clubsmalltalk.org/

According to the site:

ClubSmalltalk.org is a non-profit organization which congregates Smalltalk programmers and enthusiastics. In 2008, we are going a step forward with this new website.
The big idea behind this website is to provide a source of information about Smalltalk in general.
The Smalltalk community has not good sources of information, or they’re all over the net, and sometimes it’s difficult to find them.

If you want to contribute, you’re welcome!

It’s an spinoff of the activity of the Spanish mailing list:

http://groups.google.com/group/clubSmalltalk

Some of the most popular articles published:

Interview with Luca Bruno, the creator of Smalltalk YX

Argentinian Smalltalk Congress- Smalltalks 2008

Seaside and Ruby on rails

It has sections:

FAQs:

Smalltalk Frequently Asked Questions

GemStone Frequently Asked Questions

Environments:

Commercial Smalltalk Environments

Free Smalltalk Environments

Abbandon Smalltalk Environments

Frameworks, Platforms & Tools

and more: Tools, Resources, Community. It has links to Smalltalk Books, like:

Free Books 

Thanks to the work of Stéphane Ducasse, we have a huge collection of Free Smalltalk books online.
Download from http://www.iam.unibe.ch/~ducasse/FreeBooks.html

Creative Common Books

Our friend Diego Gomez Deck has written an excellent book in Spanish to start in Smalltalk. You can buy a hardcopy or you can download it under the creative common licence from http://smalltalk.consultar.com/.
If you like it, we recommend to buy it, we are proud of this kind of projects.

The site is in its infancy, but I hope that with the help of the Smalltalk community, it will grow and become a reference to anyone interested in ST.

It’s supported by PHP. In my opinion, it’s a good sign: for years, Smalltalk community was reluctant to integrate or use other tools or technologies. In these days, with the plethora of languages, frameworks and platforms, we must abandon such isolated trend, and be more integrated.

Angel “Java” Lopez
http://www.ajlopez.com/