Tuesday, May 22, 2012

Analysing Android test frameworks


Searching for some Android test frameworks, I found, as most relevant, Roboeletric, Robotium and Calculon.

So I had to look inside them to define which one would fit my needs.

Roboeletric 

http://pivotal.github.com/robolectric/eclipse-quick-start.html
looks like the best one to use, because it runs tests in less time than the others. It runs in JVM without the need to use an emulator or a device. Besides it has clean and meaningful syntax and provides some kind of mock through shadow objects.

Good presentation:
http://www.slideshare.net/joemoore1/tdd-android-applications-with-robolectric

Robotium 

http://code.google.com/p/robotium/
is nice too, but it's slow because it needs an emulator or a device to run tests. It's the best option to run some specific tests that Roboeletric doesn't implement and to run on real devices. It shows the clicks on screen, edit fields being filled and screen navigation, which make things more realistic.

Reference:
http://www.slideshare.net/hugojosefson/robotium-at-android-only-2010-0929

Calculon

https://github.com/kaeppler/calculon
http://brainflush.wordpress.com/2010/01/10/introducing-calculon-a-java-dsl-for-android-activity-testing/
on the other hand, has it's own syntax to make more semantical tests , more readable. It also needs an emulator or a device to run tests, making it slow too.

Great presentation:
http://www.slideshare.net/matthiaskaeppler/calculon



Which I'll use


Roboeletric will be the one I'll choose, mostly because I'm doing TDD and really like faster response.

Monday, May 7, 2012

Analysing ORMs for Android



ActiveAndroid

https://www.activeandroid.com/
-Verbose
--Need to declare everything with annotations
--Query with too much method calls
-$19.90 / developer

android-active-record

http://code.google.com/p/android-active-record/
+No model configuration
+Annotation only when not following convention
-Database configuration before every access to database
-No relations support
-CRUD methods in _db object
--Manager like JPA EntityManager

Androrm

http://androrm.the-pixelpla.net/
-Always need to pass the ApplicationContext
-Need to call object's method that retrieves a QuerySet, where query methods are implemented
--Ex:
    Author.objects(getApplicationContext()).all();
+Create, update and delete methods called directly from Models (although passing applicationContext)
+Relations support
-Verbose model configuration
--Inspired by Django
--Ex:
    protected CharField mTitle;
    protected ForeignKeyField mAuthor;
   
    public Book() {
        super();
       
        mTitle = new CharField(80);
        mAuthor = new ForeignKeyField(Author.class);
    }
 

ORMLite

http://ormlite.com/sqlite_java_android_orm.shtml
-Uses dao for each model with crud methods
-Lack of documentation for Android
-Model configuration with annotations
--Ex:
    // you get the SQLiteOpenHelper from your Android Activity
    ConnectionSource connectionSource =
         new AndroidConnectionSource(sqliteOpenHelper);
    Dao accountDao =
         BaseDaoImpl.createDao(connectionSource, Account.class);
    TableUtils.createTable(connectionSource, Account.class);

    String name = "Jim Smith";
    Account account = new Account(name, "_secret");
    if (accountDao.create(account) != 1) {
         throw new Exception("Failure adding account");
    }
    Account account2 = accountDao.queryForId(name);
    connectionSource.close();

GreenDAO

http://greendao-orm.com/
-Lot of configuration
-It uses another app to create entities
+Relations support
-Programmatic model configuration
--EX:
    Entity user = schema.addEntity("User");
    user.addIdProperty();
    user.addStringProperty("name");
    user.addStringProperty("password");
    user.addIntProperty("yearOfBirth");
-Verbose query creation
--Ex:
    QueryBuilder qb = userDao.queryBuilder();
    qb.where(Properties.FirstName.eq("Joe"),
    qb.or(Properties.YearOfBirth.gt(1970),
    qb.and(Properties.YearOfBirth.eq(1970), Properties.MonthOfBirth.ge(10))));
    List youngJoes = qb.list();
 

Sugar

https://github.com/satyan/sugar
+Little configuration
-No relations support
-Need to pass context and class everytime
--Ex:
    # inserting values
    Note note = new Note(context, "Note 1");
    note.save();
    # query
    Note.findById(context, Note.class, 1);
    Note.find(context, Note.class, "title=?", new String[]{"Note 1"});
    # delete
    Note note = Note.findById(context, Note.class, 1);
    note.delete();
    # few more..
    Note.listAll(context, Note.class);
    Note.deleteAll(context, Note.class);
 

