Veja também:

• Python : aumento e redução percentual
• Curiosidades sobre loops no Python
• O professor de matem?tica mais legal que voc? j? viu
• [Curiosidade] Matemática de mendigo
• Um novo tipo de espelho que não inverte a imagem

Veja também:

• Curiosidades sobre loops no Python
• Um novo tipo de espelho que não inverte a imagem

Veja também:

• Python : aumento e redução percentual
• Por tr?s das cenas : jogo : De volta para o futuro
• Veja o Sikorsky X2 quebrando o recorde mundial de velocidade de helicópteros
• [Curiosidade] Música Panamericano
• Porque os Hard Disks eram chamados de winchester?

Veja também:

• Google Nexus Two
• [ Adobe AIR ] Package Assistant Pro
• Adobe AIR – Empacotador para iPhone OS + demos
• [Android Game] Angry Birds : acessando níveis travados
• Segundo comercial DROID da Verizon : stealth ataca EUA

Vimos no post anterior como lidar com listas em Scala.
Listas são uma das estruturas mais úteis no dia a dia de desenvolvimento, muitas vezes modelando bem a maioria dos problemas que envolvem algum tipo de estrutura de dados. Mas listas tem uma desvantagem que muitas vezes passa desapercebida em nossos programas: elas estão completamente definidas na memória. Isso significa que mesmo que o programa não necessite de todos os elementos da lista para executar, ainda sim a lista estará definida completamente.

Vamos a um exemplo para que fique mais claro o problema. Imagine que queremos encontrar o segundo número primo entre um determinado intervalo de inteiros. Para isso vamos começar definindo uma função que verifica se o número é primo:
Leia mais…

Twitter!

.

Essa notícia é bem interessante, e no sentido real da palavra, de que nos interessa e muito, o Rafael Martinelli trouxe diretamente da MAX essa informação. Fiquei bastante impressionado com o MoleHill, motivo que me fez escrever esse post dando uma introdução sobre o assunto.

Estarei acompanhando com muito interesse o que estiver acontecendo nesse segmento e sempre que possível vou procurar trazer novidades sobre essa engine.

Mas afinal, o que é MoleHill?

“Molehill” é o nome de código para um novo conjunto de baixo nível, com APIs de aceleração GPU  3D  que permitirá avançadas experiências em 3D nas telas através do Adobe ® Flash ® Platform runtimes.

Existem diversas comunidades, frameworks para desenvolvedores poderem ampliar seus horizontes na criação de aplicações 3D, como Alternativa3D, Away3D, Flare3D, Sophie3D ou Yogurt3D.

Durante a AdobeMAX um vídeo muito interessante foi apresentado para os participantes, ele mostra um jogo em 3D com gráficos mais apurados, algo que não deixa nada a desejar a consoles físicos para games, e que, talvez não fosse nada fantástico o vídeo abaixo se o game não estivesse rodando em um FlashPlayer.

Impressionante ver o que a Adobe fez, e contrariando muitos que dizem que o flashplayer requer processamento da máquina, a Adobe fez um game com uma estrutura potente e que requer ZERO, isso mesmo, ZERO de processamento da CPU, utilizando somente a placa aceleradora.

Confira o vídeo antes de continuar o artigo.

.

De acordo com o anúncio feito pela Adobe, no primeiro semestre de 2011, (quando em versão pública beta) a versão do Flash Player irá suportar essas novas APIs, bem como também acontecerá uma atualização do Adobe Flex SDK. Para obter mais informações leia atentamente o Molehill faq:

http://labs.adobe.com/technologies/flash/molehill/#faq

Para a maior parte das suas dúvidas você com certeza encontrará as respostas aí nesse link, portanto vou me fixar a falar das possibilidades de algo assim.

Não será novidade pensar que milhares de desenvolvedores começarão a criar seus games, mas não é só de game que vive o homem, apesar de ser muito bom é claro. Essa engine nos dará possibilidades de experimentar de fato uma nova era da web em 3D. Lembramos que o shockwave não deu certo, não emplacou, mas pelo visto a Adobe aprendeu com o erro e fez uma engine de qualidade, a cada dia mais e mais computadores saem de fábrica com placa aceleradora 3D, ao ponto que isso está se tornando comum, se essa engine é a primeira fase, podemos esperar muito pelo que esta por vir.

Pense nas aplicações 3Ds que poderão ser desenvolvidas, pensem em um showroom virtual, hotsites etc, tudo aquilo que era feito antigamente com as piores gambiarras possíveis, hoje poderá ser realizado com qualidade.

Sou suspeito para tecer elogios a Adobe visto que sou um entusiasta, fiz minha carreira em cima de todos os seus sofwares, e claro, da Macromedia, que hoje é Adobe… portanto fico feliz em saber que ela nunca abandonou o Flash, e mais que isso, se empenhou em criar inclusive um conversor de SWF para HTML5, fazendo com que os desenvolvedores Flash (vulgo flasheiros) não percam seu mercado, afinal, se Flash fará HTML5, certo é dizer que HTML5 nunca fará um SWF e nem chegará perto da qualidade, visto que essa tecnologia com todo respeito ainda está engatinhando.

