Kvardek Du

Setting up CommonQt on OSX

2011-12-09T09:39:00.001Z

CommonQt can be tricky to setup due to its dependencies from C++ land. Tricky enough to warrant writing down the steps I went through to get it running on Mac OS 10.7:

If you don't already have Xcode, install it because you'll need g++.
Grab and install the Qt Libraries (not the Qt SDK). I used version 4.7.4.
Install CMake. (I used brew install cmake.)

Download, compile and install the SMOKE library:

$ git clone git://anongit.kde.org/smokegen
$ cd smokegen
$ cmake .
$ make install

$ cd ..
$ git clone git://anongit.kde.org/smokeqt
$ cd smokeqt
$ cmake -DSmoke_DIR="$PWD/../smokegen/cmake" .
$ make install

At this point, smokephonon failed to build so I had to manually install the two modules I actually needed:

$ make -C qtcore install
$ make -C qtgui install

Get an SBCL with threads enabled and Quicklisp.
CommonQt needed a couple of tweaks for OSX and recent changes in SMOKE. While said changes aren't reviewed and integrated into the main repository, you can fetch them as follows:
```
$ cd ~/quicklisp/local-projects
$ git clone git://gitorious.org/~luismbo/commonqt/commonqt-luis.git
$ cd commonqt-luis
$ git checkout modular-smoke-and-osx-fixes
```
Start SBCL and (ql:quickload :qt).

Hopefully that went well. Next we'll try and run an application.

