blog.2solutions.com.br

Java no Ubuntu : Acertando Encoding no Eclipse

Hildebrando — Wed, 15 Oct 2008 15:50:36 +0000

Uma coisa que precisamos nos preocupar quando temos ambientes heterogêneos de desenvolvimento é que em algum momento haverá a troca de dados de uma estação para outra, essa troca pode ser uma simples copia de arquivo ou o acesso a repositorio de arquivos.

Para que essas trocas não levem a problemas de caracteres é preciso que os ambientes de desenvolvimento conversem na mesma lingua.

Padronizando no Eclipse, seguimos a ajuda de http://www.guj.com.br/posts/list/18869.java , o que precisamos fazer é ajustar todas nossas estações para utilizar o mesmo padrão de encoding de arquivo, no caso utilizaremos o ISO-8859-1.

No Eclipse :

Window >> Preferences >> General >> workspace >> Text File Encoding

Feito isso agora funciona perfeito. Todos codificam no mesmo padrão.

Java no Ubuntu : Inicio

Hildebrando — Wed, 15 Oct 2008 15:17:24 +0000

Estamos fazendo um estudo para migrar as estações de desenvolvimento que não são .NET para o Sistema Operacional Ubuntu.

Nosso primeiro requsito é a parte de instalação do JDK no Ubuntu e para isso é preciso intalar o Java e configurar a variavel de ambiente JAVA_HOME.

Instalar o Java, pode ser feito tanto pelo gerenciador de pacotes do Ubuntu quanto fazendo download pelo site da Sun. Se for feito pelo gerenciador a opção que se tem é o OpenJDK e é so fazer um next>next>finish, sem mistério.

