Estudo para certificação – Capítulo 05

Esse é a quinta parte de uma série de posts que irei fazer.
Nesses posts, vou colocando um resumo ou talvez até mesmo trechos na íntegra do livro: Certificação Sun para Programador Java 6 da Kathy Sierra e Bert Bates.

Obs: Caro leitor, você não deve ter como base para uma certificação Java apenas a leituras desses meus resumos em meu blog. É de suma importância a leitura por completo do livro, bem como a realização de alguns simulados.

Capítulo 5 – Controle de Fluxo, Exceções e Assertivas.

1) Escreve o Código Usando Instruções If e Switch
– O único argumento válido para uma instrução if é um valor booleano.
– Cuidado com atribuições booleandas (=) que podem ser confundidas com testes de igualdade booleano (==).
boolean x = false;
if(x = true) {} //Uma atribuição, então x sempre será true!

– As instruções switch podem avaliar somente os tipos de dados byte, short, int e char.
– A palavra-chave default deve ser usada em uma instrução switch se você quiser executar um código quando nenhum dos valores das instruções case coincidir com o valor condicional.
– O bloco default pode ser inserido em qualquer local do bloco switch.

2) Escrevendo o Código Usando Loops
– Uma instrução ‘for’ básica possui três partes: a declaração e/ou inicialização, a avaliação booleana e a expressão de iteração.
– Se uma variável for incrementada ou avaliada dentro de um loop ‘for’ básico, terá que ser declarada antes do loop ou dentro da declaração do loop for.
– Você pode inicializar mais de uma variável na primeira parte da declaração do loop ‘for’ básico; cada inicialização de variável tem que ser separada por uma vírgula.
– Um foreach tem duas partes, a declaração e a expressão.
– Com um foreach, a expressão é o array ou coleção através do qual você deseja fazer o loop.
– Com um foreach, a declaração é a variável do bloco, cujo tipo é compatível com os elementos do array ou coleção, e essa variável contém o valor do elemento para iteração em questão.
– O loop ‘do-while’ entrará no corpo do loop pelo menos uma vez, mesmo se a condição do teste não for atendida.

3) Usando break e continue
– Se a instrução break ou continue for rotulada,ela fará com que uma ação semelhante ocorra no loop rotulado e não no loop mais interno.

4) Manipulando Exceções
– As exceções ‘verificadas’ incluem todos os subtipos de Exception, excluindo as classes que herdam de RunTimeException.
– As exceções verificadas estão sujeitas à regra de manipulação ou declaração; qualquer método que puder lançar uma exceção verificada(incluindo os métodos que chamam outros métodos capazes de realizar essa tarefa) deve declará-la usando a palavra-chave throws ou manipulá-la com um bloc try/catch apropriado.
– Se você usar o bloco opcional finally, ele sempre será chamado, independente de uma exceção do bloco try correspondente ser ou não lançada e de uma exceção lançada ser ou não capturada.
– As exceções não capturadas serão propagadas para baixo na pilha de chamadas, a partir do método em que a exceção foi lançada e terminando no primeiro método que tiver um bloco catch.
– Você pode criar suas próprias exceções, geralmente estendendo Exception ou um de seus subtipos.
– Todos os blocos catch devem ser ordenados do mais específico ao mais geral.

5) Trabalhando com o Mecanismo de Assertivas
– As assertivas lhe fornecerão uma maneira de testar suas suposições durante o desenvolvimento e a depuração.
– As assertivas geralmente são habilitadas durante o teste, mas desabilitadas durante a implantação.
– Não use assertivas para validar argumentos de métodos públicos.
– Use assertivas – mesmo em métodos public – para garantir que um bloco de código específico nunca seja alcançado.


Principal referência:

SIERRA, Kathy; BATES, Bert. Certificação Sun para Programador Java 6 – Guia de estudo – SCJP EXAME 310-065. Rio de Janeiro: Alta Books Editora, 2011.

Não deixem de verificar os próximos capítulos.
Valeu pessoal!

