Escalare - A louca jornada de um programador » Programação

Boo e Android

gbenatti — Thu, 08 Apr 2010 02:05:33 +0000

Nas ultimas semanas, tenho trabalhado nas horas vagas no Boojay, com o intuito de programar para dispositivos com Android.

E os primeiros frutos apareceram, agora é possivel executar o que poderia ser considerado o Hello World do Android.

namespace net.gbenatti
import android.app
import android.os
class Main(Activity):
override def onCreate(savedInstance as Bundle):
super(savedInstance)
setContentView(0×7f030000)

Na verdade esse código é meio diferente do original java, onde a constante hexadecimal é definida em uma classe, mas isso logo será resolvido.

Agora deixa eu voltar a assistir Fringe.

Curiosidades em Boo – Pipeline de compilação

gbenatti — Wed, 18 Nov 2009 14:53:51 +0000

Como já comentei, Boo é uma linguagem que tem como uma das caracteristicas mais marcantes sua extensibilidade.

A extensibilidade se dá na forma de macros e atributos sintaticos que modificam o código gerado no momento da compilação, e também em mudanças no próprio compilador, através do conceito de pipelines de compilação.
Para se entender melhor, quando você usa o compilador booc, o mesmo executa uma série de passos, que começa com o parsing do arquivo, execução das analises semanticas, transformações na AST e por fim geração do assembly (exe ou dll). Isso é o que é conhecido como pipeline padão de compilação.
O compilador booc já vem com várias outras pipelines definidas, e permite também que o programador defina outras.

Uma das pipelines bem interessantes que já vem com o compilador é a pipeline chamada boo, essa pipeline executa todo o processo de compilação normal, com todos os passos e todas as transformações que são aplicadas a AST e no final, invés de gerar um assembly, gera uma saida boo com todo o código que seria compilado para a criação do assembly.

Parece abstrato demais ? Vamos ao código então, o velho e bom Hello World.

print "Hello World"

Esse é um código mínimo em Boo que escreve a mensagem “Hello World” na tela, mas você pode se perguntar, esse não é um executavel .Net ? Cadê o static void Main… ?

Vamos usar a nossa nova conhecida, a pipeline boo, pra descobrir. Salve o programa no arquivo hello.boo e rode:

booc -p:boo hello.boo

E você terá:

[System.Runtime.CompilerServices.CompilerGlobalScopeAttribute]
public final transient class HelloModule(object):
private static def Main(argv as (string)) as void:
System.Console.WriteLine(‘Hello World’)
private def constructor():
super()

A saída mostra o código que seria compilado depois de todas as mágicas executadas pelo compilador.

Note o uso do parâmetro -p:boo, é ele que diz ao compilador pra usar a pipeline boo e não a padrão.

Um detalhe, a chamada a print virou um System.Console.WriteLine, porque print é uma macro que ao ser executada expande para a chamada equivalente WriteLine.

Isso é só uma pequena parte do que pode ser feito com as pipelines, de geração de código em outra linguagem, verificação de padrões de desenvolvimento, compilação em memória, code completing, as possibilidades são várias.

Truques em Scala – Extractors

gbenatti — Thu, 05 Nov 2009 14:41:46 +0000

Scala muitas vezes me surpreende com a elegancia e integridade da linguagem. O que chamo aqui de integridade, é a forma como a linguagem combina vários conceitos de uma forma uniforme.

Uma das features interessantes de Scala é que ela permite ao programador extrair informações de objetos usando pattern matching, por exemplo se você tiver o seguinte tipo chamado Email:

case class Email(name: String, domain: String)

Seria possivel testar se um objeto é do tipo Email, e ao mesmo tempo retornar o name e domain com o seguinte código:

unknownObject match {
case Email(name, domain) =>
println(name + " at " + domain)
case _ =>
println("It’s not an email")
}

No caso de unknownObject ser declarado como:

val unknownObject = Email("georges", "gbenatti.net")

A saida seria “georges at gbenatti.net”

Já se unknownObject fosse declarado como:

val unknownObject: Any = "georges@gbeatti.net"

A saida seria “It’s not an email”

Mas não seria muito legal se fosse possivel fazer essa segunda opção funcionar ? Ai entra a elegância de Scala, você pode definir extractors que permitem que sejam extraidos dados de determinadas estruturas, sejam elas árvores, listas e até mesmo strings.

Um extractor é um objeto Scala que define um método unapply. A responsabilidade do unapply é fazer o matching de um valor e o separar em seus componentes, para o caso acima o extractor poderia ser definido assim:

object EmailStr {
def unapply(str: String): Option[(String, String)] = {
val parts = str split "@"
if (parts.length == 2) Some(parts(0), parts(1)) else None
}
}