Mas o assunto é MoleHill, vamos  continuar falando de quem vai se dar bem nessa história toda na minha opinião.

.

.

Evidente, ela já se deu bem, e depois e todo o alvoroço e discussão sobre o Flash rodar ou não no Iphone fica aí um susto que a Adobe está dando a Apple, ou não, pois talvez a mesma já previa tal situação e portanto procurou evitar os games em Flash para poder alavancar a AppStore, sem entrar muito no tema, nem são os games 3Ds os mais vendidos na mesma (portanto nem sei porque da preocupação do Steve, talvez parcerias , enfim) mas…  certamente essa é uma tecnologia fantástica que faz a Adobe novamente ficar a frente dos demais, como sempre esteve. Afinal, uma plataforma para desenvolvimento de games mais sérios, com suporte a joysticks, volantes etc, (nada pronunciado a respeito mas isso vemos nos vídeos, o volante do XBox sendo utilizado), combinado com um Flash Media Server, um ambiente de multiusuário, online,  pode ser realmente devastador (no bom sentido) para o mercado como um todo.

Então não poderíamos deixar de falar quem é que mais ganha com isso.

.

Android

.

O Android tem sido um parceiro do Flash simplesmente porque a Apple não quis ser no seu iOS, e a Adobe já se pronunciou a respeito dizendo que haverá acesso as APis 3D também para as plataformas móveis…  fantástico, não só para games, mas como falei, para outros recursos de aplicativos.

A web sempre procurou introduzir o 3D, é uma tendência natural, também sou suspeito para falar do assunto pois sempre apostei no 3D e sou um 3Ddesigner também e obviamente amo o assunto e sempre acreditei que a experiência 3D é muito poderosa, pois ela trata quase todas as sensações visuais que o cérebro pode comportar, dando é claro maior realismo ainda que não haja muitos detalhes gráficos.

Posso dizer que consigo passar horas desenvolvendo algo em 3D sem me cansar, pois me sinto imerso no ambiente, mas não é a mesma coisa para desenvolver algo em 2D.

Enfim, o Android de fato vai se dar bem nessa história, vai abocanhar todo um mercado de 3D para mobile, com milhares de desenvolvedores famintos para migrar diversas aplicações e games prontos para essa engine, para rodar em Flash.

.

Portanto quem também ganha com isso?

Os diversos frameworks que já citei.

.

Dentre eles eu aposto mais no AlternativaPlatform, me pareceu mais robusto, mais acabado inclusive, a maioria dos vídeos que trago aqui são desse framework, no mais, outras como Frare3D e Away3D também me parecem boas, mas como ainda não botei a mão em nenhuma delas fica suspeito comentar, em um futuro próximo farei alguns testes (como designer) e darei a minha visão. Mesmo assim, tanto designer como desenvolvedor terá uma gama de possibilidades bastando ver as suas necessidades, e ter várias opções nesse caso é muito bom.

Vou dar um foco maior a AlternativaPlatform, portanto veja o anúncio feito no blog da própria empresa sobre a Adobe Max.

http://blog.alternativaplatform.com/en/2010/10/16/alternativa-3d-is-free-see-you-at-adobe-max

Confira a qualidade do site:
http://alternativaplatform.com/en/

Uma breve introdução visual:

.

Vamos agora a imersão, vamos aos vídeos:

.

Confira outro vídeo, agora de uma visão externa mostrando o “jogador” do MaxRacer :

.

.

Outro vídeo da Alternativa3D:

.

.