Estudo para certificação – Capítulo 04

Esse é a quarta parte de uma série de posts que irei fazer.
Nesses posts, vou colocando um resumo ou talvez até mesmo trechos na íntegra do livro: Certificação Sun para Programador Java 6 da Kathy Sierra e Bert Bates.

Obs: Caro leitor, você não deve ter como base para uma certificação Java apenas a leituras desses meus resumos em meu blog. É de suma importância a leitura por completo do livro, bem como a realização de alguns simulados.

Capítulo 4 – Operadores

1) Operadores de Comparação
– Os operadores de comparação sempre resultam em um valor booleano.
– Ao comparar variáveis de referência, == retorna true somente se ambas as referências apontarem para o mesmo objeto.

2) Operador instanceof
– É utilizado com variáveis de referência e verifica se o objeto é de um tipo específico.
– Para interfaces, um objeto passa no teste instanceof se alguma de suas superclasses implementar a interface do lado direito do operador instanceof.

3) Operadores Aritméticos
– O operador resto (%) retorna o resto de uma divisão.
– As expressões são avaliadas da esquerda para a direita.
– Os operadores *,/ e % têm maior precedência do que + e -.
– Se um dos operandos for uma String, o operador + concatenará os operandos.

4) Operadores de Incremento/Decremento
– O operador pré-fixado será executado antes do valor ser usado na expressão.
– O operador pós-fixado será executado depois que o valor for usado na expressão.
– O valor das variáveis final não pode ser incrementado ou decrementado.

5) Ternário
– Retorna um entre dois valores baseando-se nos casos de uma expressão booleana ser true ou false.

6) Operadores Lógicos
– O operador && não avaliará o operando direito se o esquerdo for false.
– O operador || não avaliará o operando direito se o esquerdo for true.
– Os operadores & e | sempre avaliam os dois operandos.


Principal referência:

SIERRA, Kathy; BATES, Bert. Certificação Sun para Programador Java 6 – Guia de estudo – SCJP EXAME 310-065. Rio de Janeiro: Alta Books Editora, 2011.

Não deixem de verificar os próximos capítulos.
Valeu pessoal!

Estudo para certificação – Capítulo 03

Esse é a terceira parte de uma série de posts que irei fazer.
Nesses posts, vou colocando um resumo ou talvez até mesmo trechos na íntegra do livro: Certificação Sun para Programador Java 6 da Kathy Sierra e Bert Bates.

Obs: Caro leitor, você não deve ter como base para uma certificação Java apenas a leituras desses meus resumos em meu blog. É de suma importância a leitura por completo do livro, bem como a realização de alguns simulados.

Capítulo 3 – Atribuições

1) Pilha e Heap
– As variáveis locais(variáveis de métodos) residem na pilha.
– Os objetos e as suas variáveis de instâncias residem no heap.

2) Literais e Conversão(cast) de Tipos Primitivos
– Os literais inteiros podem ser decimais, octais ou hexadecimais.
– Os literais para longs terminam com L ou l.
– Os literais para float terminam com F ou f, os double terminam com um dígito, com D ou d.
– Os literais para char são um único carácter dentro de aspas simples.

3) Escopo
– O escopo refere-se ao tempo de vida de uma variável.
– Variáveis estáticas vivem basicamente pelo mesmo tempo que as suas classes.
– Variáveis de instância vivem pelo mesmo tempo que os seus objetos.
– Variáveis locais vivem pelo mesmo tempo que os seus métodos na pilha; entretando, se o método chamar outro método, elas ficam temporariamente indisponíveis.
– Variáveis de bloco (p. ex. em um for ou em um if) vivem até a conclusão do bloco.

4) Atribuições Básicas
– As expressões com tipo inteiro sempre geram um resultado com o tamanho de int, nunca menor.
– Os números de ponto flutuante são implicitamente doubles(64 bits).
– Atribuições compostas (p.ex. +=) realizam uma conversão(cast) automático.
– Uma variável de referência armazena os bits que são usados para se referir a um objeto.
– As variáveis de referência podem referir-se a subclasses do tipo declarado, mas não a superclasses.
– Ao se criar um novo objeto, três coisas acontecem:
– Cria-se uma variável de referência do tipo do objeto.
– Cria-se um novo objeto.
– Atribui-se o objeto criado à variável de referência.

