Free Software takes a philosophical position toward software and how it should be shared. Open Source (OS) software, with the same practical position, does not share this philosophical position. Its position is more Free Software can improve the process to develop software.

Free Software (FS) is based one four simple freedoms:

  1. freedom to use the software
  2. freedom to redistribute the software
  3. freedom to study the software
  4. freedom to modify and to redistribute the software

FS does not care about the business aspect attached to software, it is not against it however it is deliberately socially targeted. This social dimension of FS software is very important, and it is for me an important difference with OSS. It makes the human been at the center. It is particularly clear with the freedom #3.

So how are all these considerations related to the Smalltalk paradigm?[1]

Before being a Smalltalk experienced coder, I was a C++ developer. With this language I wrote the Dr. Geo interactive geometry software, targeted for educators in mathematics. When we look at the Dr. Geo sources the barrier of entrance for an educator to study and to modify the source code is very high and for most users out of reach. I think it is a serious problem regarding the social dimension of the FS. Not only C++ is a complicate language, worst the environments to develop and to modify the source code are not intuitive and limited in their scope[2]. These problems appear in all the languages I have used but Smalltalk.

So what is special about Smalltalk?

In 1981, Dan Ingalls a founding father of Smalltalk, wrote in the Byte magazine:

The purpose of the Smalltalk project is to provide computer support for the creative spirit in everyone. Our work flows from a vision that includes a creative individual and the best computing hardware available. We have chosen to concentrate on two principle areas of research: a language of description (programming language) that serves as an interface between the models in the human mind and those in computing hardware, and a language of interaction (user interface) that matches the human communication system to that of the computer.

The focus is not only on a suited language for creativity for everyone but also a user interface to interact with it. This later point was very innovative 30 years ago, it is still innovative today. So what is exposed there is how to make as smooth as possible the access to creativity with software: it is true not only when creating new software but also when studying and modifying an existing software.

Indeed, with Smalltalk it is just so obvious to modify a software you are using. Not only with the key stroke [Alt]-b you access to the source code of the application your are using, but you can also modify its source code and all the processes of compilation and execution is done transparently. With Smalltalk the barrier of entrance to modify source code is very low and it makes it a wonderful tool perfectly matching the philosophical approach of Free Software.

Next Dan explained:

Personal Mastery: If a system is to serve the creative spirit, it must be entirely comprehensible to a single individual.

This principle is very strong and it clearly states the application source code and all its necessary components must be in the reach of the user. How is it explicitly done with Smalltalk and what are the consequences for the end user?

To achieve Personal Mastery as defined by Dan, Smalltalk is written in itself. If you take a script language like Python, this one is written in C and most of its libraries are also written in C. C is a different language, thus another environment, thus a barrier when one wants to understand the use or design of the Python class libraries. I remember how complicated it was for me when I wanted to understand how to use the GTK+ binding for Python.

In Smalltalk, the language itself is written in Smalltalk, it is circular: all the class libraries are written in Smalltalk, even the basic arithmetic or boolean operators or loop and test constructors are written in Smalltalk. The consequence is that for the user, it is just one mouse clic away (Implementor button in the class browser) to access to the definition of these classes. So again there is a direct access to the source to study a software as wished in the FS philosophy, with Smalltalk it is pushed very far to make it accessible to a lot of users.

Later Dan explained:

Good Design: A system should be built with a minimum set of unchangeable parts; those parts should be as general as possible; and all parts of the system should be held in a uniform framework.

This is the idea of Smalltalk being largely written in itself, thus only a minimal part of Smalltalk cannot be changed (6 keywords and 3 message sending protocols), then most of Smalltalk can be studied as any piece of Smalltalk code and of course modified if necessary by the end user.

I found it very interesting how Smalltalk, long time before FS, pushed very far this idea of the access to source code. This is a thought I want to share with you.

Notes

[1] Smalltalk is not only a programming language but also a way to interact with a computer.

[2] With these environments the user is limited to the source code of the software. From these environments, the user can't easily browse in the source code of the third party components (like widget and standard class libraries) used to developed the software itself, and of course the user can't modify easily these components.