Agora da Frima Studio (http://www.frimastudio.com/), que utilizou a engine usada para PSP do jogo Zombie Tycoon (http://www.zombietycoon.com/EN/index.htm) migrando para Molehill (sim fantático, não o jogo mas a possibilidade) :

.

.

Away3D :

.

.

Vamos a uns vídeos mais instrutivos:

O primeiro é a sessão de Sebastian (engenheiro-chefe na Molehill):

.

.

O segundo vídeo é da equipe Flare3D, apresentando o Molehill e suas vantagens:

.

.

Away3D e Alternativa3D teams (equipes), ainda sobre seus respectivos frameworks e vantagens:

.

.

E então a Pixel Bender 3D:

.

.

Bom galera, espero que esse post tenha sido uma boa introdução para conhecer o assunto, fiz uma pesquisa vasta para trazer as melhores informações sobre o tema e espero que tenham gostado.
Assim que tiver novas informações interessantes estarei postando, até lá se você também tiver algo a acrescentar não deixe de comentar aqui nesse post.

E que venha o mundo 3D na web.

_________________________________________

Eduardo Horvath é UX Specialist e Designer na DClick.
Formado pela Faculdade Impacta de Tecnologia no curso Design de Mídia Digital ele atua na área de Design a mais de 15 anos.
@eduardohorvath

Twitter!

Aprendendo Scala

Estou começando uma série de posts sobre Scala para divulgar as minhas experências com a linguagem e suas aplicações. Vou tentar passar o funcionamento da linguagem e seus recursos, assim como também um pouco do paradigma de programação funcional, e tentar chegar em aplicações práticas no ambiente de desenvolvimento.

Existem alguns tutoriais disponíveis na internet bem interessantes mas que as vezes jogam muito conteúdo sem dar tempo para assimilar os conceitos. Nessa série de posts tentarei colocar os conceitos e ferramentas de Scala e linguagens funcionais de uma maneira natural, conforme eu mesmo for evoluindo na linguagem e também dando exemplos e exercícios para que você possa assimilar o que está sendo passado. Vou tentar explicar também conceitos mais teóricos do paradigma funcional, para que a linguagem que estamos falando seja a mesma.

Minha experiência com Scala é algo bem próximo do zero, por isso estou escrevendo esta série de posts com o intuito de me forçar a estudar a linguagem e também ajudar a divulgar uma das possíveis alternativas ao Java, afinal se trata de uma linguagem nova e que ainda não foi muito difundida na comunidade. Tratarei bem do básico nos primeiros posts com exemplos bem trivias apenas para ajudar na compreensão dos conceitos básicos. Também colocarei algumas bibliografias de onde se pode encontrar documentação sobre a linguagem.

Linguagens funcionais e Scala

Não é nova a ideia de se programar em um paradigma funcional. Linguagens funcionais existem a quanse tanto tempo quanto existe linguagens de programação. Com certeza na sua faculdade você viu, ou verá, linguagens como LISP, Scheme, Erlang, Clojure, etc… e atualmente que está ficando bem conhecida: Scala que roda em cima da JVM, a virtual machine do Java. Linguagens funcionais mudam o paradigma para focar em ‘funções’. Assim como em linguagens orientadas a objeto onde a unidade básica é uma intância de um objeto, em linguagens funcionais a unidade básica é uma função. Uma função nada mais é do que uma operação que recebe parâmetros, executa alguma ação e devolve um resultado. O funcionamento é muito parecido com o dos métodos em linguagens orientadas a objeto.

O interessante sobre Scala, é que a linguagem permite uma mescla do paradigma funcional com orientação a objeto. Existem conceitos de ambos implementados na linguagem e que fazem sentido quando aplicados em conjunto. Por exemplo, em scala existe o conceito de classe e de instâncias de classes, que são os objetos. Também existem funções que independem de uma classe para existirem. Se trata de um conceito muito poderoso, pois possibilita toda padronização e controle do design do sistema que as linguagens orientadas a objeto permitem, sem restringir o uso do dinamismo e abstração da linguagem funcional.

Mas claro que Scala e linguagens funcionais tem seus problemas. Por exemplo, não existe uma IDE sólida como o Eclipse ou o NetBeans para Scala. O que dificulta no momento de trabalhar com projetos muito grandes, com uma equipe com vários programadores. O dinamismo da linguagem também impede uma análise de código que por exemplo o PMD, ou o FindBugs disponibilizam no Java. Dessa forma, deveríamos garantir que as boas práticas e o design está sendo seguido com nossos testes unitários.

Chega de filosofar sobre a linguagem, vamos para a parte prática.

Instalando Scala

Para instalar o Scala basta acessar a página oficial de download neste link, e fazer o download de acordo com sua plataforma. Feito isso, descompacte o conteúdo em alguma pasta na sua máquina e adicione a pasta ‘bin‘ ao path do seu sistema operacional. Para se certificar que foi tudo instalado corretamente, abra um console e digite ‘scala‘, o terminal do scala deve abrir e aparecer uma tela como essa:

Agora que o terminal está sendo executado, digite ‘1 + 1‘ e repare na saída:

É uma saída um tanto quanto confusa, mas que faz sentido no contexto do Scala. O que está acontecendo é que a unidade básica em Scala é uma função, portanto a operação + também é uma função, que foi executada no objeto ‘1‘, passando o parâmetro ‘1‘. Para se ter uma idéia melhor desse funcionamento, digite o seguinte no terminal:

e aperte Enter. Repare na saída:

Com exceção do tipo que era int e agora é Double, o funcionamento é exatamente o mesmo. Tal sintaxe já deve estar bem claro na cabeça da maioria dos programadores, mas a primeira sintaxe é só uma maneira difetente de se fazer a mesma chamada.

Conceitos básicos da linguagem

Vamos definir uma função para entender um pouco mais da sintaxe. Digite o seguinte:

Aqui estamos definindo uma função com o nome ‘a‘ que não recebe parâmetros, e devolve o resultado da soma ‘2 + 2‘. A palavra restrita return não é necessária, o compilador consegue inferir que a última expressão da função será o valor devolvido. Repare também que não precisamos definir o tipo que a função devolve, o qual também foi inferido pelo compilador. Portanto ao contrário do que possa parecer, Scala é uma linguagem tipada em tempo de compilação, portanto o seguinte trecho não compila:

Repare que o compilador inferiu que o tipo da variável ‘b‘ é String (note que é o String do java), e que o tipo devolvido por ‘a‘ é Int, logo o código não compila. De certa forma esse comportamento é bom, pois garante uma maior integridade do código, sem que você tenha que programar para “deixar o compilador feliz“, ou seja, não existem tantas regras na escrita do código, porque muitas podem ser deduzidas a partir do contexto.

Um outro conceito de Scala é a diferença entre chamada por valor, e chamada por nome. Na chamada por valor é feita a evaluação da expressão assim que o código é executado, mesmo que não seja necessário usar o resultado da chamada. A vantagem é que evitamos executar outras vezes a expressão para obter o resultado, pois este já foi determinado. Na chamada por nome a evaluação da expressão ocorre apenas quando o resultado da chamada será usado, tendo um comportamento mais lazy. A desvantagem é a execução da expressão várias vezes para se obter o mesmo resultado, mas a vantagem é não fazer a execução quando não for necessário. Vamos ver um exemplo da diferença entre a chamada por valor e por nome. Volte no terminal e defina a seguinte função:

Agora defina uma função que recebe dois inteiros e devolve o primeiro:

Agora execute a chamada passando ‘loop‘ como segundo parâmetro e se prepare porque seu console irá travar na execução =):