Se for baixar do site da Sun (http://java.sun.com) baixe a versão binaria (é a não RPM).

O unico detalhe é que o arquivo não vem executável, para isso :

chmod 777 jdk1.5....

Execute o arquivo

./jdk1.5...

Após a instalação do JDK ser realizada com sucesso o próximo passo é configurar a variável de ambiente.

Para que todos os usuarios acessem essa variavel de ambiente, é preciso adicionar algumas configurações nos arquivos /etc/bash.bashrc e /etc/profile.

As configurações precisam ser feitas nos dois arquivos pois um é para login shel (console) e o outro é login no shel (gnome por exemplo).

export JAVA_HOME=/usr/lib/jdk1.5 export PATH=$JAVA_HOME/bin:$PATH

JPAQL - Filtrando pelo ultimo status de um historico

Hildebrando — Thu, 09 Oct 2008 18:21:51 +0000

Para alguns sistemas toda a alteração que ocorre em uma entidade deve ser armazenada com informações como “quem alterou”, “a data” e “para qual situação mudou”. Podemos representar assim :

1 - Entidade Chamado
2 - Entidade ChamadoHistorico
3 - Entidade Status

public class Chamado { private Integer id; private List chamadoHistoricos; } public class Status { private Integer id; private String descricao; } public class ChamadoHistorico { private Integer id; private Date data; private Chamado chamado; private Status status; }

Na tela que mostra todos os chamados, precisamos retornar uma lista com os chamados e seus ultimos status. Para isso devemos criar métodos na entidade Chamado que retornem seu ultimo status algo como :

@Transient public Status getUltimoStatus(){ Status status = null; if(chamadoHistoricos != null && !chamadoHistoricos.isEmpty()){ for (ChamadoHistorico chamadoHistorico : chamadoHistoricos) { status = chamadoHistorico.getStatus(); } } return status; }

@Transient public Date getUltimaData(){ Date data = null; if(chamadoHistoricos != null && !chamadoHistoricos.isEmpty()){ for (ChamadoHistorico chamadoHistorico : chamadoHistoricos) { data = chamadoHistorico.getData(); } } return data; }

Percorrendo essa lista utilizando JSTL e EL.

Id	Ultima Atualizacao	Status
${chamado.id}	${chamado.ultimaData}	${chamado.ultimoStatus.descricao}

E da parte de JPAQL, posso ter a situação de filtrar apenas os chamados “EM ABERTO” == 1 :

select chamado from Chamado chamado left join chamado.chamadoHistoricos as historico where historico.id in (select max(ch.id) from ChamadoHistorico ch group by ch.fise.id) and historico.status.id = 1

Arquitetura Java 2Solutions (utilizando struts2+spring+jpa)

Hildebrando — Wed, 17 Sep 2008 22:25:42 +0000

Abaixo estou listando um passo-a-passo para a implementação de requisitos de um sistema, utilizando a arquitetura Java da 2Solutions.

Em primeiro lugar, os frameworks que adotamos para o desenvolvimento são :

Struts2 : View e Controller
JPA (Hibernate) : Persistência
Spring : IoC e DI

Os frameworks se relacionam, facilitando o nosso trabalho assim, os trabalhos iniciam assim:

Resumo de Levantamento de requerimentos

A primeira coisa a fazer no desenvolvimento de software é o levantamento/descobrimente de requerimentos. Essas informações são bem armazenadas na forma de diagramas de caso de uso.

A ideia dos casos de uso é ser o mais simples possivel, apenas documentando as funcionalidades, deixando de descreve-las a fundo. O caso de uso deve ser documentado com um usuario e quais funcionalidades do sistema ele ira interagir, por exemplo :

Ator : Gerente de contas
Caso de Uso : Cadastrar novo cliente

Se o caso de uso ‘cadastrar novo cliente’ for um pouco complexo, repare bem, SE for complexo, dai sua lógica deve ser armazenada em um diagrama de atividades. Ou podemos utilizar cenários para armazenar as situações.

Junto a isso pode ser feito protótipos para ser apresentado ao cliente e este levantar mais informações pertinentes. Nesta fase não temos codigo compilado, apenas telas e informações sobre a funcionalidade. Podemos agilizar isso com reunioes, ou com viagens ao codigo e planos de teste.

Modelagem

A medida que as funcionalidades vão sendo descobertas o próximo passo é ir descrevendo as entidades encontradas. Essa descrição pode ser feita direto no banco de dados, ou pode ser feita associando classes.

Na 2Solutions nós fazemos as classes e anotamos seu nome e seus atributos para que as tabelas sejam geradas.

Por tanto o primeiro passo é fazer a modelagem das classes.

Uma forma de verificar se o modelo esta bem feito é criando testes unitários. Teste unitário é apenas garantir que aquela funcionalidade especifica da sua entidade como ‘inserir no banco’ esta funcionando. O ideal é criar para cada entidade testes unitarios de insert, select, update e delete.

Action/Jsp

Depois que suas classes estiverem corretamente modeladas e testadas, dai partimos para as interfaces. Por padrão toda entidade criada pode ser manipulada utilizando interfaces genéricas. Para que isso funcione voce precisa.

1 - Criar o arquivo EntidadeAction no pacote actions, seguindo o modelo de uma action padrão :

public class ClienteAction extends GenericAction { public ClienteAction(GenericService service){ super(service); } }

2 - Com a entidade criada, o próximo passo é fazer as associações no Spring. O Spring é o responsável por cuidar da parte de instanciar objetos e seta-los nas entidades. Com o Spring temos benefícios imediatos como a IoC (Inversion Of Control) e a DI (Dependency Injection)

br.gov.sp.sucen.controledengue.entity.Cliente

3 - Com tudo configurado a sua entidade ja esta com as operações basicas de manipulação prontas.

http://localhost:8080/MeuProjeto/cliente!novo.action
http://localhost:8080/MeuProjeto/cliente!pesquisar.action
http://localhost:8080/MeuProjeto/cliente!salvar.action
http://localhost:8080/MeuProjeto/cliente!remover.action
http://localhost:8080/MeuProjeto/cliente!editar.action
http://localhost:8080/MeuProjeto/cliente!visualizar.action

Personalizando

Procure sempre criar interfaces baseadas nas entidades. Com recursos como AJAX, nós podemos ter uma tela desempenhando varias funções no mesmo ambiente. Por exemplo, se na interface de cadastro de cliente você precisar mostrar uma lista com os vendedores, para selecionar qual o vendedor desse cliente, o processe ficaria assim.

Combo (, por exemplo. Estes campos são mais complexos pois é necessário uma segunda consulta para mostrar os dados no combo, algo como :

Carro <%= collection_select(:carro, :fabricante_id, Fabricante.find(:all), :descricao, {:prompt => true}) %>

JavascriptGeneratorTemplate

Para que voce possivel utilizar o mínimo de javascript para interações Javascript, foi desenvolvido uma forma de estruturar os arquivos em que a unica linguagem envolvida é o Ruby.

Um exemplo clássico é a pagina de listagem, aonde ao clicar em inserir um novo registro, este aparece na listagem sem que haja refresh na tela. Na prática é incluir uma nova linha na tabela através de operações DOM.

Para quem ja trabalhou com manipulação de objetos DOM em algum elemento HTML (tabela por exemplo) sabe que é preciso um pouco de conhecimento (e código) para que fique do jeito que esperamos. Ja com Rails, o templa RJS faz isso de forma que ele é o arquivo que encapsula a lógica de atualização da interface.

O processo fica assim

Arquivo principal : É a pagina contendo a tabela renderizada.
Arquivo include de linha: O trecho que representa cada linha da tabela é um arquivo de inclusão, que sera utilizado pela pagina principal e pelo script RJS
Arquivo script RJS: O método da controller, ao retornar uma pagina, retorna esse arquivo. Por ser uma chamada assincrona, o resultado do processamento desse arquivo é um codigo Javascript gerado pelo RJS.

Ruby On Rails - Dia 3

Hildebrando — Fri, 05 Sep 2008 00:58:11 +0000

Na aula anterior finalizamos a aplicação CRUD. Tomou um certo tempo devido a alguns ajustes de configuração e também porque a cada camada alguns conceitos iam sendo discutidos. Hoje o objetivo foi o estudo aprofundado de ActionRecord e ActionController.

ActionRecord

Existem algumas estratégias para fazer o mapeamento objeto-tabela (ORM), no caso do ActiveRecord uma funcionalidade que o difere de outras implementações (como DAO por exemplo) é o fato de a própria entidade possuir métodos de interação com o banco. Isso faz com que se diminua o numero de classes e se reaproveite os atributos do objeto.

Mas isso é so uma parte. Como a estrutura da linguagem Ruby é tão flexível, é possível ter definições de método de consulta no próprio objeto como por exemplo :

User.find_by_username("login")

Inclusive, dizer que o Rails é um framework ORM eu considero meio equivocado, na verdade o Rails não mapeia as colunas para os atributos, ele adiciona nos objetos as colunas. Toda vez que se pede algo para uma classe, o Rails faz um metadados na tabela associada a insere esses atributos dinamicamente no objeto. Assim, se alguem inserir uma nova coluna na tabela, ela automaticamente sera carregada nos objetos.

Isso remete a um outro assunto discutido em sala, Migration.

Migration

Atualizações em tabelas de banco são muitas. Por mais que se faça um trabalho legal de modelagem, invariávelmente temos que criar colunas, refatorar nomes, ajustas associações e por ai vai. Manter essa documentação de atualizações organizada de forma coerente e prática pode demandar uma intereção custoza na equipe de desenvolvimento/banco. Nisso entra o Migration. Com um padrão de nomenclaturas de arquivo e uma facilidade de comandos, é possível versionar os estados das estruturas e trocar facilmente de uma versão para outra. Bem interessante.

Mas isso não tem a ver só com Rails. Isso tem a ver com a organização da manutenção dos dados da empresa. O legal é que como a linguagem utilizada é Ruby e o framework é o Rails, fica muito mais prático, porém poderia ser utilizado para qualquer equipe em qualquer linguagem/plataforma.

Operações Bulk

Operaçoes em massa são aquelas que alteram varios registros ao mesmo tempo, por exemplo :

update users set ativo = 1

Acessível pelos métodos

User.update_all("ativo = 1") User.destroy_all("ativo = 1")

Eventos - Callbacks

Métodos de callbacks são aqueles invocados quando ocorre determinada situação. No rails eles aparecem nos eventos de interação com o banco. São bem simples de criar e utilizar.

Exemplos :

class User < ActiveRecord::Base before_destroy :manda_email
def manda_email #Manda email para alguém end end

Outros recursos

Para validações ja tem um monte de funções prontas para serem utilizadas, é possível especializar algumas e criar as suas. Muito útil e fácil.

validates_inclusion_of :age , :in => 15..99

Para os acumuladores (count, sum, minimum, etc) também é bem prático e útil.

User.count(:condition => "age > 18")

Um assunto que discutimos muito (e eu sempre me emociono) é da parte de transações. Como eles conseguiram deixar tão simples.

User.transaction do
a1.deposit(100)
a2.withdraw(100)
end

Se der exceção é feito rollback senão commit. E a funcionalidade não para ai, se você quiser que os objetos retornem ao estado anterior do bloco de transação é so :

User.transaction(a1,a2) do
a1.deposit(100)
a2.withdraw(100)
end

Mais um recurso, facil de implementar, porém muito inteligente são as colunas timestamps, que se seguirem a convenção de nomes funcionam assim :

created_on grava a data/hora ao inserir um novo registro
created_at grava a data ao inserir um novo registro
updated_on grava a data/hora ao atualizar o registro
updated_at grava a data ao atualizar o registro

E por ultimo, um recurso que muita gente nem conhece, Lock otimista (Optimistic Lock). Funciona assim, quando consultamos um registro no banco e abrimos seus dados para edição o registro não fica “lockado” para nosso acesso, ele fica disponível para outros fazerem a mesma operação no mesmo registro. Isso ocorre porque em aplicações com muitos usuarios, se houvesse esse lock todos os outros usuarios ficariam esperando o primeiro finalizar, seria a estratégia pessimista, pois ja pensa que se não segurar o registro outro vai na frente e salva antes. Isso pode acontecer, lógico, mas a estratégia implementada é criar uma coluna de versão.
Quando eu consulto um registro, fica a informação da versão que estou editando, se alguem salvar na minha frente vai atualizar a versão, e quando eu for salvar o ambiente de avisa “Olha, alguem ja salvou antes”.
Implementar isso leva um certo tempo de desenvolvimento, porém em rails é so voce criar uma coluna com o nome lock_version.

Da parte do ActionRecord foi isso vamos ao ActionController

ActionController

Para quem esta acostumado com frameworks web, esse é o controlador de fluxo. Vantagens do framework Rails é a facilidade de criação (não tem XMLs nem anotações, somente convenções) e inclusão de actions (métodos que recebem requisições).

Todo método criado na classe Controller pode receber requisição, e o legal é que existe um diretorio específico para cada pagina de cada controlador. É mais ou menos o que acontece na realidade, um controlador acaba “gerenciando” um grupo de paginas específicas do seu contexto.

O interessante é que acessar a pagina de outro controlador, mudar de pagina para retorno em conteudo texto ou verificar se é uma requisição ajax é facil. É abstraido muitos conceitos da parte de troca de mensagens HTTP.

Exemplos:

Para retornar texto

def teste_texto s = "Esse é o texto que sera retornado" render :text => s end

Para retornar uma pagina do mesmo controller

def teste_uma_pagina #Faz algumas operacoes render :action => 'uma_pagina' end

Para retornar uma pagina com mesmo nome do método

def uma_pagina #Faz algumas operacoes end

Para retornar uma página de um outro Controller (adivinham ?)

def teste_mais_complexo #Faz algumas operacoes render :controller => 'loja_virtual' , :action => 'outra_pagina' end

Também existem recursos de verificação, como so deixar executar os métodos que forem por post.

verify :method => :post, nly => [ :destroy , :create , :update], :redirect_to => { :action => :list }
Para configurar os layouts utilizados por esse controler, é so adicionar no inicio do corpo da classe :

layout :loja_virtual_usuario

Para configurar filtros de requisição :

before_filter :valida_usuario def valida_usuario #faz a validacao end

Existem outros recursos como flash[:notice] para o envio de mensagens com tempo de vida da requisiçao, outra funcionalidade é o render para montar as paginas de resposta, tem tambem o rescue para lançar excessão e depois trata-la.

Tanto o assunto de ActionRecord quanto de ActionController foram muito bem trabalhados no livro. Vale a pena dar uma conferida.

Amanhã tem mais.

Ruby On Rails - Dia 2

Hildebrando — Wed, 03 Sep 2008 01:39:54 +0000

Uma palavra que resume bem o dia 2 é a seguinte “atualização”. Eu não estava trabalhando com Ruby +2.0 e infelizmente, o livro também segue a versão mais antiga. O problema é que houveram algumas atualizações que tomaram um pouco do tempo do treinamento, no entanto, não impactaram no resultado final. Finalizar o aplicativo CRUD.

Bem, vamos detalhar algumas dificuldades encontradas. O inicio do desenvolvimento foi focado na modelagem das entidades (Model). Hoje adicionamos métodos de negocio, como um metodo para criptografar senha. Tudo ia muto bem até a hora de gerar os controllers e views.

O comando utilizado para isso é o scaffolding

ruby script/generate scaffolding Car

A listagem resultado do comando mostra que tudo foi gerado, no entanto o conteudo das paginas de listagem (index), edicao, novo e visualização não estão com os campos da entidade. Assim tivemos que fazer tudo na mão. Pelo menos serviu para o pessoal dar uma praticada e ir entendendo uma parte da sintaxe dos controllers e views.

Se você não implementou a entidade model, a sintaxe do scaffolding deve ser

ruby script/generate scaffold Car model:string year:integer preco:float data_compra:datetime

Interessante que agora não é mais gerado as telas com um for pesquisando as colunas e sim, é adicionado os campos diretamente. Isso ajuda pois na realidade ao ajustar as telas o mais comum é retirarmos colunas.

Com o scaffolding executado, a estrutura principal das nossas entidades esta pronto. O que nos resta fazer é irmos as especializando e adicionando outras com funcionalidades não ligadas a uma entidade específica.

Para simularmos essa situação implementamos um requisito de autenticação. Dificilmente você ira participar do desenvolvimento de uma aplicação que não utilize recursos de autenticação (e a maioria ainda precisa de autorização também), e para o treinamento essa funcionalidade tem alguns objetivos didáticos :

1) A interface de login não esta associada a nenhuma entidade e portanto deve ser criada a parte
2) O controlador precisa de método fora do padrão CRUD, como login e logout
3) Na logica de autenticação é preciso criar um metodo que saiba o que fazer com o login/senha, e assim trabalhamos com esses métodos de negócio nas entidades (User). Esse método além de realizar manipulação de banco de dados, tambem trabalha um pouco com a sintaxe da linguagem.
4) No controlador (LoginController) manipulamos dados da sessão
5) No controlador manipulamos dados no flash[:notice], especifico para armazenar dados durante uma requisição
6) O redirecionamento das paginas (login com sucesso ou nao)

