Mostrando postagens com marcador OO. Mostrar todas as postagens
Mostrando postagens com marcador OO. Mostrar todas as postagens

segunda-feira, 22 de junho de 2015

MoonScript

Adaptado no blog novo.
MoonScript Há muito pouco tempo atrás um amigo meu me sugeriu dar atenção à MoonScript. Admito que eu via a linguagem com preconceito, mesmo assim resolvi dar uma olhada.

Resultado: todos os meus códigos em Lua acabaram convertidos para MoonScript. :-)

A linguagem é extremamente enxuta, limpa e poderosa. Não vou entrar em detalhes, se estiver curioso, leia o guia da linguagem.

Mas também não puxei assunto por nada, vou dar alguns exemplos.

Paradigma Funcional

Para lidar com o paradigma funcional, a sintaxe de MoonScript é bem mais concisa e que a de Lua. Por exemplo, o combinador Y.

Lua é uma linguagem estrita e não suporta o combinador Y em sua forma lazy. Como MoonScript é compilado para código Lua, sofre do mesmo mal. Assim, é preciso usar o combinador Z, que é versão estrita do combinador Y.

O combinador Z é definido como: λf.(λx.xx)(λx.f(λv.xxv)). Isso é facilmente representado em MoonScript:
Z = (f using nil) -> ((x) -> x x) (x) -> f (...) -> (x x) ...

Com isso é possível, por exemplo, implementar facilmente o quick sort:
Z = (f using nil) -> ((x) -> x x) (x) -> f (...) -> (x x) ...

tconcat = (...) -> [e for t in *{...} for e in *t]

Z (qsort using tconcat) ->
    (xs) ->
        if #xs <= 1
            xs

        else
            x, xs = xs[1], [e for e in *xs[2,]]
            lesser = [e for e in *xs when e <= x]
            greater = [e for e in *xs when e > x]
            tconcat (qsort lesser), {x}, (qsort greater)

Orientação a Objetos

Em Lua é preciso toda uma ginástica com metatabelas para simular eficientemente orientação a objetos. MoonScript tem suporte a classes na linguagem.

Por exemplo, podemos criar uma pilha (stack) facilmente:
import bind_methods from assert require "moon"

class Stack
    list: nil

    set: (x) =>
        @list =
            next: @list
            value: x

    get: =>
        v = nil
        {value: v, next: @list} = @list if @list
        v

bind_methods Stack!

LuaJIT

Como MoonScript compila para código Lua tradicional, você pode gerar código para virtualmente qualquer plataforma que rode Lua, como LuaJIT e LÖVE.

Por exemplo, você pode usar C-structs e metatipos:
ffi = assert require "ffi"
import sqrt from math

ffi.cdef [[
    typedef struct { double x, y; } point_t;
]]

local Point = ffi.metatype "point_t",
    __add: (o) => Point @x + o.x, @y + o.y
    __len: => @\hypot!
    __tostring: => "(#{@x}, #{@y})"
    __index:
        area: => @x * @y
        hypot: => sqrt @x*@x + @y*@y

Point

bash$ luajit
LuaJIT 2.0.3 -- Copyright (C) 2005-2014 Mike Pall. http://luajit.org/
JIT: ON CMOV SSE2 SSE3 SSE4.1 fold cse dce fwd dse narrow loop abc sink fuse
> moon = assert(require "moonscript.base")
> Point = (moon.loadfile "point.moon")()
> p = Point(3, 4)
> = tostring(p)
(3, 4)
> = p:area()
12
> = #p
5
>
Bem, acho que já fiz propaganda suficiente da linguagem. ;-)

[]’s

quarta-feira, 18 de setembro de 2013

Um editor de textos rapidinho

Veremos como é simples criar uma aplicação gráfica rapidamente usando Tkinter.

Vamos começar a a partir de um boilerplate:

#!/usr/bin/env python
# coding: UTF-8
from __future__ import absolute_import, division, print_function, unicode_literals

#-------------------------------------------------------------
# Cabeçalhos
#

# Aqui vão entrar os imports

__all__ = ['Editor']


#-------------------------------------------------------------

class Editor(object):

    def mainloop(self):
        pass


#-------------------------------------------------------------
# Rodapé

if __name__ == '__main__':
    app = Editor()
    app.mainloop()

A primeira coisa que precisamos fazer é criar nossa janela raiz. Para tanto, adicione aos cabeçalhos o import:

from Tkinter import *

Método construtor

Em seguida, no começo da classe Editor, vamos começar a escrever nosso construtor:

class Editor(object):

    def __init__(self):
        root = self.root = Tk()
        root.title('EditPy')

Precisamos então de um frame para colocar os botões de abrir, salvar e salvar-como:

        fbuttons = Frame(root)
        Button(fbuttons, text='Open', command=self.open) \
              .pack(side=LEFT)
        Button(fbuttons, text='Save', command=self.save) \
              .pack(side=LEFT)
        Button(fbuttons, text='Save As', command=self.save_as) \
              .pack(side=LEFT)

O pai (master) do frame fbuttons é nossa janela raiz e o pai dos botões é o frame.

Agora precisamos de uma caixa de texto para editar e exibir o conteúdo dos arquivos. Primeiro vá aos cabeçalhos novamente e acrescente o import:

from ScrolledText import ScrolledText

Então, continuando o construtor, crie a caixa de texto com rolagem:

        steditor = self.steditor = ScrolledText(root)

Para fechar o construtor só falta exibir o frame e a caixa de texto, e colocar o foco na caixa:

        fbuttons.pack(expand=True, fill=X)
        steditor.pack(expand=True, fill=BOTH)
        steditor.focus()

Loop principal

Se você tentar rodar o código agora, nada acontece. Isso porque o método mainloop() faz isso: absolutamente nada.

Precisamos então, neste método, chamar o loop principal do Tkinter. Para isso, altere o método:

    def mainloop(self):
        self.root.mainloop()

Chamamos então o loop principal através da janela raiz (root).

Abrir um arquivo

Porém coisas estranhas e erros esdrúxulos podem acontecer, pois ainda não implementamos nenhum dos métodos chamados pelos botões – self.open, self.save e self.save_as.

Parece-me justo que comecemos pelo método de abertura de arquivo. Criemos a assinatura do método:

    def open(self):

Para abrir um arquivo, precisamos de uma ferramenta chamada askopenfilename que precisamos importar, então nos cabeçalhos acrescente:

from tkFileDialog import askopenfilename

Então, de volta ao método open(), podemos pegar o nome do arquivo e carregá-lo:

        filename = askopenfilename(title='EditPy | Open')
        if filename:
            self.filename = filename
            self.load_file()

O método load_file() é quem vai de fato carregar o arquivo, mas precisamos antes apagar o conteúdo da caixa de texto:

    def load_file(self):
        filename = self.filename
        steditor = self.steditor

        steditor.delete('@0,0', 'end')
        with open(filename) as fd:
            steditor.insert('@0,0', fd.read())

O método delete() da caixa de texto apaga parte do conteúdo da caixa e os parâmetros são os índices de começo e fim:
  • @0,0 significa linha 0, coluna 0 (começo do texto);
  • end significa o final do texto.

O método insert() inserte a string (lida do descritor de arquivo) na posição indicada (@0,0).

Salvando o texto

Para salvar o texto, precisamos implementar o método save(). Ele precisa:
  1. Verificar se temos um nome de arquivo – se não tivermos, é um save_as.
  2. Abrir o arquivo para escrita.
  3. Obter o texto da caixa de texto.
  4. Gravar o texto no arquivo.

Simples, indolor e o código é intuitivo:

    def save(self):
        filename = self.filename
        if not filename:
            return self.save_as()

        with open(filename, 'w') as fd:
            fd.write(
                self.steditor.get('@0,0', 'end')
            )

Repare nos índices usados no método get().

Em seguida é preciso saber o que fazer quando não temos o nome do arquivo ou quando escolhemos Save As.

Primeiro a assinatura do método:

    def save_as(self):

Caso haja um nome de arquivo, é honesto usá-lo como ponto de partida para caixa de diálogo de salvamento. Para isso precisamos separar o nome de diretório do nome base do arquivo e uma forma de fazer isso é com o método de string rfind.

Para sabermos qual o separador de diretórios usado, adicione aos imports:

from os import path

Então continue no método:

        filename, directory = self.filename, None
        if filename and path.sep in filename:
            index = filename.rfind(path.sep) + 1
            directory = filename[:index]
            filename = filename[index:]

[update 2014-04-12]
Optei por usar rfind, mas poderia ter usado path.basename e path.dirname. É uma questão de escolha e estilo.
[/update]
Feito o slice, já podemos exibir a caixa de diálogo de salvamento. Para isso precisamos da ferramenta asksaveasfilename.

Modifique o import do askopenfilename para:

from tkFileDialog import askopenfilename, asksaveasfilename

Continuando agora no método save_as(), podemos exibir a caixa de diálogo e, se algum arquivo for informado, chamar o método save():

        filename = asksaveasfilename(
            title = 'EditPy | Save As',
            initialfile = filename,
            initialdir = directory,
        )

        if filename:
            self.filename = filename
            self.save()

E pronto! Já pode testar seu editor de texto!

Lapidando

Uma forma de melhorar um pouco o visual da aplicação é usando a extensão ajulejada do tk, chamada ttk.

Para tanto, basta adicionar ao cabeçalho, no final dos imports:

from ttk import *

Você também pode usar os métodos wm_protocol() e bind_all() da janela raiz para adicionar funcionalidades interessantes, mas isso é história pra outro dia. ;-)

[]’s
Cacilhας, La Batalema

terça-feira, 22 de dezembro de 2009

Seaside

Squeak Seaside é um arcabouço (framework) para desenvolvimento de aplicações web para Smalltalk. É descrito pelo próprio autor como um arcabouço herético, por quebrar todas as regras dos gurudons atuais.

Pessoalmente gosto muito de coisas heréticas ou subversivas. Sou um apaixonado por subversão. =D

Olhando a documentação, podemos ver que Seaside é suportado pelas máquinas virtuais Cincom VisualWorks, GNU Smalltalk, VA Smalltalk, Squeak e seus derivados Pharo e GLASS.

GNU Smalltalk


A máquina virtual recomentada é Squeak, da qual gosto muito e que é ótima para aplicações desktop, no entanto Squeak é uma plataforma muito pesada, consome muitos recursos da máquina, por isso, para Seaside, optei por uma plataforma mais leve: GNU Smalltalk.

GNU Smalltalk sofre porém de um mal extremamente irritante: a sintaxe da linguagem é muito irregular – para ser eufémico.

Teoricamente GNU Smalltalk suportaria a sintaxe correta de Smalltalk-80, mas não funciona bem assim… ele é muito chato e levanta erros de sintaxe para códigos perfeitamente corretos, mas que diferem do que o GNU Smalltalk espera de Smalltalk-80. Então é preciso experimentar algumas formas diferentes – mas regulares – de fazer as coisas antes de encontrar uma que funcione (às vezes ele implica até com nomes de argumentos).

Vou usar aqui a sintaxe Smalltalk-80 precisa – e que funciona no GNU Smalltalk –, mas colocarei o mesmo código na sintaxe peculiar do GNU Smalltalk ao final deste artigo apenas por curiosidade.

Preparação da imagem


Para criar a imagem para nosso exemplo usei o comando:
bash$ gst-load -iI seaside.im Seaside Seaside-Development Seaside-Examples


Isso cria uma imagem seaside.im com os pacotes Seaside (Seaside em si), Seaside-Development (ferramentas de desenvolvimento) e Seaside-Examples (exemplos).