5) Utilizando Variável ou Elemento de Array que não tenha sido Inicializado ou Atribuído
– Quando um array de objetos for instanciado, os objetos do array não serão instanciados automaticamente, mas todas as referências receberão o valor padrão null.
– Quando um array de tipos primitivos for instanciado, todos os elementos receberão seus valores padrão.
– As variáveis locais/automáticas/de método nunca recebem um valor padrão. Se você tentar usar uma antes de inicializá-la, receberá um erro do compilador.

6) Passando Variáveis Para os Métodos
– Os argumentos dos métodos são sempre cópias.
– Os argumentos dos métodos nunca são objetos reais(podem ser referências a objetos).

7) Declaração, Construção e Inicialização de Arrays
– Os arrays podem conter tipos primitivos ou objetos, mas o array propriamente dito sempre será um objeto.
– Os arrays multidimensionais são apenas arrays compostos por outros arrays.
– Um array de tipos primitivos aceitará qualquer valor que possa ser promovido implicitamente ao tipo declarado para o array. Por exemplo, uma variável byte pode ser inserida em um array de int.
– Um array de objetos pode conter qualquer objeto que seja uma subclasse ao tipo declarado no array. Por exemplo, se Horse estender a classe Animal, então o objeto Horse poderá ser inserido em um array de animais.
– Se você atribuir um array a uma referência de array já declarada, o array terá que estar na mesma dimensão da referência ao qual for atribuído.
– Pode ser atribuído um array de um tipo a uma referência de array já declarada de um de seus supertipos.

8) Blocos de Inicialização
– Os blocos de inicialização estáticos rodam uma vez, quando a classe é carregada pela primeira vez.

9) Usando Wrappers
– As classes Wrappers estão correlacionadas aos tipos primitivos.
– Os Wrappers têm duas funções principais:
– Encapsular tipos primitivos para que possam ser manipulados como objetos.
– Fornecer métodos utilitários para tipos primitivos(geralmente conversões).
– Os construtores wrapper podem usar uma String ou um tipo primitivo, exceto para Character, que só pode usar um tipo char.
– Os métodos importades em wrapper são:
– xxxValue(): Retorna um tipo primitivo.
– parseXxx(): Usa String de parâmetro, retorna um tipo primitivo.
– valueOf(): Usa String de parâmetro, retorna um objeto encapsulado.

10) Boxing
– O recurso de boxing lhe permite converter tipos primitivos em wrappers ou converter wrappers em tipos primitivos automaticamente.

11) Sobrecarga Avançada
– Não pode ampliar/transformar de um tipo wrapper para outro(É-UM falha).
– Não pode ampliar e depois fazer boxing(Um int não pode se tornar um Long).
– Você pode fazer boxing e depois ampliar. (Um int pode se tornar um Object, através de um Integer)

12) Coleta de Lixo
– A finalidade da coleta de lixo é excluir objetos que não possam ser alcançados, liberando memória.
– Um objeto está qualificado para a coleta quando nenhuma thread ativa consegue alcançá-la.


Principal referência:

SIERRA, Kathy; BATES, Bert. Certificação Sun para Programador Java 6 – Guia de estudo – SCJP EXAME 310-065. Rio de Janeiro: Alta Books Editora, 2011.

Não deixem de verificar os próximos capítulos.
Valeu pessoal!

Estudo para certificação – Capítulo 02

Esse é a segunda parte de uma série de posts que irei fazer.
Nesses posts, vou colocando um resumo ou talvez até mesmo trechos na íntegra do livro: Certificação Sun para Programador Java 6 da Kathy Sierra e Bert Bates.