E tivemos tempo de trabalhar um pouco com filtros. É um assunto com uma leve carga conceitual, porém com uma implementação muito simples.

Resumindo nossos trabalhos, podemos destacar uma revisão em conceitos de OO, pratica na linguagem Ruby, os geradores de codigo script/generate e algumas funcionalidades interessantes como sessao, flash e filtros.

Um outro recurso interessante é para quem não gosta de geradores de código (eu). Ao invés de deixar os controladores gerados pelo scaffolding com todas as assinaturas de métodos, adicione a linha no corpo da sua classe :

scaffold :car

Assim seu controller “ganha” as funcionalidades CRUD padrão, e o numero de linhas de código cai mais ainda.

Observação : Em alguns projetos Java que eu trabalho nós criamos Actions (strus2) genéricas com Jsp genéricos também, assim, para situações em que o CRUD nao precisa de nenhuma especialização não é preciso codificar as telas.

Nos próximos dias vamos aprofundar o assunto em cada tópico.

Até amanhã

Ruby On Rails - Dia 1

Hildebrando — Tue, 02 Sep 2008 13:09:49 +0000

Para servir de repositorio de dados do conteudo passado no treinamento Ruby On Rails em Sao Luiz - MA eu resolvi criar um post especifico de cada dia de treinamento. O treinamento é baseado no livro do Fabio Akita, que além de ter uma ordem cronológica didática, também tem exemplos práticos. Cada aluno tem seu exemplar do livro para acopanhamento. Vou aproveitar para detalhar o que levantamentos de util nas aulas pois pode ser útil para mais alguém.