Usei então o exemplo de componente da própria documentação: MyCounter.st.
  • O método de classe #canBeRoot diz se o componente pode ser registrado como uma aplicação autónoma ou não.
  • Na inicialização (#initialize) o atributo count é zerado.
  • O método #states retorna uma coleção de estados que podem ser retrilhados (backtracked).
  • O método #renderContentOn: é usado para renderizar a página.
  • Ao final a mensagem #registerAsApplication: registra o componente como aplicação.


O código fica então (se copiar e colar, substituia ↑ por ^):
" See: http://www.gnu.org/software/smalltalk/manual/html_node/Seaside.html "

Seaside.WAComponent subclass: #MyCounter
instanceVariableNames: 'count'
classVariableNames: ''
poolDictionaries: ''
category: 'Seaside Examples'
!

!MyCounter class methodsFor: 'testing'!

canBeRoot
↑true
!

!

!MyCounter methodsFor: 'initializing'!

initialize
super initialize.
count := 0.
!

!

!MyCounter methodsFor: 'accessing'!

states
↑{ self }
!

!

!MyCounter methodsFor: 'rendering'!

renderContentOn: html
html heading: count.
html anchor
callback: [ count := count + 1 ];
with: '++'.
html space.
html anchor
callback: [ count := count - 1 ];
with: '--'.
!

!

MyCounter registerAsApplication: 'mycounter'.


Para carregar o componente na imagem usei o comando:
bash$ gst -I seaside.im -S MyCounter.st


Rodar a aplicação


O seguinte comando levanta a máquina virtual no modo servidor:
bash$ gst-remote -I seaside.im --daemon


Depois disso você poderá ver a máquina virtual ouvindo na porta 12345/TCP:
bash$ netstat -ln4 | grep 12345
tcp 0 0 0.0.0.0:12345 0.0.0.0:* LISTEN


É possível obter o PID do processo da máquina virtual com seguinte comando:
bash$ gst-remote --pid


Porém o Seaside não está rodando. Para rodar o serviço web use o comando:
bash$ gst-remote --start=Seaside


É possível também iniciar a máquina virtual já rodando o Seaside com o seguinte comando:
bash$ gst-remote -I seaside.im --daemon --start=Seaside


Por padrão o serviço web Seaside estará escutando na porta 8080/TCP.

Para acessar a aplicação que acabamos de criar use o endereço http://localhost:8080/seaside/mycounter.

Parar a aplicação


Para parar a aplicação use o comando:
bash$ gst-remote --stop=Seaside


Repare que, apesar do serviço web ter parado, a máquina virtual continua rodando. Para pará-la:
bash$ gst-remote --kill


Para comparação


A título de comparação, segue o código usando a sintaxe bizarra e esdrúxula peculiar do GNU Smalltalk:
Seaside.WAComponent subclass: MyCounter [
| count |

<category: 'Seaside Examples'>
<comment: nil>

MyCounter class >> canBeRoot [
<category: 'testing'>
^true
]


initialize [
<category: 'initializing'>
super initialize.
count := 0
]

states [
<category: 'accessing'>
^{ self }
]

renderContentOn: html [
<category: 'rendering'>
html heading: count.
(html anchor)
callback: [count := count + 1];
with: '++'.
html space.
(html anchor)
callback: [count := count - 1];
with: '--'
]
].

MyCounter registerAsApplication: 'mycounter'.


[]'s
Cacilhas, La Batalema

quinta-feira, 19 de março de 2009

Sobre APIs

Umas das coisas mais importantes em programação, sem a qual ninguém consegue desevolver, é API.

API – Interface de Programação de Aplicativos – é o conjunto de recursos de que o programador dispõe para desenvolver suas aplicações.

Este artigo faz uma comparação – na verdade, mais uma demonstração – de cinco APIs muito usadas: IEEE 1003, STL, OpenStep, GLib e Java.

Para a demonstração será usado um trecho de código para ler a primeira linha de um arquivo.

Por que não a API do Windows?


Antes de começar, é preciso esclarecer por que não a API do Windows.

O objetivo de uma API é oferecer um ambiente homogêneo de programação, para que o programador não seja obrigado a reaprender a mesma coisa diversas vezes. Para facilitar isso, muitas APIs ainda podem ser usadas em diversas linguagens diferentes, outras em apenas uma.

No entanto uma API que funciona apenas em um único sistema operacional – ou ainda no grupo de sistemas operacionais de uma única empresa – não está fazendo seu trabalho, por mais usado que esse(s) sistema(s) possa ser.

Assim a API do Windows não faz mais do que se espera da interface de um sistema operacional.

É claro que é necessário que o Windows possua uma API, mesmo que seja exclusivamente para conexão de outras APIs mais universais.

IEEE 1003 (POSIX)


O padrão POSIX, definido pela IEEE, oferece uma interface completa para sistemas compatíveis com UNIX. Alguns exemplos são IBM AIX, Solaris, GNU (e daí também Linux), BSD, Mac OS X, MS Xenix e muitos outros.

O trecho de código em C para ler a primeira linha de um arquivo:
FILE *fd = fopen(filename, "r");

if (fd) {
while (!eof(fd)) {
char buf;
fread(&buf, sizeof(char), 1, fd);
printf("%c", buf);
if (buf == '\n')
break;
}

fclose(fd);
}


Observação1: é preciso incluir o cabeçalho stdio.h ou, em C++, cstdio:
#include <stdio.h>


Observação2: a variável filename é do tipo const char *.

Observação3: foi preciso procurar ocorrência do carácter \n pois POSIX não ofereça uma função de alto nível para ler uma linha.

Observação4: o padrão POSIX é completamente procedimental – as demais APIs citadas aqui são orientadas a objetos –, sendo um pouco desajeitado para algumas operações.

STL


A linguagem de programação C++ possui uma biblioteca padrão própria bastante completa chamada STL – Standard Library.

Para o exemplo, é preciso incluir o cabeçalho fstream para a manipulação de arquivo e o cabeçalho iostream para a exibição dos dados na tela:
std::ifstream fd(filename);

if (fd.is_open()) {
char buf[1024];
fd.getline(buf, 1023);

std::cout << buf << std::endl;
fd.close();
}


Observação1: como citado acima, é preciso incluir pelo menos o cabeçalho fstream ao manipular arquivos:
#include <fstream>


Observação2: a variável filename precisa ser do tipo const char * – std::ifstream não suporta std::string.

OpenStep


A empresa NeXT de Steve Jobs, ora adquirida pela Apple, abriu a API de seu sistema operacional em 1992 num acordo com a SUN Microsystems, sob o nome de OpenStep, o que permitiu, além da criação de aplicações de terceiros para NeXTSTEP, também o desenvolvimento de outros sistemas operacionais compatíveis com sua API e APIs de programação para sistemas já existentes, tornando-os compatíveis com OpenStep.

Exemplos de sistemas compatíveis com essa API são Mac OS X e GNUstep (portável para Windows e qualquer plataforma compatível com POSIX).

A API OpenStep funciona exclusivamente em Objective-C, apesar de haver alguns portes para outras linguagens, como C++, Smalltalk e Guile Scheme.

Vamos ao exemplo em Objective-C:
id fd = [NSFileHandle fileHandleForReadingAtPath: filename];

if (fd != nil) {
char buf = 0;
[fd seekToEndOfFile];
unsigned long long eof = [fd offsetFile];
[fd seekToFileOffset: 0];

while (([fd offsetInFile] < eof) && (buf != '\n')) {
[[fd readDataOfLength: 1] getBytes: &buf length: 1];
printf("%c", buf);
}

[fd closeFile];
}


Observação1: é preciso importar o cabeçalho Foundation.h:
#import <Foundation/Foundation.h>


Observação2: a variável filename precisa ser do tipo NSString.

Observação3: eu não conheço um método para ler uma linha de um arquivo em OpenStep, portanto usei um esquema similar ao usado acima em POSIX.

GLib


A GLib começou como parte do toolkit gráfico Gtk+ na versão 2.0, tendo evoluído para se tornar uma API multiplataforma orientada a objetos completa e independente da interface gráfica.

Você pode usar GLib em qualquer sistema POSIX e em Windows.

A maior curiosidade da GLib é que ela deixa explícita o equívoco – ou a falácia – de quem crê que não seja possível programar orientado a objetos em uma linguagem não orientada a objetos: é escrita em C e completamente orientada a objetos.

Aliás a base da GLib é o GObject que, curiosamente, não é compatível com a estrutura de orientação a objetos de C++ e outras linguagens clássicas, apesar de haver portes para C++ e outras.

O exemplo a seguir é um trecho de código em Vala, linguagem criada expecificamente para a GLib:
var file = File.new_for_path(filename);

if (file.query_exists(null)) {
try {
var fd = new DataInputStream(file.read(null));
stdout.printf("%s\n", fd.read_line(null, null));
fd.close(null);
} catch (Error e) {
// Ignora exceções
}
}


[update 2009-03-19]Faltou o close.[/update]

Observação1: é preciso «usar» GLib:
using GLib;


Observação2: a variável filename é do tipo string – equivalente em C a GString e gchar *.

Observação3: é preciso usar o pacote (--pkg) gio-2.0, que importa GIO, recursos de I/O da GLib.

Java


Em sua linguagem de programação, a SUN Microsystems optou por criar uma API própria (bem complicada e verborrágica em relação às demais, diga-se).
BufferedReader fd = null;
try {
fd = new BufferedReader(new FileReader(filename));
System.out.println(fd.readLine());

} catch (Exception e) {
// Ignora exceções

} finally {
try {
if (fd != null)
fd.close();
} catch (IOException e) {
// Ignora exceções
}
}


Observação1: as classes usadas estão no pacote java.io:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;


Observação2: a variável filename é do tipo String.


**

Fica aqui a dica de três APIs interessantes.

[]'s
Cacilhas, La Batalema

quinta-feira, 29 de janeiro de 2009

Propriedades e acessores

Em Java e em C++ há um bom motivo para que os atributos sejam sempre privados: preservar a interface das classes.

Por exemplo, imagine que temos uma classe que representa o registro de uma pessoa. Nela temos a idade. Sendo um número inteiro, poderia ser um atributo público:
Person person;
person.age = 23;
std::cout << person.age << std::endl;


Faz sentido. Agora imagine que mais tarde descobrimos que é preciso fazer um tratamento do valor recebido – para estar numa faixa aceitável, por exemplo…

Sem alterar a interface – e efetuar uma refatoração total de todo código onde ocorre instância – é impossível.

Então, em Java e C++ é importante usar métodos acessores e manter os atributos privados. Dessa forma qualquer alteração futura pode ser feita na classe sem alterar o restante do código:
Person person;
person.setAge(23);
std::cout << person.getAge() << std::endl;

Propriedades

Já em Python isso não faz sentido!

Em Python, além de atributos e métodos, há as propriedades. Então atributos podem ser públicos e, caso seja necessário adicionar alguma lógica na leitura ou gravação do atributo, basta substituí-lo por uma propriedade, sem prejudicar a interface.
class Person(object):

    def __init__(self):
        self.name = ""
        self.age = 0


Substituindo por propriedades:
class Person(object):

    def __init__(self):
        self.name = ""
        self.__age = 0

    def _get_age(self):
        return self.__age

    def _set_age(self, age):
        if 0 <= age < 150:
            self.__age = age

    age = property(_get_age, _set_age)


E a interface permanece imutável!

Aviso: não use propriedade quando não for necessário! Use atributo público. Um pouco de desempenho não faz mal a ninguém, mesmo em scripts.
Aviso²: testei esse código no prompt e não funciona, mas funciona em script. Se alguém puder descobrir o que está acontecendo, agradeço.

[update 2009-08-26]Usando IPython funcionou corretamente, portanto não sei o que causou o erro. =P

Assim assim, valeu Thiago Coutinho por tê-lo identificado (acho que ainda ocorre durante a interpretação em linha do CPython tradicional).[/update]

Usando metaclasse

Uma forma de implementar automaticamente autopropriedades foi sugerida por Guido van Rossum em Unificando Tipos e Classes (original).

Usaremos uma metaclasse:
class autoprop(type):

    def __init__(cls, name, base, dict):
        super(autoprop, cls).__init__(name, base, dict)
        props = {}
        for method in dict:
            if method.startswith("_get_") \
                or method.startswith("_set_") \
                or method.startswith("_del_"):
                props[method[5:]] = True
        for prop in props:
            fget = getattr(cls, "_get_" + prop, None)
            fset = getattr(cls, "_set_" + prop, None)
            fdel = getattr(cls, "_del_" + prop, None)
            setattr(cls, prop, property(fget, fset, fdel))

A ideia por trás dessa metaclasse é identificar métodos iniciados por _get_, _set_ ou _del_ e criar propriedades a partir daí. O método iniciado por _get_ representa a leitura, _set_ representa a escrita e _del_ representa a remoção.

Nossa classe então ficaria assim:
class Person(object):
    __metaclass__ = autoprop

    def __init__(self):
        self.name = ""
        self.__age = 0

    def _get_age(self):
        return self.__age

    def _set_age(self, age):
        if 0 <= age < 150:
            self.__age = age

Usando decoradores

Mas realmente, ao contrário da metaclasse para singleton, usar metaclasse para autopropriedade é como usar uma escopeta para espantar uma mosca.

Vamos usar decoradores!

O decorador @property pode ser usado para criar propriedades. Funciona muito bem e deixa o código bastante limpo:
class Person(object):

    def __init__(self):
        self.name = ""
        self.__age = 0

    @property
    def age(self):
        return self.__age

    @age.setter
    def age(self, age):
        if 0 <= age < 150:
            self.__age = age

A função deve ter o nome da propriedade. O método de escrita deve chamar-se fset, o de leitura fget e o de remoção fdel. A parte mais feia desse código é o retorno. =)

**

Fica aqui a dica!

[]'s
Cacilhas, La Batalema

quarta-feira, 28 de janeiro de 2009

Interface fluente

Outro pattern interessante é conhecido como carrying return (não confundir com carriage return, carácter com código ASCII 13).
[update 2009-01-29]Esse era o nome dado há uns anos atrás, quando conheci esse pattern. Porém ele não ganhou espaço entre os programadores na época e poucos continuaram usando (como eu). =P

Hoje em dia ele voltou com o nome Fluent Interface, Interface Fluente.

A propósito, troquei o título deste artigo para usar uma linguagem mais nova e mais fácil de ser reconhecida.

Valeu Walter e Lucas![/update]


Há outros nomes, mas não consigo encontrar no São Google, pois não é um pattern muito usado.

Parecido com Smalltalk