Obs: Caro leitor, você não deve ter como base para uma certificação Java apenas a leituras desses meus resumos em meu blog. É de suma importância a leitura por completo do livro, bem como a realização de alguns simulados.

Capítulo 2 – Orientação a Objetos

1) Encapsulamento, relacionamento É-UM e TEM-UM
– O encapsulamento ajuda a ocultar a implementação por trás de uma interface(ou API).
– O código encapsulado fornece dois recursos: As variáveis de instâncias são mantidas protegidas e os métodos getters e setters fornecem acesso a essas variáveis de instância.
– O relacionamento É-UM refere à herança.
– O relacionamento TEM-UM significa que a instância de uma classe ‘tem uma’ referência à instância de outra classe.

2) Herança
– A herança é um mecanismo que permite que uma classe seja uma subclasse de outra, e, dessa forma,herdar variáveis e métodos da superclasse.

3) Polimorfismo
– Uma variável de referência é sempre de um só tipo imutável, mas ela pode referer-se a um subtipo do objeto.
– O tipo da variável de referência (não o tipo do objeto) determina quais métodos poderão ser chamados.
– As chamadas polimórficas a métodos se aplicam apenas a métodos de instâncias subscritos.

4) Sobrescrita e Sobrecarga
– Os métodos podem ser sobrescritos(Override) ou sobrecarregados(overload), os construtores podem ser sobrecarregados, mas não sobrescritos.
– Os métodos abstract devem ser sobrescritos pela primeira subclasse concreta.
– Os métodos final não podem ser sobrescritos.
– Métodos privates não podem ser herdados, logo, não podem ser sobrescritos.
– Sobrecarga significa reutilizar o mesmo nome de método, mas com argumentos diferentes.
– O polimorfismo é aplicável à sobrescrita e não à sobrecarga.

5) Conversão(casting) de Variáveis de Referência
– Downcast: se você tiver uma variável de referência que aponte para um objeto de um subtipo, poderá atribuí-la a uma variável de referência do subtipo. Você precisa fazer um cast explícito para isso, e o resultado é que você pode acessar os membros do subtipo com essa nova variável de referência.
– Upcast: você pode atribuir uma variável de referência a uma variável de referência de um supertipo explicitamente ou implicitamente. Essa é uma operação inerentemente segura porque a atribuição restringe as capacidades de acesso da nova variável.

6) Implementando uma Interface
– Quando você implementa uma interface, está cumprindo o seu contrato.
– Uma mesma classe pode implementar várias Interfaces.

7) Tipos de Retorno
– Os métodos sobrecarregados podem modificar os tipos de retorno, os métodos sobrescritos não podem, exceto no caso de retornos covariantes.
– Para métodos com tipo de retorno primitivos, pode ser retornado qualquer valor que possa ser convertido implicitamente para o tipo de retorno.
– É permitido que você use simplesmente return em qualquer método com um tipo de retorno void, para interromper um método antes da sua finalização.
– Métodos com um tipo de retorno que é uma referência a um objeto podem retornar um subtipo.
– Métodos com um tipo de retorno que é uma interface podem retornar qualquer implementador.

8) Construtores e Instanciação
– A execução do construtor ocorrerá da maneira a seguir:
– O construtor chamará o construtor de sua superclasse, que chamará o construtor de sua superclasse, e assim por diante, até alcançar o construtor do Object.
– O construtor de Object será executado, retornando em seguida ao construtor chamador, que será processado até sua conclusão, e por sua vez retornará ao construtor que o chamou, dando prosseguimento a essa sequência até a execução do construtor da instância que estiver sendo criada.
– Os construtores podem usar qualquer modificador de acesso.
– A primeira instrução de todo construtor de ser uma chamada a super() ou this().
– As classes abstract possuem construtores que são chamados quando uma subclasse concreta é instanciada.
– As interfaces não têm construtores.

9) Static
– Use métodos static para implementar comportamentos que não sejam afetados pelo estado de quaisquer instâncias.
– Use variáveis static para armazenar dados que sejam específicos à classe, em vez de à instância.
– Métodos static não podem ser sobrescritos, mas podem ser redefinidos.