Vamos fazer uma pequena modificação na definição de ‘primeiro‘ para tornar possível a execução de tal código:

O que definimos agora foi que o segundo parâmetro de ‘primeiro‘ será uma função que devolve um Int. Assim seu resultado só será obtido quando for feita a chamada direta na expressão. Agora conseguimos fazer a chamada em nossa função:

Nossa função executou e finalizou sem problemas dessa vez, isso porque não foi necessário utilizar o segundo valor para obter o resultado. Essa é chamada por nome, e o primeiro exemplo é a chamada por valor.

Até agora vimos como invocar funções, como definir funções (def) e como definir variáveis (var). Vimos também o básico de inferência de tipo pelo compilador do scala e os primeiros conceitos da linguagem. Mas como eu havia dito, Scala também tem conceitos de orientação a objetos, portanto vamos definir nossa primeira classe em Scala:

Lembre-se que não somos obrigados a definir o tipo devolvido pela função caso esteja explícito e também não precisamos da palavra reservada ‘return‘. O que fizemos foi definir uma classe que se chama ‘AcumulaSoma‘ que tem um atributo, que por padrão do Scala é de acesso privado, que se chama acumulado e que o compilador inferiu o tipo inteiro baseado no valor atribuído. Também definimos para a classe a função ‘acumula‘ que recebe um inteiro, guarda o valor acumulado até então da soma com o parâmetro passado e devolve tal valor. Vamos instanciar um objeto da nossa classe e fazer a chamada ao método:

Algumas diferenças com o Java (supondo que estamos mais acostumados com a sintaxe do Java) já podem ser notadas. Além da inferência do tipo de ‘ac‘ para ‘AcumulaSoma‘, criamos ‘ac‘ com a a palavra reservada ‘val‘, ou seja, estamos dizendo que diferente de ‘var‘ onde criamos uma variável, estamos criando um valor e estamos garantindo em tempo de compilação que este valor não pode ser alterado no código. No Java teríamos que usar a palavra ‘final‘ para obter o mesmo comportamento, em Scala temos que “satisfazer menos o compilador“. Também não foi necessário usar ‘()‘ para invocar o construtor de AcumulaSoma, e assim como no Java toda classe em Scala tem por padrão o construtor que não recebe parâmetros com acesso público. Continuando o exemplo:

Nada de novidade aqui, estamos invocando a função ‘acumula‘ no objeto ‘ac‘. Porém ‘acumula‘ é uma função que recebe um único parâmetro e devolve um valor. Dessa forma podemos executar a chamada da nossa função da outra forma que vimos anteriormente:

No Java conseguimos definir classes estáticas. Em Scala não existe exatamente o conceito de classes, atributos e parâmetros estáticos, porém existe um conceito mais bem definido: ‘object‘. Criamos um ‘object‘ igual criamos uma classe, com a diferença de que não é possível instanciarmos um object, afinal estamos definindo o próprio. Com essa diferença, estamos garantindo em tempo de compilação que o design do código, em que foi tomada a decisão de restringir a existência de apenas uma definição para determinada classe seja seguida. Em Java também é possível garantir tal critério em tempo de compilação, mas demanda a escrita de bem mais código e de uma compreensão um pouco maior do funcionamento e limitações da linguagem. Um exemplo de object:

Existem os tipos primitivos básicos em Scala como Int, Long, Boolean, Float, Double, Short, Byte, Char e String, sendo que String é a String do ‘java.lang‘. Um fato interessante sobre Scala é que como a linguagem roda em cima da JVM, todas as bibliotecas disponíveis para Java também estão disponíveis para Scala.

O tipo que não vimos ainda é o ‘void‘. Em Scala não existe o conceito de void, toda função devolve um valor e quando não há um valor explícito a ser devolvido o compilador se encarrega de devolver um valor do tipo ‘Unit‘. Exemplo:

‘print’ é uma função que imprime um valor no terminal e não devolve valor, logo nossa função ‘imprime‘ também não devolve valor, portanto o tipo devolvido é ‘Unit‘, que também pode ser expressado/escrito como ‘()‘. A diferença básica entre void e Unit, é que Scala permite criar valores e variáveis do tipo Unit, e em Java por exemplo não é possível criar uma variável do tipo void. Também é possível analisar o valor devolvido por qualquer função mesmo que a função não devolva um valor definido e neste caso será um Unit. Um exemplo trivial de como usar este comportamento:

O tipo ‘Any‘ é análogo ao ‘Object‘ do Java, portanto pode ser qualquer valor, função ou objeto.

Nessa função estamos usando um tipo de switch case para obter o mesmo comportamento do ‘instanceof‘ em Java, afinal não existe tal operação em Scala. O que está acontecendo é que a função verificaUnit recebe uma função que não recebe argumentos e devolve um valor qualquer. A função ‘f‘ é então evaluada e o resultado da função é testado nos cases da operação ‘match‘. Caso seja do tipo Unit, imprimimos “Eh Unit!”, e no caso padrão imprimimos “Nao eh Unit!”. Repare que diferente do ‘switch‘, no ‘macth‘ não temos que chamar a operação ‘break‘ para não executar os outros casos. Para testar verificaUnit vamos fazer a chamada usando nossas outras duas funções que foram definidas:

Um exemplo mais prático

Vamos implementar um exemplo um pouco mais prático que calcula a raiz quadrada aproximada de um número. Para isso vamos usar o método de Newton de aproximações sucessivas. A idéia é bem simples, nada mais é do que uma busca binária entre os palpites que se aproximam cada vez mais da raiz quadrada do número passado. Vamos começar definindo uma função que diz se a raiz encontrada é boa o suficiente para ser o resultado:

O bloco if é igual a sintaxe usada no Java, o mesmo vale para o else e o else if. Na segunda função estamos verificando se o número elevado ao quadrado é próximo o bastante do original. Agora vamos definir a função que faz um palpite melhor:

O que fizemos foi pegar um número para palpite que está entre o nosso palpite anterior e x dividido sobre o palpite anterior, onde x é o número que queremos obter a raiz quadrada. O método de Newton garante que para x >= 1 essa aproximação é sempre válida. Vamos agora a função que executa o método de Newton propriamente dito:

Estamos calculando a raiz quadrada de modo recursivo até que o resultado seja bom o suficiente. Agora basta definir uma base para nossa função, para isso iremos pré-definir um valor para o palpite base, guardando a chamada nesse escopo em uma outra função:

Pronto, basta brincar com algumas chamadas para nossa função que calcula a raiz quadrada =).

O resultado obtido não é muito preciso, mas também essa não é a melhor maneira de se calcular a raiz quadrada, inclusive para números muito grandes o algorítmo não funciona por restrições com a precisão do Double.

Algumas Considerações

A grande moda das linguagens funcionais está surgindo porque acreditasse que elas são o futuro para a programação concorrente e paralela, de que se o seu programa foi escrito em uma linguagem funcional você terá ganho o benefício da execução concorrente sem grandes esforços, bem, isso não é verdade. Linguagens funcionais como qualquer outro paradigma necessitam que o programa seja escrito de maneira que seu design seja voltado para execução concorrente ou paralela, a difenrença é que a sintaxe e as ferramentas disponíveis nas linguagens funcionais facilitam tal design.

Existem algumas técnicas de programação que surgiram com linguagens funcionais, como por exemplo Recursão em Cauda, que não entrarei no mérito nesse post mas que vale a pena pesquisar sobre o assunto. Tais técnicas facilitam a vida do compilador no momento em que for possível ser feita algum tipo de otimização.

Uma comparação que logo surge na cabeça dos programadores é: qual linguagem é melhor, Scala ou Java? A resposta é fácil… nenhuma. Cada linguagem tem um escopo e paradigma de atuação diferente, não tem como comparar ambas. O que talvez faça sentido comparar sejam fatores mais fora do domínio da linguagem, como por exemplo o tamanho da comunidade que utiliza efetivamente a linguagem, o tipo de suporte, a documentação disponível, as restrições de uso, mas em geral depende do caso de uso específico para o seu problema, e principalmente do gosto do programador.