Imagine que você tem uma classe Java que recebe muitos parâmetros na instanciação:
Person person = new Person(
aString, aDate, anotherString, aLoad, aPerson, anotherPerson
);


A quantidade de argumentos pode explodir ao extremo. Python pode apresentar maior visibilidade quanto ao significado dos parâmetros:
person = Person(
name=aString,
birthdate=aDate,
id=anotherString,
load=aLoad,
father=aPerson,
mother=anotherPerson
)


Smalltalk, uma linguagem bem mais antiga do que Python ou Java, já tinha uma abordagem bem mais elegante:
person := Person new.
person
setName: aString;
setBirthdate: aDate;
setId: anotherString;
setLoad: aLoad;
setFather: aPerson;
setMother: anotherPerson.


É possível conseguir um código similar em Java usando acessores tipo setter:
Person person = new Person();
person.setName(aString);
person.setBirthdate(aDate);
person.setId(anotherString);
person.setLoad(aLoad);
person.setFather(aPerson);
person.setMother(anotherPerson);


Finalmente


Mas é possível obter um código ainda mais elegante usando o pattern em questão.

A ideia é simples: em vez dos acessores setter não terem retorno (void), basta eles retornarem this:
class Person {
private String name;
private Date birthdate;
private String id;
private Load load;
private Person father;
private Person mother;

public Person() {
name = null;
birthdate = null;
id = null;
load = null;
father = null;
mother = null;
}

public String getName() {
return name;
}

public Person setName(String name) {
this.name = name;
return this;
}

public Date getBirthdate() {
return birthdate;
}

public Person setBirthdate(Date birthdate) {
this.birthdate = birthdate;
return this;
}

public Load getLoad() {
return load;
}

public Person setLoad(Load load) {
this.load = load;
return this;
}

public Person getFather() {
return father;
}

public Person setFather(Person father) {
this.father = father;
return this;
}

public Person getMother() {
return mother;
}

public Person setMother(Person mother) {
this.mother = mother;
return this;
}
}


Agora podemos usar uma estrutura de código similar à de Smalltalk:
Person person = new Person()
.setName(aString)
.setBirthdate(aDate)
.setId(anotherString)
.setLoad(aLoad)
.setFather(aPerson)
.setMother(anotherPerson);


[]'s
Cacilhas, La Batalema

terça-feira, 27 de janeiro de 2009

Singleton

Um design pattern bastante conhecido na engenharia de software é singleton.

Singleton é quando uma classe possui apenas uma instância e não se deseja que em uma mesma aplicação haja mais de uma.

Exemplos de classes desejadamente singleton são pools e carregadores.

Em C++ a saída para criar uma classe singleton é tornar protegido seu método construtor e criar um método getInstance para retornar a instância única:
class Loader {
protected:
Loader();

public:
~Loader();

static Loader& getInstance();
}


O método getInstance deve guardar uma referência estática para a instância:
static Loader& Loader::getInstance() {
static Loader *instance = 0;
if (!instance)
instance = new Loader();
return *instance;
}


Java utiliza a mesma abordagem, já outras linguagens, como Perl, Python e Ruby têm uma abordagem bem mais elegante.

Singleton em Python


A ideia de singleton em Python – Perl e Ruby – é usar o próprio construtor da classe para obter a instância.

Por exemplo, em vez de (Java):
Image character = Loader.getInstance().getImage("char.png");


Teremos (Python):
character = Loader().getImage("char.png")


Há três formas de implementar singleton em Python: 1implementando diretamente na classe, 2herdando um classe pai ou 3usando metaclasse (o mais divertido!).

Implementação direta na classe


Você pode implementar uma classe singleton diretamente, usando os metamétodos __new__ (construtor real) e __init__ (construtor de inicialização).

A classe ainda precisa ter um atributo de classe para armazenar a instância.

A ideia mais simples é implementar __new__ para devolver a instância em vez de uma nova a cada vez:
class Loader:

__instance = None
__initialized = False


def __new__(cls, *args, **keyw):
if cls.__instance is None:
cls.__instance = object.__new__(cls)
return cls.__instance


Repare no atributo __initialized… isso é porque ainda temos um problema: o construtor de inicialização (__init__) será chamado novamente a cada tentativa de obter a instância.

Então precisamos verificar se a inicialização já foi executada:
    def __init__(self, *args, **keyw):
if not self.__initialized:
self.__initialized = True
# Restante do método...


Pronto! Nossa classe já é singleton.

Herança


Podemos usar uma classe pai que implemente unicidade e estendê-la:
class Singleton:

__instance = None
__initialized = False

def __new__(cls, *args, **keyw):
if cls.__instance is None:
cls.__instance = object.__new__(cls)
return cls.__instance

def __init__(self, *args, **keyw):
if not self.__initialized:
self.__initialized = True
self._init(*args, **keyw)


Assim, para implementar uma classe singleton:
class Loader(Singleton):

def _init(self, *args, **keyw):
# Este será o construtor...


A vantagem desta abordagem é sua capacidade de reaproveitamento: é possível reutilizar a classe Singleton como classe pai de cada nova classe singleton.

No entanto traz dois inconvenientes: primeiro os métodos podem conflitar com métodos de outras classes pai em herança múltipla; segundo é preciso prestar atenção à implementação estranha (uso de _init em vez de __init__) e ter cuidado com a sobrescrita de métodos.

A solução para tornar isso mais transparente é usar uma metaclasse.

Metaclasse


Metaclasse é um classe cujas instâncias são classes. Vamos criar uma metaclasse cujas classes sejam singleton:
class singleton(type):

def __init__(cls, name, base, dict):
super(singleton, cls).__init__(name, base, dict)
cls.__instance = None
cls.__copy__ = lambda self: self
cls.__deepcopy__ = lambda self, memo=None: self

def __call__(cls, *args, **keyw):
if cls.__instance is None:
cls.__instance = \
super(singleton, cls).__call__(*args, **keyw)
return cls.__instance


Agora vem a beleza da metaclasse: para criar uma classe singleton basta fazer:
class Loader:
__metaclass__ = singleton


Nada mais! Todo o resto da classe pode ser implementado sem preocupações.

A única dúvida que pode ocorrer é: e se a classe tiver outra metaclasse?

É fácil resolver! Por exemplo: imagine uma classe singleton que implemente autopropriedades:
class Loader:

class __metaclass__(autoprop, singleton):
pass


**

Está aqui outra dica! Mais sobre singleton pode ser encontrado nas Reflexões de Monte Gasppa e Giulia C..

[]'s
Cacilhas, La Batalema

sexta-feira, 5 de dezembro de 2008

Persistência de dados entre execuções em OpenStep

GNUstep OpenStep facilita a persistência de dados entre uma execução e outra do programa através da classe NSUserDefaults.

Para persistir dados para a próxima execução, basta criar um dicionário (NSDictionary) representando um hash dos dados a serem persistidos.

Digamos que o dicionário seja defaults e APP_NAME é uma string (NSString) representando o nome da aplicação:
[[NSUserDefaults standardUserDefaults]
setPersistentDomain: defaults
forName: APP_NAME
];


E para recuperar os dados persistidos da última execução:
NSDictionary *defaults = [
[NSUserDefaults standardUserDefaults]
persistentDomainForName: APP_NAME
];


Então defaults será um dicionário contendo os dados persistidos!

Simples assim. =)

Referência: GNUstep Base.

[]'s
Cacilhas, La Batalema

quinta-feira, 13 de novembro de 2008

Objective C

GNUstep Escrevi recentemente um artigo com um exemplo bem simples de desenvolvimento de uma aplicação para ambiente GNUstep, mas cometi a gafe de não dedicar algum tempo falando da linguagem de programação em questão, Objective C.

Objective C, ou Objective-C, ou ObjC, é uma linguagem de programação reflectiva orientada a objetos criada nos idos da década de 1980 – mais ou menos na mesma época que o C++ – pelos fundadores da Stepstone, mais tarde adquirida pela NeXT. É na verdade uma camada bem fina sobre a linguagem C padrão.

Isso significa que, se você sabe programar em C, conseguirá programar em ObjC sem muito esforço.

Diferenças para C


Sobre a linguagem C, ObjC adiciona os seguintes recursos:
  • Orientação a objetos, adaptada de Smalltalk.
  • Tipo boleano – BOOL. Verdadeiro é YES e falso é NO.
  • Comentário de linha, iniciado por // (na época C não suportava).
  • A diretiva de preprocessador #import, que funciona como #include, mas só inclui o cabeçalho se ele não foi incluído ainda.
  • O tipo id, similar a void * de C/C++.
  • A constante nil, que é um objeto id sem valor: (id)0.


A maior parte dos comandos referentes a orientação a objetos começam com @, como @interface, @implementation, @end, @private, @protected, @public, @protocol, etc.… Entre colchetes é avaliado o ambiente de mensagem, com uma sintaxe muito parecida com a de Smalltalk.