10) Acoplamento e Coesão
– Acoplamento refere-se ao nível em que uma classe conhece ou usa membros de uma outra classe.
– O baixo acoplamento é o estado desejável para classes bem encapsuladas, que minimizam as referências umas às outras e limitam a extensão do uso da API.
– A coesão refere-se ao nível em que uma classe tem um único e bem definido papel ou responsabilidade.


Principal referência:

SIERRA, Kathy; BATES, Bert. Certificação Sun para Programador Java 6 – Guia de estudo – SCJP EXAME 310-065. Rio de Janeiro: Alta Books Editora, 2011.

Não deixem de verificar os próximos capítulos.
Valeu pessoal!

Estudo para certificação – Capítulo 01

Esse é a primeira parte de uma série de posts que irei fazer.
Nesses posts, vou colocando um resumo ou talvez até mesmo trechos na íntegra do livro: Certificação Sun para Programador Java 6 da Kathy Sierra e Bert Bates.

Sei que hoje a certificação está voltada para a versão Java 8, mas do mesmo modo, grande parte dos conceitos da linguagem Java, continua a mesma.
Eu havia feito esses resumos há algum tempo, porém, não havia recebido o retorno da Editora para disponibilizar em meu blog. Após ter recebido, editei os mesmos e acabei deixando-os de publicar, dando preferência para temas relacionados a Android.
Volto agora para publicas todos esses resumos e espero que possa ajudar muitos devs iniciantes que queiram ver alguns detalhes da linguagem, bem como os devs que estão a mais tempo na área, e que acabam esquecendo um ou outro conceito. Do modo geral, aproveitem! =D

Obs: Caro leitor, você não deve ter como base para uma certificação Java, apenas a leituras desses meus resumos em meu blog. É de suma importância a leitura por completo do livro, bem como a realização de alguns simulados.

Capítulo 1 – Declarações e Controles de Acesso

1) Identificadores
– Os métodos JavaBeans devem ser nomeados usando-se camelCase e, dependendo do propósito do método, devem começar com set, get, is, add ou remove.

2) Regras de Declaração
– Um arquivo de código-fonte só pode ter uma classe pública.
– O arquvivo só pode ter uma instrução package, porém, várias de import.
– O arquivo pode ter mais de uma classe não pública.

3) Modificadores de Acesso a Classe
– Há três modificadores de acesso: public, protected e private.
– Há quatro níveis de acesso: public, protected, default e private.
– As classes só podem ter acesso public ou default.

4) Modificadores de Classe(não referentes a acesso)
– Uma classe não pode ser final e abstract.
– Uma classe final não pode ter subclasse.
– Uma classe abstract não pode ser instanciada.
– Uma classe com somente um método abstract significa que a classe inteira deve ser abstract.
– A primeira classe concreta a estender uma classe abstract terá que implementar todos os métodos abstracts.

5) Implementação de Interfaces
– As interfaces são contratos que definem o que a classe poderá fazer, mas não dizem nada sobre a maneira pela qual ela deverá fazê-lo.
– Uma interface só pode ter métodos abstracts.
– Os métodos das interfaces são, por padrão, public e abstract.
– As interfaces podem ter constantes, que são sempre public, static e final.
– A classe só pode estender uma classe, porém, pode implementar várias interfaces.
– As interfaces podem estender uma ou mais interfaces.

6) Modificadores de Acesso a Membros
– this sempre referenciará o objeto que estiver sendo executado no momento.
– Os membros private só podem ser acessados por um código da mesma classe.
– Os membros private não podem ser herdados.
– Os membros default só podem ser acessados por outras classes do mesmo pacote.
– Os membros protected podem ser acessados por outras classes do mesmo pacote, além de subclasses, independente do pacote.

7) Variáveis Locais
– Não podem ter modificadores de acesso.
– final é o único modificador disponível para variáveis locais.
– Devem ser inicializadas antes do uso.