Por enquanto é isso, em um próximo post tratarei de alguns outros tipos de funções e falarei um pouco mais sobre currying. Também darei exemplos de tipos diferentes de declarações de classes e objetos.

Referência: Scala By Example, Martin Odersky

Web RunTime é uma das possibilidades que a Nokiaoferece para criação de aplicativos para seus dispositivos movéis. Se você já é um desenvolvedor web, você não precisa de quase mais nada para começar a desenvolver para os dispositivos Nokia usando o WRT. Ele permite a criação de widgets para plataforma S60 sendo uma extensão do navegador Webkit permintindo que as instâncias do browser sejam executadas como se fossem aplicativos separados. E você ainda pode criar aplicativos mais ricos com o uso do Flash.

Ferramentas de desenvolvimento.
A Nokia oferece algumas ferramentas para facilitar o desenvolvimento para WRT:

• Nokia Web Developer Environment Standalone.
• Plugin para o Aptana Studio.
• Extensão para o Adobe Dreamweaver.
• Plugin para o Microsoft Visual Studio.

Também oferece UI Framework e Library como:

• Guarana WRT UI library – Uma library baseada em JQuery para o Nokia WRT feita pelo pessoal do INdT(Instituto Nokia de Tecnologia) com sede em Manaus.
• Nokia Mobile Web Templates – Um conjunto de templates otimizados para mobile e para você customizar como quiser.

E tem algumas API’s para se trabalhar com os recursos dos dispositivos movéis.

• Platform Service 2.0 – Uma API em JavaScript e ActionScript 2.0 para acessar recursos dos dispositivos movéis como acelerometro, geolocalização etc.
• API Bridge – é um componente para aparelhos Nokia com Symbian, que permite widgets WRT, conteúdo Adobe Flash Lite e aplicações Java possam acessar recursos do dispositivo através de uma arquitetura plug-in. Os desenvolvedores podem estender o componente APIBridge com os seus próprios plug-ins.

Como funciona os widgets feitos com Web RunTime? esse widgets são arquivos com extensão .wgz que nada mais é que um arquivo compactado com os arquivos de seu site. Os arquivos que não podem faltar são:

• Info.plist – arquivo responsavel pelas informações de seu widget como versão, pagina inicial, nome etc
• index.html – na verdade, pode ser qualquer nome desde que esteja setado no Info.plist como MainHTML.

Criar widgets com WRT e Flash Lite
Como você usa html para criar seus widgets com WRT, nada impede de usar o Adobe Flash na mesma maneira de como você usa normalmente atraves do html. Vamos ver um exemplo usando JavaScript para fazer a comunicação com o Flash atraves da classe ExternalInterface. Nesse exemplo utilizarei o Nokia Web Developer Environment Standalone.

• Crie um novo projeto do tipo Symbian web apps->Basic web app project. Dê um nome para seu projeto e clique em next. São gerados os arquivos basicos para seu projeto.

Daremos a opção do usuario escolher dois videos para tocar. Começaremos com o html contendo as opções de video.

E o html que carregará o swf responsavél por tocar o video:

Editaremos o arquivo basic.js para adicionar o método que mandará para o swf o video que deverá ser tocado.

No Flash, criamos um arquivo do tipo Flash Lite 3.0 ou 3.1. No painel da library, clique em na opção “new Video”. Dê o nome de instancia de “vd”. Em type deixe selecionando “Video (ActionScript-controlled) e adicione no stage. Adicionaremos o seguinte codigo para que o Flash execute o video via stream a partir do Flash Media Server:

Usamos a classe estatica ExternalInterface para que nosso método dentro do Flash possa ser chamado a partir do JavaScript. Executando o emulador do Nokia Web Developer, devemos ter algo parecido com isso:

Emulador Nokia Web Developer

Para gerar o arquivo .wgz, bastar clicar com o botão direito no projeto e pedir “Package Web app” e seu aplicativo está pronto para rodar no celular. Testei no Nokia 5230

Para saber mais:
http://www.forum.nokia.com/Develop/Web/Tools/
http://wiki.forum.nokia.com/index.php/Category:Web_Runtime_%28WRT%29
JQuery Mobile
Adobe Flash Lite

Esta é uma aplicação muito útil para gerar a versão instalável nativa [Windows, Mac, Android]

 

Package Assistant Pro

 

O processo de criação dos instaladores nativos para AIR 2.0 e arquivos APK para o Android não são algo fácil de se fazer na unha. Então esta aplicação, o Package Assistant Pro, é uma aplicação para lhe auxiliar de maneira fácil, o empacotamento de aplicações em Adobe AIR, gerando um instalador nativo para desktop ou para Android, sem a necessidade de uso de linha de comando.

Tenha em mente: até a presente data(Outubro/2010), considere o Package Assistant Pro como nível beta.