Orman

https://github.com/ahmetalpbalkan/orman
-No transaction
-Need to pass class everytime
+Few model configuration
+Create, update and delete methods called directly from Models
-Verbose query creation
--Ex:
    List students = Model.fetchAll(Student.class);

    String name = (String) Model.fetchSingleValue(ModelQuery.select()
                    .from(Student.class)
                    .orderBy("Student.gpa", "-Student.registrationDate")
                    .limit(1)
                    .selectColumn(Student.class, "name")
                    .getQuery());


Hadi

http://hadi.sourceforge.net/
-DAO
-Classes annotations
-Less used

 

Some comparison


  1. http://software-workshop.eu/content/comparing-android-orm-libraries-greendao-vs-ormlite
  2. http://www.ninthavenue.com.au/android-orm-jpa
  3. https://github.com/ahmetalpbalkan/orman/wiki/Why-orman-is-better-than-other-orms-for-you%3F


Which I'll use

As a Rails developer, I first tried to find something like ActiveRecord for Android. Actually I tried to create it first, then I thought that it should exists somewhere over the internet.

So I was looking for something easy to use and zero configuration, but as I tried to build it in Java, I saw that was impossible to do with Java what is done with Ruby, then I just discovered that many Frameworks.

At first, like I was searching for some ActiveRecord for Android, I found ActiveDroid and android-active-record, and a lot of others came during my research.

Finally, after creating this comparative post I decided to study deeper two of then: android-active-record and Sugar, just because they were simplest, and based in my original problem too, that was "How difficult is to add a new field in database and it show up on view".


That's it.

Edit: After studying both android-active-record and Sugar, I chose Sugar because of its zero configuration and simplicity.

Friday, March 12, 2010

Resultado de uma retrospectiva

Este é o resultado da última reunião de retrospectiva da equipe onde trabalho.

É muito interessante como esse feedback dá um panorama geral do projeto, e não apenas dos desenvolvedores.

A partir desse feedback você pode tomar decisões importantes e impactantes no projeto.

Pra quem não conhece, a retrospectiva tem como objetivos avaliar e melhorar o processo de desenvolvimento.

Os integrantes da equipe desenham, num pedaço de papel:
- uma carinha feliz, pra colocar o que achou legal
- uma triste , pra colocar o que acha que tem que melhorar
- e deixam um espaço em branco, pra colocar o que não foi ruim nem bom.


Avaliação da equipe:

Coisas Boas =)
- Entrosamento da equipe
- Aprendizado (2 vezes)
- Dinamismo entre o grupo (Ambiente de trabalho) (2 vezes)
- Refatoração e testes
- Feedback do cliente
- Fato do projeto começar do zero
- A paciência do Scrum Master
- Flexibilidade de horário
- Liberdade de expressão
- Galera caiu dentro
- Gerência no excel
- Conseguimos atingir a meta no final do ano
- Equipe firme para este ano
- Crescimento do projeto
- Cliente satisfeito