Criando uma classe


Como exemplo, vamos criar a classe Point, com os atributos x e y.

Para tanto, primeiro criamos a interface no arquivo Point.h:
#ifndef _POINT_H
#define _POINT_H

#import <Foundation/Foundation.h>

@interface Point : NSObject
{
int x;
int y;
}

+ (id) newWithX: (int)valuex Y: (int)valuey;
- (id) initWithX: (int)valuex Y: (int)valuey;
- (int) diagonal;
- (int) getX;
- (int) getY;
- (void) setX: (int)value;
- (void) setY: (int)value;

@end

#endif


As diretivas #ifndef, #define e #endif já são velhas conhecidas dos programadores C/C++. O #import já foi explicado, funciona parecido com #include.

O cabeçalho Foundation/Foundation.h inclui a classe NSObject, definida pela API OpenStep, usada aqui como classe pai de nossa classe Point.

O comando @interface inicia a descrição da interface e o comando @end encerra. O pequeno escopo entre chaves define os atributos de instância, protegidos por padrão – para defini-los como públicos a sintaxe seria:
{
@public
int x;
int y;
}


As linhas começadas por um sinal de menos (-) indicam métodos de instância – métodos de classe são iniciados por +. Por exemplo:
- (id) initWithX: (int)valuex Y: (int)valuey;

Significa um método de instância que recebe dois atributos inteiros – valuex e valuey, e retorna um id.

Agora precisamos implementar a interface. Para isso vamos criar o arquivo Point.m:
#include <math.h>
#import "Point.h"

@implementation Point

+ (id) newWithX: (int)valuex Y: (int)valuey {
return [[Point alloc]
initWithX: valuex Y: valuey];
}

- (id) initWithX: (int)valuex Y: (int)valuey {
if ((self = [super init])) {
x = valuex;
y = valuey;
}
return self;
}

- (int) diagonal {
return (int) sqrt((double) ((x * x) + (y * y)));
}

- (int) getX {
return x;
}

- (int) getY {
return y;
}

- (void) setX: (int)value {
x = value;
}

- (void) setY: (int)value {
y = value;
}

@end


O código é muito parecido com C, e até mesmo com C++, cabendo apenas alguns comentários:
  • self é uma palavra reservada que representa a instância, como this de Java e C++.
  • super referencia a classe pai, como em Java.
  • Repare no comando [super init]: aqui é passada uma mensagem para super e o valor retornado é atribuído a self.


Para instanciar um objeto, a sintaxe é:
id point = [Point newWithX: 4 Y: 5];


Ou, com tipagem estática:
Point *point = [Point newWithX: 4 Y: 5];


Para obter o valor de x:
printf("x = %d\n", [point getX]);


E para mudar seu valor:
[point setX: 2];


OpenStep


OpenStep é a API aberta para desenvolvimento de aplicações para NEXTSTEP, resultado de um trabalho colaborativo da NeXT com a SUN Microsystems.

Diversos sistemas e ambientes oferecem suporte a OpenStep, como OS X e GNUstep.

Diversos recursos interessantes são oferecidos nessa API, desde vantagens semelhantes à STL de C++, até conjunto de widgets para construção de janelas, toolkit.

Já vimos uma classe dessa API, NSObject. Outra interessante é NSString, cuja finalidade é a mesma de std::string de C++ e String de Java.

A criação de uma NSString é:
id url = [NSString stringWithCString: "http://kodumaro.blogspot.com/"];


Há ainda um apelido sintático:
id url = @"http://kodumaro.blogspot.com/";


Um forma legal de conhecer mais sobre OpenStep é ler os manuais de referência do GNUstep (toolkit aqui) e do OS X.

[]'s
Cacilhas, La Batalema

sexta-feira, 7 de novembro de 2008

Desenvolvendo aplicações GNUstep

GNUstep Sempre fui fascinado pelo NeXTSTEP e gostaria muito tivesse dado certo. Por mais que a Apple negue, seu Mac OS X não é muito mais do que uma versão nova de um NeXTSTEP portado para equipamentos MacIntosh.

Mas não só o OS X herdou os recursos do NeXTSTEP. No começo da década de 1990, em colaboração com a SUN Microsystems a NeXT lançou o OpenStep, uma especificação aberta que define a API para o NeXTSTEP.

Assim ambientes baseados em NeXTSTEP podem rodar em quaisquer sistemas operacionais e aplicações portáteis podem ser criadas.

A Free Software Foundation lançou um projeto de implementação da API OpenStep para sistemas GNU, o GNUstep.

Mais do que uma API de programação, GNUstep é todo um ambiente, desde a API até aplicações e ambiente operacional.

Inicialmente o ambiente gráfico / geranciador de janelas era o AfterStep. Certo dia, na lista de discussão para definir os rumos da versão 2 do AfterStep, um brasileiro chamado Alfredo Kojima sugeriu a reescrita do código do zero.

Enquanto o grupo continuava debadendo, Kojima decidiu iniciar o desenvolvimento da versão 2 do AfterStep, codinome WindowMaker, por conta própria e depois apresentou-o à comunidade. O Window Maker então substituiu o AfterStep como gerenciador de janelas do projeto GNUstep e o AfterStep continuou seu desenvolvimento a parte.

Diversas versões do Window Maker foram lançadas, apesar de nunca ter chegado a uma versão 1.0, um eterno beta – atualmente se encontra na versão 0.92. Porém seu desenvolvimento esfriou gradativamente.

Ano passado o projeto voltou a esquentar e promessas de novas versões estão no ar, o que me inspirou a escrever este artigo.

Consulte o blog do Bardo.


GNUstep


Mas este artigo não é sobre Window Maker, e sim sobre GNUstep.

Para desenvolver aplicações GNUstep, você precisa baixar seu core antes. Acesse a página de recursos, vá ao tópico GNUstep Core e baixe as versões estáveis de cada pacote. Descompacte, compile e instale na ordem em que os pacotes aparecem na tabela (startup, make, base, gui e backend). O core do GNUstep deverá ser instalado em /usr/GNUstep/.

Você precisa acrescentar /usr/GNUstep/System/Tools a seu path de executáveis, /usr/GNUstep/System/Library/Libraries a sua lista de diretórios de bibliotecas – em ambiente GNU/Linux, acrescente esse path ao arquivo /etc/ld.so.conf e execute ldconfig – e crie uma variável de ambiente GNUSTEP_MAKEFILES com o valor /usr/GNUstep/System/Library/Makefiles e outra GNUSTEP_INSTALLATION_DOMAIN com o valor SYSTEM.

Tendo o GNUstep instalado, podemos partir para as ferramentas de desenvolvimento, Gorm e Project Center. Você também encontrará apontadores para as versões estáveis na mesma máquina de recursos, no tópico GNUstep Development Tools.

Criando um projeto


Vamos criar nosso primeiro projeto GNUstep!

Primeiro abrimos o Project Center com o comando:
bash$ openapp ProjectCenter


Vá em Project → New... (ou pressione M-n), vai abrir uma janela de diálogo pedindo o nome do projeto. Selecione o tipo Application e forneça o nome Temperature e clique Ok.

Por enquanto nossa brincadeira com Project Center acaba por aqui. Pode salvar – Project → Save ou M-s – e sair – Quit ou M-q.

Criando uma aplicação


Agora vamos trabalhar no Gorm, execute:
bash$ openapp Gorm


Um segredinho: nas versões anteriores você mandava abrir o Temperature.gorm a partir do Project Center e ele já abria o Gorm para a aplicação atual. Na versão que experimentei – Gorm 1.2.6 e Project Center 0.5.0 – há um bug. O truque é abrir o Gorm a parte e criar uma nova aplicação.
Se quiser testar se está funcionando – em algumas lugares que testei funcionou – para abrir o Gorm, na janela principal do Project Center clique em Interfaces e duplo clique em Temperature.gorm.

No Gorm, crie uma janela e marque como Visible at launch time.


No Gorm então acesse Document → New Application, depois vá em Document → Save As.... Na janela de diálogo encontre seu projeto Temperature, dentro dele Resources e, dentro desse, salve como Temperature.gorm – confirme o Replace.

Vão abrir três janelas: Main Menu, My Window e Temperature.gorm. Se as janelas Palettes e Inspector não estiverem abertas, encontre-as no menu Tools.

Selecione a janela My Window – ela representa a janela principal da aplicação – e veja em Inspector o campo Title contendo My Window – se não estiver vendo, mude o seletor para Attributes. Mude o título para Temperature Converter – repare que o título da janela My Window também mudou.

Repare que na janela Palettes tem alguns widgets. Para acrescentar um widget à janela é só segurar e arrastar (drag'n'drop). Vamos acrescentar três tipos de widget: Text, System Bold e Button. Adicione componentes até ficar mais ou menos com a cara deste corte:
screenshot 1