Atenção: Antes de utilizar essa aplicação tenha certeza que a respectiva configuração, como exibida na imagem acima está correta e que o seu arquivo XML de descrição da aplicação possua a configuração da tag supportedProfiles. É preciso ter certeza que o namespace está correto e que a janela inicial está setada para visível. Procure utilizar a última versão disponível do AIR SDK para o Android, o qual exige o versionNumber (altere a tag version).

 

Download da versão para Mac OS X

(~1.2 MB .DMG)

Download da versão para Windows

(~1.2 MB .ZIP)

Esta aplicação foi criada por: Serge Jespers

 

O que eu preciso para usar o Package Assistant Pro?

Para executar o Package Assistant Pro, você vai precisar do AIR 2.0 Runtime, do AIR 2.0 SDK e o AIR 2.5 para Android, o qual está disponível em um beta privado (até a presente data Outubro/2010), mas você pode se registrar e participar deste beta.

 

Como esta aplicação foi criada?

O Package Assistant Pro foi desenvolvido utilizando o AIR 2.0, sem o qual não seria possível sua implementação. Para aprender como usar o recurso Native Process do AIR 2.0, veja neste link.

 

Como usar o Package Assistant Pro?

 

Você também pode efetuar o download do guia de uso do Package Assistant Pro em PDF.

Veja também:

• Adobe AIR – Empacotador para iPhone OS + demos
• [Adobe AIR 2 : NativeProcess] projeto de exemplo : Windows Console
• Preview: Mac OS X Snow Leopard
• [Android Game] Angry Birds : acessando níveis travados
• Flerry 1.2.0 disponível

O grande e mais que antecipado FlashCamp Portugal 2010 foi realizado no passado Sábado, em Lisboa.

Para já, fiquem aqui com o brilhante vídeo criado pelo Márcio Bonus Pité para a introdução do FlashCamp Portugal 2010:

Flash Camp Portugal – Open titles from Márcio Bonus Pité on Vimeo.

Para as pessoas que vieram do Norte, como eu, o dia foi longo! Começou com a entrada no comboio às 05:47 da manhã (ouch!) e seguiram-se duas horas e meia a falar de tudo e mais alguma coisa. Obviamente a tecnologia foi o tema dominante assim como praticamente todos os software da Adobe. À chegada à capital, fomos de Metro até à Universidade Lusófona onde já estavam muitas pessoas à entrada.

Fica aqui um “relato” sobre o evento:

AUGPT Presentation and FlashCamp2010 - Como não podia deixar de ser, o Paulo Moreira e o João Fernandes foram os primeiros a falar. Apresentaram o Adobe User Group Portugal, mostraram a agenda do dia e que planos tinham para o grupo. É sempre bom ouvi-los dizer que querem sempre mais e mais e mesmo com uma fasquia tão alta, prometem para o ano voltar a surpreender-nos. Aqui estamos nós para ajudar e participar!

Mike Jones – Designing Flex Components - Depois de aberto o evento por parte dos organizadores, foi a vez do Mike Jones, Platform Evangelist do Flex fazer a sua apresentação sobre como customizar componentes em Flex.

O Mike falou sobre como podemos integrar o Flash CS5 e o Flash Builder para podermos criar componentes e integrar os mesmos nas nossas soluções. Foi uma sessão interessante uma vez que explicou como podemos facilmente atingir um resultado bastante interessante recorrendo a estas duas ferramentas.

Coffee Break (manhã) – Coffee Break e muito network. A maior parte dos participantes aproveitaram para conversar um pouco, beber um café e foi porreiro rever muita malta que já encontrei nos eventos de Lisboa e também nos eventos aqui do Porto. Estes trinta minutos também foram agitados devido ao pequeno jogo de networking que estava preparado para os participantes. A ideia era trocar pins uns com os outros de forma a termos quatro cores diferentes para podermos participar nos sorteios ao fim do dia.

Paulo Fierro - Mobile projects - Notava-se perfeitamente que o Paulo Fierro estava totalmente à vontade na sua apresentação. Foram umas dezenas de minutos em que se falou de oportunidades de negócio resultantes de nichos de mercado que são encontradas quase ao acaso e para satisfazer as nossas necessidades pessoais. Falou também que, por vezes, não basta saltar de cabeça para um projecto e que convém estarmos com os pés na terra porque podemos sempre ter alguns dissabores ao longo do tempo. É bom ver este tipo de abordagem que quase nunca é falada em eventos tecnológicos e de certeza que colocou ali muitas cabeças cheias de vontade para pegarem nos seus projectos e alcançar os seus objectivos.