No inicio do treinamento ja discutimos sobre a necessidade de alguns conceitos fundamentais para um melhor aproveitamento do treinamento.

Em primeiro lugar, para mergulhar de cabeça em Ruby On Rails, você TEM que ter alguns pré-requisitos :

1) conceitos de modelagem de dados : Não precisa ser expert em nenhum banco, no entanto, saber criar tabelas e relacionamentos é fundamental.
2) conceito de orientação a objetos : Muitos recursos do Ruby e do Rails exigem que o desenvolvedor entenda bem de classes e objetos. Se você enxerga classes apenas como o mal necessário para criar objetos, acho melhor voce dar uma estuda nestes conceitos. De uma revisada em polimorfismo, herança e encapsulamento (pilares da OO).
3) Familiaridade com ambiente web : O foco do treinamento é em um framework web, e por tanto, você deve ter noção de como funciona aplicações web. Servidor web, provendo paginas estáticas ou dinâmicas, processando requisições de clientes, request, response, sessão e conceitos de segurança ajudam.
Atende os requisitos ? Então vamos la.

Ambiente

Ruby é uma linguagem interpretada, e por tanto você precisa do interpretador. Acessa o site http://www.ruby-lang.org e baixa o binario para o seu sistema operacional. Vai vir muito mais coisa que o interpretador, com destaque para o “ri” (consultar a documentação das classes) e “rdoc” para gerar documentação

