Como configurar a conexão de dados TIM no Android

0 comments

Posted on 25th novembro 2009 by gbenatti in Sem categoria

, ,

Os dados da APN da Tim para o Android são os seguintes:

Name – TIM CONNECT FAST 72403
APN – tim.br
proxy – not set
port – not set
Username – tim
Password – tim
Server – not set
MMSC – not set
MMS proxy – not set
MMS port – not set
MCC – 724
MNC – 03
APN type – not set

O MNC pode ser 02, 03 ou 04, dependendo da região.

Curiosidades em Boo – Pipeline de compilação

0 comments

Posted on 18th novembro 2009 by gbenatti in Programação | Sem categoria | boo | truques

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.

  1. 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:

  1. booc -p:boo hello.boo

E você terá:

  1. [System.Runtime.CompilerServices.CompilerGlobalScopeAttribute]
  2. public final transient class HelloModule(object):
  3.     private static def Main(argv as (string)) as void:
  4.         System.Console.WriteLine(‘Hello World’)
  5.  
  6.     private def constructor():
  7.         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.

Boo Friday – Parte II

0 comments

Posted on 6th novembro 2009 by gbenatti in Sem categoria | boo

,

De volta a nossa série sobre Boo. Hoje eu vou falar sobre o primeiro item do Boo Manifesto. Que diz que Boo é uma linguagem que foi concebida para ter uma sintaxe limpa e de fácil digitação.

Quais caracteristicas Boo tem que estão ali pra atender esse objetivo ?

Parecido com Python.

Python é uma linguagem que é conhecida pela sua elegância e sua capacidade de expressar uma grande quantidade de informação de uma forma sucinta, copiando o básico da sintaxe de Python, Boo já começa com o pé direito nesse quesito.

Açúcar sintático para patterns comuns de programação.

Boo suporta uma gama de construções de forma simplificada, listas, hashtables, arrays. Alem dessas estruturas, formas simples de criação de objetos, uso de expressões regulares, formatação de strings e vários outros detalhes fazem de Boo uma linguagem que necessita de pouca digitação.

Alguns exemplos:

  1. # literais simples
  2. myArray = (1,2,3,4,5,6)
  3. myList = [1,2,3,4,5,6]
  4. myHash = {1: "um", 2: "dois", 3: "tres"}
  5. # formatação de strings
  6. language = "Boo"
  7. grade = "Awesome"
  8. print "${language} is ${grade}"
  9. # uso de regex
  10. print("Cool") if language =~ /^Boo/

Declaração automática de variáveis.

Em Boo, um assignement cria uma nova variável local naquele escopo.

  1. newVar = 1 # cria uma nova variável newVar

Inferencia automatica de tipos.

Uma coisa verdadeira no mundo da computação, é que muitas vezes nós programadores somos preguiçosos, só as vezes é claro. Exemplo, da do um método como o a seguir:

  1. def two():
  2.   return 2
  3. dois = two()

Não está na cara que o método two, retorna um tipo inteiro ? e que dois contem um inteiro também ? Então porque devemos escrever códigos assim:

  1. def two() as int:
  2.   return 2
  3. dois as int = two()

Na verdade em Boo não é necessário, a primeira versão funciona perfeitamente, gerando código equivalente a segunda versão, tendo assim todas as vantagens de código estaticamente tipado.

Fica a cargo do programador decidir qual código escrever. Eu como bom programador sei qual versão prefiro ;) .

Classes não são necessárias.

Para algumas utilizações como em scripts, muitas vezes a declaração de uma classe só pra deixar o compilador feliz não faz muito sentido.
Vocês já viram maior cambiarra do que o famoso “public static void main” ? Poxa, eu só queria escrever um hello na tela e tenho que declarar uma classe ? com um método public static ?? que recebe uma lista de parâmetros que eu não estou interessado ???

Ainda bem que em Boo, meu HelloWorld pode ser simplesmente

  1. print "Hello World"

Esse post já esta meio grande, no proximo falaremos de expressividade. Até lá espero aprender o que isso quer dizer.

Cheers.

Truques em Scala – Extractors

0 comments

Posted on 5th novembro 2009 by gbenatti in Programação | Sem categoria | scala | truques

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:

  1. 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:

  1. unknownObject match {
  2.   case Email(name, domain) =>
  3.     println(name + " at " + domain)
  4.   case _ =>
  5.     println("It’s not an email")
  6. }

No caso de unknownObject ser declarado como:

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

A saida seria “georges at gbenatti.net”

Já se unknownObject fosse declarado como:

  1. 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:

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

Definido esse extractor poderiamos reescrever o match da seguinte forma:

  1. unknownObject match {
  2.   case Email(name, domain) =>
  3.     println(name + " at " + domain)
  4.   case EmailStr(name, domain) =>
  5.     println(name + " at " + domain)
  6.   case _ =>
  7.     println("It’s not an email")
  8. }

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…