Prendo spunto dal grandissimo lavoro svolto da Livio Sandel per provare, a partire da oggi e con cadenza più o meno regolare (molto più meno che più), a studiare il linguaggio di programmazione Objective-C.
Faccio questo utilizzando principalmente le guide fornite (in inglese, e io con l’inglese non sono mai andato d’accordo) da Apple e prendendo spunto qua e là dalla Rete ed infine scrivendo, scrivendo e scrivendo.
Scrivere, e cercare di spiegare, aiuta ad imparare. L’ho sempre pensato.
Perciò chiedo già scusa fin da ora per gli strafalcioni, spero non grammaticali, e ringrazio chi vorrà pormi delle domande!
Bene. Partiamo.

Che cos’è Objective-C?

Objective-C è un linguaggio di programmazione orientato agli oggetti basato sul C standard.

Tradotto in Italiano Objective-C è il linguaggio C, al quale sono state aggiunte delle estensioni (piccole, ma potenti) per renderlo un vero e proprio linguaggio di programmazione ad oggetti. Queste estensioni derivano in gran parte da un altro linguaggio di programmazione: lo Smalltalk, uno dei primissimi linguaggi orientati agli oggetti e sul quale non mi dilungherò.

Una buona infarinatura di C è quasi d’obbligo per imparare Objective-C. Ma io sottolineo il quasi. In effetti questo linguaggio di programmazione, pur essendo un’estensione del C, è diverso quanto basta per impararlo da zero.

Nella prossima puntata inizieremo a parlare di Oggetti

das ultimative Frauen”problem”

365 days and nights – are so richtig die description des “Problems”

A couple of recent comments have raised the issues of closures and non-local returns.

1. Closures
   Absolutely. Wisp (and Wisp Smalltalk) support closures where “closure” is defined as “a first class function with free variables that are bound in the lexical environment”.
2. Non-local returns
   Probably, but I have only examined a small number of cases.

I am designing Wisp for Internet applications using “cloud-based” servers (Google App Engine, Microsoft Azure) with client-side programs running in browsers (JavaScript, Flash, Silverlight).

If a “real-world” case can be made for supporting a certain programming style, then I will implement it.

The Smalltalk parser (version 0.8.12) can now handle these iteration statements:

• whileTrue:
• whileFalse:

Here is a transformation test:

| x |
x := 0.
[x < 10] whileTrue:[
x := x + 1.
Transcript show: x; cr]

when placed in a Smalltalk window and “parseIt” produces the following Wisp code:

(lambda()
(let ((x))
(set! x 0)
(do () ((not ((lambda()
(< x 10)))))((lambda()
(set! x (+ x 1))
(let ((temp Transcript))
($ temp "show:" x)
($ temp "cr")
))))))

To execute the Wisp code, enclose it in an extra pair of brackets, then place it in a Wisp workspace and “doIt”.

The next development step — in a few days from now — will add the Object system.

Jonathan Sterling discusses writing fully native Cocoa applications in Smalltalk with F-Script in "Writing Mac OS X applications in Smalltalk"

What I really wanted was a version of Smalltalk that used the same object model as Objective-C, like Pragmatic Smalltalk of Etoilé, or even MacRuby on Mac OS. Most of all, I wanted it to treat me like an adult: I don't need a class browser, thank you, I'm more comfortable working with plain-old files. The persistent image construct in Smalltalk really makes me uncomfortable. Eventually, I found F-Script, a scripting environment for Mac OS based on Smalltalk. It is not really meant for developing full applications, but with a little work, I was able to make this work. Read more…

Why is it that people sound so surprised when it’s cold and wet in winter? There is nothing wrong with what they’re saying, the weather at the moment is awful, but it’s November, it’s supposed to be cold.

Of course, people aren’t really commenting on the weather, they just hate silence and have to fill every quiet gap with inconsequential small talk, which is invariably made up of mundane clichés and fake smiles. People really shouldn’t waste their time, this country probably wastes millions of hours a year between all the small talkers.

Just think what they could do with their time, I know what I’d do, particularly if I was also partial to the odd bit of weather chat: I’d set up Sky Plus to record every second of Laura Tobin’s weather forecasts. Good grief, what a fantastically gorgeous woman. Since when have weather forecasters been meant to look so good? And if it’s pouring down you get the chance to snigger like a little schoolboy when she mentions the word “moist” and “warm fronts”:

She certainly makes my isobars tighten. More of Ms Tobin please BBC, I might even pay my licence fee if the standard of weather presenters remains so high*

Anyway, the small talkers will have plenty to moan about in the coming weeks seeing as winter is well and truly in full flow now – something which happens every year, yet still seems to catch people completely unawares. I’d just rather they kept their weather chat to themselves. Yes it gets cold, it gets wet, it gets windy. Put a jacket and scarf on and shut your face. “I need some sunshine” they moan, bollocks do you. You’re the same people who spend all summer moaning that it’s too hot and that it’s so dry your plants are dying. Make your minds up or better still, just get on with your lives and let the weather take care of itself. It will be ok, not passing the time of day with someone whilst pondering whether or not the weather will “make its mind up” won’t hurt you, the world won’t end.

Though if people stopped caring about the weather, would that mean forecasts would be pulled and there’d be no more Laura Tobin? I daren’t contemplate that, keep it up smalltalkers! You’re doing a fine job.

*I do pay my licence fee, I was just being humorous. Guffaw!

El pasado viernes junto a Carlos presentamos el trabajo que estamos haciendo en algo3. En la sesión hubo unas 50 personas. Comenzamos la sesión presentando el contexto en el cual dictamos la materia, luego Carlos explicó el régimen de cursada y la forma en que se encara la parte teórica de la materia, después de eso yo expliqué el enfoque utilizado en la práctica, donde a mi parecer lo más interesante es el uso de alguna prácticas ágiles como TDD, desarrollo iterativo, pair programming, collective ownership e integración contínua.

Durante la presentación tuvimos algunas consultas de la audiencia . En una de ellas un asistente comentó que el pedirles a los alumnos un informe con la explicación del TP realizado le parecía “anti” ágil, pues los métodos ágiles prefieren código corriendo en lugar de documentación. La realidad es que tengo 2 respuestas para esto:

1. Los métodos ágiles no dicen que no haya que documentar, sino que es más importante la aplicación funcionando y en nuestro caso pedimos la aplicación funcionando y ADEMAS un informe de cómo fue resuelta la problemática (en ese orden de prioridad).  Nota: próximamente voy a escribir un blogpost sobre agilidad y documentación pues creo que hay un mal entendido general de este tema)
2. En el contexto de la materia enseñamos a desarrollar software, lo cual es más ámplio que la mera escritura de código, los alumnos deben entender el problema a resolver, tomar decisiones de diseño y comunicarlas. Un diseño por más bueno que sea, si no es bien comunicado puede traer muchas complicaciones a futuro. Es por esto que hacemos incapié en la aplicación funcionando y TAMBIEN en las pruebas unitarias y el informe como dos herramientas para comunicar el diseño.

Otro comentario que tuvimos fue tal vez la gran cantidad de herramientas y contenidos vistos podian restar importante cantidad de tiempo para el correcto aprendizaje del paradigma y junto con esto nos proponian dar todo la materia sólo con Smalltalk. Personalmente no comparto esta visión y creo justamente la variedad de herramientas vistas permite a los alumnos una mejor comprensión del paradigma.

Como de costumbre al finalizar la sesión pedí feedbak a los asistentes utilizando la técnica de las caritas (   :-|  ). Comentí el error de no dejar en claro si el feedback era sobre la calidad de la sesión o si era una opinión sobre el enfoque presentado. Algunos dieron su opinion sobre ambas cosas, pero la mayoria no. Más allá de este detalle el resultado fue: 80%   20% :-|

Después de la sesión estuvimos hablando con varios docentes de universidades de la patagonia y de UTN quienes se mostraron interesados con el enfoque presentado.

Personalmente estoy muy conforme con la presentación y muy contento con el enfoque que estamos utilizando.

La presentación completa fue grabada por los organizadores del evento y próximamente está disponible (seguramente en el site de la conferencia). Mientras tanto para los interesados el slide deck utilizado esta disponible aquí (inglés) y también puse una versión en castellano aquí.

The Smalltalk parser (version 0.8.11) can now handle these iteration statements:

• timesRepeat:
• to:do:
• to:do:by:

For example, with the Smalltalk source:

1 to: 100 by: 2 do: [:x |Transcript show: x; cr]

