so JIT, WOW

This is so amazing I don't want to lose it:


A Smalltalk-80 VM written in LuaJIT, that boots the images from the eighties:
https://github.com/rochus-keller/Smalltalk#a-smalltalk-80-interpreted-virtual-machine-on-luajit

Approachable tutorial on JITs. The second part talks about metatracing.
https://news.ycombinator.com/item?id=23740655

I recently discovered this guy and he's awesome. Haven't particularly examined this repo, but please, also check out his other stuff.
https://github.com/spencertipping/jit-tutorial

Dan Ingalls showing smalltalk magic

• https://www.youtube.com/watch?v=NqKyHEJe9_w
• https://www.youtube.com/watch?v=4ki2AQvneD8
• https://www.youtube.com/watch?v=Ao9W93OxQ7U
• https://www.youtube.com/watch?v=if72CFsF_SY

Old OOP lecture by Dan Ingalls

So here's this great talk where Dan Ingalls shows OOP concepts with superb clarity.

What made Xerox PARC so special?

Via Hacker News, I found this cool answer by Alan Kay about "What made Xerox PARC so special?"

Very nice, and I got a couple of book references I'm already pushing in my to-read.

EDIT: I just read that Bob Taylor has died today at 85. :(

Alan Kay interviews and more ideas

Recently, Alan Kay (you know, my 1st reference for maaany things) appeared in Code Mesh and Joe Armstrong (of Erlang fame) interviewed him. As always, lots of insights and some old concepts mixed with new ones. 

https://www.youtube.com/watch?v=fhOHn9TClXY . HN discussion here : https://news.ycombinator.com/item?id=13033299

Also here is a 2h+ long interview from 1990 that I think appeared recently on the internet.
http://openvault.wgbh.org/catalog/V_D9DC82D997454711A71B586E17D23119

More 'Kayisms', some thoughts, reflections and examples on how to store data that can last (as in be read) practically forever.
http://www.vpri.org/pdf/tr2015004_cuneiform.pdf . (related to http://worrydream.com/TheWebOfAlexandria/ )


And here there are a couple of other links I hadn't seen about him, the story of personal computing, and progress/critical thinking  in general.

• http://factordaily.com/alan-kay-apple-steve-jobs/
• http://techland.time.com/2013/04/02/an-interview-with-computing-pioneer-alan-kay/
• http://www.vpri.org/pdf/m2004001_power.pdf
• http://www.wheels.org/spacewar/stone/rolling_stone.html

definitely not planar

Once in a while, you find something enlightening, that changes your perspective. One of them is geometric progressions. How they grow so fast, and how dense graphs (k-graphs) deal with this kind of progressions al the time. But I digress...

Irreal (a very active blogger in the emacs scene) has been posting about a series of posts from John Kitchin, about Hy. All this referred by Karl Voit.  It's kinda funny when for a given John's post, there is an Irreal's counterpart, that links to John's, and probably to older Irreal's posts of the same topic.  This reminds me somehow of classes pointing to superclasses and metaclasses (In smalltalk). 

Here's how I imagine it.

Also, let me add myself to the chain, and also mention that planet emacs is logging all this activity, so probably this picture is an oversimplification of the situation.  It's probably more similar (in complexity) to the real smalltalk class-metaclass structure:

When adding tweets and retweets that refer one to another (and probably with cycles), it's kinda funny how things lay together. OOP (smalltalk one) is definitely a nice inspiration for many things, way beyond the explicit implementation side of the things, but in a systems aproach. Ah, here's where you can learn about the smalltalk(pharo's) class/metaclass beauty.

Kiss the cuke

I don't care if you're cuking it right or wrong.

But you can use cukes whatever language you use.

• Ruby, obviously
• Perl? sure, look in CPAN.
• Python.. Yeah, they have it too.
• Smalltalk. It seems we have it too.
• Elisp. WTF? Yeah, why? because we can.

So, there's no excuse, if you like BDD, not to use it.

Amber language (former jtalk), digging deeper

Lots of changes have happened in jtalk world since last week.

• Jtalk is now Amber. The project has changed its name when the 0.9 release happened. That means that the repo is now different, and the website too.
• JQuery bindings have been removed from the system. Now we can access javascript objects directly, and use asJQuery in the same way, so there's no drawback, only the way to deal with jquery is more smalltalkish. Counter new appendToJQuery: 'body' asJQuery works perfectly, so no problem.

Creating functions
If you want to know a bit more on amber, you have to keep in mind that it's a smalltalk, so you can explore everything in your IDE. Let's try to find out a bit more on how the compilation from smalltalk to js works. This will allow us to debug our in a lower level than usual, and find glitches in our codes, or detect where our closure is missing the variables (when interfacing with js, sometimes it's useful to see the whole js code, and make conclusions on js).

Let's create a new class Foo with a method that gets a block (callback) and executes it. Now, to find out how it's compiled, we'll make amber print the compiled source of the method:

(Foo methodDictionary at: 'get:') fn compiledSource "print it".

If we print it, the result will be the js source of the method

You can try variations like returning explicit values, try to pass instVars to the closure, and see what is the translation to js. This helps sometimes to find out your way.

Can I inspect?
Inspector is there, but for the moment, it's in very early stage.

Debugger

Debugger is also there, also in early development. You can see the stacktrace, and inspect the methods, but not changing values and so.

NodeJS

We can use amber for the server side, running the generated javascript on node.js. Due to the hability of Amber to interoperate with plain js, we can use a shitload of libraries from amber. Here follow a couple of examples of amber on node.js

Server

Nicolas Petton wrote a fileserver meant to be used in the node.js side. This allows us to commit changes to our files transparently without the need of webdav,python(see last post), or any external server. It's Amber all way down.

The usage is fairly easy. Just cd to the root amber directory and run ./bin/server, that will run ./server/FileServer* things.

IRCBot
Trying the node.js part of amber, we can try to build a small program, and as no programming language is complete unless it has a IRC bot in it, let's solve this issue:) Btw, I hacked a couple of emacs functions to deal with st files a bit better.

emacs and smalltalk, a bit closer

Today I've been hacking around with jtalk. Implementing something for the node.js backend means that probably you'll be using your editor of choice.

I've downloaded paolo bonzini's smalltalk-mode.el

I've hacked some shortcuts to navigate through classes using emacs narrowing feature.

Here's the hack:

HN Frenzy

HackerNews is not in its greatest moments lately, but today, lots of diferent great articles/links appeared. It's a bit overflow of info in just one moment, you open a handful of links and you face.

• Probably the greatest hello world on linux kernel module



• A funny study on most pressed keys on different languages.I'm thinking if that's possible to include it in jtalk.
• http://www.forthos.org/
• Another great tutorial on git explaining things in a very simple way. The more I know about git, the better I rate git tutorials. I'm probably suffering the "I don't understand until it's obvious" syndrome


• if this then that. API comunication between most famous intertubez sites. IT could be named THE INTERNETZ DBUS

Not in HN but a tiny example of how cool is the project that's driving some of smalltalkers to sleep 4 hours per night.Jtalk. Credits on that go to Bromagosa

Jtalk tutorial. (Valid until the end of this week)

TL;DR
write this in a workspace, select, and click 'DoIt'. Instant reward.
Counter new appendToJQuery: 'body' asJQuery




You know Smalltalk, it is an object oriented programming language developed at Xerox PARC during the 70's by Alan Kay, Dan Ingalls and other brillant guys. It is known that Kay, and probably other members of the team, was born from the leg of Zeus. Jtalk is an implementation of Smalltalk that runs on top of JavaScript, developed by Nicolas Petton. It allows the use of Smalltalk for client side applications. Even more, Jtalk allows you to use the famous IDE from the Smalltalk world directly in your browser. It compiles to JavaScript, and follows Pharo, a fork of the Squeak Smalltalk implementation.

The canonical "Hello World" looks like this:


You create a subclass of Widget, and you implement the #renderOn: method. Jtalk will pass an HtmlCanvas instance that we call html in our code. This object provides some "brushes" allowing to "paint" into the html canvas by message passing. We created a div element by sending the div message to html. The div element has it's class and id attributes defined, and it contains a h1 element. Everything is performed by passing messages to the html object. Those familiar with the Seaside web framework will recognize the html canvas. After the HelloWorld class is
defined, you can see it in the browser by appending an instance to the page's body using JQuery:

HelloWorld new appendToJQuery: 'body' asJQuery

A JQuery object is created by passing the #asJQuery message to the string object 'body'. Then we pass the #append message to the JQuery object, with an instance of HelloWorld as argument. You can evaluate this expression in the Workspace and see it in action.

Another way to do the same is going to JQuery class, and send the #body message.

Where is the Counter?
If you know Seaside you'll want to look at the Counter example. I will reproduce the example from the Jtalk website, which you can find also with the IDE's class browser. It is a good example because it shows how you can write stateful applications in Samalltalk, by simply using its object system as you would do in any application:

As in Seaside, the button definition is beautiful. Since the object itself holds the state of the application, you simply bind a Smalltlak code block to the onclick event, and Jtalk will take it from there.

Interacting with the DOM with JQuery and JS evaluation

As you can see, there is JQuery support provided by the JQuery class. We just used it for appending a piece of html to the body element of our page. There is support for a good part of the JQuery api, as you can see by browsing the methods implemented in the JQuery class. You can do DOM insertion, css manipulation, event handling, etc. If something you like is not implemented, you can evaluate JS code by enclosing it with the "<" and ">" characters. A wrapper for ajax is also available:



Here we create an Ajax object and then we send some messages to it. As you can see, we use Samlltalk blocks as callbacks, this blocks are compiled to JavaScript anonymous functions for execution. There are other messages availables in an Ajax object, like #onCompleteDo. Dictionary like syntax is provided for passing additional settings to the Ajax object:



As test, I wrote a small HTTP service interfacing a CouchDb instance. I did it in Python using the small but cool Flask framework:



Please consider it almost pseudo code. You can note its very simple stuff. We serve the Jtalk DE at "/", and we provide access to the database in "/get/<doc_id>". Now, we could build a small wrapper for accessing this service:



We provide a single method called get:onSuccess: allowing the client code to request a document and executing a callback block on the resulting data. Smalltalk blocks are constructed using brackets, and they are like anonymous functions. Temporary named arguments are declared with the :argName, and after the bar you can write any Smalltalk statement. Our onSuccessDo callback takes the data received form the Ajax request as argument. This data comes in JSON format, so we
use an instance of the Smalltalk object to translate this to a Jtalk object, and then we pass that to the block provided by the client code, which we called "aBlock".

An experiment using Rasta.js for data persistence

Rasta.js is a very simple key/value storage service. It provides a REST API and a client library:

<script src="http://rastajs.errorjs.com/rasta.min.js" type="text/javascript">

We can use this for looking at how can we delegate execution to a JavaScript object and also for providing some data persistence to a static website.



That was easy. The Rasta class has one instance variable, called "rasta". Instance attributes are private in Smalltalk, you have to implement methods if you want to access them from the outside. But in this case, our rasta attribute is for internal use, we don't need the stinky accessors. The Rasta.js API provides two simple JS functions:

Rasta.get('age', function(val){
/* val == '100' */
})

Rasta.set('age','100', function(){
/*      */
})

Since they use an upper cased name, and in Smalltalk those are reserved for classes, we have to use a special trick. Jtalk will get confused if you try to evaluate "Rasta" directly. This not happens with lower case JS names, which are available directly in the Jtalk IDE (you can try
console log: 'fooBar' for an example in the Workspace.) So, we will use our "rasta" instance attribute for storing the JS object, we use the <jsobject> notation for getting a sort of proxy object which will delegate messages in the JS one, and we can access it under the "rasta"
name in our messages. Now we can use the Rasta.js KISS service for our data storage:

database := Rasta new.
database get: 'aKey' onSuccess: [ :data | 'div#container' asJQuery append: data ].

Ok, usualy you will want to format the data. We can wrap this into a Widget subclass and implement a #renderOn: method. At this point we can put all these features together in our mind: you get a nice programming environment which promotes good code practices like layers and concerns separation, clean and readable syntax, testing facilities, and who knows
what, with an IDE accessible directly from the browser.

On code persistence

I will just say it. If you press "F5" (or "r" if you are a hacker) you will lose your code. The IDE features a "Commit category" button, which sends a PUT request with the compiled ST in the body. But as Jtalk is focused in client side coding, it is your responsability to handle the
request and save the code into the "js/" folder, next to the Jtalk library. I will show you the "almost pseudo code" thing again, with Flask and Python:



Note that I used the secure_filename from werkzeug to sanitize the data, since I use it to build the path. You don't want to allow write to your .zshrc or similar.

Concluding

Jtalk can help you to write heavy client side applications by taking advantage of the ancient wisdom from the Smalltalk world. It still has some sharp edges but it is there for you to try it. Allows you to write stateful client code easily, and to port known and tested patterns to
the web browser, for great justice. And there is a plus. Jtalk is part of a legendary story, the Smalltalk one. After all, I have told you, these guys came from the leg of a god.

A moving target

In the couple of days that Rodrigo Bistolfi and me have been experimenting with Jtalk and writing this article (In fact he wrote most of the article), a bunch of things changed already, or are going to change shortly. For example, Capitalized Javascript objects are parsed now without problems in Jtalk. On the JQuery side, Nicolas Petton recently said that JQuery binding is going to disappear from jtalk bundle. It seems we'll be able to fetch DOM nodes directly with jtalk. So better be up to date with the jtalk git repo, because jtalk is moving fast.

Btw, there's a lot more related to Jtalk. Goran Krampe wrote jtalkc, that compiles jtalk code to js able to run in node.js. I haven't digged on that yet, but seems it also opens a shitload of possibilities... :)

Cya!

ESUG in: 2011 on: Edinburgh

ESUG 2011 is over, and I'm back from my holidays, with a couple of interesting bits about the smalltalk world, and lots of energy.

Here are the talks that impressed me most:

- Martin McClure explained Maglev smalltalk to ruby ffi. It seems maglev is more than a simple smalltalk vm. In fact it runs ruby code and smalltalk code seamlessly (at least, that's what I understood). Unfortunately, it only exist in 64-bit shape, so I couldn't try it myself. The core of the presentation though was the nice FFI that VMWare guys (former GemStoners) prepared to run Ruby code from Smalltalk.

As most of you know, Ruby is heavily influenced by smalltalk. In fact, so much that Martin and friends were able to make one object for both worlds. So String class is the same for ruby and smalltalk. Objects are the same, but the names are different, so SmallInteger for smalltalk, is fixnum for Ruby. 'super' pointer is also different, enabling to build variations in hierarchies and supporting singleton classes for ruby.

Lots of nice tricks that enable us to use ruby objects as smalltalk ones.

- Bifrost. Jorge Ressia is implementing great improvements in the reflexivity side of Pharo. Being able to treat data as code is one of the aims of bifrost. Not losing the link on logs and where a log entry comes from, or being able to hook on variable usage when debugging... Thanks to Bernat I was able to try it in my own pharo image. (Bifrost is only the framework, you have to install the programs separately)

- Jtalk. I think this was the killer talk of this ESUG. Goran Krampe and Nicolas Petton presented their (mostly Nico's) smalltalk implementation in js. Running smalltalk in browser is not only being able to write smalltalkish syntax. It means you have a full stack smalltalk in your browser. Many firebug features will come for free in Jtalk. Goran showed some experiments he's doing with node.js and jtalk compiler to js. Yes, you're able to write smalltalk for the server side. Probably I'll post more about jtalk, so keep tunned.

There were a lot of other interesting presentations, like Gerardo and Javier live garbage collection tweaks(writing garbage collectors in smalltalk and rebinding garbage collector on your live system), redline (smalltalk in your jvm) and Coral (pharo for those who can type).

It's great stuff all way down!

Back to the future. Xerox PARC innovations.

From time to time. I spend an afternoon doing some monographic research of a great Computer Scientist, or simply people I've seen some day in TED, and would like to know more about him/her.

Sometimes it's Joe Armstrong, sometimes it's Guy Steele, but Alan Kay and friends take these afternoons more often than others.

Here are 3 Conferences by Alan Kay and one from Dan Ingalls. Those two men (and their collegues at Xerox PARC) have done probably more for our field than any other single group in the 70 years of history of CS (or call it tinkering, or computer tekne)


Alan Kay at TED talk, sharing his ideas about ideas. 2007


If you liked it (you SHOULD like it), here you can see a longer talk about Alan's last work (STEPS)

• http://www.tele-task.de/de/archive/lecture/overview/5819/

Here's Dan Ingalls talking about his work at PARC Place. Great stuff too.

• http://www.infoq.com/presentations/Forty-Years-of-Fun-with-Computers

And another Kay's talk about great innovations of the 60's and 70's. In XXI century, we haven't exploited many of these ideas yet.

• http://video.google.com/videoplay?docid=-533537336174204822

If you know of other related talks, please, put links in comments.

Smalltalk tutorial on IRC

Last week at #emacs-es on Freenode I did a very-short-and-introductory-hands-on-workshop on smalltalk. Just in case you know spanish, here's the log, with names removed to protect the guilty.

Text Driven Development

As I already posted, I got a new job in Barcelona, doing mostly apps in Rails (particularly ubiquo, cms)

Luckily, the company is pro-gnu, so I can use linux with all my usual configs. Using ratpoison in a double screen is an awesome experience.

For the moment I lived between the two worlds (gnome vs ratpoison) because I'm continuously asking things to more experienced people, and they usually want to use the mouse when they are on my computer. And I haven't configured everything yet.

Outlines

Last week, I was assigned a project and was given a 100+ pages document with the functional analysis of the project. First thing to do was reading it and making good outlines of it to create a mental model of the program.

I decided to use emacs org-mode to do the outlinings, and probably the TODOs and Schedules. IT's pretty neat, and doing everything with text files gives me a kind of relief, that everything is under control. In fact, that's one of the things that gets on my nerves about pharo. Being able to use your well known tools in a synergic way is great (IMHO)

UML

After that, I created an UML class diagram.
"We use argouml" someone said. Well, argouml has improved amazingly since the last time I tried it, but honestly, for me it doesn't cut. It has some kind of code generator (for java) and some design-critics, that seem cool enough to use it, but given that the web development constrains you to use minimal oop features, I could not listen to the design-lint.

After finishing the damn UML, I looked for other tools that could do pretty UML diagrams from ascii. And they do exist. Great! I'll try to use them the next time. I think plantuml is a fairly good option and, guess what? you can integrate it in emacs.

Slides

On the other side, on wednesday, I did a talk at smalltalk.cat about pharo regexes. The slides where presented in a terminal, in plain ASCII, using a small app borrowed from fxn. Btw, the talk went pretty well. Very informal and kind of simple for people versed in regexes (smalltalk regexes do not have any special unique feature but the opposite, a bit simple IMO), but I think maybe 30% of the people didn't know about regexes and used them just copypasting, so I extended my talk to touch some more theoric side, and in the end, I think everyone learned something.

Btw, if you feel like implementing a regex engine for smalltalk, you can get ideas from this paper. A good read IMHO

ESUG 2010: It's awesomeness all way down

ESUG 2010 was held at Barcelona (well, technically, Cornellà). For people that don't know what's ESUG, it's one of the most important smalltalk events worldwide.

A week full of talks, great fun, hours of hacking and chatting with other smalltalkers.

The weekend before the conference, citilab was open to all smalltalkers who wanted to participate in the SmalltalkCamp. Two days of coding and meeting with other smalltalkers. I started rereading the seaside book and got some help from Bernat. It was fun to see the creators of what I was trying to understand (seaside) walking and coding around. Another nice curiosity was when someone entered the SmalltalkCamp with an OOPSLA t-shirt. It was like: "wow, important people around!" :)

Monday, at 9:00 the conference started officially, but by then, I had already met some great smalltalkers. Here is the schedule of the whole esug.

90% of the talks where amazing, I mean, good contents, with an accurate dose of humour, and talks given by people with nice speech skills.

Xtreams (Martin Kobetic), Design decisions behing Patagonia(Hernán Wilkinson), All Esteban Lorenzano's talks (mars and reef), Helvetia (Lukas Renggli), Stephane Ducasse's talks, Richie and ..... too many good ones to remember the name of all.

Citilab made a great job organizing it all, and we, the local group had very little to do (thanks to volunteers too). Myself I just had to help some people with maps, subways and take some smalltalkers to 'visit' Barcelona. :)

I bought a special edition of the seaside book and got it signed by Ducasse and Renggli. WOW!

Well, it's been a short and late post, but I can't write a post with all cool things I learned there, so it's more a "I've survived" post than a "hey, look what they showed us".

Soon, citilab will make the recordings of ALL the talks available on the web. I think they'll be hosted in cincom's servers. I'll post about that when it effectively happens.

I met many people and had lots of fun talking not only about smalltak but technology in general, and life, universe and everything. Mostly argentinians but not only them. Gabriel, Gabriela, Hernán Wilkinson, Leandro, Richie, Javi, Nico, Ricardo, Esteban Lorenzano,... Great people.

Back to the future?

9:00
Llego al currele, y mientras estoy haciendo mi navegacion de
reconocimiento, encuentro porahí un link interesante: Google’s
Do-It-Yourself App Creation Software. Alguna frikada de google
labs... ya verás. Total, que empiezo el articulo y leo que el
proyecto esta liderado por un tal "Harold Abelson". H.Abelson en
google? (pues se ve que se ha pillao un sabático del MIT). Bueno, el
proyecto va encaminado a que todo el mundo pueda ser programador de
sus miniaplicaciones.

17:00
Recibo un mail en una maillist Que pone "se nos acabóo el trabajo".
Coño! Esto es scratch!!!
Reflexión: Los Schemers chupando de smalltalk? Bueno, puede ser,
entre comunidades pioneras... pero en google, hacen algo en
scheme/smalltalk? Bueno, de hecho, scratch tambien sale del MIT, creo.

17:30
Llego a la pagina oficial del proyecto y efectivamente al final de la pagina.
(...) Open Blocks visual programming is closely related to the Scratch
programming language, a project of the MIT Media Laboratory's Lifelong
Kindergarten Group.

The compiler that translates the visual blocks language for
implementation on Android uses the Kawa Language Framework and Kawa's
dialect of the Scheme programming language, developed by Per Bothner
and distributed as part of the Gnu Operating System by the Free
Software Foundation. (...)

18:00
Me pregunto si contestar al mail de la maillist contando de donde
viene todo esto, quien es Abelson, y entro en otra
batalla épica? Respondo con un : "joer, estos de google son la ostia,
estas cosas, solo las pueden inventar ellos...", me callo?.


En fin... Esta claro que poco a poco van alcanzándonos, pero la
verdad es que me encanta estar en este mundillo (pionero después de
casi 30 años), y estas aproximaciones que hacen 'los grandes' le dan a
uno la confirmación de la sospecha: "yeah, voy un paso por delante,
que se jodan" :D

Versioning in squeak/pharo using Monticello

Lately I've been working on a simple website I'm doing in smalltalk. It's not a complex thing, but it's someway new being my first serious website I've done.

To build it I'm using pier and seaside. And it's mostly fantastic. But sometimes, all of the sudden, some unknown error occurs and my image freezes. And my last codes are lost. No way to recover it even using the recovery tool.

So I remembered something Mr. Ducasse said in the course he did in UPC. The idea is you could throw away your image every day, and start with a fresh new one, EVERY DAY.

One option is fileOuts and fileIns, and in fact, it's simple, reliable and it just works (tm), but you cannot store different versions, and if you did the manual filename juggling, the versions would not have any relationship between them.

Then, here comes monticello. A kind of apt-get + launchpad. It's a package browser and installer (no dependency tracking AFAIK), where repos can be lots of different places, from local directories, to squeaksource remotes, or ftp, or ....

The trick is opening a create a new package (+package button) with the name of the category you want to save. Then, it will appear in the left panel of monticello browser. After that, create a new repository (+Repository button) and add a directory where you want to save it. Then just press the save button.

When you open a new image and want to load the package, open monticello browser, open the repository (+Repository again), click it, and browse. There you'll be able to load the package, and once it's loaded, it will appear in the left panel of the main Monticello Browser.
In the second screenshot you see top left, the different repository types. on the right, the main Monticello screen with the two panels.  My advise is to play a bit with it, selecting and unselecting items to get the feeling of it.

Btw, there's a new project related to source maintaining and versioning called Metacello that seems to be the next iteration of monticello, or "monticello done right", adding full support for package managing, being aware of versions and so.  I'm just guessing as I'm a newbie in both projects and I just skimmed the docs, so please, correct me if I'm wrong.

Are you attending more classes? No I'm just charging my batteries

I'm fucking amazed. I mean, I'm really FUCKIN amazed.

These Advanced OOP Design classes are more meta than I ever could have thought. Stéphane is that kind of guy that charges your batteries when listening him. A great and passionate speaker.

Today's class was more like a open-your-eyes session than a hardcore technical lecture. Maybe many people does not like these kind of things, but myself, I love them. It's when you feel you're not sure you're in the right path, or don't feel motivated enough to hack on things, the right person cracks in and explains his experiences, and gives you metarules to clear your ideas. Like giving you the toolkit and materials to build your toolchain to eval on yourself, and then, make or break.

Instead of doing the explanations on "why tiny methods matter", or discussing about aggregation vs composition (luckily I did my homework yesterday anyway), he pointed us some ideas of "how stuff should work" (Note to self: buy www.howstuffshouldwork.something), or better said, "where things are going". Also, explained his opinions about some dynamic languages. And explained the beauty of uniformity (object -> class -> metaclass-> metaclass class).

Some points I got (all bullets multiplied by my vision of things):

• Gimme a man(1) with examples, or better still: gimme access to the code that uses XYZ function.
• Simple and small m/(systems|rules)/ make $1 powerful and extensible. Don't break the simplicity as far as you can.
• Systems should be small, but not smaller than useful (They're trying to do that in pharo)
• Object -> Classes -> Metaclasses -> Metaclass class is so beautiful
• Marketing is capable of amazing things.

On the meta side (all bullets multiplied by my vision of things):

• Do stuff you like. Be a kid. play with stuff, break things, fix them, or throw them away, but don't be passive about the world.
  
• Take the time to learn things. Invest in yourself. And now it's easier than ever getting info about anything you like. No more traveling 30 km to get a book that iif you're lucky, you can take home. "OH HAI INTERNETZ".
  
• Value your time. Signal / noise is low nowadays. Evaluate what you spend time on.
  
• Use internet wisely. After you downloaded all the crap you won't have time to watch/listen, take a look at http://arxiv.org/ ,http://portal.acm.org , or just take a project you like, and play. You can mail your 'idols' and probably they will answer you kindly.
  
• You're not obliged to do anything of that, but keep in mind we're part of our community (the REAL world), and it depends on us building the future of the culture, community and so. Choice is yours.
  

I want to make clear that he didn't say anything of this textually, so most of the bullets are versions of high-level-ideas-he-said strongly modified by my highly biased way of thinking.

It's difficult to express how happy I am to attend these lectures. Thanks again to JD and SD. I think I'll subscribe to pharo mail list, and try to collaborate in anything I can do. Even if I only can do little support on IRC to smalltalk newbies.

Advanced OOP design with Smalltalk and Stéphane Ducasse

I've just been in the first lecture of Dr Ducasse's course on advanced OOP design here in Barcelona.

And I've to say it's been GREAT. A guru that talks with hackers in mind, being a great one himself. And with lots of good points in the prespective one should care about when entering a new world of hacking/amusement.

He started with an introduction to smalltalk while jumping back and forth to meta-level . We already saw the boolean implementation in the first 20 minutes, and jumped to ifTrue:ifFalse: implementation.

During the talk, he spoke about some real cases he encountered in his life, talking about india, china, project costs in "Old Europe" vs eastern, and the importance of having a delta that makes you different from your co-workers (oponents?). I've always thought like that too, so this guy seems really cool to me :).

On the technical side, He talked about the importance of taking advantage of the object system, and keep in mind that the dispatcher on message sends act as case statements, so we should use them as such. Minimizing logic in our code make it faster, more solid, and prettier.

We're following these slides mixed with these others.

While doing the lecture, he mentioned some cool books, some of them I already heard about (even read them), but others not, so I'm afraid my TOREAD list is about to grow a bit.

All in all, I had a really good time, and it's been only the first class!. It seems I'll be hacking some smalltalk in near future :)

Thanks to Jordi Delgado for making this possible, and to Stéphane for coming to Barcelona and sharing his knowledge.

--EDIT--
Btw, if you don't know what is smalltalk nor who Stéphane Ducasse is, you should check pharo and you'll get a fair idea of what's smalltalk about and you'll be watching what is Stef working on.