8) Outros Modificadores – Membros
– Os métodos final não podem ser substituídos em uma subclasse.
– Os métodos abstract terminam com ponto-e-vírgula.
– O modificador synchronized só é aplicado a métodos e a blocos de código.
– O modificador native só é aplicado a métodos.
– O modificador strictfp só é aplicado a classes e métodos.

9) Métodos com var-args
– Aceita zero a vários argumentos.
– Só pode haver um parâmetro var-arg por método.
– O parâmetro var-arg deve vir por último na assinatura de um método.

10) Declarações de Variáveis
– As variáveis de instância não podem ser declaradas com abstract, synchronized, native ou strictfp.
– As variáveis final não podem ser reinicializadas, uma vez que tiverem um valor atribuído.
– As variáveis final devem ser inicializadas antes que a execução do construtor seja concluída.
– Os modificadores transient e volatile só podem ser aplicados a variáveis de instância.

11) Declarações de Arrays
– É sempre um objeto.
– Um array de objetos pode conter qualquer objeto que passe no teste de IS-A(É UM).

12) Variáveis e Métodos Estáticos
– Existe apenas uma cópia de uma variável e/ou classe estática, que é compartilhada por todas as instâncias.
– Métodos static não têm acesso direto a métodos não estáticos.

13) Enums
– Pode ser declarado fora ou dentro de uma classe, mas não é um método.
– Especifica uma lista de valores constantes.
– Podem conter construtores, métodos, variáveis e corpo de classes constantes.

Principal referência:

SIERRA, Kathy; BATES, Bert. Certificação Sun para Programador Java 6 – Guia de estudo – SCJP EXAME 310-065. Rio de Janeiro: Alta Books Editora, 2011.

Não deixem de verificar os próximos capítulos.
Valeu pessoal!

Relatório – Os Princípios de UX para Aplicativos em Dispositivos Móveis

Hoje, aproveitei para estudar um pouco sobre UX para aplicativos para dispositivos móveis.
Ao buscar materiais na internet, encontrei um excelente documento produzido pela Google.
Com este documento, especialistas apresentaram “a estruturação de conversões otimizadas, customizadas para aplicativos em dispositivos móveis (sem considerar aplicativos em tablets).”

Pois bem, qual a minha intenção de fazer esse post?
Gostaria apenas de compartilhar pontos que achei cruciais neste documento.
Todo o texto a seguir, poderá ser encontrado nesse documento da Google. Portanto, recomendo muito ler este documento inteiramente.
O documento possui versão em português e inglês.

1) Telas de abertura, dicas e técnicas de ativação

“A primeira impressão conta, e a tela de abertura
(splash screen) oferece uma janela pequena, mas
crucial para engajar o usuário com a sua proposta.
Porém, nunca deixe os usuários esperando.”

“Opções de Dicas/Ajuda ou uma sequência de
Técnicas de Ativação só devem ser implementadas
se necessário – para não interromper os usuários –
porém, quando utilizadas de maneira adequada,
essas funções podem guiar o usuário na sua
experiência inicial e adesão.”

2) Tela inicial e Navegação

“A tela inicial de um aplicativo deve proporcionar ao
usuário jornada(s) e funcionalidades para completar
suas tarefas prioritárias, além de proporcionar
conteúdo que atende as suas necessidades e
expectativas.”

“A navegação deve ser clara, com foco
na tarefa e lógica.”

“Aplicativos não são sites e NÃO precisam de um
logo de marca em todas as telas que fazem o
link para a tela inicial.”

“[…] reforce a sua identidade de maneira sutil. Por
exemplo, em vez de usar o nome completo da
sua marca, utilize um ícone ou uma cor […]”

“Aplicativos devem ser claros e as
jornadas/tarefas devem ser óbvias, portanto, a marca
deve priorizar o conteúdo e as funcionalidades
primárias e colocar todo o resto fora da tela […]”