the parsed output is:

(lambda()
(do ((x 1 (+ x 2)))((> x 100))(let ((temp Transcript))
($ temp "show:" x)
($ temp "cr")
)))

which gives the correct result when evaluated.

Tomorrow, I will add:

• whileTrue:
• whileFalse:
• value
• value:
• value:value:
• value:value:value:
• value:value:value:value:

After that comes the Object system and method lookup.

Bus bekommen.
Knapp.
Mit meinem Frühstück in der Hand zur Tür gesprintet. Morgenliche Vorbereitung auf den Tag: 2 Knäckebrote mit Baguettesalami und ein Apfel.
Smalltalk. Ich rieche die Fahne das Mannes hinter mir und die betörenden Parfummengen der kleinen Checkerin vor mir, während diese beiden sich wahrscheinlich vom Geruch meiner Basguettesalami belästigt fühlen.
Währenddessen nicke und lächle ich und höre zu, alles in mir schreit “laangweilig!”
Ich sage etwas über das Wetter und sie nickt, lächelt und hört zu.
Ich fühle mich unehrlich. Sie steigt aus, ich mache Musik an.

The MagLev alpha was released recently.  Before I get too far in to this post I need to make it clear that I’m not affiliated with the MagLev development team.  I’m not really even much of a Ruby interpreter hacker.  I’m a curious ruby developer that has heard some interesting things about the project and wanted to get it up and running now that it’s available.  I decided to make this post because the install and setup procedure is anything but standard.  It’s not complicated, just not what you normally would expect.

First lets get the code:

$ git clone git://github.com/MagLev/maglev.git

Initialized empty Git repository in /Users/rgarver/Sources/maglev/.git/
remote: Counting objects: 28955, done.
remote: Compressing objects: 100% (12671/12671), done.
remote: Total 28955 (delta 15669), reused 28427 (delta 15200)
Receiving objects: 100% (28955/28955), 14.97 MiB | 539 KiB/s, done.
Resolving deltas: 100% (15669/15669), done.
Checking out files: 100% (2180/2180), done.
Initialized empty Git repository in /Users/rgarver/Sources/maglev/.git/remote: Counting objects: 28955, done.remote: Compressing objects: 100% (12671/12671), done.remote: Total 28955 (delta 15669), reused 28427 (delta 15200)Receiving objects: 100% (28955/28955), 14.97 MiB | 539 KiB/s, done.Resolving deltas: 100% (15669/15669), done.Checking out files: 100% (2180/2180), done.

$ cd maglev

Great, we have the code.  Next step is to do a base install.  This installs the base libraries and GemStone which is the fabled persistence layer that MagLev has integrated.  GemStone is a object persistence layer originally built for Smalltalk.  If you haven’t ever played with Smalltalk or some of the variants (eg: Squeak) I recommend it.  It will turn your head upside down.

$ ./install.sh
[Info] Starting installation of MagLev-22578.MacOSX on sirius.local
Password:
Sat Nov 21 09:22:44 PST 2009
[Info] Setting up shared memory
  Total memory available is 4096 MB
  Max shared memory segment size is 4 MB
  Max shared memory allowed is 4 MB
[Info] Increasing max shared memory segment size to 2048 MB
kern.sysv.shmmax: 4194304 -> 2147483648
[Info] Increasing max shared memory allowed to 2048 MB
kern.sysv.shmall: 1024 -> 524288
[Info] Adding the following section to /etc/sysctl.conf
# kern.sysv.shm* settings added by MagLev installation
kern.sysv.shmmax=2147483648
kern.sysv.shmall=524288
kern.sysv.shmmin=1
kern.sysv.shmmni=32
kern.sysv.shmseg=8
[Info] Setting up GemStone netldi service port
[Info] Adding "gs64ldi  51456/tcp" to /etc/services
[Info] Downloading GemStone archive using /opt/local/bin/wget
--2009-11-21 09:22:44--  http://glass-downloads.gemstone.com/maglev/GemStone-22578.MacOSX.zip
Resolving glass-downloads.gemstone.com... 207.171.185.197
Connecting to glass-downloads.gemstone.com|207.171.185.197|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 74858717 (71M) [application/zip]
Saving to: `GemStone-22578.MacOSX.zip'

100%[==========================================================================>] 74,858,717   847K/s   in 1m 45s

2009-11-21 09:24:32 (694 KB/s) - `GemStone-22578.MacOSX.zip' saved [74858717/74858717]