AUGPT Community Showcase - Jorge Varandas/Paulo Afonso, Nuno Morgadinho, Nuno Ribeiro, João Gonçalves - Como é óbvio, uma das mais-valias destes eventos é promover, e bem, o que se faz em Portugal. Foi este o caso. A qualidade estava bastante elevada nos projectos que foram apresentados. O João Gonçalves mostrou o seu último trabalho para a Audi que era bastante interactivo e que, pelos vistos, foi um sucesso para a marca fazendo esgotar as datas dos test-drives para os carros em questão! O Jorge Varandas e o Paulo Afonso (quem diria que ele era nortenho? Uma surpresa!) monstraram alguns truques bem interessantes para elevar o nível dos sites feitos em Flash a um patamar superior não descurando os factores de SEO que tanto importam às marcas. O Nuno Morgadinho também demonstrou projectos muito interessantes nos quais tinha trabalhado. Por fim o Nuno Ribeiro que, depois um showcase dos seus trabalhos, resolveu falar sobre o que está mal no mercado português a nível de web design, empresas, projectos para a web, etc. Foi a apresentação que causou mais controvérsia e discussão. No entanto, como tinha chegado a altura de almoçar e a malta tinha de ir embora para cumprir os prazos do evento, tivemos todos de sair da sala, porque era garantido que havia ali pano para mangas…

Almo̤o РAlmo̤o com os estrangeiros a gostarem da dobrada que serviram na cantiga da faculdade! Aproveitou-se a oportunidade para se falar sobre as apresenta̵̤es que ocorreram de manḥ e tamb̩m sobre tudo e mais alguma coisa

João Saleiro – Skin Flex 4 apps with Spark – O João Saleiro brindou-nos, como é habitual, com uma apresentação muito hands-on que nos demonstra como os profissionais trabalham no mercado actual. Confesso que gostei bastante do conteúdo se bem que entendo que, com um plateia muito preenchida de designers, foi um assunto que colocou algumas pessoas confusas. Acho que o problema aqui foi não passar a informação que os designers não precisavam de escrever uma linha de código para poder criar so componentes para os developers trabalharem.

Niqui Merret – Bugs Catch’em All – Uma apresentação super divertida mas ao mesmo tempo muito séria sobre um assunto que nos deve preocupar a todos… Os bugs! Foram mostradas diversas plataformas e software que nos ajuda na exterminação destes pequenos problemas que fazem a nossa vida um inferno! Quando abordado com uma precisão quase matemática, a forma de analisar um bug pode tornar-se um processo interessante! Confesso que não conhecia o “Charles” visto que sempre utilizei o Service Capture, mas vou, com certeza, testar!

Coffee-Break (tarde) – Foi uma surpresa encontrar pessoas que estão em Lisboa a trabalhar e que já trabalharam aqui no Porto comigo. Depois de colocar a informação up-to-date, foi a vez de falar com mais malta que não conseguia e falar sobre o Adobe User Group Porto.

Rui Silva – Internationalization in the Flash Platform – Depois do descanso da tarde, foi a vez do Manager do Adobe User Group Porto, o Rui Silva, falar sobre um tema que tendemos a esquecer mas que é de importância extrema quando pensamos em internacionalizar o nosso produto, as línguas! Foram dadas várias dicas e mostradas várias soluções que a plataforma Flash já possui para facilitar esta implementação de múltiplas línguas nos nossos produtos e que, colocar o nosso software em outra língua não é só a “bandeirinha” e os textos.

Lee Brimelow – My Head Hurts – Por fim… Um senhor que é quase a estrela de rock da plataforma Flash mundial (muito por culpa do seu site, gotoandlearn que deverá ter sido o primeiro sítio onde as pessoas aprenderam a programar em Flash, e ao seu blog de referência, theflashblog). Nota-se perfeitamente que o Lee Brimelow é um senhor a fazer apresentações. Já muito habituado a estas andanças, tratou de um assunto sério, que nos preocupa a todos (Flash, HTML5, onde estamos, onde vamos, etc.) mas de uma forma extremamente interessante e que gerou muitos comentários da parte dos presentes.

As críticas, todas as que pensei ter foram apontadas noutros blog, mas aqui ficam:

- Os microfones. Como a sala era grande, não se ouvia muito bem o que as pessoas diziam;

- O microfone do speaker. Como era estático, obrigava-os a ficarem quietos, o que para alguns, foi uma tensão extra (ou no caso de serem altos, como o João Saleiro, que se tinha de curvar para que se fizesse ouvir bem);

- Acho que não haver uma indicação que havia wireless, e uma hashtag para o twitter, foi uma falha, porque a malta queria era comunicar e expressar o que ouvia;

- O jogo dos pins podia ser mais difícil, vi alguma malta a aldrabar aquilo eheh;

Tirando estas pequenas falahas, foi um dia muito bem passado, com muito conteúdo para digerir e só posso dizer… Venha o próximo!

Um muito obrigado ao Paulo, ao João e a muitos outros que fizessem com que o evento fosse um sucesso e parabéns à malta que criou o logótipo, o site, e tudo o resto!

PS :Aqui fica uma grande recordação deste dia (obrigado ao Francisco Costa pela foto!):