“Na primeira utilização do aplicativo, o menu lateral (Navigation drawer) – se o aplicativo utilizar esse componentes –
pode ser revelada de maneira padronizada para apresentar
a variedade de conteúdo e a organização antes que
o usuário inicie a navegação.”

3) Cadastro, Log-In e Permissões

“Para proporcionar uma experiência
para o usuário com o menor número de barreiras
para a conversão, os aplicativos móveis devem:

– Proporcionar uma jornada sem a necessidade de log-in.
– Solicitar o cadastro do usuário “apenas” quando ele agrega valor e mesmo assim…
– Solicitar o menor número de dados possível.
– Apresentar afirmações claras de benefícios.”

“Se o aplicativo solicita o cadastro, o usuário
pode escolher continuar como visitante.”

“Os usuários devem ser apresentados a diversas
opções de cadastro, como nome de usuário/senha
e cadastro através de redes sociais.”

“Os usuários não devem ter que fazer o log-in toda vez
que acessarem o aplicativo após a conclusão do
cadastro porque uma das grandes diferenças entre
um site e um aplicativo é que este oferece uma
experiência prolongada para proporcionar
conveniência e personalização contínua.”

4) Busca

“Se a busca for uma função primária do seu aplicativo,
destaque-a, já que esse recurso pode ser a rota mais
rápida de descoberta para os usuários com alta
intenção de conversão.”

“Ofereça sugestões automáticas (ou resultados de
textos predeterminados) o mais rápido possível,
como, por exemplo, depois que o terceiro caractere
for digitado, para agregar valor imediato e reduzir os
esforços de digitação dos usuários.”

“Os primeiros resultados de busca devem ser
altamente relevantes”

“Ofereça alternativas quando não houverem
resultados de busca. (nada de becos sem saída)”

“O usuário deve facilmente poder filtrar os
resultados de busca.”

5) Produtos e Serviços

“As telas de produto são onde os usuários fazem
suas decisões de conversão-chave, ex.: adicionar
ao carrinho, adicionar à lista de desejos, reservar
agora, ligar agora, preencher o formulário, etc.
Boas telas de produto em aplicativos permitem
que os usuários concluam a transação
rapidamente, salvem os dados para mais tarde e
compartilhem os itens sobre os quais eles devem
tomar alguma decisão.”

6) Informações pessoais e endereço

“Para usuários recorrentes, as informações
pessoais e o endereço são preenchidos
automaticamente.”

“Para usuários recorrentes, o processo inteiro
da transação ocorre em uma única tela.”

“Usuários recorrentes, cujas informações pessoais, de
endereço e de pagamento já estão armazenadas no
aplicativo, devem ter uma experiência de transação
em uma única tela, onde todos os dados são
preenchidos automaticamente (com opções de
edição) […]”

7) Pagamentos

“Alguns consumidores consideram o pagamento
express/métodos de check-out uma alternativa mais
conveniente do que cartões de crédito e débito ou o
preenchimento manual de informações pessoais e
endereço.”

“Quando usuários de primeira viagem selecionarem
um cartão como a forma de pagamento, a bandeira do cartão
é detectado automaticamente após
o preenchimento dos primeiros quatro dígitos
do cartão (ex.: cartão de débito Visa)”

“Caso seja solicitado um documento de identidade,
será exibida a opção de leitura óptica (ex.: passaporte ou CNH)”

8) Check-out e confirmação

“Maximize a conversão na última etapa do check-out
tomando as seguintes medidas: remova todas as
distrações (tudo que não leve à decisão de
conversão); garanta atendimento ao cliente; ofereça
uma experiência de check-out em uma única tela
para usuários recorrentes; confirme os principais
detalhes da transação; e forneça conteúdo
contextual que agregue valor além da operação
imediata (e que contribua para a retenção).”

“Se o usuário fechar o aplicativo
durante um check-out parcial, ao
reabri-lo, todas as entradas são
restauradas para que ele possa concluir
o processo de forma conveniente.”

9) Self-service, engajamento e satisfação (ou encantamento)