[Info] Uncompressing GemStone archive into /Users/rgarver/Sources
[Info] Linking gemstone to /Users/rgarver/Sources/GemStone-22578.MacOSX
[Info] updating MSpec, RubySpec, and RBS submodules
Submodule 'benchmark' (git://github.com/acangiano/ruby-benchmark-suite.git) registered for path 'benchmark'
Submodule 'spec/mspec' (git://github.com/rubyspec/mspec.git) registered for path 'spec/mspec'
Submodule 'spec/rubyspec' (git://github.com/rubyspec/rubyspec.git) registered for path 'spec/rubyspec'
Initialized empty Git repository in /Users/rgarver/Sources/maglev/benchmark/.git/
remote: Counting objects: 7332, done.
remote: Compressing objects: 100% (5521/5521), done.
remote: Total 7332 (delta 1595), reused 6917 (delta 1274)
Receiving objects: 100% (7332/7332), 9.90 MiB | 578 KiB/s, done.
Resolving deltas: 100% (1595/1595), done.
Submodule path 'benchmark': checked out 'd807eea7f7b2f38240bc177a0c22e599081882ea'
Initialized empty Git repository in /Users/rgarver/Sources/maglev/spec/mspec/.git/
remote: Counting objects: 2745, done.
remote: Compressing objects: 100% (1080/1080), done.
remote: Total 2745 (delta 1848), reused 2484 (delta 1644)
Receiving objects: 100% (2745/2745), 378.57 KiB | 383 KiB/s, done.
Resolving deltas: 100% (1848/1848), done.
Submodule path 'spec/mspec': checked out 'bcec47c70e0678a29fd0c1345358c4daf7b971a3'
Initialized empty Git repository in /Users/rgarver/Sources/maglev/spec/rubyspec/.git/
remote: Counting objects: 26787, done.
remote: Compressing objects: 100% (8705/8705), done.
remote: Total 26787 (delta 18332), reused 25672 (delta 17482)
Receiving objects: 100% (26787/26787), 3.71 MiB | 520 KiB/s, done.
Resolving deltas: 100% (18332/18332), done.
Submodule path 'spec/rubyspec': checked out 'b0a18cf80dc706d39ee550831b8b941224b60fb6'
[Info] Creating new default 'maglev' repository
[Info] Generating the MagLev HTML documentation
[Info] Finished upgrade to MagLev-22578.MacOSX on sirius.local

[Info] MagLev version information:
maglev 0.6 (ruby 1.8.6) (2009-11-20 rev 22578-1067) [x86_64-linux]
GEMSTONE: 3.0.0 Build: 64bit-22578
MONTICELLO: MagLev-ao.1067.mcz
MAGLEV: commit e2a4fe2e0f7ca85cdcb141e6b56913eba802eefd
        Author: Allen Otis <otisa@abaco.gemstone.com>
        Date:   Thu Nov 19 19:57:09 2009 -0800
[Info] GemStone version information:
GemStone/S 64 Bit
3.0.0 Build: 64bit-22578
Fri Nov 20  8:22:00 2009

[Info] Adding these to your .bashrc will make it easier to run MagLev
export MAGLEV_HOME=/Users/rgarver/Sources/maglev
export PATH=$MAGLEV_HOME/bin:$PATH

[Info] After you complete this upgrade and verify MagLev is working, run
  rake stwrappers
to generate the .rb files for the GemStone/Smalltalk FFI
in MAGLEV_HOME/lib/ruby/site_ruby/1.8/smalltalk/

As you can see on OS X it will build everything for 64bit which is pretty cool.  It also downloaded a bunch of support libraries and updated all of the submodules.  If you ever update the code locally you are supposed to run ‘$ ./update.sh’ to rebuild everything and get it all up and running.

Once you have it installed you should add the following lines to your .profile or .bashrc

export MAGLEV_HOME=/Users/rgarver/Sources/maglev
export PATH=$MAGLEV_HOME/bin:$PATH

You’ll need to make sure you run those lines on the command line also.  Once the environment is setup you can run ‘$ rake maglev:start’.  This command apparently boots up the core MagLev engine.

$ rake maglev:start
(in /Users/rgarver/Sources/maglev)
startstone[Info]: Starting Stone repository monitor "maglev".
startstone[Info]: GemStone server 'maglev' has been started.

Once that is started you are good to go:

$ maglev-irb
/Users/rgarver/.irbrc
error , no such file to load -- readline,
          during /Users/rgarver/Sources/maglev/lib/ruby/1.8/irb/completion.rb
error , no such file to load -- readline,
          during /Users/rgarver/.irbrc
irb(main):001:0> puts 'hi'
hi
=> nil
irb(main):002:0>

The Smalltalk parser can now handle branch statements.

http://gxt.latest.wispdev.appspot.com

Given the Smalltalk source:

3 < 4
ifTrue: [Transcript show: 'Less than'; cr]
ifFalse: [Transcript show: 'Not less than'; cr]


the parser will output the translation:

(lambda()
(if (< 3 4)((lambda()
(let ((temp Transcript))
($ temp "show:" "Less than")
($ temp "cr")
)))((lambda()
(let ((temp Transcript))
($ temp "show:" "Not less than")
($ temp "cr")
)))))

All the branching messages – “ifTrue:”, “ifFalse:”, “ifTrue:ifFalse:”, and “ifFalse:ifTrue:” – are parsed correctly.

Parsing for the iteration messages – “do:”, “to:do”, “to:do”by:”, and “timesRepeat:” – will take another day to complete.

As of version 0.8.10, the Smalltalk parser can handle some complete statements.

http://gxt.latest.wispdev.appspot.com

Given the Smalltalk source:

| a b c |
a := 3.
b := 4.
c := 5.
Transcript show: a + b * c; cr

the parser will output the translation:

(lambda()
(let ((a)(b)(c))
(set! a 3)
(set! b 4)
(set! c 5)
(let ((temp Transcript))
($ temp "show:" (* (+ a b) c))
($ temp "cr")
)))

Executing this in a Wisp workspace will produce a compiled function (closure) – to obtain the value of the function, use “apply” or simply enclose the expression in parenthesis. Note that the value of the output is “35″, which is the correct evaluation of “3+4*5″ in Smalltalk.

The example shows the use of assignments and local variables. Tomorrow, I will extend the parser to include branching and iteration statements.

Fabian Schuiki explains how F-Script can be used as a debugging tool when developing Cocoa applications in "F-Script: The Ultimate Debugging Console".

If it weren’t for F-Script, I would have spent 5 hours today writing debugging code and creating some testing UI for Artifica which would have been another source for bugs which increases complexity of the debugging process again. F-Script gives you the possibility to completely split up the development of your object model and your view model, which not only saves you a lot of time and is more productive, but is also less frustrating since you never have to go figure whether your app’s functionality is broken due to a bug in the UI, the object model or even worse, somewhere in between. Read more…

The french Ruby and Smalltalk communities are organizing the first BlockCamp event in Paris on the 28th november 2009. I will be there and will talk about F-Script 2.0. Come join us! More information here…

In this fun video clip, it takes Jeff only a few seconds to bring support for Snow Leopard’s text substitutions to WriteRoom… Cool demo of F-Script injection, for those unfamiliar with it.

Smalltalk and Wisp workspace windows

http://gxt.latest.wispdev.appspot.com

There are now two types of workspace window:

• Smalltalk workspace
• Wisp workspace

The Smalltalk workspace has a single choice on the context menu: “parseIt”.

“ParseIt” takes the highlighted code in the Smalltalk workspace, compiles it with the Smalltalk parser, and then sends the output to the transcript window. In the above example, the Smalltalk code was:

Transcript show: 'Hello World'; cr

and the resulting Wisp code was:

(let ((temp Transcript))
($ temp "show:" "Hello World")
($ temp "cr")
)

I copied the output to the Wisp workspace window where it produced the expected output when executed.

As I have stated in an earlier post, it will probably be about another week until the Smalltalk parser is complete. The development process is:

1. Smalltalk parser generates correct Wisp (source) output
2. Smalltalk parser generates correct compiled output
3. Object system integration
4. Tools – class browser, inspectors, etc

We can’t jump to (4) until 1-3 are completed – my guess is that we will be at (4) by the end of this month (Nov 30), hopefully across all platforms (Java, JavaScript, Flex, .Net) simultaneously.