Definido esse extractor poderiamos reescrever o match da seguinte forma:

unknownObject match {
case Email(name, domain) =>
println(name + " at " + domain)
case EmailStr(name, domain) =>
println(name + " at " + domain)
case _ =>
println("It’s not an email")
}

E ele funcionaria tanto com objetos da classe Email quanto com strings no formato name@domain, ou seja, código final do usuário simples e elegante.

Até mais pp pessoal…

Truques em Scala – Structural Typing

gbenatti — Tue, 27 Oct 2009 22:06:43 +0000

As linguagens dinâmicas como Ruby e Python tem algumas capacidades bem interessantes, entre elas esta a possibilidade de passar um objeto para um método e desde que o objeto implemente os métodos necessários (ex: name, height), o método executará corretamente.

Já as linguagens estáticas normalmente não tem essa capacidade, algumas, como por exemplo Boo implementam essa possibilidade através de dispatch in runtime para os métodos que necessitam dessa caracteristica, já Scala tem uma solução bem elegante.

Por exemplo, digamos que você queira definir um método que espere um objeto que tenha as propriedades name e age, uma forma comumente usada em linguagens estáticas seria a seguinte:

Definir uma interface com os métodos que interessam:

trait BasicProperties {
def name: String
def age: Int
}

Escrever as classes implementando BasicProperties e o método recebendo como parametro um objeto do tipo BasicProperties:

class Pet(val name: String, val age: Int) extends BasicProperties
class Person(val name: String, val age: Int) extends BasicProperties
def printProp(in: BasicProperties) =
println(in.name+" is " + in.age + " years old")

E então você poderia chamar o método assim:

printProp(new Pet("Galfildo", 8))
printProp(new Person("Maria", 18))

Se você tivesse uma classe tipo:

class Antique(val name: String, val Age: Int, val cost: Int)

Você não poderia usar um objeto desse tipo como parametro para printProp, já que a classe não herda BasicProperties.

A solução está na capacidade que Scala tem de definir algo que poderia ser chamado de anonymous interfaces, no caso, o método printProp seria escrito assim:

def printProp(in: {def name: String; def age: Int}) =
println(in.name+" is " + in.age + " years old")

Como se você estivesse definindo como parametro um tipo anonimo, que tem um método name do tipo String e um método age do tipo Int

E então poderia executar:

printProp(new Pet("Galfildo", 8))
printProp(new Person("Maria", 18))
printProp(new Antique("Monalisa", 450, 1000))

Como se ve, um código muito parecido com o escrito em Ruby e Python, mais ainda com uma caracteristica de documentação, já que o método é explicito sobre o que ele necessita.

Truques em Scala – Como fazer parsing de um xml

gbenatti — Tue, 27 Oct 2009 16:35:00 +0000

Ontem eu precisei extrair alguns dados de um xml, e acho que as lições aprendidas merecem ficar registradas, vai que mais alguem nesse mundão precisa fazer algo assim.

service="Service 1">
>
key="key1">value1>
key="key2">value2>
>
>

O objetivo era extrair o nome do service como uma string e as entries como um map de key values.

O servico como string é bem facil, considerando que o xml esta em uma variavel serviceXml, teriamos:

val serviceName = (serviceXml\"@service").text

O que isso faz é basicamente pegar o attributo service do nó em questão e com esse dado pegar o nó como text.

A segunda parte é um pouco mais complexa então vamos por parte, primeiro pegamos as entries:

val entries = serviceXml\"extra"\\"entry"

Esse codigo executa basicamente um XPath extraindo do xml o nó “extra” e deste a lista de nós “entry”

Então, para cada entry extraimos uma tupla com o valor da key e o value:

val entriesTuple = for (entry <- entries) yield ((entry\"@key").text, entry.text)

Aqui usamos um for expression para percorrer a lista entries e retornar (usando yield) uma tupla que contem o valor da key e o inner text da entry

E por fim criar um Map com esses dados:

val mapResult = Map(entriesTuple: _*)

Por fim, como construir um Map apartir de uma lista, ou nesse caso de um generator ?

Maps podem ser contruidos usando de um numero variavel de tuplas usando algo como Map(tupla1, tupla2, tuplaN).

Se tentarmos usar Map(entriesTuple) o compilador vai reclamar falando que esse metodo nao pode ser executado com uma Seq[(String, String)], ou seja, uma sequencia de tuplas contendo duas Strings.

Temos que dar um jeito de passar essa Seq como um numero variavel de argumentos, e os desenvolvedores de Scala nos deram uma forma de fazer isso, quando temos que passar uma lista para um método que espera um número variavel de argumentos podemos fazer assim:

Map(entriesTuples: _*)

Essa anotação diz ao compilador para expandir os parametros

Juntando tudo temos:

val mapResult = Map((for (entry <- serviceXml\"extra"\\"entry") yield ((entry\"@key").text, entry.text)): _*)

Muita explicação pra pouco código, assim é Scala

Cheers

Instalando Scala

gbenatti — Thu, 10 Sep 2009 01:18:00 +0000

Para instalar Scala no Mac OS X, baixe o instalador do seguinte link:

http://www.scala-lang.org/downloads/distrib/files/scala-2.7.5.final-installer.jar

Esse link é pra versão 2.7.5 da linguagem.

Execute o instalador, entrando no terminal, vá até o diretório onde se encontra o instalador e digite:

sudo java -jar scala-2.7.5.final-installer.jar

Escolha a linguagem de sua preferência e o local de instalação. No meu caso eu vou aceitar as opções Inglês e /usr/local/

Depois de terminada a instalação, adicione o path de instalação as variáveis de ambiente, edite o arquivo .profile no seu diretório HOME, e adicionar a seguinte linha:

export PATH=/usr/local/scala-2.7.5.final/bin:$PATH

Onde /usr/local/scala-2.7.5.final é o local onde o compilador foi instalado.

Para testar a instalação, feche o terminal e o abra novamente, digite scala -version e você deve ver a mensagem:

É isso ai, até a próxima.

Como programar para Android no Mac OS X

gbenatti — Tue, 01 Sep 2009 16:07:00 +0000

Para desenvolver para Android você necessita ter instalado o Java, algum IDE e o Android SDK.

Java

Você necessita de uma versão do java instalado, o JDK 5 ou 6 por exemplo. A instalação apenas do runtime, conhecido como JRE não é suficiente, você precisa do development kit completo, eu recomendo a instalação do JDK 6.

IDE

Você precisa ter instalado também um IDE para desenvolvimento Java. Eclipse, Netbeans, Idea, todos eles tem suporte pare desenvolvimento Android. Nos meus testes tenho usado o Netbeans (versão 6.7 ou maior) e o Eclipse (versão 3.3.1 ou maior), os dois tem prós e contras, acho o Netbeans mais estavel, mas o Eclipse tem algumas features a mais.

Android SDK

Depois, faça o download do Android SDK, a versão para download na página do projeto atualmente é a 1.5 r3. Faça o download e instale o SDK, esse será o seu SDK install directory, anote em algum lugar o path completo para esse diretório, pois o mesmo será usado no futuro.

Plugin de desenvolvimento

Para poder trabalhar com o desenvolvimento para android com o IDE que você escolheu será necessario a instalação de um plugin. Abaixo descrevo como instalar os plugin para Eclipse e para Netbeans.

Para instalar o plugin no Eclipse:

1 – Inicie o Eclipse, e selecione a opção de menu Help > Software Updates…
2 – Clique a aba Avaiable Software
3 – Clique o botão Add Site…
4 – Entre o endereço do site de update do Android: https://dl-ssl.google.com/android/eclipse/

Clique o Ok

5 – O site de update do Android deve aparecer na lista de Avaiable Software. Selecione o checkbox ao lado do mesmo e então clique Install…
6 – Clique Finish para iniciar o processo de download e instalação.
7 – Assim que a instalação terminar, reinicie o Eclipse.
8 – Quando o Eclipse abrir novamente, será necessário configurar onde o Android SDK está instalado. Selecione o menu Eclipse > Preferences > Android, e entre o diretório de instalação que você anotou no começo. Clique Ok.

Bem, se tudo deu sorte e os Deuses do java permirtirem, você poderá começar a criação do seu tão sonhado software para Android.

Para instalar o plugin do Netbeans

1 – Inicie o Netbeans e selecione a opção de menu Tools > Plugins
2 – Clique na aba Settings
3 – Clique no botão Add
4 – Entre um nome, por exemplo nbandroid e o endereço do update center do plugin http://kenai.com/downloads/nbandroid/updates.xml

Clique o Ok

5 – Na aba Available plugins entre nbandroid, ou o nome que vc escolheu no campo de busca, selecione o checkbox ao lado do ite encontrado e clique Install…
6 – Clique Next, aceite a licença, clique em continue (ignore os avisos sobre ‘unsigned plugins’) e voilá.

Você agora pode usar todos seus Skills de Netbeans no desenvolvimento para Android.

O mundo de Android

gbenatti — Mon, 31 Aug 2009 13:22:00 +0000

Começei a brincar nos ultimos dias com a plataforma Android. E gostei da forma como certas coisas são feitas no sistema, como a idéia de Activities e Intents, o fato de você poder executar o programa direto no aparelho, sem a necessidade de certificados, provisioning profiles e todas esses detalhes comuns no IPhone.

Espero escrever logo algumas impressoes sobre a programação para Android versus a programação IPhone.