Coisas a melhorar =(
- Pagamento atrasando direto (5 vezes)
- As doideiras que o cliente pede
- Ter que refatorar muita coisa
- Ninguém dava um rolé no sistema no sistema para achar erros e só ficavam perguntando o que tinha pra fazer
- Ninguém ia aos dojos
- Perda de foco nas reuniões com o cliente
- Ausência por alguns momentos do Scrum Master
- Isolamento da equipe do restante da equipe
- Ausência do gerente de projetos
- Falta de enfoque em tarefas gerenciais

Não foi ruim nem bom =|
- Layout "abandonado"
- Ferramentas de trabalho

Atividades para melhoria do processo
- Fazer um diagrama de classe (feito)
- Scrum Master passar feedback dos outros projetos e eventos
- Galera comparecer nos outros projetos e eventos
- Fazer o cliente focar no sistema na planning
- Justificativa da falta no trabalho
- Forçar a equipe a ser mais independente do Scrum Master (auto-gerenciável)
- Criar um mecanismo para nos proteger do atraso no pagamento

Monday, February 15, 2010

Comandos mais usados do svn

Estou criando esta lista pra gente ter sempre à mão os comandos mais usados do svn no terminal, de modo simples e compacto.

* Para mais comandos e detalhes: http://www.tigris.org/scdocs/ddUsingSVN_command-line

checkout (co)
add
del
move (mv)
status (st)
diff
log
revert
update (up)
resolved
commit (ci)


Esteja na pasta que foi realizado o checkout para executar os comandos.

checkout
Baixa o projeto
svn co http://svn.address.com/trunk dest_folder --username user

add
Adiciona um novo arquivo ao versionamento
svn add file

del
Remove um arquivo do versionamento
--keep-local mantém o arquivo localmente, porém fora do versionamento
svn del file --keep-local

moveRenomeia ou move um arquivo no versionamento (deletando o antigo e adicionando o novo)
svn mv orig dest

status
Visualiza se um arquivo será ou foi adicionado, deletado, ou modificado localmente ou no repositório
-u para ver modificações do repositório
svn st -u

diffVisualiza as alterações feitas no arquivo
svn diff file

logVisualiza a mensagem de commit do arquivo
svn log file

revertReverte a alteração local feita no arquivo
svn revert file

update
svn up

resolvedRemove o status de conflito do arquivo
svn resolved file

commitEnvia as alterações para o repositório
svn ci -m message

Tuesday, December 8, 2009

Resumão OSGI

http://www.springsource.org/training/osgi/online

Spring - DM Server -> Dinamic Modules Server

1-OSGi -> Sistema de modularização dinâmica para Java -> Modularização de verdade

Modular:
-Projetos (módulos), que são chamados de Bundles
-JAR files com meta-data
-Baseado em pacotes
-Versionamento de pacotes e bundles

Dinâmico:
-Adicionar, remover, startar e parar bundles em runtime
-Usa serviços compartilhados para compartilhar objetos, não apenas tipos

"Bundles usam JAR Manifest para meta-data" -> a configuração é feita no Manifest.mf dentro do META-INF

Por default um bundle não consegue enxergar as classes dos outros

Para que um suas classes (tipos) fiquem disponíveis para os outros bundles é necessário exportar seus pacotes

BOAS PRÁTICAS
-Separe as interfaces das implementações
*Coloque-os em pacotes diferentes
*Exporte apenas as API públicas e esconda os detalhes
*Exponha as implementações como serviços
-Versione seus pacotes
*Libere várias versões no mesmo runtime
*Clientes pegam a versão que eles precisarem

Para ter acesso aos tipos dos outros bundles é necessário importar os pacotes disponíveis (você pode especificar um range da versão que quer usar. Ex: "[1.0.0,2.0.0)" - incluindo a 1 e excluindo a 2)

Os containers OSGi têm um pequeno core e são leves
-Equinox (RI - eclipse)
-Apache Felix
-Knoplerfish

Bundles são instalados no container OSGi e têm um lifecicle
-Installed (faltando dependências)
-Resolved (parado, mas com as dependências satisfeitas)
-Starting
-Started (serviços disponíveis)
-Stopping
-Uninstalled (sai no restart)

Você deve disponibilizar os tipos (interface) através do manifest.mf e deve exportar os serviços em uma classe que estende org.osgi.framework.
BundleActivator.

Para utilizar o serviço você deve importar, no manifest.mf a classe que está disponível e, em um BundleActivator, recuperar a instância do serviço

2-OSGi + Spring

Simplifica o uso do OSGi através do applicationContext

Os arquivos do Spring ficam em META-INF/spring

namespace osgi

Você usa o bean de outro bundle como dependência e o Spring injeta (osgi:reference)

O Spring disponibiliza o serviço para você (osgi:service)

BOAS PRÁTICAS
-Separar arquivos normais de configuração do Spring dos arquivos de configuração do Spring-DM

3-Enterprise OSGi

OSGi não suporta aplicações web, então a Spring implementou isto no seu servidor DM

Não possui nenhuma das funcionalidades de EJB, JNDI, etc..

4-Modularização da aplicação

-Vertical
*Por funcinalidade
°Pedidos, Pagamentos, Vendas...
-Horizontal
*Por camadas
°Web, Repositório, Serviço...

Compartilhar infa-estrutura faz sentido
-DataSources
-TransactionManager
-JMS

Qual o tamanho de um Bundle?
-Responsabilidade definida
-Alta coesão
-Baixo acoplamento

Modularização horizontal tende a acoplar os módulos

5-Sumário

OSGi modulariza de verdade dinamicamente

Muitos benefícios em potencial, mas não são fáceis de se conseguir

OSGi é uma área que ainda está no início da evolução (2008) e novos produtos e padrões estarão surgindo