Se for tudo no Next >> Next >> Finish sera criado um diretorio Ruby e o sub-diretorio Bin ja vai estar configurado no path.

Abra o console (prompt) e execute “ruby” de qualquer diretorio. Assim ja validamos se a instalação foi executada com sucesso.

Bem, o Ruby é muito legal e eu recomendo uma leitura mais avançada na linguagem, no entanto, para nosso treinamento as coisas vão sendo passadas sob demanda. Por tanto vamos ao Rails.

gem update --system gem install rails --include-dependencies

A instalação de pacotes adicionais é feita utilizando esse gerenciador “gem”

Começando meu projeto

Depois de instalado é hora de criarmos o nosso projeto:

rails meuprojeto

Todos os diretorios do projeto são criados e cada um tem a sua função específica.

Vamos iniciar configurando o acesso ao banco de dados.

Seguimos o wiki do Rails para configurar o acesso ao SQL Server

http://wiki.rubyonrails.org/rails/pages/HowtoConnectToMicrosoftSQLServer

Essa atividade foi mais demorada, pois tivemos que pesquisar esse driver e seguir o tutorial. Fizemos o teste ja executando um comando do rake para fazer a carga no banco com as nossas tabelas.

rake db:schema:load

começamos a construção das nossas entidades (model)

ruby script/generate model User ruby script/generate model Task

