Viciado em desafios, fã incondicional das mais variadas e felizes combinações entre matématica, computação, robótica e afins. Formado em Análise e Desenvolvimento de Sistemas, atualmente trabalhando no desenvolvimento de um sistema especialista baseado em regras de produção, onde minhas tarefas variam desde a modelagem e implementação do background, à prototipação e desenvolvimento do frontend(HTML5 | CSS3) / mobile nativo (iOS). [email protected]
[Description]Photon Rally Tutorial (”Top Paid” da sua categoria) é um projeto basilar para a criação de um jogo de corrida/combate usando a Photon Engine, a plataforma para jogos em rede mais popular da Unity. [/Description]
[Role]Eu fui o responsável pelo aprimoramento do sistema de armamento dos veículos, possibilitando a fácil inclusão de novos modelos de armas e a flexibilização do arsenal de cada carro disponível.[/Role]
[Description]GOT é um projeto que visa resgatar tweets antigos sem o limite de tempo ao se utilizar o Twitter Search API. A busca através dessa api está restrita apenas ao tweets publicados nos últimos 7 dias (ver documentação). A idéia para quebrar essa restrição é simular a busca avançada do twitter no browser, visto que lá não há nenhuma restrição nesse sentido.[/Description]
[Role]O projeto nasceu a partir de uma necessidade pessoal em se buscar tweets muito antigos e perceber que isso não seria possível pela API ou mesmo barato, visto que alguns sites oferecem essa possibilidade por meio de algum tipo de pagamento. Resolvi tornar o projeto público por encontrar outras pessoas que passavam pela mesma dificuldade e não sabiam como proceder, tanto que em um de seus primeiros usos o projeto foi essencial para a fase de coleta de dados de um trabalho de mestrado de um amigo, cujo objetivo era a análise de sentimentos em tweets.[/Role]
[Description]Vision Blocks é um projeto do grupo Camera Culture do MIT Media Lab. É uma aplicação web baseada em html/javascript com o objetivo de facilitar a programação baseado em visão computacional.[/Description]
[Role]Colaborei com o desenvolvimento da principal feature presente no projeto, que é a possibilidade de montar todo o algoritmo por meio de uma interface drag-and-drop. Tal interface permite que até crianças possam utilizar a ferramenta sem grandes dificuldades.[/Role]
[Description]O Cangaço é um jogo 3D com muita ação e estratégia, que pode ser jogado tanto em modo campanha single player, quanto contra os amigos em rede local e pela internet. No Cangaço, você vive o papel um heroi (cangaceiro ou volante), e poderá controlar todos os aspectos da evolução desse personagem ao longo das batalhas: atributos, habilidades, rezas e armas são apenas algumas das possibilidades. [/Description]
[Role]Principal desenvolvedor jogo, responsável pelo parte de gameplay e a campanha single player, além de ajudar na elaboração e implementação do modo multiplayer via internet.[/Role]
[Description]Sense é uma ferramenta que auxilia o gestor de um empresa a acompanhar os KPIs (Key Perfomance Indicators) de acordo com as necessidades observadas dentro da instituição.[/Description]
[Role]Trabalhei em todas as frentes do projeto, desde a concepção de protótipos, ao desenvolvimento da parte de backend, frontend e mobile. Participei também de implantações em clientes e elaboração de planos para realização dessas implantações. Como desenvolvedor mobile fui responsável por propor e implementar testes BDD (Behavior Drive Development), viabilizando uma maior inserção da diretoria e dos coordenadores na melhoria da qualidade do projeto.[/Role]
Sou formado em Análise e Desenvolvimento de Sistemas pelo Instituto Federal do Piauí (IFPI) em 2012 e mestre em Ciência da Computação no Programa de Pós-Graduação em Ciência da Computação (PPGCC) da Universidade Federal do Piauí (UFPI). Atuei em pesquisas relacionadas a Mineração de Dados e Inteligência Computacional.
Possuo experiência de mais de 6 anos no mercado de trabalho, atuando boa parte deles como desenvolvedor sênior. Gosto bastante de desafios e não me intimido com problemas dificeis que necessitem de abordagens/tecnologias diferentes para serem solucionados. Já fui desenvolvedor backend, frontend e mobile, além de utlizar diferentes linguagens devido a necessidades acadêmicas ou profissionais, como: Java, Python, Pure Data, C#, Javascript, etc. Atualmente trabalho com desenvolvimento de um framework para facilitar o desenvolvimento de jogos multiplayer, projeto encabeçado pela empresa alemã Exit Games / Photon Engine.
Formação Acadêmica
Mestre em Ciência da Computação
Período: 2014 - 2016
Instituição: Universidade Federal do Piauí
Proposta: Análise do cancelamento eletivo de contratos em planos de saúde privados. Classificação dos beneficiários em grupos com futura possibilidade de cancelamento. Estudos das árvores de decisão geradas para um melhor entendimento das causas e razões.
Tecnólogo em Análise e Desenvolvimento de Sistemas
Período: 2009 - 2012
Instituição: Instituto Federal do Piauí
Proposta: BONE: Uma Alternativa Dinâmica para se Divulgar e Encontrar Ofertas.
Publicações
Automatic Mapping between Gameplay and Aesthetics RPG Character Attributes through Fuzzy System. 2014 Brazilian Symposium on Computer Games and Digital Entertainment (SBGAMES), Porto Alegre.
Uma Abordagem para a Caracterização do Cancelamento Eletivo de Contratos em Planos de Saúde Privados. 2016 Learning & Nonlinear Models (L&NLM).
Comunicação
Inglês: Nível Intermediário fala/escuta. Nível Avançado leitura.
Português (BR): Língua nativa.
Prêmios e Títulos
SCJP - Sun Certified Java Programmer, Sun Microsystems. 2010.
SCJA - Sun Certified Java Associate, Sun Microsystems. 2009
Atuação Profissional
Desenvolvedor (Contrato). Exit Games / Photon Engine.
Período: 2016 - presente
Funções: Desenvolver um framework para desenvolvimento de jogos multiplayer, com o objetivo de minimizar o tráfico da rede e viabilizar a sincronizaçao de um elevado número de objetos.
Funções: Desenvolver uma solução BI para a criação, consulta e análise de KPIs (Key Perfomance Indicators). Atuei desde os processos de concepção a implementação do produto nos contextos: backend, frontend e mobile nativo (Android e iOS).
Professor. Universidade Federal do Piauí - CEAD.
Período: 2015 - 2015
Funções: Ministrar disciplinas de introdução a programação para o curso de engenharia elétrica e orientação para trabalhos de conclusão de curso no curso de sistemas de informação.
Desenvolvedor de Jogos (Contrato). Sertão Games.
Período: 2013 - 2014
Funções: Principal desenvolvedor do jogo Cangaço - inpirado nas histórias do sertão nordestino que retratam os confrontos entre cangaceiros e volantes.
Desenvolvedor Backend (Meio turno). Remanso Mineradora e Construtora.
Período: 2009 - 2012
Funções: Desenvolver framework interno para padronização e facilidade de prototipação das tarefas relacionadas a frontend. Participei do desenvolvimento de um sistema para gerência e controle de atividades empresariais.
Como prometido no último post, eu vou fazer um pequeno tutorial para escolha de personagens usando a Unity3d. A escolha de personagens pode ser feita de várias formas, fica pra nós a tarefa de implementar aquela que mais se encaixa no projeto em que estamos envolvidos. Eu fiz de uma forma e gostaria de compartilhar com vocês, mas caso ela não seja o tipo de seleção que você está procurando, os seguintes links têm uma abordagem diferente:
Video 1
Video 2
Video 3
Você pode ver minha versão estilizada aqui:
Eu chamei de "versão estilizada" porque neste tutorial você vai aprender como fazer o básico. Mas eu só demorei 10 minutos pra ir da versão básica pra "versão estilizada". Portanto você pode fazer coisas incriveis começando da versão básica.
Note: Todos os arquivos podem ser acessados via Github.
1 - Vamos começar criando um projeto vazio na Unity3D (minha versão é a 4.1.5f), para este projeto você não precisa selecionar nenhum pacote:
2 - Configure o objeto “main camera” para os seguintes valores:
3 - Temos um projeto vazio, então precisamos de algo muito importante para o tutorial, os personagens... Como esse não é um tutorial de modelagem, vamos utilizar modelos prontos, caso você tenha os seus pode usá-los a vontade, para os que não possuem existem vários sites que oferecem modelos gratuitos, eu acessei esse endereço e baixei os 5 primeiros http://www.mixamo.com/c/3d-characters/free. Você pode escolher outros ou utilizar os meus (Link). Depois de baixados vamos criar a pasta “chars” dentro de “Assets” e colocar nossos modelos:
4 - Feito isso vamos para a parte mais importante deste tutorial, as marcações. É com as marcações que eu indico onde os personagens irão ficar quando o programa estiver rodando. A idéia é criar 5 marcações, duas marcações para os personagens que a gente não estiver vendo, e 3 marcações para os personagens que estarão sendo vistos na tela. Essa marcações são simples “Empty Objects”, então vamos criar 5 deles e posicionar na tela, eu vou criar “Cubes” pra facilitar a visualização de onde devem ficar os marcadores, mas você vai utilizar os “Empty Objects”:
5 - Pronto, por incrível que pareça a parte mais complicada está feita, já marcamos onde os personagens devem ficar, agora só falta adicionar um script. Mas antes, a fim de deixar o projeto organizado, vamos criar outro “Empty Object”, na posição X=0;Y=0;Z=0, e colocar os marcadores dentro dele, teremos como resultado isso:
6 - Você agora vai criar o script que utiliza os marcadores e faz as ações de seleção, depois disso é só adicionar no último "Empty Object" que a gente criou, aquele que contém os marcadores, lembra?. No caso dessa minha implementação eu utilizei a linguagem C#, mas o código é facilmente portável para outras linguagens como Javascript. No link a seguir você pode encontrar o arquivo comentado:
SelectChar.cs
7 - Com o arquivo criado só precisamos fazer a linkagem dos objetos com o script, tanto os marcadores como os modelos 3D:
8 - Fizemos pouca coisa até agora, mas... nós já fizemos tudo =D. Se você colocar o projeto para rodar tudo já deve estar funcionando, o meu resultado foi o seguinte:
Esse foi um tutorial bem rápido mas muito útil, usamos uma das coisas mais legais da Unity3D, que é o poder de ligar objetos diretamente aos nossos scripts. Usando simples “Empty Objetcs” para marcar posições nós conseguimos fazer uma tela básica de seleção de personagens, básica mas com efeitos que já agradam muitos usuários. Do que nós fizemos você pode modificar, inovar na forma de escolher personagens, adicionar um background bonito, colocar modelos com animações e por aí vai... se possível não esqueça de compartilhar os resultados. Até breve...
Já faz algum tempo que estou contribuindo com a Sertão Games(Site) no desenvolvimento do seu mais novo jogo, Cangaco RPG (Link). Aproveito esse curto post pra mostrar uma foto com boa parte da equipe, que foi compartilhada na FanPage no último final de semana.
Nossa ferramenta de desenvolvimento está sendo a Unity3D, juntamente com a linguagem C#. Pretendo em um próximo post mostrar um tutorial de como criei uma tela básica pra troca/seleção de personagem, fica a dica para quem se interessar pelo assunto.
Vamos a foto então, eu sou o primeiro da esquerda pra direita:
Facebook Post
“Esse é o time (quase completo) que desenvolve o Cangaço RPG. Da esquerda para a direita:
- Jefferson Henrique - programador Unity3D (GUI, navegação, animações, etc);
Para quem leu o post passado (Melhoria de perfomance em Grails), vou agora mostrar detalhadamente como utilizar a implementação que eu fiz para redução da quantidade de requisições a arquivos JS. A idéia é criar um projeto Grails, adicionar alguns arquivos JS e testar a versão com e sem a melhoria.
Link para o github: https://github.com/Jefferson-Henrique/grails-request-performance.
Obs.: Neste tutorial estou utilizando o seguinte:
Eclipse Indigo (Com plugin do Grails)
Grails 2.2.0
Padronização de arquivos em UTF-8
Os passos para este tutorial são os seguintes:
1 - Para começar vamos criar um projeto Grails com o nome “request-perfomance-test”
2 - Feito isso vamos abrir o diretório “web-app/js”, é nele onde ficam os javascripts do seu projeto, contendo um por padrão chamado “application.js”. Agora vamos criar a seguinte estrutura dentro dessa pasta, para mais na frente mostrar a flexibilidade da construção dos grupos, neste momento crie os arquivos JS vazios:
3 - Criada a estrutura com os arquivos vazios, vamos agora colocar conteúdo, algo simples, adicionando no conteudo do body um texto referente ao nome do arquivo (você pode modificar isso a seu contento). O conteúdo pode ser o seguinte:
4 - Vamos agora modificar o arquivo “views/index.gsp”, que é o arquivo para o qual somos direncionados em um recém-criado projeto Grails. Precisamos incorporar a chamada aos nossos arquivos js, então o arquivo vai ficar assim:
6 - Agora já podemos verificar quanto tempo demorou o nosso projeto para fazer o carregamento, como estou utilizando o chrome vou abrir uma nova aba e deixar a ferramenta para desenvolvedores aberta na aba network (você pode tentar também com o firebug), ficando assim:
7 - Acessando nosso projeto na aba recém-criada podemos acompanhar as estatisticas de carregamento:
8 - Tivemos um total de 6 requisições, com um tempo de 47ms para carregar, isso na versão sem a otimização, agora vamos prosseguir com o tutorial. Devemos fazer duas coisas em nosso projeto, uma é a dependência a biblioteca YUICompressor e a outra é adicionar os arquivos "_Events.groovy" (Github), na pasta "scripts", e o arquivo "bundle.json" (Github), na raiz do projeto:
9 - Tudo correndo bem já temos um projeto configurado e funcionando, agora toda vez após a fase de compilação será gerado um arquivo “all.js” na pasta "web-app/js". Então vamos alterar o arquivo "views/index.gsp" para carregar apenas o "all.js":
10 - Reexecutando alguns passos anteriores podemos coletar os novos dados de carregamento e fazer as comparações, que são as seguintes:
Sem Arquivão | 6 requisições | 47ms
Com Arquivão | 2 requisições | 44ms
Obs.: Talvez para alguns de vocês o tempo de carregamento com o arquivão seja maior neste exemplo, isso se deve ao encapsulamento dos arquivos dentro de funções, porém isso só acontece nesses casos de teste, onde o conteúdo original do arquivo é muito simples. Nos casos normais, onde os arquivos são grandes e possui certa complexidade, é certo que a redução tanto de requisições como de tempo sempre ocorrerá.
É fácil, e óbvio ver que houve uma redução significativa na quantidade de requisiçõe feitas ao servidor, e isso porque os arquivos são pequenos, imagine com arquivos maiores... o tempo seria bem melhor ainda, porque com esse tipo de solução reduzimos duas coisas que impactam muito no carregamento: tempo de espera da requisição (não precisa esperar vários arquivos, apenas um) e tamanho do arquivo (ganho gerado com a minificação).
Você está livre para adaptar essa solução ao seu contexto, assim como utilizar as bibliotecas que mencionei no post anterior. São soluções simples mais que realmente impactam no tratamento com o cliente, no meu caso o tempo de carregamento caiu pela metade, como consequência ganhei até um aperto firme de mão do meu coordenador. Simples e efetivo, uma ótima dupla que você também pode usar no seu projeto...
Quem já desenvolveu para web, principalmente grandes aplicações (mas não obrigatoriamente), provavelmente já se deparou com problemas de perfomance, carregamento lento, transições que mais aparentam bugs, enfim, total falta de respeito com o usuário, e com o seu emprego!! caso você não seja o chefe... hehe
Muitos são os motivos para esses problemas de perfomance, e antes de tudo deve ser feita uma análise para identificar quais aspectos levaram para esse mal comportamento. Os links a seguir podem ajudar você a melhorar, descobrir e resolver os mais recorrentes casos:
Bom mais ainda não expliquei qual deles eu escolhi pra atacar, e o escolhido foi....
Requisições excessivas. Quanto mais arquivos você precisa utilizar na sua aplicação web, mais requisições serão feitas enquanto o usuário estiver lá, de olho na tela do computador. Para muitos isso é natural: “Ah meu site é grande, é claro que preciso de muitos arquivos, não tenho como fugir disso”.. Êpa, não é bem assim...
Dependendo do tipo de arquivo, como JS(meu caso) e CSS, você pode fazer algumas pequenas mudanças e carregar um grupo deles em único arquivo, claro que isso não é um santo graal, pois se esses grupos de arquivos não tiverem um lógica de criação correta, o usuário terá de esperar o carregamento completo desse arquivão pra ver alguma coisa interessante na tela. E isso é muito importante, então caso você não tenha entendido, ou mesmo se entendeu, vou exemplificar pra deixar tudo claro:
Imagine que você tenha vários arquivos JS que são carregados quando o usuário entra na página principal, e um deles é o arquivo que mostra a tela de login do sistema:
login.js: Mostra um formulário para que o usuário acesse o sistema;
validation.js: Valida os dados inseridos pelo usuário;
ajax.js: Faz requisições utilizando ajax;
upload.js: Faz upload de arquivos.
Carregando os arquivos de um por um, e tendo o login.js como um dos primeiros, rapidamente o usuário verá a tela de login, e mesmo que os outros arquivos ainda não tenham sido carregados isso já foi um feedback para o usuário, e muito importante por sinal.
Mas caso você tenha otimizado, juntado todos os arquivos JS em um só, o usuário vai precisar esperar pelo arquivo inteiro para que a tela de login apareça, nesse caso o tempo vai ser bem menor porque menos requisições estão sendo feitas, porém não se pode abdicar do feedback ao usuário. Nesse tipo de situação o arquivão deverá conter todos os arquivos, exceto aqueles que por algum motivo tenham uma prioridade maior para serem carregados, como o login.js.
Na aplicação que estou desenvolvendo junto com minha equipe, o tempo de carregamento da tela inicial estava muito alto, reclamações e mais reclamações, até que atacar esse problema virou uma prioridade, e eu resolvi trabalhar nessa tarefa.
Meu contexto de desenvolvimento é aplicação Java/Groovy para WEB, utilizando Grails como framework de desenvolvimento, e muito javascript para o gerenciamento da interface, portanto a solução é bem voltada para essa combinação. Antes de explicar a minha implementação para resolver isso no Grails, surgem as perguntas: Que tipo de requisição será mesmo reduzido? Não existe solução pronta pra isso?
Bom, como eu falei inicialmente os javascripts eram o meu caso, portanto nessa primeira investida ataquei o número excessivo de requisições para arquivos desse tipo;
Sim, existem muitas, mas infelizmente não consegui configurar nenhuma delas bem no meu projeto. Para os interessados aqui estão algumas das que eu pesquisei.
YUI Minify Resources (Grails): Essa foi a mais significativa que encontrei no contexto Grails; [http://grails.org/plugin/yui-minify-resources]
A par de tudo isso minha solução foi bem especifica, reduzir o números de requisições para arquivos javascript, tendo como meta juntar vários arquivos em um só (de forma flexível), e para matar dois coelhos com uma cajadada pretendia também minificar esse arquivão, reduzindo o tamanho do mesmo e otimizando ainda mais minha página inicial. Comecei a estudar sobre as bibliotecas existentes e tomei conhecimento de uma muito boa, o YUICompressor (http://yui.github.io/yuicompressor/) , que é utilizada por alguns dos plugins que encontrei e listei acima.
Mas a biblioteca apenas comprimia um arquivo JS, precisava então juntar todos eles em um arquivo antes de prosseguir com a execução, mas como fazer isso de forma automática toda vez que fosse buildar meu projeto Grails?.
Por alguns momentos pesquisei sobre Ant e GAnt, até que encontrei exatamente o que eu queria, “_Events.groovy”. Pra quem não sabe ainda, a partir desse arquivo pode ser feito hook de eventos que são lançados no build do projeto, como “inicio da fase de compilação”, “fim da fase de compilação” e “fim do packaging”. Maiores informações podem ser encontradas aqui: http://grails.org/doc/latest/guide/commandLine.html (Capitulo 5.5 - “Hooking into Events”).
De posse do conhecimento necessário, só precisei definir como iria configurar cada grupo de arquivos JS que gostaria de compactar. Escolhi o formato JSON para isso, mas essa parte pode ser facilmente substituida por outra de sua preferência, como XML[http://www.w3schools.com/xml/] ou YAML[http://www.yaml.org/].
Para finalizar esse post vou mostrar duas coisas, uma é o código em si, que compacta os arquivos JS e utiliza a biblioteca YUICompressor para comprimir o arquivo, e a outra parte é o arquivo de configuração em JSON. Se você estiver interessado em testar e entender melhor como funciona pode conferir no próximo post, onde detalho o passo a passo da utilização, com um exemplo bem prático, além de um link para um repositório do Github com o projeto.
Bom vou tentar abranger o máximo nesse blog, desde as descobertas, os estudos, os bugs encontrados e extintos, enfim, tudo aquilo que valer a pena compartilhar, afinal uma idéia não é de ninguém, e sim de todos nós =D.
Como próxima postagem pretendo demonstrar e explicar uma simples solução para problemas de perfomance quando há um alto número de requisições sendo feita. Pra esse caso meu contexto foi o http://grails.org/. Vou detalhar mais sobre isso no post, então aguardem...
Jefferson Henrique @jeff-heineken-pt - Tumblr Blog | Tumgag
