PharoConf Annecy 2011

La première PharoConf Annecy aura lieu le jeudi 10 février à l'IMUS.

Site web de l'évènement: http://pharoconf-annecy.seasidehosting.st/

Les interventions seront plus tournées vers des coding-dojo et ateliers, développer du vrai code qui tourne :)

Deux points forts:
- Randori Test-Driven Development animé par Miguel Moquillon du Club Agile Rhône Alpes
- PharoSprint animé par Stéphane Ducasse

Entrée gratuite, mettez à jour vos agendas !

(Et merci de faire passer le message :)

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