Monografia
Esse documento se apresenta dividido basicamente em três partes. A
primeira trará uma breve apresentação e histórico da empresa OPUS Software onde
realizei meu estágio, de modo a posicioná-la no mercado de trabalho atual. A
segunda parte será toda direcionada às atividades realizadas durante este
estágio e em particular ao projeto OPUS StarClient que foi desenvolvido durante
os últimos quatro meses de meu estágio e foi o enfoque principal da minha Apresentação do Projeto de Formatura e
do Pôster. A terceira
e última parte deste documento apresentará uma visão mais pessoal do que foi
meu estágio. Como este se inseriu no curso, quais os pontos positivos e
negativos de cada um deles.
OPUS Software
A OPUS Software é uma empresa de informática que atua no mercado desde
1987, prestando serviços nas áreas de treinamento e desenvolvimento de sistemas
e de consultoria em diferentes áreas. Em 1989 passou a atuar também na área de
desenvolvimento de software. A partir de 1999 a OPUS Software modificou seu
portfólio de produtos e serviços, tendo como foco principal o
"desenvolvimento de software levado a sério", slogan da OPUS. Com
este objetivo, desenvolve sistemas utilizando a metodologia de desenvolvimento
de sistemas Tree, criada de acordo com padrões amplamente aceitos no mercado,
garantindo a seus clientes a eficácia do projeto, desde a definição do escopo
até a disponibilização do sistema. Atualmente a OPUS Software possui uma
parceria com a Microsoft representada pelos seguintes programas:
Sempre atuando no mercado corporativo, a OPUS Software tem como clientes
grandes empresas dos segmentos bancários, industrial e de seguros, entre eles
os bancos Itaú, Santander, a companhia Indiana Seguros e a C&A.
A empresa se apresenta dividida basicamente em quatro grandes focos de
serviço:
Toda empresa visa o sucesso e tem de enfrentar um mercado extremamente
competitivo com o máximo de agilidade nas tomadas de decisões. Para tanto, é
necessário ter em mãos informações precisas e objetivas que formem um cenário
do mercado presente, ao mesmo tempo que descreve tendências pelas quais se
guiará no futuro. Dentro deste cenário, a Opus Software oferece uma solução de
Business Intelligence, Opus-BI, criada para fazer com que o sistema de
informação de sua empresa disponibilize a informação certa às pessoas certas,
no momento certo. Opus-BI é uma das soluções de Business Intelligence mais
eficazes disponíveis no mercado e está estruturada para integrar-se aos mais
diversos ambientes tecnológicos das empresas. Esta solução foi criada visando a
facilidade de customização e implantação, considerando um custo que cabe dentro
do orçamento das empresas e gerando benefícios já a curto prazo.
A OPUS Software disponibiliza a seus clientes, profissionais altamente
qualificados, em constante aperfeiçoamento e alinhados à sua metodologia para
integrar a equipe de desenvolvimento de sistemas, agregando conhecimento e
experiência. Os profissionais da OPUS são especializados nas tecnologias que
utilizam e comprometidos com os objetivos traçados junto à equipe de
desenvolvimento do cliente. Estes profissionais trabalham em conjunto com a
área de informática, acelerando o processo de aprendizado da equipe e
realizando a transferência de tecnologia. - Consultoria A alta capacitação
técnica dos profissionais da OPUS Software, constituída através da larga
experiência de participação em projetos, disponibiliza aos seus clientes,
consultores nas áreas de: Performance & Tunning de Banco de Dados. Definição
de Modelos de Dados. Otimização de Data Warehouse e Data Mart. Projeto e
implementação de Intranets. Desenvolvimento de aplicações Web. Metodologia de
Desenvolvimento de Software.
A OPUS Software desenvolve sistemas de informática completos,
personalizados para seus clientes, utilizando praticamente qualquer tecnologia
disponível no mercado. Os sistemas são desenvolvidos pela OPUS e implantados na
empresa do cliente através de uma política de transferência de tecnologia. Assim,
o cliente passa a ter autonomia sobre o sistema adquirido. A Opus Software
desenvolve também aplicativos que são intregrados à presença das empresas na
Internet ou a outros sistemas internos utilizando tecnologia Internet. Desta
forma, a OPUS Software agrega valor às soluções de e-Commerce e e-Business das
empresas.
Além disso, a área de desenvolvimento da OPUS Software disponibiliza
soluções prontas para seus clientes. Estas soluções, conhecidas como produtos,
estão prontas para serem instaladas e utilizadas pelos clientes. A implantação
desses produtos é de baixa customização e de fácil realização.
Meu estágio foi realizado todo ele na área de desenvolvimento
interno da OPUS Software.
Projeto OPUS StarClient
Ao fim do primeiro semestre, como abordado na Proposta de Projeto de
Formatura apresentado, iniciei no meu estágio uma atividade praticamente
exploratória a respeito de um novo mundo que se apresentava: a plataforma J2ME
(Java 2 Micro Edition).
O J2ME é basicamente um subconjunto do Java (JDK) destinado ao
desenvolvimento de aplicações para Mobile Devices. A plataforma J2ME oferece
para tanto, uma máquina virtual Java, chamada de KVM, pequena o bastante para
ser suportada dentro das restrições de memória destes dispositivos. Essa
máquina, por sua vez, não suporta todas as classes e funcionalidades do JDK. O
J2ME é formado basicamente por duas outras especificações.
Uma é a Connected Limited Device Configuration (CLDC) que é fornece um
conjunto de Java API para wireless application, ou seja, que sejam suportadas
pelo mobile device. Essa especificação fornece as classes responsáveis por
conexão, input e output streams, classes de manipulações de strings, de
operações matemáticas e outras semelhantes às do JDK.
A outra é a Mobile Information Device Profile (MIDP) que oferece uma
biblioteca de interface gráfica para o mobile device. Essa especificação provê
ainda as classes para memória persistente e algumas classes que definem objetos
de formulário que foram utilizadas no desenvolvimento do StarClient.
Para o estudo desta plataforma foram utilizados basicamente tutoriais de
J2ME existentes na página da Sun (www.java.sun.com),
manuais de usuário das ferramentas disponíveis para essa plataforma, como o
Sun´s J2ME Wireless Toolkit, o Java Application Loader (JAL Lite) da Motorola ,
que por fim foram os softwares utilizados para o desenvolvimento do OPUS
StarClient, e o Code Warrior da MetroWerks bem como listas de discussões da
página da Motorola (www.motorola.com) e
da iDEN (www.idendev.com).
Na parte de Interface Gráfica foi utilizado o livro Wireless Java Programming
with J2ME escrito por Yu Feng e Dr. Jun Zhu.
Ao fim de alguns meses de pesquisa e de desenvolvimento de pequenos
programas de teste que nos possibilitaram observar o que esse mundo nos
disponibilizava e quais eram suas limitações pudemos chegar junto ao setor de
Negócios da OPUS a uma idéia de projeto que pudesse ser útil para novos
desenvolvimentos sobre esta plataforma e ao mesmo tempo tivesse uma boa
possibilidade de colocação no mercado. E foi dessa idéia que se originou o mais
tarde chamado projeto OPUS StarClient.
A idéia era a de criar uma aplicação J2ME que pudesse atuar como um
cliente em uma aplicação de arquitetura cliente/servidor disponibilizada na
rede e que ao mesmo tempo tivesse uma boa interface para o usuário, coisa que a
tecnologia WAP não apresenta. Com esta aplicação poderíamos ter um celular se
comunicando diretamente com uma aplicação servidor que poderia estar atuando em
grandes bases de dados e apresentando assim uma grande possibilidade para o
ramo de e-Commerce e outros já bastante abordados pela Internet.
Mais do que simplesmente desenvolver uma aplicação cliente para o
sistema, o projeto consistiu em criar um ambiente de desenvolvimento para estas
aplicações. Desta forma, a aplicação deveria ser capaz de se comunicar com uma
aplicação servidor executando em um Web Server, receber deste o código de uma
aplicação cliente e de, deste código, gerar apresentações e formulários da
aplicação e a executar, fazendo a comunicação com o servidor e a interface com
o usuário. Desta forma, chegamos ao ponto de que a aplicação teria que ser um
cliente genérico para toda e qualquer aplicação de arquitetura cliente/servidor
que pudesse se comunicar com o celular. Para isso, o celular teria que receber
a aplicação sob um formato especifico para que o sistema pudesse fazer o parser
e criar todos os elementos envolvidos na aplicação. Logo, faria parte do
projeto também, a criação de um tradutor que seria executado junto à aplicação
servidor de modo a transformar as informações provenientes deste num código que
pudesse ser entendido pelo gerador de aplicação do celular.
Uma vez concluída a idéia do que seria o projeto, elaboramos então o Documento de Visão/Escopo do
projeto, de modo a definir o que seria desenvolvido e o que seria assumido a
priori como fora do escopo do projeto e, a partir da aceitação deste documento
por parte do Gerente de Projeto que assumiu este, se iniciou a modelagem e
implementação do sistema. Por ser um projeto relativamente pequeno e não
apresentar grandes restrições de prazo, uma vez que era um desenvolvimento de
produto, e não de uma solução para clientes, foi passada à minha
responsabilidade toda a modelagem e implementação e ao Gerente de Projeto,
apenas a de acompanhar o desenvolvimento do processo e a participação direta
nas tomadas de decisão relacionadas a características de apresentação e
funcionalidade do produto. Além disso, contei com ajuda de outros
desenvolvedores mais experientes na parte de coleta dos requisitos necessários
para que minha aplicação tivesse toda a genericidade desejada.
A modelagem e a implementação do StarClient foi dividido basicamente em
três partes: a definição e implementação da interface gráfica; a definição do
padrão e a definição e implementação do gerenciador de aplicações. A seguir
trataremos cada uma destas etapas.
Interface Gráfica
Como uma das propostas do projeto em si era a de oferecer uma interface
mais aceitável do que a tecnologia WAP oferece, barramos na limitação das
bibliotecas gráficas oferecidas pela especificação MIDP do J2ME e, decidimos
então implementar toda a interface gráfica que utilizaríamos na nossa
aplicação. Uma interface que pudesse ser totalmente configurada através do código
enviado pela aplicação servidor. Depois de algum trabalho de levantamento de
requisitos definimos o Diagrama de
Classes da Interface Gráfica do
StarClient.
A modelagem, bem como a implementação desta interface buscou o tempo
todo a maior orientação a objeto possível, de modo a tornar o código, bem como
a aplicação dele mais tarde, dentro das aplicações mais simples e intuitivo. Entretanto
em alguns pontos não foi possível manter uma orientação a objetos ideal por
limitações das classes do J2ME de apresentação de gráficos e imagens na tela do
aparelho, que exige que algumas variáveis e métodos sejam globais. Outra
limitação que tivemos foi a de tempo de processamento apresentar e mover as
imagens (formulários, textos...) na tela. Por esta, tivemos que limitar algumas
caracterizações de tipo e tamanho de fonte, estilo de texto e outras, por
tornar a aplicação lenta demais.
Padrão StarClient
Inicialmente, a idéia do projeto era utilizar como padrão de entrada
para o código da aplicação cliente passada para o celular um documento XML que
seguiria um XMLSchema definido propriamente para esta aplicação. Ou seja, um
XMLSchema que previsse tags para definir apresentações, caixas de entrada
(input), labels, botões, textos, seleção, e além disso definir elementos
necessários para o gerenciamento e execução da aplicações, como links, tipos de
dados de entrada ( texto, numérico, senha ), tipos de seleção (radio button,
check box, combo box) e identificadores para apresentação, para controle de
seção e etc.
Entretanto, nesta etapa barramos novamente nas limitações do sistema
sobre o qual roda o J2ME. Esses dispositivos móveis (Mobile Devices) como
palms, celulares, PDAs, apresentam fortes restrições de memória, e se
utilizássemos como código de entrada um documento XML, a aplicação teria que
conter um parser XML empacotado junto com suas classes de interface e
gerenciamento de aplicação que foram implementadas, umas vez que,
diferentemente da utilização e criação de classes e bibliotecas para o Java,
que podem ser importadas por outras classes, no J2ME, todas as classes
utilizadas que não fizerem parte das especificações CLDC e MIDP que são as que
compõem o J2ME, precisam ser empacotadas no mesmo arquivo .jar da aplicação.
O problema então, foi que o menor parser XML encontrado ( o TinyXML ) já
ocupava sozinho quase todos os 50K disponíveis para uma aplicação J2ME ser
instalada no celular. E assim, como teríamos que programar um novo parser para
o XML que suportasse apenas o que fosse extremamente necessário para nossa
aplicação, julgamos mais interessante definir um padrão mais direto que
facilitasse a implementação do parser e que deixasse o trabalho maior por conta
do tradutor, já que este estaria rodando no servidor, sem restrições de memória
ou grandes problemas de desempenho.
O padrão definido foi baseado em Lisp, onde cada elemento aparece entre
parênteses e apresenta o tipo do elemento, todos os seus atributos na ordem já
determinada pelo parser, depois os elementos contidos nele e por fim fecha o
parêntese. Além disso todos os tipos de elemento ou atributos que possuem
valores possíveis bem definidos são representados por números inteiros, o que
torna mais rápido o parser e, assim a geração das telas da aplicação. Este Padrão de Entrada, tal qual o
padrão utilizado para o envio de submits e recebimento de responses pela
aplicação, foi documentado num arquivo texto comum para mais tarde ser
transformado num XMLSchema (
padrão.xsd
) .
Gerenciador de Aplicações
A terceira etapa do desenvolvimento do StarClient foi a definição,
modelagem e implementação do Gerenciador de Aplicações, que no projeto recebeu
o nome de Client Interface. Este seria responsável por fazer a carga e execução
das aplicações e pode ser dividido também em três partes: as classes
responsáveis pela conexão, o gerenciador de cache e o parser em si. A modelagem
destas partes resultou no Diagrama de
Classes do Client Interface.
A primeira parte faz a seleção da aplicação, pega o endereço do servidor
e solicita uma conexão. Essa conexão é feita por Sockets e a transmissão de
dados é feita através de DataInputStreams e DataOutputStreams que são
suportadas pela CLDC. Uma vez estabelecida a conexão, os dados passam para o
gerenciador de cache.
O cache do StarClient foi implementado utilizando RecordStores que são
objetos definidos pela classe RecordStore da especificações MIDP e que é a
única classe que oferece recurso de memória persistente dentro da plataforma
J2ME. Foram criadas assim três RecordStores, uma para o nome da aplicação, uma
para a versão e uma para o código em si. Desta forma, quando é estabelecida a
conexão, o servidor envia ao celular o nome e a versão da aplicação a ser
executada. Se existir nas RecordStores uma entrada semelhante a esse par
nome-versão dado pelo servidor, o gerenciador de cache manda para o parser o
código que já se encontra gravado, economizando assim o tempo de transferência
do código do servidor até o aparelho. Caso contrário, é feita a transferencia
deste código e, se a versão é diferente, a entrada da RecordStore é atualizada
e se o nome da aplicação é diferente, uma nova entrada nesta é criada.
Uma vez passado o código de uma aplicação ao parser, este faz toda a parte
de geração dos objetos, criação da árvore de elementos que representa cada uma
das apresentações, já que em uma mesma apresentações podemos ter elementos que
contém outros elementos e assim por diante, e inicializa a execução da
aplicação. Toda aplicação possui ainda um ambiente que é uma tabela Hash
(implementação da HashTable já é suportada pela CLDC) que guarda os elementos
que podem assumir diferentes valores durante a execução da aplicação e além
disso, para cada apresentação (tela da aplicação) é instanciada uma outra
tabela de Hash para mapear as teclas do celular com ações. Essas ações em geral
são de navegação ou de submits e a alteração dos valores das variáveis do
ambiente é feita através do parser ao receber os responses do servidor.
O Client Interface é responsável também por terminar as aplicações,
encerrando a conexão e fechando as RecordStores e chamando o método
destroyApp() que é o método padrão para terminação de uma MIDlet (aplicações
J2ME) e retorno ao menu do sistema do device.
Atualmente já foi desenvolvido e implementado toda a parte da aplicação
que roda no mobile device ( toda a aplicação J2ME ) e já funciona em emulador (
já faz a conexão, testa o cache, gera e executa as aplicações), uma vez que o
acesso à rede sem fio e a Web Servers por parte dos celulares, bem como o
fornecimento de IP reais para estes ainda não esta totalmente disponível ,
faltando apenas o desenvolvimento do Tradutor do XML definido pelo XMLSchema
Padrão.xsd para o formato padrão de entrada StarClient, que rodará junto com a
aplicação servidor, para que o desenvolvimento do projeto seja finalizado e
passemos então para as fases de deployment e testes.
Considerações Finais
Nesta seção deste documento falarei a respeito das experiências pessoais
encontradas e realizadas ao decorrer do estágio e do desenvolvimento do OPUS
StarClient.
Inicialmente é importante relatar que esta foi a minha primeira
experiência profissional e que a diferença entre a responsabilidade com relação
a trabalhos desenvolvidos durante o curso e a que se encontra no mercado é
enorme. A princípio, nos trabalhos desenvolvidos no curso, quem depende de um
bom rendimento seu é apenas você mesmo ou quando muito alguns companheiros de
trabalho que na maioria das vezes são amigos que têm as mesmas prioridades e
dificuldades que você. No mercado, você tem outras pessoas, outros processos
esperando que você tenha um rendimento aceitável e faça o que lhe foi
designado. Apesar de quase todo o estágio eu ter passado desenvolvendo o
StarClient, tive algumas oportunidades de trabalhar em pequenas soluções para
alguns cliente, soluções estas que tem que ser desenvolvidas o mais rápido
possível e nem sempre tendo todo o conhecimento necessário a priori. E aí, além
da responsabilidade é necessário muita iniciativa e facilidade para aprender
coisas novas num espaço muito curto de tempo. Acredito que o curso do BCC
desenvolva muito isso nos alunos, a capacidade de aprender sozinho e de se
adaptar a mudanças rapidamente e isso é muito importante no mercado do trabalho
e, bom para nós que saímos deste curso, muito reconhecido.
Meu estágio foi realizado na área de desenvolvimento de software, que é
uma área que eu particularmente gosto e me identifico. Um dos aspectos que me
atrai para esta área é o fato de que a realidade muda muito rápido. A cada novo
projeto existe um mundo totalmente diferente, não só em relação a requisitos e
necessidades de cada projeto, mas em relação à própria tecnologia utilizada. Esse
foi outro ponto positivo no meu estágio. A OPUS, por ser uma empresa que vende
tecnologia, ela precisa ter em seu quadro gente capacitada para desenvolver
para qualquer tipo de ambiente, sobre qualquer plataforma, e isso faz com que
eles incentivem sempre o aprendizado a coisas novas que surgem no mercado. E
por mais que você não esteja estudando ou trabalhando com uma determinada
tecnologia, você sabe que o desenvolvedor do seu lado está, e que quando
necessário você terá a quem recorrer facilmente. E todas essas tecnologias
passam a fazer parte da vida da empresa e assim, mesmo sem estudá-la a fundo ou
ter um conhecimento mais avançado, você tem uma noção de onde ela se aplica e
como, tornando mais fácil um futuro aprendizado, mesmo que sozinho.
Um dos pontos que podem se apresentar meio negativo do meu estágio foi o
fato de eu fazer o desenvolvimento de todo o projeto sozinho. Acho que isso fez
com que eu não tivesse a experiência de trabalho em equipe que eu poderia, e
que sem dúvida acrescentaria bastante na minha formação profissional. Por outro
lado, sendo o único responsável pelo projeto, tive que realizar todas as etapas
deste, o que dá um conhecimento maior sobre as fases de definição, modelagem e
implementação de um sistema, que muito pode me ajudar em projetos futuros dos
quais participar.
Com relação às disciplinas do curso do BCC, acho que quase todas são
muito importantes para aprendermos a pensar e chegar a soluções rápidas para
problemas, bem como para nos dar um grande poder de iniciativa e uma capacidade
de aprender coisas sozinho já citadas. Entretanto algumas delas com certeza se
relacionaram mais ao projeto desenvolvido no meu estágio e que, logo, me
ajudaram bastante. Dentre estas, a que julguei mais importantes foram
Programação Orientada a Objeto, Engenharia de Software e Conceitos Fundamentais
de Programação, uma vez que parte do projeto StarClient foi a construção de um
interpretador para o padrão que definimos. Outras disciplinas como Introdução a
Computação, Desenvolvimento de Algoritmos e Estrutura de Dados foram fundamentais
para se criar uma base para todo e qualquer trabalho de desenvolvimento.
Em particular, gostaria de ressaltar entre as disciplinas do curso a
iniciativa da professora Ana Cristina Melo na disciplina Engenharia de Software
de formar grupos aleatórios entre os alunos, nos obrigando a trabalhar com
pessoas que nem sempre eram do nosso meio de convivência, e que acrescenta
muito no aprendizado do que é trabalhar em equipe. Acredito que essa iniciativa
só não foi mais proveitosa por o curso apresentar uma carga de trabalhos e
projetos e de aulas muito carregado, o que impossibilitava reuniões freqüentes
para a elaboração de um bom projeto. Fica aqui talvez uma sugestão para que a
duração do curso seja aumentada de quatro para cinco anos, o que permitiria uma
melhor distribuição da carga didática e dos projetos, podendo o aluno se
empenhar mais em cada um deles.
Concluindo, acredito que o curso do BCC me proporcionou toda a base
necessária para uma boa atuação, e até um destacamento, na carreira
profissional. Daqui pra frente, só dependerá de iniciativa e empenho, e tenho
certeza de que oportunidades boas sempre aparecerão, não só a mim, mas a todos
que fazem este curso. Mas acredito também na necessidade de continuar sempre
estudando, se aprimorando e aprendendo coisas novas, já que o mundo que
escolhemos é um mundo onde tudo acontece e muda muito depressa, mas com uma
base teórica e conceitual forte como a que adquirimos com o curso, acompanhar
essas mudanças não é uma tarefa muito complexa.
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
diagrama de
classes - interface gráfica
