Recently I came to know and started to learn Smalltalk, an age-old pure Object-Oriented programming language. I fell in love with it quickly. Smalltalk is a very small language with some consistent concepts and abundant class libraries. I was puzzled at the very begining, as Smalltalk has very few keywords(maybe 5 I think), and those keywords don't includeany control structure(a.k.a if, while, for), how could we write programs? Althougth I know we could implement iterative sturucture via recursion, how about conditional execution? Finally I figured out that Smalltalk provides control strucutre in its class library only using some basic OO concepts. Followings are the codes from Smalltalk class library.
1Boolean>>ifTrue: alternativeBlock
2 self subclassResponsibility
3
4Boolean>>ifFalse: alternativeBlock
5 self subclassResponsibility
6
7"and True and False are subclasses of Boolean."
8
9True>>ifTrue: alternativeBlock
10 ^alternativeBlock value
11
12True>>ifFalse: alternativeBlock
13 ^nil
14
15False>>ifTrue: alternativeBlock
16 ^nil
17
18False>>ifFalse: alternativeBlock
19 ^alternativeBlock value
and then in some codes, we could do the conditional executionas follows
14 > 3 ifTrue: [Transcript show: 'Hello']
So that we could get the following code
14 〉3 ifTrue: [Transcript show: 'Hello']
which could be translated in Java like this:
new Integer(4).isGreaterThan(new Integer(3)).ifTrue(new BlockClosure() {
public Object value() {
System.out.println("Hello");
return null;
}
});
That's quite simple(some dynamic languages on JVM ,e.g. Groovy, do the same thing), but it indeed brings some profound changes to my thought.
First, considering that 'if','for' and 'while' are no longer pre-defined keywords, we could define our own control structures. For example, we could define Order has its own way to do something.
1anOrder ifExpired: [ do reactive order]
2 ifCanceled: [do something else]
Taking no account of performance and semantic speaking, there is no difference between the code above and undermentioned:
1 4 >3 ifTrue: [do something]
2 ifFalse: [do somthing]
More fancy, we could define a new test structure like this:
1anOrderTest should: [some assert] when: [do some initalize].
So we could have programmable control structure in Smalltalk ( something like we do in Lisp via continuation:) ), and define our own DSL easily.That's the amazing lightweight syntax feature in Smalltalk!
Second, we could get full capability of Von Nouma Style Programming Language via pure OO concepts.We could construct software in consistent OO concepts.
I began my adventure in Object technology by using C++ in 1995, and then I chose Java as my main working language. All my experiences about OO come from half-blooded OO language.So that for a long time, I thought Object-Oriented Programming is a big patch to imperative languages. The imperative languages are desgin to record the sequence of instruments which are used to manipulate the computer, so they are lack in semantic, and poor in abstraction. Though the Object technology introduces a successful type system and provides some abstraction mechanism, I still feel sucks to program in inconsistent concepts, because I should be careful about keeping programming more in OO-style rather than in procedural-style(something like Domina Model or not, sucks!).
Once I accused Object-Oriented Methodology of all the fault, I blamed imperfection on Object-Oriented Methodology.But now, I found out it's only because that I have little talent and learning in OO, it turned out to be my fault, I should say sorry to Object-Oriented Methodology.