Welcome to Smalltalk.org.
Getting The Message
The Essentials of Message-Oriented Programming with Smalltalk
By Alan Lovejoy
Smalltalk is a foundational programming language that is based on pervasive message passing
, pervasive dynamic strong typing
, pervasive reflection
and pervasive object orientation
: Almost all computation in Smalltalk happens via the sending of messages. The only way to invoke a method is to send a message—which necessarily involves dynamic binding (by name) of message to method at runtime (and never at compile time.) The internals of an object are not externally accessible, ever—the only way to access or modify an object's internal state is to send it a message. So function and data abstraction are both complete and universal. Pervasive message passing
is Smalltalk's most important feature—a point that was lost on most of those who have tried to emulate Smalltalk when designing other programming languages.
The full import of "object-oriented programming" as originally defined by Dr. Kay—and how and why the meaning of "OOP" as it applies to Smalltalk differs from the meaning of "OOP" as commonly understood outside of a Smalltalk context, is fully explained in the sections that follow. In addition, Dr. Kay's article "The Early History of Smalltalk" is highly recommended reading for anyone who wants to gain an even deeper insight into why and how Smalltalk came to be what it is, and why it is so different from the mainstream programming languages.
Smalltalks 2009 Argentina Conference
All those connected with Smalltalk, be it faculty, students, researchers, developers or entrepreneurs, are invited to participate, free of cost, as presenters and
members of the audience. The organization committee will announce the registration website shortly.
The conference's goal is to gather both the Argentine and International Smalltalk community to get connected sharing our work and experience with regards to Smalltalk
or related topics. Smalltalks 2009 presentations will be divided between the "Industry and Development" and "Research and Education" categories. In addition, the event
will host a Smalltalk programming contest. As in other editions, well known personalities from the international community will attend the conference.
Argentina's third Smalltalk conference, Smalltalks 2009, will be held from November 19th through November 21rd at the Facultad de Ciencias Exactas y Naturales (FCEyN),
Universidad de Buenos Aires (UBA).
2010 International Smalltalk Conference
The 2010 edition of the largest European Smalltalk event will include the regular Smalltalk developers
conference with renowned invited speakers, a Smalltalk camp that proves fruitful for interactions and discussions.
This year will see the 5th edition of the Innovation Technology Awards where prizes will be awarded
to authors of best pieces of Smalltalk-related projects and an international workshop on Smalltalk and dynamic languages.
The 2010 ESUG conference will be held at Sept 11 to 17 in Barcelona, Spain.
Remember to send smalltalk dot org your event schedules, links and graphics. [:)]
ANSI Smalltalk Standard Group ANNOUNCEMENT
Written by Bruce Badger
in a posting to comp.lang.smalltalk
I have had a conference call with representatives of INCITS and it seems that getting the process
restarted to revise the ANSI standard for Smalltalk is very doable.
The first step is to submit a proposal for the project of working on the Smalltalk standard.
If the proposal is successful the outcome will be some form of committee which we must then populate and put to work.
CONTINUOUS NUISANCE DOUBLE TYPE COGNITIVE DISSONANCE TAX
Written by Peter William Lount, [ | peter at smalltalk dot org ].
A "DOUBLE TYPE TAX" is a perfect way to describe any language that forces the
user or programmer to "type" as in typing characters the "type" specification of
every variable. How tedious typing type information is, and it's only of limited
use. Anytime type information is really needed in a program it can be checked at
runtime with minimal or insignificant cost. In fact many programs ultimately run
faster with type-less languages, aka dynamic languages, such as Smalltalk. This
is because many programs tend to be disk bound or thrash the cache anyhow, and
significantly because of the poor implementations of class libraries in
languages that force type specifications upon poor unsuspecting programmers who
don't know any better or who don't want to change and adapt to a world of
programming free of type specifications on variables, parameters, etc...
By virtue of their success dynamic typeless languages are valid programming
models which drives type-focused programming types crazy.
All type checking is simply redundant at compile time. It's effectively useless
except for detecting a few categories of errors and for a few optimizations.
Languages with types are effectively not any higher level than C or Assembly
What especially drives "type fiends" nuts is that there are those of us who
recognize that dynamic languages are far superior to typed language programming
paradigms. We rain on their parade.
Types have their purpose but it's very limited and should be banned from
programming languages for the most part. The main difference between a type and
an untyped language is that in untyped language, say Smalltalk for example, the
so called "type" information is attached to the object itself and not to the
variable/parameter slot. This allows tremendous flexibility and most importantly
FREEDOM from the DOUBLE TYPE TAX.
Learning to Talk: Introduction to Talking
Written by Jeffrey Massung
My first exposure to Smalltalk was around 2001. It was using Smalltalk MT, and I created a simple raytracer with it (that was the typical pet project I did with all new languages at the time). It turned out reasonably well. I didn't really understand much about Smalltalk at the time other than the syntax and how to move around the environment. Once I did enough to feel that I had a "reasonable understanding" of the language, I put it down and moved onto other things....
First, let me say that the boys (Andy Bower and Blair McGlashan) at Object Arts did an absolutely fantastic job with their presentation of the language. All implementations I'd seen to-date were either very foreign (Squeak) or extremely "old" (ObjectStudio, MT). This not only looked and felt modern, it actually had all the features a professional programmer expects from a development environment: syntax highlighting, view composing, source control (built in), tutorials, and more, all presented very elegantly. Andy and Blair really took their time and got it right!
The Essence of Smalltalk
Smalltalk and it’s usage in Microsoft’s .Net
Written by Aditya Dutt
Smalltalk was one of the first systems to pioneer the WIMP (Windows,
Icons, Menus and Pointers) interface. Compared to conventional
programming languages such as C or Pascal, Smalltalk has an unusual
syntax. Objects are employed to represent everything in Smalltalk,
including all the conventional data types that may be found in any
programming language: such as integers, Booleans, floating-point
numbers, characters, strings, arrays. In addition to this, objects
are used to represent display items such as menus, windows and even
the compiler itself. Smalltalk is therefore described as a uniformly
object-oriented language. Smalltalk language was developed at the
Xerox Palo Alto Research Center in 1970s, the programming environment
greatly influenced the development of Apple Macintosh and Microsoft
has an extended version of Smalltalk-80 called VisualWorks (derived
from the original ParcPlace version), which provides window-building
facility and database connectivity.
IBM's VisualAge is a development environment designed to support the
easy creation of software applications on multiple platforms. IBM
Smalltalk provides a platform-independent application program
interface (API) based on industry standards.
Bytecode-to-bytecode adaptive optimization for Smalltalk
Submitted by Scott Bleackley
Edited by Peter William Lount
"Smalltalk is a vision of the computer as a medium of self expression. ... A humanistic vision of the computer as something everyone could use and benefit from. If you are going to have a medium for self expression, programability is key because unless you can actually make the system behave as you want you are a slave to what's on the machine. So it's really vital, and so language comes to the for because it's through language that you express yourself to the machine."
- Elliot Miranda
Dynamic Runtime Type-Object-Class Inference
By Peter William Lount
Run time type inference is a technique that has long been applied to dynamic programs to recover the type information while the program is running. It was experimented with at Xerox Parc. It is known that Dynamic Type Inference "recovers" type information - well recovers is not really the most accurate term, maybe "discovers" is better - and that the information may have additional uses. For example, the Self system uses this runtime "type/class" information of the prototypical objects to customize and recompile methods under the covers and on the fly which enables some performance optimizations. Other uses are certainly possible such as using the information for Refactoring.
Exploring Type Safety in Smalltalk
By Peter William Lount
Something magical happens when "manifest" type information is left out of programs. Smalltalk is an excellent example of this magic. While adding type information has it's benefits it also alters the shape of how you build programs. As there are somethings that can be done with "manifest typed" programs that can't be done with dynamic programs, the reverse is also especially true: untyped, non-typed, or dynamic programs have special capabilities that typed systems don't have. It's very interesting that a line in the sand between typed and dynamic systems exists, very interesting indeed. How do we know this line exists? The evidence is simple and based upon facts, Smalltalk exists and works well - very well - without the need for types. In addition when types are added to Smalltalk the way that you program changes, limits are now placed upon variables, parameters, and return values that alter the "shape", "nature", and "style" of code writing. These changes have a huge impact upon the flexibility, terseness and other advantages that Smalltalk has to offer.
Dynamic Systems are where Capability Rules
"Isn't the Meijer/Drayton paper
trying to bridge the divide by pragmatically adopting
what form of type checking is necessary at
any given point instead of taking absolutist positions?" - Dilip asked.
Ah NO! What gave you that idea? Their paper has very little to actually say about dynamic typing.
Essentially it rants about the authors desired "type" straight jackets and does little if nothing to
bridge the "gap" between these very different styles of programming languages.
Moving Forward Towards The Right Kind of More Less
Michael Lucas-Smith writes:
"I firmly believe in "less is more", so long as it's the right kind of less.
There are lots of languages out there that declare types for instance variables.
Smalltalk doesn't - but it does make you declare instance variables.
This, I think, is a bad thing. It means that the shape of a class must be "overridden"
if you want to "extend" it to do more jobs. So my first change to Smalltalk would be to
remove instance variable declaration."
, article series
, blog headlines
Remember to Meet Up
with other Smalltalkers to contribute, learn and earn. Monthly
meetings are happening in your area now. Join in. Do it Now!
Smalltalk.org is seeking Smalltalker to contribute articles. Expand your horizons, contact us.
1999-2010 by Smalltalk.org, All Rights Reserved.
October 25 2014
On speaking languages
naturally with ease
aiming for fluid fluency.