Petite horloge

Morphic basics with a little Watch (Horloge in french).

Add the class:

StringMorph subclass: #Horloge
 instanceVariableNames: ''
 classVariableNames: ''
 poolDictionaries: ''
 category: 'Sandbox'

One method called periodically thanks to stepping mechanism of Morphic:

Horloge>>step
 self contents: Time now printString.

Then evaluate in a Workspace:

Horloge new openInWorld.

Stop the watch:

Horloge allInstances last stopStepping

Start it again:

Horloge allInstances last startStepping

Finally close it:

Horloge allInstances last delete

My cat is a Linux geek :)

Revenge of Smalltalk

(Joke inside)

In Paul Graham's essay Revenge of the Nerds (Read it, good ideas there):

Appendix: Power

As an illustration of what I mean about the relative power of programming languages, consider the following problem. We want to write a function that generates accumulators-- a function that takes a number n, and returns a function that takes another number i and returns n incremented by i.

(That's incremented by, not plus. An accumulator has to accumulate.)

In Common Lisp this would be

(defun foo (n)
  (lambda (i) (incf n i)))

In Smalltalk the code is slightly longer than in Lisp:

foo: n                              
  |s|                      
  s := n.                          
  ^[:i| s := s+i. ]

because although in general lexical variables work, you can't do an assignment to a parameter, so you have to create a new variable s.



Well, the Lisp code has 34 significant characters while the Smalltalk code has only 25 significant characters (we can remove the last dot). So the Smalltalk code is 26% shorter than the Lisp code :)

• Perl example: 32 characters
• Javascript example: 46 characters
• Python example: 54 characters

Yeah, Smalltalk is really powerful ;P

Update:
Looking at Parser code we can easily remove the temp. variable limitation and write:

foo: n               
  ^[:i| n := n+i]

So

• One power of Smalltalk is to be able to change the system.
• 17 significant characters: Smalltalk 100% more powerful than Lisp :D
(still a joke - but ....)

Why this design decision ? Some explanation from Nicolas and Adrian.

Three views of OO Programming

By Ralph Johnson, quoted in The Myths of Object-Orientation p.624:


I explain three views of OO programming. The Scandinavian view is that an OO system is one whose creators realise that programming is modelling. The mystical view is that an OO system is one that is built out of objects that communicate by sending messages to each other, and computation is the messages flying from object to object. The software engineering view is that an OO system is one that supports data abstrac- tion, polymorphism by late-binding of function calls, and inheritance.


It seems that in (French) schools we learn the engineering view. Then with experience we can agree on the mystical view. With Smalltalk I think I now understand the Scandinavian view.


Oscar Nierstrasz have written in Ten Things I Hate About OOP:

For me the point of OOP is that it isn’t a paradigm like procedural, logic or functional programming. Instead, OOP says “for every problem you should design your own paradigm”. In other words, the OO paradigm really is: Programming is Modeling

Autotest for Pharo

I've started a new little project. Autotest is a live testing tool (similar to Ruby Autotest, but the Smalltalk way, more dynamic).

Autotest automatically runs tests related to the method you edit. Screencast to see it in action: 

Autotest uses the following heuristics to find the tests to run:

- if the method is a test, runs it

- it the method is a test setUp or tearDown, run all the tests of the TestCase

- else find all senders which are tests in the same package and runs them (it detects different packages that are related, for example ProfStef-Core and ProfStef-Test)

To activate the Autotest dashboard:

- open the settings browser

- go under System

- check "Show Autotest Dashboard" option

To load it:

Gofer new

squeaksource: 'Autotest';

package: 'Autotest';

load

HelpSystem book included.