Para mudar o texto de um widget, use o duplo clique. Você também pode mudar a borda no Inspector. Altere os widgets até ficarem mais ou menos assim:
screenshot 2

Agora é hora de criar a classe para gerenciar essa janela! Hora de codar? Ainda não…

Na janela Temperature.gorm, na barra principal clique em Classes e selecione NSObject – futuca um pouco que você acha. No menu Operations selecione SubClass. Na lista da direita vai aparecer NewClass e o Inspector vai selecioná-lo – veja a caixa Class com NewClass. Mude o nome da classe para ConverterManager. Apenas confirme na janela Modifying Class.

Podemos agora criar os atributos (outlets) e métodos da classe (actions).

Vamos criar um atributo para cada caixa de texto que criamos – incluside a de Kelvin.

Na janela Inspector há a aba Outlets (0) com o botão Add. Clique nesse botão e teremos NewOutlet com um duplo clique você será capaz de mudar seu nome para degreeC.

Crie mais dois atributos: degreeF e kelvin.

Para criar o primeiro método acesse a aba Actions (0) e siga o mesmo procedimento anterior. Os métodos serão chamados convertC2F: e convertF2C:.

E a classe já está pronta!

Instanciando a classe


Mantendo a classe ConverterManager, no menu principal do Gorm selecione Classes → Instantiate. Na janela Temperature.gorm aparecerá um objeto ConverterManager: é agora que vem parte da mágica…

Precisamos inicialmente ligar o atributo degreeC dessa instância à primeira caixa de texto da janela (ao lado do rótulo °C).

Segure a tecla Ctrl, clique sobre a instância, segure e arraste, solte sobre a caixa de diálogo – vai aparecer um T na caixa –, então, na janela Inspector selecione degreeC e clique no botão Connect. Vai aparecer um S sobre a instância e, na janela Inspector, em Connections, vai aparecer: degreeC (TextField(0)).

Faça o mesmo para as outras caixas ligando cada caixa a um atributo.

Agora precisamos fazer com que os botões acionem métodos da instância, para isso o procedimento é o inverso: segurando a tecla Ctrl clique sobre o botão Celsius to Fahrenheit, segure, arraste e solte sobre a instância de ConverterManager na janela Temperature.gorm.

Na janela Inspector clique em target → convertC2F: e então clique no botão Connect.

Faça o mesmo para conectar o outro botão ao outro método. Agora todas as ações estão conectadas!

Salvando tudo


Na janela Temperature.gorm, selecione Classes e encontre a classe ConverterManager. Selecione-a, então, no menu principal do Gorm clique em Classes → Create Class Files. Apenas confirme as duas janelas de diálogo. Isso criará os dois arquivos ConverterManager.m e ConverterManager.h dentro de Resources.

Agora clique em Document → Save All e Quit.

De volta ao Project Center


Volte ao Project Center e clique em Project → Open... e abra o arquivo PC.project do projeto Temperature.

Na janela principal do projeto dê um duplo clique em Classes e depois em ConverterManager.m, isso adicionará o código ao projeto do Project Center.

Finalmente o código!


Precisamos finalmente editar o conteúdo dos métodos. Duplo clique sobre ConverterManager.m na janela principal e vai abrir a janela do editor:
/* All Rights reserved */

#include <AppKit/AppKit.h>
#include "ConverterManager.h"

@implementation ConverterManager


- (void) convertC2F: (id)sender
{
/* insert your code here */
}


- (void) convertF2C: (id)sender
{
/* insert your code here */
}

@end


O código é Objective C, um variante orientado a objetos de C que lembra um pouco Smalltalk.

O método covertC2F deve obter o valor do atributo degreeC – que está ligado à caixa de diálogo com o valor em graus Celsius –, calcular e ajustar os valores em Fahrenreit e Kelvin:
- (void) convertC2F: (id)sender
{
float celsius = [degreeC floatValue];
float fahrenreit = (9.0f * celsius / 5.0f) + 32.0f;

[degreeF setStringValue: [NSString stringWithFormat: @"%1.2f",
fahrenreit]];

[kelvin setStringValue: [NSString stringWithFormat: @"%1.2fK",
(celsius + 273.15f)]];
}


O método convertF2C deve fazer o contrário:
- (void) convertF2C: (id)sender
{
float fahrenreit = [degreeF floatValue];
float celsius = 5.0f * (fahrenreit - 32.0f) / 9.0f;

[degreeC setStringValue: [NSString stringWithFormat: @"%1.2f",
celsius]];

[kelvin setStringValue: [NSString stringWithFormat: @"%1.2fK",
(celsius + 273.15f)]];
}


Salve agora (M-s) e feche o editor. Clique no ícone com a chave de fenda para compilar:
Build

Na janela de build há outro ícone igual, clique nele para compilar. Se tudo correr bem você verá uma bela mensagem:
=== Build succeeded! ===


Se falhar, volte e veja o que está errado.

Clique então no ícone do foguete para rodar:
Launch

Na janela Launch clique no mesmo ícone e a janela irá abrir. Faça alguns testes para ver se funciona bem.

Para sair clique com o botão direito e escolha Quit.

Se tudo funcionar bem, seu programa está pronto! Salve tudo em Project → Save.

Instalando a aplicação


Para instalar, abra um terminal:
bash$ cd Temperature/
bash$ make
bash$ sudo make install


Assim sua aplicação estará instalada em /usr/GNUstep/System/Applications/Temperature.app – ou /usr/GNUstep/Local/Applications/Temperature.app, se você se esqueceu de ajustar o conteúdo da variável de ambiente GNUSTEP_INSTALLATION_DOMAIN – e você executá-la com o comando:
bash$ openapp Temperature


Conclusão


Espero que com este artigo algumas pessoas se interessem pelo desenvolvimento de aplicações para ambiente GNUstep, que aliás roda sobre Mac OS X também – em plataforma OS X, o WINGs (toolkit de widgets para Window Maker) e o GNUstep são abstrações do Cocoa, toolkit de widgets do OS X.

A facilidade de desenvolvimento de aplicações gráficas para GNUstep com Project Center e Gorm é incrível, apesar de seu jeitão esquisito e do uso da tremendamente estranha linguagem de programação Objective C.

[]'s
Cacilhas

PS: Eu já estava morrendo de sono quando escrevi este artigo, portanto alguns erros de português podem ocorrer. Por favor me avisem!

domingo, 29 de junho de 2008

Embaralhando palavras

Squeak Outro dia o Walter estava falando sobre um comportamento irregular da implementação de expressões regulares em Python, especificamente o token \b.

Havia uma brincadeira em Ruby com regex que seleciona cada palavra em uma frase e embaralha a ordem das letras, mantendo a primeira e a última em seus lugares.

Para separar as palavras e os elementos de espaçamento entre elas, usava-se uma regex com \b. Resolvi fazer a brincadeira em Smalltalk, mas descobri que o token também não funciona, portanto precisei fazer uma expressão que representasse cada bloco: ((\w+)|(\W+)).

Para reproduzir essa brincadeira, usando Squeak, primeiro usando o System Browser crie um método shaked na categoria copying da classe String:
shaked
| aux fst i lst temp |

(self size <= 3) ifTrue: [ ↑ self copy ].

fst := (self byteAt: 1) asCharacter asString.
lst := (self byteAt: self size) asCharacter asString.
aux := self copyFrom: 2 to: self size - 1.
temp := Array new: aux size factorial.

i := 0.
aux permutationsDo: [ :s |
i := i + 1.
temp at: i put: (fst, s, lst).
].

↑ temp at: temp size atRandom.


Agora, em um workspace, execute o seguinte código:
| phr |

" Esta é a frase a ser embaralhada "
phr := 'Kodumaro: as sombras da programação'.

Transcript open.
phr regex: '((\w+)|(\W+))' matchesDo: [ :s |
Transcript show: s shaked.
].

Transcript cr.


Selecione tudo (M-a) e execute (M-d).

[]'s
Cacilhas, La Batalema

segunda-feira, 26 de maio de 2008

Ordenando uma lista de objetos em Python

Quer ordenar uma lista de objetos em Python, usando um atributo desses objetos? É fácil! basta user o operator.attrgetter.

import operator

class Language(object):
def __init__(self,year,name):
self.year = year
self.name = name

def __repr__(self):
return ' - '.join(map(str,(self.name,self.year)))


java = Language(1995,'Java')
python = Language(1991,'Python')
ruby = Language(1995,'Ruby')
haskell = Language(1990,'Haskell')
javascript = Language(1995,'Javascript')
self = Language(1986,'Self')
perl = Language(1987,'Perl')

languages = [java,python,ruby,haskell,javascript,self,perl]