e interagimos com o banco de dados através do ambiente de execução do Rails

ruby script/console

Exemplos

u = User.new u.username = "teste" u.full_name = "Teste de usuario" u.hashed_password = "12313" u.save

Com a parte de integração com o SQL Server funcionando, fechamos a parte de preparação do ambiente. Uma duvida que surgiu foi referente a documentação.

Para visualizar a documentação de uma classe podemos utilizar o ri.

Exemplo :

ri String

ou, especificando o método

ri String#upcase

Mas quando existe mais de um metodo com essa assinatura significa que o Ri esta encontrando essa classe#metodo em mais de uma fonte de documentacao.
Nesses casos você precisa especificar qual documentação deve ser pesquisada.

Exemplo :

ri --system String#upcase

As opções disponíveis são :

By default ri searches for documentation in the following
directories:

c:/ruby/share/ri/1.8/system
c:/ruby/share/ri/1.8/site
C:\Users\hfurlan/.rdoc
c:/ruby/lib/ruby/gems/1.8/doc/*/ri

Specifying the –system, –site, –home, –gems or –doc-dir
options will limit ri to searching only the specified
directories.

Do primeiro dia foi (resumidamente) isso.

Amanhã tem mais.

High-Tech e High-Touch

Hildebrando — Sat, 11 Aug 2007 12:06:00 +0000

Se você é da área de tecnologia (ou não) ja deve ter ouvido a palavra High-Tech associada a um computador, acessório, veículo ou midia. A tradução fiel para este termo é algo altamente tecnológico.

Já a palavra High-touch significa algo altamente assessorado, com uma atenção e atendimento especial. Por exemplo, se uma pessoa te faz uma visita é uma interação high-touch pois você esta em contato direto com o individuo.

Agora, o que as palavras têm em comum além do “High” ?

Levando para o campo do desenvolvimento de software a ideia é que, em algumas situções, você precisa desenvolver algo extremamente high-tech, ou seja, utilizar dos mais avançados recurso para possibilitar o “high-touch”. Imagine um aplicação de Broker (compra e venda de ações) em que a utilização de alta tecnologia é indiscutível dado o numero de integrações, a robustes, a escalabilidade e a disponibilidade do serviço, porém os canais de suporte são falhos quanto ao “touch”. Como suporte demorado, atendimento somente via ferramentas de abertura de chamados e telefones burocráticos. Aplicar o “high-touch” é essencial e de implantação não tão complicada :

Destacando duas aplicaçoes interessantes de “High-touch” em sistemas :

1 - Disponibilizar ferramentas de chat online além dos tradicionais canais de telefones. Um chat tem uma linguagem mais informal e mais direta. O usuario consegue detalhar algumas informações ou mesmo ter agilidade para ter uma pergunta respondida. Por ser um aplicativo este pode ser desenvolvido para encontrar um atendente para determinado perfil, armazenar o historico da conversa, suporta o usuario copiar/colar mensagens do sistema.

2 - Acompanhar as ações do usuario (movimento do mouse, digitação, cliques, etc) , através da utilização de ferramentas de acesso remoto.

a) VNC. É um dos softwares mais famosos do segmento, em que a unica necessidade é o usuario a ser acessado instalar o VNC server. Para acessar um computador o atendente utiliza o VNC client.

b) Remote Desktop Connection é um aplicativo nativo do Windows XP. Quem for acessar precisa apenas digitar o IP do usuario que ja consegue acesso direto. Neste caso não é necessário instalar nenhum aplicativo.

c) LogMeIn que, diferente dos outros, não obriga o usuario a possuir um IP quente (IP válido), podendo ser utilizado dentro de uma rede interna. Tambem necessita da instalação de um programa na estação a ser gerenciada remotamente.

Todos eles exigem senhas de autenticação para garantir a segurança no acesso.