“Durante esta etapa, o foco principal é ser útil,
gerar engajamento e satisfação
(encantamento) para reter consumidores ou
incentivar fidelidade. Isso porque aplicativos
em dispositivos móveis são o ponto de contato
mais adequado para: interações recorrentes e
transações frequentes; clientes e membros
que já são fieis a uma marca; casos de primeira
utilização móvel (que não existiriam sem os
recursos únicos do smartphone); serviços que
alavancam dados ricos e contextuais; etc.”

“Essencialmente, é mais barato reter um
consumidor do que adquirir um novo.”

10) O que NÃO fazer

“Não copie elementos da UI de outras plataformas. (de Android para iOS e vice-versa)”

“Não utilize links sublinhados. (aplicativos utilizam botões e NÃO links)”

“Não direcione os usuários ao navegador (os usuários devem ficar no aplicativo sempre).”

Não farei minha análise sobre questões que abordei aqui. Como comentado no começo deste post, minha intenção, é apenas disseminar este excelente documento criado pela equipe da Google.

Caso descorde de algum ponto que coloquei aqui, por favor, comente aqui para analisarmos.

Apenas relembrando… Não deixem de ler todo o documento no site do Think With Google!

Valeu pessoal!

Livro “O codificador limpo (Clean coder)”

Finalizei a leitura do livro “O codificador limpo – um código de conduta para programadores profissionais”.

Livro tem como autor, Robert C. Martin (Uncle Bob).
Sem dúvida, Uncle Bob é um grande exemplo para todos nós desenvolvedores de software.

E, com este livro, ele tentou passar inúmeras experiências vividas afim de tornar-se um programador “profissional”.
Felizmente, o livro explora bem histórias vividas por Uncle Bob, explicando caso-a-caso.

Porém, algo triste no livro (obs: ao qual, acontece com muitos livros na nossa área..), são os erros em relação a tradução do mesmo.
Sugestão: Tradutores e editoras, avaliem termos técnicos ao traduzirem. Em inúmeros casos, ao meu ver, deve-se permanecer em inglês o termo.

Enfim, citarei alguns trechos que identifiquei serem interessantes:

É bem mais fácil não ser profissional. Não profissionais não podem ser responsabilizados pelos trabalhos que fazem – eles deixam isso para seus empregadores. Se um deles comete um erro, o empregador limpa a bagunça. Mas quando um profissional comete um erro, ele limpa a bagunça.

À medida que amadurece em sua profissão, sua taxa de erro deve diminuir rapidamente em direção à assíntota de zero. Ela jamais chegará a zero, mas é sua responsabilidade chegar ao mais próximo possível.

Você deve planejar trabalhar 60 horas por semana. As primeiras 40 são para seu empregador. As 20 restantes para você. Durante essas 20 horas restantes, você deve ler, praticar, aprender e, de outro modo, potencializar sua carreira.

Aqui vai uma lista mínima de coisas em que todo profissional de software deve ser proficiente:
– Design patterns: Você deve ser capaz de descrever todos os 24 padrões do livro GOF e ter um conhecimento de trabalho de muitos dos padrões do livro POSA.
– Design principies: Você precisa conhecer os princípios SOLID e ter um bom entendimento de seus principais componentes.
– Metodologias: Você precisa entender XP, Scrum, LEan, Kanban, Waterfall, Análise estruturada e design estruturado.
– Disciplinas: Você precisa praticar TDD, design orientado a objetos, programação estrutural, integração contínua e programação em par.
– Artefatos: Você deve saber como usar UML, DFDs, estrutura de gráficos, Petri Nets, Diagramas e tabelas de transição, gráficos de fluxo e tabelas de decisão.

[…] S meta ao formar uma equipe é dar a ela tempo suficiente para se tornar sólida e então mantê-la como um motor a fim de conseguir que mais projetos sejam feitos.

Estas são as citações que gostaria de apresentar neste post.
Recomendo a leitura deste livro.

Pensando bem, recomendo a leitura de todos materiais de Uncle Bob! =D

Até a próxima!