#print(languages)
languages.sort(key=operator.attrgetter('year'))
print(languages)
#Apenas Python 2.5 agora!
languages.sort(key=operator.attrgetter('year','name'))
print(languages)


Um pequeno truque que é sempre bom ter guardado na manga ;)

sábado, 19 de abril de 2008

Peculiaridades do GNU Smalltalk

VisualWorks Visual Works é uma ótima ferramenta para desenvolvimento de grandes sistemas em Smalltalk, no entanto suas limitações na versão gratuita são extremamente incômodas.

Há algumas boas alternativas ao Visual Works, como Squeak e GNU Smalltalk.

Como sou fã do Projeto GNU, escolhi como substituto GNU Smalltalk.

Mas GNU Smalltalk também tem lá seus inconvenientes, todos contornáveis com a criação de uma nova imagem personalizada, o que pode ser feito na linha de comando ou com a ajuda da ferramenta gráfica Blox.

Também podemos resolver esses «inconvenientes» no próprio código. Por exemplo, cadê a potência (#**)?

[update 2008-06-12]O trouxa aqui não sabia que os números em Smalltalk respondem à mensagem raisedTo:. =P[/update]


Vamos calcular potência de dois em GNU Smalltalk:
#!/bin/sh
"exec" "gst" "-f" "$0" "$@"

Number extend [
** val [
| aux |

aux := 1.
1 to: aux do: [ :i |
aux := aux * self
].
^aux.
]
].


0 to: 10 do: [ :i |
Transcript
show: i printString;
tab;
show: (2 ** i) printString;
cr.
].


Claro, esta não é uma solução definitiva para potência, apenas um quebra-galho.

A mensagem extend estende os recursos de uma classe acrescentando novos métodos, no caso #** (potência).

Vamos agora ao cálculo de números primos…

O método #at:ifAbsent: de Dictionary, quando retorna o valor por defeito, não o retorna diretamente, mas passa a ele a mensagem value, que quase nenhuma classe trata.

Então precisamos estender Object para tratar a mensagem:
#!/bin/sh
"exec" "gst" "-f" "$0" "$@"

Object extend [
value [
^self
]
].

count := 0.
max := 5000.
primeList := Dictionary new.

primeList at: 1 put: false.

2 to: max do: [ :i |
(primeList at: i ifAbsent: true) ifTrue: [
Transcript show: i printString; tab.
count := count + 1.
(i * 2) to: max by: i do: [ :j |
primeList at: j put: false
]
]
].

Transcript
cr;
show: 'Quantidade de primos: ', count printString;
cr.


Conforme for encontrando outras peculiaridades do GNU Smalltalk, vou postando aqui.

[]'s
Cacilhas, La Batalema

sexta-feira, 18 de abril de 2008

Io

Smalltalk Depois de cinquenta e três dias afastado da rede mundial, estou de volta, podendo novamente postar artigos.

Para marcar esta volta, quero falar de uma novíssima linguagem de programação que, apesar ainda estar saindo do forno – não sei sua idade, mas deve ter pouco mais de um ano –, pode vir a se tornar uma escolha viável: Io.

Io é uma linguagem de programação pequena e prototipada. Seus conceitos são inpirados em outras linguagens de programação, como Smalltalk, Self, Lisp, Lua e outras.

É uma linguagem de código aberto – licença BSD –, a máquina virtual é pequena – por volta de 10KB – e roda atualmente em quatro plataformas: Unix-like, Windows, Symbian e Syllable – antigo AtheOS.

Possui uma sintaxe muito semelhante à de Smalltalk e um forte conceito de orientação a objetos.

Em Io, em vez de atributos, propriedades, métodos e variáveis, temos slots. Slot consiste no armazenamento de um objeto dentro de outro, ou seja, cada objeto possui slots contendo outros objetos.

Todas linhas de código são mensagens interceptadas pelo objeto Lobby: a primeira «palavra» é interpretada como o nome de um slot de Lobby. Caso o slot não exista, é gerada uma exceção.

Caso exista, o objetos residente naquele slot é retornado e o resto da mensagem é passada para ele, e assim sucessivamente.

Se o objeto num dos slots for um método, ele será executado e seu retorno será usado para tratar o restante da mensagem.

A atribuição de valor a um slot é feita por =, caso o slot não exista, será gerada uma exceção. Para a criação – e inicialização – de um novo slot, é usado :=.

Não há classes propriamente didas: a «instanciação» é feita por meio de protótipos, ou seja, clonagem de um objeto matriz.

Vamos a um exemplo…

Vamos criar um protótipo Person, que contenha nome, sobrenome e retorne o nome completo:
Person := Object clone
Person firstname := ""
Person lastname := ""
Person birth := Date
Person fullname := method("#{firstname} #{lastname}" interpolate)
Person asString = method(fullname .. ": " .. birth asString("%Y-%m-%d"))


Para «instanciar» um objeto de Person também usamos clone:
cacilhas := Person clone
cacilhas firstname = "Rodrigo"
cacilhas lastname = "Cacilhas"
cacilhas birth = Date fromString("1975-11-20", "%Y-%m-%d")


Ao ser executado:
cacilhas fullname println


Será exibido Rodrigo Cacilhas.
cacilhas println


Agora é exibido Rodrigo Cacilhas: 1975-11-20.

Para obter a data atual:
Date now println


Também é possível obter uma representação numérica da data usando asNumber, que no caso retorna a data em segundos:
Date now asNumber println


Outros slots válidos de Date now são: year (ano), month (mês), day (dia), hour (hora), minute (minuto) e second (segundo).

Pegando apontadores do Google:
SGML
xml := URL with("http://www.google.com/search?q=io+language") fetch asXML
links := xml elementsWithName("a") map(attributes at("href"))


Espero que tenham achado a linguagem tão interessante quanto eu achei e que ela alcance um nível de maturidade que permita sua aplicação extensiva.

[]'s
Cacilhas, La Batalema

segunda-feira, 3 de março de 2008

De olho no Python 2.6

Lawrence Oluyede escreveu vários posts sobre as atualizações disponíveis na versão 2.6 (trunk) do Python.

É uma série que vale a pena ler na íntegra, mas deixo aqui alguns pontos:
  • with e as agora são palavras reservadas
  • tuplas nomeadas:

      >>> from collections import NamedTuple

>>> Point = NamedTuple(‘Point’, ‘x y’)
>>> p = Point(10, 5)
>>> p.x
10
>>> p.y
5

  • os.walk() agora pode seguir links

rhymes@groove ~ % ll temp                                                                                                                 total 8

drwxr-xr-x 3 rhymes rhymes 102B Mar 18 14:49 a/
lrwxr-xr-x 1 rhymes rhymes 5B Mar 18 14:49 link@ -> /Users/rhymes/Documents
>>> import os
>>> for root, dirs, files in walk(‘temp’):
… print root, dirs, files
…
temp [‘a’, ‘link’] []

temp/a [] [‘foo’]
>>> for root, dirs, files in walk(‘temp’, followlinks=True):
… print root, dirs, files
…
temp [‘a’, ‘link’] []
temp/a [] [‘foo’]
temp/link [‘.parallels-vm-directory’, …]

  • é possível ver o que se tornará obsoleto no Python 3 usando o switch -3 ao chamar o interpretador python (python -3 arquivo.py)
  • Abstract Base Classes foram retro-portadas para o Python 2.6

Com o lançamento da versão alpha do Python 2.6, esses artigos podem servir como uma boa base de estudos!

terça-feira, 26 de fevereiro de 2008

Primos em Smalltalk

VisualWorks Smalltalk é a linguagem orientada a objetos por excelência.

Desenvolvida na década de 1960, baseada na linguagem Simula, muitos paradigmas modernos foram criados por essa equipe do MIT.

Segue aqui um exemplo aplicado de Smalltalk: busca por números primos.

O algoritmo é baseado no crivo de Aristóstenes, que consiste em, a cada primo encontrado, eliminar seus múltiplos até o fim do conjunto.

Vamos começar declarando as variáveis locais count, com a contagem de primos encontrados, max, que conterá o tamanho do conjunto, e primeList, uma lista – na verdade dicionário – dos números marcados como não-primos:
| count max primeList |

count := 0.
max := 5000.
primeList := Dictionary new.


Começamos então com nenhum primo conhecido (0) e um conjunto de cinco mil (5000) números. Vamos agora informar ao dicionário que 1 não é primo e pedir para limpar o Transcript – área (stream) onde será exibido o resultado:
primeList at: 1 put: false.
Transcript clear.


É preciso agora criar um ciclo (loop) de 2 até o máximo de números do conjunto:
2 to: max do: [ :i |


Para cada i, é preciso verificar se é verdadeiro – se o número não existe na lista (ifAbsent:), ele não é múltiplo de nenhum dos números antecessores, portanto é primo (true):
    (primeList at: i ifAbsent: true) ifTrue: [


Se o número é primo, devemos:
  1. exibi-lo no Transcript;
  2. incrementar o contador;
  3. marcar todos seus múltiplos como não-primos


Fechando os colchetes já abertos, o código fica assim:
        Transcript show: i printString; tab.
count := count + 1.
i * 2 to: max by: i do: [ :j |
primeList at: j put: false
]
]
].


Resta agora somente exibir a contagem:
Transcript
cr;
show: 'Quantidade de primos: ', count printString;
cr.


Repara que, quando várias mensagens são enviada ao mesmo objeto, elas são separadas por ponto-e-vírgula (;).

Alguns comentários:
  • Quando um número recebe a mensagem #printString, ele retorna uma representação string para exibição.
  • Transcript trata a mensagem #tab exibindo uma tabulação e a mensagem #cr exibindo uma mudança de linha.
  • Quando um número recebe a mensagem #to:do:, reitera de forma parecida com for de C.
  • A mensagem #to:by:do: funciona como #to:do:, mas acrescenta o passo.
  • A mensagem #at:put: faz o dicionários associar um par chave-valor ou mudar o valor associado a uma chave.
  • A mensagem #at:ifAbsent: faz o dicionário retornar o valor associado a uma chave, ou um valor padrão.
  • A mensagem #ifTrue: é enviada a um objeto booleano, que executa o bloco de código somente se o objeto for verdadeiro. Outras mensagens similares são: #ifFalse:, #ifTrue:ifFalse: e #ifFalse:ifTrue:.


Bem, espero que esse pequeno tutorial seja de alguma ajuda, se não para o mercado, para expandir conhecimentos.

[]'s
Cacilhas, La Batalema

domingo, 17 de fevereiro de 2008

Script para concatenar arquivos

Sempre é válido mostrar o que nossa linguagem favorita é capaz de fazer. Uma das vantagens que percebi em Python desde o começo foi o fato dela ser ideal para o dia-a-dia. Escrever scripts para tarefas repetivas ou que possam ser feitas mais rapidamente via programação, Python está entre as melhores escolhas. O principal motivo é que escrevemos pouco.

Abaixo, eu apresento um script que fiz para pegar os textos dos arquivos que estavam numa pasta e gravá-las no arquivo saida.pgn. Cada arquivo tinha uma partida de xadrez anotada em formato pgn. Queria estas partidas num único arquivo para impressão.
import os
from os import path

saida = open('saida.pgn','w')

pasta_fonte = 'india_do_rei'

pasta_base = path.abspath(pasta_fonte)

lista = os.listdir(pasta_base)

for i in lista:
print path.join(pasta_base,i)
arq = open(path.join(pasta_base,i),'r')
saida.write(arq.read())
arq.close()
saida.write('\n')
saida.close()

Este código pode ser, logicamente, adaptado para suas necessidades. Outra coisa: ele pode ser melhorado. Caso eu precise dele novamente talvez acabe refatorando. Uma das coisas a fazer seria obter o nome da pasta via argumento na linha de comando.

quarta-feira, 13 de fevereiro de 2008

Semáforo

Este vai ser um artigo mais leve… =D

Na lista do PythonBrasil, um dos participantes perguntou como controlar a quantidade de threads em um processo.

Uma forma legal de fazer isso é usando semáforos.

Observação: o exemplo neste artigo foi desenvolvido em Python 2.5.


Vamos usar um exemplo: vamos criar um servidor que aceite conexões TCP, peça alguma string, imprima-a num arquivo de log, envie um sinal de sucesso e encerre a conexão.

Podemos começar com um arquivo de configurações. Pode ser kodserv.conf:
[global]
ip = 0.0.0.0
port = 8001
max = 3
logfile = /tmp/kodserv.log


Agora vamos começar nosso executável – kodserv.py, por exemplo – criando um abeçalho com os requerimentos de módulos um procedimento principal:
#!/usr/bin/env python
# coding: utf-8
# Ou a codificação que você usa

from __future__ import with_statement
from ConfigParser import ConfigParser, NoOptionError
from logging import getLogger, FileHandler
from socket import (
AF_INET,
SO_REUSEADDR,
SOCK_STREAM,
SOL_SOCKET,
socket
)
from threading import Semaphore, Thread
import os, sys


def main():
if len(sys.argv) < 2:
print >>sys.stderr, "Use: %s configfile" % sys.argv[0]
sys.exit(1)

configfile = sys.argv[1]

# Lê o arquivo de configurações
c = ConfigParser()
try:
with open(configfile, 'r') as fd:
c.readfp(fd)
except IOError:
print >>sys.stderr, "File %s not found" % configfile
sys.exit(2)

try:
logfile = c.get("global", "logfile").strip()
except NoOptionError:
# Não tem logfile? Usa STDOUT
logfile = "/proc/%d/fd/1" % os.getpid()

try:
ip = c.get("global", "ip").strip()
except NoOptionError:
# Não tem IP? Usa todos os endereços
ip = "0.0.0.0"

try:
port = c.get("global", "port").strip()
except NoOptionError:
# Não tem port? Usa porta 8001/tcp
port = "8001"

try:
# Máximo de conexões simultâneas
max = c.get("global", "max").strip()
except NoOptionError:
# Não tem max? Vamos aceitar 1000 conexões
max = "1000"

# Endereço
addr = (ip, int(port))

# Cria objeto de log
logger = getLogger()
logger.addHandler(FileHandler(logfile))

# Cria semáforo: o cara da contagem
sem = Semaphore(int(max))

# Cria aplicação principal e inicia
app = AppServ(logger=logger, addr=addr, semaphore=sem)
app.loop()

# Encerra o logger
for handler in logger.handlers:
handler.close()

# Fim!
sys.exit(0)


Agora precisamos criar as classes.

Aplicação principal


A classe principal será AppServ. Seu construtor deve receber o logger, o endereço e o semáforo, criar o socket servidor e armazenar tudo. O método loop() será responsável pelo ciclo de conexões.

O destruidor (__del__()) será responsável por fechar o socket:
class AppServ:
def __init__(self, addr, logger, semaphore):
# Armazenamento dos objetos
self.skt = self.createSocket(addr)
self.logger = logger
self.sem = semaphore

def __del__(self):
# Destruidor
try:
self.skt.close()
except Exception, err:
self.logger.error(err.message)

def createSocket(self, addr):
# Cria o socket
skt = socket(AF_INET, SOCK_STREAM)
skt.setsockopt(SOL_SOCKET, SO_REUSEADDR, True)

# Associa socket ao endereço e prepara socket para ouvir
skt.bind(addr)
skt.listen(1)

# Retorna socket
return skt

def loop(self):
while True:
try:
conn, addr = self.skt.accept()
# Classe que tratará cada conexão
DealConn(
conn=conn,
logger=self.logger,
semaphore=self.sem
).start()
except KeyboardInterrupt:
# Sai com C-c
break


Lidando com as conexões


Precisamos agora criar a classe DealConn para lidar com as conexões recebidas.

Essa classe precisa ser filha de Thread e receber a conexão, o logger e o semáforo. É agora que vamos usar esse útimo!

O semáforo basicamente faz uma contagem regressiva a cada chamada do método acquire() a partir do valor informado no construtor. Caso a contagem chegue a zero, ele trava a execução do fluxo até que alguma thread chame o método release().

O método release() reincrementa a contagem:
class DealConn(Thread):
def __init__(self, conn, logger, semaphore):
# Chama construtor pai
Thread.__init__(self)

# Avisa ao semáforo que foi criado e armazena os objetos
semaphore.acquire()
self.sem = semaphore
self.conn = conn
self.logger = logger

def __del__(self):
# Destruidor encerra socket e libera semáforo
self.conn.close()
self.sem.release()

def run(self):
# Método chamado na thread criada
conn = self.conn

# Envia prompt e aguarda string arbitrária de até
# 1024 caracteres
conn.send("> ")
data = conn.recv(1024).strip()

# Armazena o que foi recebido
msg = "%s:%d sends: %s" % (conn.getpeername() + (data,))
self.logger.warn(msg)

# Avisa da saída
conn.send("Ciau\r\n")


Fazendo funcionar


Só falta agora fazer funcionar!
if __name__ == "__main__":
main()


Se estiver usando algum sistema operacional parecido com Unix, não esqueça de tornar o arquivo executável:
$ chmod +x kodserv.py


Agora execute seu servidor, elimine possíveis erros e tente conectar-se à porta 8001/tcp de localhost. Veja que os logs serão gerados no arquivo informado pela opção logfile do arquivo de configuração, kodserv.conf.

Tente fazer mais de três conexões simultâneas. =D

Depois brinque com o arquivo de configuração e boa diversão! Dúvidas e sugestões nos comentários, por favor.

[]'s
Cacilhas, La Batalema