Enable the swank-listener-hooks contrib by adding (slime-require 'swank-listener-hooks) to your SLIME configuration.
(asdf:load-system :qt-tutorial)
(asdf:load-system :qt-repl)
(qt-repl:start-gui-thread)
And finally, (qt-tutorial-14::test)!

If not running under SLIME, (asdf:load-system :qt-tutorial) followed by (qt-tutorial-14:main) would be sufficient.

If you want to try and skip the C++ compilation steps, grab this tarball with libcommonqt.dylib and libsmoke*.dylib. You should place libcommonqt.dylib in CommonQt's source directory. The SMOKE libs go into /usr/local/lib or similar.

TIME on steroids

2011-11-16T23:20:00.004Z

Nikodemus's recent post about a yet-to-be-released micro-benchmarking tool prompted me to talk about Perfpiece. I describe it as a tool for measuring the performance of Lisp code, not unlike the standard CL:TIME and I wrote over two years ago to measure the performance of SBCL's garbage collector.

Features

Here are its main features:

Lispy interface to PAPI (Performance Application Programming Interface). PAPI is a library that enables access modern CPU’s hardware counters. This allows us to measure several events such as processor cycles, cache misses, number of floating-point instructions, and almost two hundred other events. Perfpiece dynamically inspects the current platform’s supported events at runtime and enables the user to inspect this list and measure these events. We also use this library to measure real (wall-clock) time and user (virtual) time.
Support for other non-PAPI events such as the number of GC runs, CPU usage, and operating system resource usage (via the getrusage() system call).
Transparent support for multi-threaded programs. It includes a helper C library that when loaded through the POSIX LD_PRELOAD mechanism will preempt pthread creation/termination calls and allow for the individual measurement of events across threads created during a measurement session. This includes both Lisp threads as well as threads created by C code. This is rather limited at the moment; only real/user/cpu time is measured for new threads.
Segregation of measurements between mutator and GC.
Support for sampling. Perfpiece can repeat a given a measurement a number of times then calculate and report basic statistic analysis: minimums, maximums, geometric means, and standard deviations for each measured event.

Usage

The simplest way to interact with this library is through the ascertain macro, which works very much like cl:time. The following example shows the default events measured for a very simple arithmetic form:

PERFPIECE> (ascertain (+ 1 1))

                                          non-GC            GC         Total
────────────────────────────────────────────────────────────────────────────
                     Total cycles:         8,343             0         8,343
           Instructions completed:           481             0           481
        Level 2 data cache misses:            78             0            78
 Level 2 instruction cache misses:            24             0            24
                         GC count:             -             -             0
     Involuntary context-switches:             0             0             0
       Voluntary context-switches:             1             0             1
                      Page faults:             0             0             0
                    Page reclaims:             6             0             6
                      System time:             0             0             0
                        CPU usage:       100.00%             -       100.00%
                        User time:       6.00 µs             0       6.00 µs
                        Real time:        613 ns             0        613 ns

0 new threads were spawned

2 ; printed result of (+ 1 1)

Having loaded the helper library using LD_PRELOAD, we can measure multi-threaded code:

PERFPIECE> (ascertain (loop repeat 2 do
                        (sb-thread:join-thread
                         (sb-thread:make-thread (lambda () (sleep 0.5)))))
                      :events '(:real-time :user-time :cpu-usage))

                                          non-GC            GC         Total
────────────────────────────────────────────────────────────────────────────
                        CPU usage:         0.02%             -         0.02%
                        User time:     206.00 µs             0     206.00 µs
                        Real time:       1.335 s             0       1.335 s

2 new threads were spawned
  #0 real: 667.54 ms, user: 101.00 µs, cpu: 0.02%
  #1 real: 667.60 ms, user: 144.00 µs, cpu: 0.02%

The other main function is sample. In the following example, we're measuring FP instructions, invoking some code 10 times, and aggregating measurements in several ways:

PERFPIECE> (sample (lambda () (* 2 pi)) :events '(:papi-fp-ins) :samples 10)

[Floating point instructions]       Min           Max          Mean     Stddev
──────────────────────────────────────────────────────────────────────────────
                   total:            35            36         35.60  ±  1.376%
                  non-gc:            35            36         35.60  ±  1.376%
                 gc-only:             0             0             0  ±  0.000%

sample's got a :report keyword argument that you can use to get machine-readable results:

PERFPIECE> (sample (lambda () (* 2 pi)) :events '(:papi-fp-ins) :samples 10
                   :report nil)

((:PAPI-FP-INS :MIN (35 35 0)
               :MAX (38 38 0)
               :MEAN (184/5 184/5 0)
               :STDDEV (1.0770329 1.0770329 0.0)))

Fork it!

That's pretty much it. There is some SBCL-specific code, but it shouldn't be too hard to port to other implementations. Its use of PAPI could be made optional since that makes this library pretty much Linux-only otherwise. Patches are most welcome!

ECLM videos

2011-11-16T19:07:00.001Z

Just a quick note: Vsevolod Dyomkin has posted a couple of ECLM 2011 videos with more to come.

ECLM 2011

2011-10-25T09:18:00.007+01:00

Contrary to my expectations earlier this year, ECLM 2011 happened and ~90 people turned up. Yay!

Saturday, a bunch of us went on a guided tour across Amsterdam. We had a great guide with an awesome sense of humor and this was a nice way to meet new Lispers and catching up with folks I'd met in past meetings.

Dinner was fun. One very prominent Lisper who shall remain anonymous didn't know what Quicklisp was. Everyone sitting at that particular table was shocked. :-)

Sunday started off with Nick Levine talking about learnt lessons from his failed attempt at writing a Lisp book. Midway through, he took the opportunity to rant a little bit about how there were at least 3 overlapping, incomplete websites (cliki, c-l.net, cl-user.net) and how the solution would be to, huh, create yet another one. The consensus seems to be that cliki is the one that's best suited for a starting point, but Nick complains that its focus on Free Software Lisps is too narrow. Anyway, cliki could indeed use a revamp.

Jack Harper talked about using Lisp on portable fingerprint scanners. He had great things to say about Lispworks which, by the way, had 3 people at this year's meeting.

Luke Gorrie did an extended version of the presentation on Teclo I had seen earlier this year in Zürich. This one included even more interesting diagrams, in particular some illustrating the contrast between 3G network performance before and after enabling their product.

After lunch, Dave Cooper talked about his GDL product, which includes yet another object constraint-ish system framework thingie.

Hans Hübner picked a controversial topic: code style and conventions. (A bit reminiscent of Norvig and Pitman's slides.) He picked on the veritable 80-column rule (blasphemy!) and pushed for project/company style guides. The discussion was entertaining. The general conclusion I drew from that is that while it might be useful to write the more important points down, it's even better to programmatically enforce the more important ones like tabs vs. spaces and trailing whitespace. In my experience, good programmers pick up and follow (or challenge) code style fairly quickly without needing to go through an explicit style guide.

Paul Miller demoed his company's data analysis tool written in Lispworks and talked a little bit about how it interacted and integrated with things like Excel via COM.

Lisp hero extraordinaire Xach Beane did an awesome presentation on Quicklisp detailing some of his implementation strategies, what problems Quicklisp purports to solve, its social impact on the Lisp community, and what his vision for the future is. I was particularly excited about his plan to enable hacking on random project à la clbuild. Definitely the juiciest talk in the meeting in my opinion.

Finally, there were lots of lightning talks this year:

Marco Antoniotti announced ELS 2012.
Christophe Rhodes's talked about R's lispiness and demoed his swankr project that brings R to SLIME and has nifty features like graphical presentations.
Erik Huelsmann announced ABCL 1.0! (There were three quite enthusiastic ABCL developers at the meeting.)
Pierre-Yves Baccou shared some thoughts on Zen, his X-server in ~5K lines of CL code.
... and many others including a valiant attempt at subverting the 5+2 minute rule.

Drinks, dinner, then drinks again. Hanging out with Lispers is the best part of ECLM and there was plenty of that. Looking forward to the next one already!

Figuring out the print size of a photo at 300 DPI

2011-08-14T17:00:00.000+01:00

I was looking for an easy way to tell the print size of a photo at 300 DPI. It wasn't as easy to find the answer as I'd expected. For future reference, here's a solution using ImageMagick:

identify -format "%[fx:w/300*2.54] x %[fx:h/300*2.54] cm" photo.jpg

Joey Comeau learns CL

2011-06-02T11:00:00.000+01:00

Noticed via Twitter that Joey Comeau of "A Softer World"-fame has been doing some programming in Lisp. I liked the way he put it:

Joey: (4:01:05 PM) maybe i should take up a self abusive hobby
Joey: (4:01:08 PM) like lisp programming
Ryan: (4:01:20 PM) haha
Ryan: (4:01:23 PM) sec phone
                   after the phone call i leave the computer and don't come back
                   the next day
Joey: (9:20:29 AM) I am learning common lisp

With apologies to Joey and Emily:

(And here's one of my favourite strips.)

Workshop com o trio Azul

2011-03-01T21:40:00.001Z

[este artigo foi originalmente publicado no blogue do Sítio de Sons em 2007; estou a passá-lo para este blogue, para mais tarde recordar. :-)]

O workshop com o trio Azul no passado dia 22 de Junho [de 2007] foi um sucesso. Este é um relato pessoal desse fantástico dia.

Começámos o dia logo pela manhã com uma primeira parte dedicada aos instrumentos. Cada participante optou por assistir a uma das três sessões independentes. Chegada a hora do almoço, iniciaram-se as trocas de impressões entre os participantes visivelmente entusiasmados. Circularam descrições das reharmonizações com Coltrane changes do Frank Möbus; circularam frenéticas histórias sobre os sons de arco com pratos de bateria utilizados pelo Jim Black; circularam relatos da clareza com que Carlos Bica demonstrou o seu gosto pela simplicidade, a importância das pausas, das notas individuais e da colocação rítmica em geral. Circulou música.

À tarde juntámo-nos todos e formaram-se grupos para tocar diversos temas. Dois felizardos tiveram a oportunidade de tocar um pouco de free jazz com o Jim Black; dizem que foi uma excelente experiência. :-) Os vários músicos que tocaram nesta tarde tiveram a oportunidade de ouvir críticas altamente relevantes, construtivas e pedagógicas. Por certo, cada participante terá tido as suas epifanias distintas; estas foram duas das ideias principais que retive:

é indispensável ter convicção no que se toca. Por exemplo, não é boa ideia tocar um walking no baixo ou comping na guitarra só porque «é suposto» fazê-lo num determinado estilo de música;
é essencial ter consciência de diversas questões ao nível da orquestração. Isto é, cada músico deve ouvir o som que o grupo está a gerar e, em função disso, escolher a cada instante onde se quer colocar a nível harmónico, rítmico, tímbrico, etc. Nos seus concertos, o Jim Black ilustra frequentemente este processo de uma forma muito óbvia quando opta por simplesmente parar de tocar; o efeito com isto gerado é muito interessante.

À noite, dirigimo-nos para a Pensão Flôr de Coimbra na baixa de Coimbra para jantarmos um excelente Tofu à Espiritual, entre outros pratos com nomes menos interessantes. Seguiu-se uma jam session no Café Santa Cruz que se iniciou com dois temas do trio: «Canção de Embalar» e «Tea for Two».

O convívio musical prosseguiu pela noite fora. Penso que todos os participantes ficaram positivamente impressionados com a simpatia e abertura oferecidas pelo Carlos Bica, Jim Black e Frank Möbus. Ficamos-lhes imensamente agradecidos.

Another ZSLUG meeting report

2011-02-10T12:20:00.004Z

I seem to have picked up the habit of doing at least one Lisp conference per year. This year I was hoping for an ILC (or ECLM?), but I'll have no such luck, it seems. So, the first ZSLUG-ng meeting was it and here's a summary of my trip to Zürich.

Sunday. Met the Teclo folks for dinner. The stuff they're working on is exciting in a low-level-ish kind of way — more on that later — and their team is composed by some of the best Lispers I know. (Also, as it turns out, they must have the very best intersection between Lisp and cooking skills!) Their startup vibe is intoxicating; if you're into systems programming, low-level networking stuff, et cetera, you should definitely get in touch with them.

Monday. Could see the snowy Alps thanks to the lovely clear sky. Zürich is posh, expensive, clean, and it's got great a public transportation system, mostly trams, which I much prefer to subways. Met Jorge Tavares who was in town for the meeting. Jorge was a TA of mine who pointed me at Paul Graham's ANSI Common Lisp back in my first year of college. (Note: this was before the best Lisp book had been released.) Among many things, we talked about his rather interesting research around genetic programming and evolutionary design of algorithms using Lisp.

Hans Hübner talked about his thwarted plans to replicate the Lisp Machine using FPGAs, and how he ended up implementing a Forth system instead. I was expecting some sort of tutorial or more technical details, perhaps a demo, but, alas, no such luck. Great talk, though.

Luke Gorrie then talked about Teclo. After introducing the team, he proceeded to show us how TCP badly misbehaves in today's mobile networks using insightful time-sequenced diagrams produced by their analysis tools. Some of the TCP sessions exhibited pathological behaviour, with TCP senders getting awfully confused by the odd packet lost in the ether. It was a bit reminiscent of buffer bloat to the untrained eye; perhaps because part of the problem is that radio networks go out of their way to not drop packets. There was some explanation about how Sambal sits as a proxy between radio and wired networks and massages TCP connections to make them more amenable to the lossy radio networks. They have their own TCP/IP stack written in Lisp that bypasses the OS and handles packets in under 100 ns each. Neat stuff.

The evening carried on, to a local pub, as usual. It was a good meeting, if a bit short. I think it could have included lightning talks; those have worked quite well in past conferences.

Tuesday. Had time for some light hiking around Üetliberg, then back to Lisbon.

How a Common Lisp Programmer Views Users of Other Languages

2010-01-19T23:02:00.000Z

Via @robotickilldozr.

Happy birthday, SBCL

2009-12-18T22:00:00.003Z

Earlier this week I attended SBCL's 10th Anniversary Workshop at Goldsmiths, University of London. It was great.

Monday started off with a status update from Nick Levine on his upcoming O'Reilly book called Lisp Outside the Box. He talked about the difficulties of fitting so much material in relatively few pages and gave us printed copies of one of the draft chapters. Everyone should go read the latest draft chapters and send Nick some feedback at his blog.

Later that morning, Martin Cracauer gave us a very juicy presentation about various technical details pertaining to ITA's usage of SBCL for their high-performance flight search engine. I scribbled down some notes:

Things like SBCL's optimized struct layout and slot access and bitfield operations provide for space- and speed-efficient memory representations.
They seemed quite happy about SBCL's fixnum efficient representation. (E.g., fixnum tags end in zeroes which among other things means some arithmetic can be performed directly with the CPU's native instructions without prior untagging.) I would expect other Lisps (besides CMUCL, obviously) to have similar characteristics but I've never actually checked.
SBCL's tremendously useful declaration semantics simultaneously provide important assertions when testing and high performance in production, e.g. when dealing with 32-bit arithmetic.
They use mmap() to directly use C-struct-like data from Lisp.
Array bounds-checking is left enabled since disabling it is not worth the enourmous trouble one might get into otherwise.
GC performance is good but they use pre-allocation where usage is predictable. Earlier versions had a cons cache — which got a lot of laughs from the audience — which turned out to actually slow things down in SBCL for various reasons.

In summary, they seemed pretty happy with how things turned out with SBCL, after having used, IIUC, three other Lisp implementations in the past. In an unrelated note, I found it nice that they do automated performance regression tests with customer datasets and queries. I like that sort of stuff and I wish we had infrastructure to do this sort of thing with open-source CL libraries.

After a free lunch — the best kind of lunch — hacking and brainstorming started. It was interesting to learn that all of the windows in that building could be used as whiteboards (translucid boards?). In the afternoon some lightning talks took place. I didn't take notes at this point but I recall that Christophe Rhodes talked a little bit about his recent Unicode-related work, James Knight described his initial attempt to hook the high-level bits of SBCL's compiler into LLVM, Paul Khuong described his library for implementing lock-free algorithms, and Attila Lendvai and Levente Mészáros demoed their impressive DWIM web framework stuff.

We had dinner at a Turkish restaurant which was very good. Surprinsingly so, perhaps, because their entrance prominently displayed a “Fully Licensed” sign. Fun UK trivia: “off licensed” means an establishment may sell alcoholic drinks but they must be consumed elsewhere whereas a “fully licensed” establishment can both sell the drinks and, erm, harbour inebriates.

Hacking resumed tuesday morning and throughout the day, with some interruptions for more lightning talks. Rudi Schlatte gave us a quick intro to the magnificent org-mode, Attila and Levente showed us some nice pieces of software like the Stefil test framework, cl-rdbms, perec, and a partial evaluator. But, David Lichteblau won the gold medal of lightning talks by giving four or five talks about gencgc incremental allocation and dynamic-space relocation, his recent work on Hemlock (including a brand new Qt backend), interfacing with C++ (e.g., his own CommonQT), and some other stuff I lost track of. (See the workshop's website for more details.)

Afterwards there was some discussion about the future of SBCL. Among other things an official move to a git repository seems eminent, there was some discussion about using more of Launchpad's functionalities (e.g. for dealing with incoming patches), and the possibility of SBCL bundling some CL libraries was raised.

The day ended with everyone going to a local pub (fully licensed, I hope) where I had plenty of fun talking with Levente and Attila about life, the universe, and everything, pretty much. Levente gave us some nice math/logic puzzles to exercise our brains; it was a great evening.

Many thanks to Christophe Rhodes for organising this great workshop and to my employer for kindly sponsoring my participation and enabling my proud response to the question “What do you do?” — “I'm a Lisp programmer!” :-) I was happy to meet lots of people I regularly interact with on-line and/or whose Lisp code I have used or read at some point. Unfortunately I didn't get to chat with everyone but I hope we'll have future opportunities.

Looking forward to ELS 2010 already which, quite conveniently for me, will take place right here in Portugal with less freezing temperatures (London is rough!) and the right kind of electricity sockets and voltages.

ECLM 2009 registration deadline coming up

2009-08-07T20:16:00.004+01:00

The registration deadline for this year's European Common Lisp Meeting is August 15th so if you're interested in attending, you should register soon!

Illustrating SBCL's build process

2009-06-24T20:41:00.006+01:00

A while back I read Christophe Rhodes's paper “SBCL: A Sanely-Bootstrappable Common Lisp” which describes SBCL's bootstrap procedures.

The paper includes a bunch of diagrams for each build stage. These were pretty helpful in improving my understanding of the build process. So, I tried to take them a step further and create a single diagram that provides a global overview of the build process:

I'm interested in hearing any comments you might have. If you already know how the build process works, does it make you cringe? If you are vaguely familiar with (parts of) the process, does it provide you with some sort of new insight? Given that I haven't included a legend, does it make any sense at all?

Tobias Rittweiller's SLIME talk

2008-12-06T13:34:00.005Z

Tobias has posted the slides from his SLIME talk at a recent Munich Lisp Group meeting. Besides presenting a nice overview of SLIME's internals and features, it includes a bunch of useful tips and tricks.

For instance, did you know that you can recompile a frame with higher debug settings right from the debugger? Or that, after changing some macro in your code, you can recompile all functions that use it with just a few keystrokes?

Lisp at Stack Overflow

2008-09-16T18:42:00.007+01:00

Stack Overflow is a new programming-oriented Q&A website recently launched by well-known bloggers Jeff Atwood and Joel Spolsky.

So far, there's only a handful Lisp-related questions with a couple of answers, some better than others.

I hate web forums as much as the next guy. Long live comp.lang.lisp and all that. However, it's not really just a web forum; it features Reddit/Digg-like voting mechanism and wiki-style editing and it might be a good way of building a (better) Lisp FAQ of sorts, collaboratively. Seems worth a try.

Internacia Konferenco de Fizik-Studentoj 2008

2008-08-20T14:50:00.009+01:00

Ĉi-somere mi ne partoprenis Esperantan konferencon. Anstataŭe, mi vojaĝis al Pollando por la Internacia Konferenco por Fizik-Studentoj en Krakovo (ICPS 2008), kvankam mi fakte ne studas fizikon.

Utilis ke mi partoprenis IJK-on 2006 en Sarajevo ĉar estas kelkaj vortoj similaj inter la pola kaj la bosna lingvoj, pivo kaj piwo (biero), interalie. Mi ne lernis multe pli ol simplaj vortoj, sed mi lernis iomete pri la kompleksa pola alfabeto kaj amuziĝis legante hazardajn vortojn ĉe la stratoj.

Kvankam ĉi tiaj konferencoj temas precipe pri festumado, la oficiala temo estis fiziko. Kelkaj prelegoj estis tre interesaj, kvankam mi ne komprenis amason da aferoj. Mi venis hejmen kun la volo lerni iomete pli pri fiziko, tamen.

Estis ankaŭ alia grava simileco inter la du konferencoj: ambaŭ havis tre internaciajn etosojn. (Fakte, IKFS-partoprenintoj venis el pli da landoj ol IJK-partoprenintoj, mi kredas, kvankam la plejmulto venis el Eŭropaj landoj, en ambaŭ kazoj.) Sed, la oficiala lingvo estis, kompreneble, la angla kaj mi bone sentis kelkajn aspektojn de tiu lingva malneŭtraleco. La britoj havis grandegan avantaĝon: ili sinesprimis ege pli flue ol la ceteraj partoprenintoj kaj tio donis al ili pli altan statuson.

Kaj mi ne havas klarigon por la jeno: la konferenco atrofiigis niajn denaskajn lingvojn. Multaj portugaloj uzis anglajn vortojn en siaj paroladoj, pli ofte ol kutime. Se mi bone memoras, tio tute ne okazis al mi post IJK.

Nu, tre interesa konferenco ĝenerale. Konis multajn interesajn homojn kaj verŝajne partoprenos denove venontjare en Kroatio.

The features of Common Lisp

2008-08-20T14:30:00.005+01:00

Abhishek Reddy has compiled an interesting list of Common Lisp features. It's quite concise and includes examples for almost every feature described. It'll come in handy next time someone asks you what is it that attracts you to Lisp.

CFFI 0.10.0 released!

2008-07-29T23:24:00.006+01:00

It's been a while since CFFI's previous release, almost two years. During this period, a lot of development work happened and lots of cool new features were implemented. Here's a brief highlight of some of the important changes:

foreign string encodings using Babel. UTF-8 becomes the default encoding for foreign strings.
improved foreign type system that takes better advantage of CLOS features.
emulated :long-long types on Lisps whose native FFI doesn't support these types.
integrated a groveller inspired by SBCL's sb-grovel.
support for the stdcall calling convention.
removed finalizer-related code in favour of trivial-garbage.
function and variable lookups can now be linked to a specific foreign library instead of assuming a global namespace.
the cffi-features package has been deprecated in favour of trivial-features. CFFI-specific features are now interned in the CFFI-SYS package.
dozens of bug fixes and minor enhancements.

The long hiatus between releases caused all sorts of problems and confusions. Hopefully that won't happen again and you'll see more frequent CFFI releases in the future.

Paneo E-planeda

2008-05-23T09:55:00.004+01:00

Pro fuŝo mia, E-planedo estis neatingebla ĉi-nokte. Dankon al Kalle Kniivilä pro la atentigo. Ĉio enordas denove, mi esperas.

Mensagem dos Amigos da Cultura

2008-01-27T14:04:00.001Z

«Um grupo de pessoas de Coimbra resolveu juntar-se para manifestar o seu descontentamento com o rumo da política cultural em Coimbra, tendo daí surgido o texto “Pelo direito à cultura e pelo dever de cultura!”.

A sua apresentação pública e dos nomes dos 160 subscritores iniciais foi feita em conferência de imprensa no Café-Teatro do Teatro Académico de Gil Vicente, na quarta-feira passada. Em resultado, foi criado um blogue que está disponível para acolher novos subscritores e para publicar os depoimentos pessoais de todos quantos queiram enriquecer a discussão pública agora iniciada.

Foi igualmente anunciada a data do debate com o qual se pretende dar seguimento a esta iniciativa. Terá lugar no próximo dia 20 de Fevereiro, a partir das 17:00h, no Teatro Académico de Gil Vicente. A sua participação é essencial. Se tal como nós, entende que é urgente voltar a tomar posição pública sobre esta matéria que a todos/as nós diz respeito, visite o blogue e assine.»

originalmente publicado no blogue do Sítio de Sons

Podcasts sobre música e músicos

2008-01-01T21:32:00.000Z

Certamente muitos já conhecem o programa de rádio «Pessoal e... Transmissível» da TSF, que está também disponível em formato de podcast, mas que infelizmente não contém o nome dos entrevistados ou qualquer outra informação acerca dos conteúdos dos programas. O arquivo, por outro lado, embora tenha uma descrição de cada programa, não tem os ficheiros num formato que possa ser ouvido num iPod, por exemplo.

Digo isto porque neste programa de Carlos Vaz Marques houve já imensas entrevistas com excelentes músicos portugueses e estrangeiros que merecem ser republicadas e ouvidas com atenção. Seguem-se então as ligações para os ficheiros MP3 de algumas destas excelentes entrevistas: Maria João, Mário Laginha, Gary Burton, Carlos Bica, Hermeto Pascoal, Afonso Pais, Sofia Ribeiro, Egberto Gismonti, Zé Eduardo e Pat Metheny.

A entrevista com o Hermeto Pascoal é particularmente fascinante.

(originalmente publicado no blogue do Sítio de Sons)

E-planedo legebla per retpoŝto

2008-01-01T17:13:00.000Z

Ekde nun, eblas legi e-planedon per retpoŝto, se vi tion preferas. Se vi aliĝos, vi ricevos retpoŝtajn mesaĝojn po maksimume unu ĉiutage kun ĉiuj afiŝoj de la koncerna tago.

Dolĉa Rizo, Koimbro-stila recepto

2007-12-31T00:20:00.002Z

Kiel promesite, jen la recepto por prepari Dolĉan Rizon.

Ingrediencoj

por 6 personoj

250 g da rizo
1.5 l da lakto
100 g da sukero
citronŝelo
pulvora cinamo

Preparado

Boligu la lakton kun la citronŝelo.
Dume, varmigu 2 dl-ojn da akvo en poto. Kiam ĝi boliĝas, aldonu la rizon.
Post bolkuiri ĝin dum 3 aŭ 4 minutoj ekaldonu la lakton. Dum oni malrapide aldonadas la lakton, nepras ĉiam kirli (malrapide, per lignkulero). Tio daŭros pli ol unu horo.
Iam aldonu la sukeron. Atentu, tiam la rizo ne plu bolkuiriĝos, kaj bona rezulto estos rizo nek tro mola nek tro malmola.
Daŭre bolkuiru la miksaĵon. Ĝi iĝos pli kaj pli densa. Denove, tio estas arto; ĝi estu nek tro flua nek tro densa. Vi devas ĉiam kirli aŭ ĝi gluiĝos al la poto. Uzu malfortan fajron. Postulas multe da pacienco tiu ĉi dolĉaĵo.
Finfine surŝutu ĝin sur telerojn kaj aldonu la cinamon.

Frandumado

Manĝu ĝin tuj varman, manĝu ĝin poste malvarman, manĝu ĝin eĉ post unu aŭ du tagoj. Tiu ĉi dolĉaĵo, kiam bone preparita, bongustas ĉiam kaj ĉiel.

Dolĉa Rizo

2007-12-26T13:30:00.000Z

Iam mi scipovos kuiri! Dume, mi faras provojn. Jen la unua fojo, ke mi faras la tradician dolĉaĵon “Dolĉa Rizo”. (Internacie konata kiel “Rizpudingo”, mi kredas.) Ĝi tradicias ĉe mia regiono verŝajne pro la rivero Mondego kaj siaj rizkampoj.

Ĉifoje, mankis iom da rizo — mia patrino informas min, ke la recepto kiun mi uzis malĝustas kaj mi devintus uzi trifoje pli da rizo — kaj, kompreneble, ĝi ne estis tiel bongusta kiel tiu de mia patrino aŭ mia avino. Tiu ĉi dolĉaĵo postulas multe da pacienco kaj iom da sperto. Paciencon mi havis, antaŭsperton tute ne. Venontfoje, se la kuirado estos pli sukcesa, mi skribos pri la recepto. Tamen, sciu jam, ke tiu ĉi Koimbro-stila versio ne enhavas ovojn; tiujn kun ovoj mi tute ne ŝatas. :-)

Guglo sugestas studi Esperanton

2007-10-29T22:42:00.000Z

En sia ĉefa blogo, Guglo priskribas la spam-sistemon de sia retpoŝtservo, Gmail. Tiu blogero inkluzivas amuzan videon pri la sistemo. Per la tempo kiun oni ne plu malŝparas forviŝante spamojn, ili sugestas danci kaj... studi Esperanton!

Practical Common Lisp

2007-09-23T18:00:00.000+01:00

Just recently, I have finally bought Peter Seibel's book Practical Common Lisp.

I had already read most of it on the web. The chapters on CLOS and LOOP were particularly useful for me since the previous Lisp book I had read, Paul Graham's ANSI Common Lisp, largely neglects these important features.

What can I say? It's a great common lisp tutorial.

Update: as someone kindly mentioned in the comments, Seibel's book has a chapter dealing with CL's condition system, aptly named “Beyond Exception Handling: Conditions and Restarts”. This very important feature is also neglected by pretty much every other book about Lisp.