domingo, 30 de março de 2014

Reunião Semanal 30/03 esofteacher@sHoRTcut

sHoRTcut.png

Resumo das Reuniões da Semana:

  • Discussão sobre o uso do git:
    Alguns membros do grupo encontraram dificuldades devido às múltiplas edições simultâneas do código fonte. Esses problemas levaram à discussão sobre qual seria a melhor forma de uso da ferramenta de controle de versão. Chegamos às seguintes conclusões:
    • Adotar o uso da seguinte sequência para evitar conflitos de merge:
      1. commit
      2. pull
      3. eventual resolução local de conflitos
      4. push
    • O código será modularizado em cenas e a divisão de tarefas também será feita considerando as cenas, gerando arquivos separados que serão alterados por apenas um desenvolvedor a cada momento. Assim, cada cena pode ser desenvolvida em paralelo, diminuindo a probabilidade de conflitos.
Foi sugerido o uso do gitk para facilitar a visualização. A decisão de utilizá-lo ou não ficou por conta de cada desenvolvedor.

  • Novamente foi discutido a necessidade de expandir o tema tratado no jogo. Chegamos à conclusão de que, embora existam muitas diferenças na parte de Engenharia de Requisitos entre os processos ágeis e os tradicionais, percebemos que o jogo pode ser mais interessante ao lidar também com outras situações, como a parte de testes ou da formulação das reuniões. Decidimos que essa decisão deveria ser validada com o cliente, então enviamos um e-mail para a Luciana perguntando se ela aceita a decisão.

  • Avaliamos as horas da última estimativa de disponibilidade de tempo e concluímos que será necessário a refatoração da mesma, para que assim possamos determinar o tamanho da próxima corrida (sprint).- Essa necessidade surgiu da percepção do tempo gasto com tarefas extra-código, como preparação de posts no Blog, slides para apresentação, estudo da matéria, etc.

  • Parte da equipe investiu na criação de um recurso automático de postagem no Blog a partir do que é feito no Trello, motivados pela grande quantidade de tempo que gasta-se formatando o texto a ser enviado. Entendemos que essa tarefa é secundária em relação ao desenvolvimento do jogo, mas que pode nos ajudar a ter mais tempo para o desenvolvimento. O desenvolvimento desse item ainda não está pronto, mas  foi possível obter uma evolução.

  • Discutimos como fazer os testes do nosso jogo. O nosso desejo era utilizar Testes de Unidade (Unit Tests) e Desenvolvimento Orientado aos Testes (TDD):

    • Chegamos à conclusão de que não será possível aplicar Desenvolvimento Orientado aos Testes no nosso trabalho. O nosso código é feito em forma de script que é chamado pela engine do renpy e o resultado de sua execução, de forma resumida, é o aparecimento de imagens e texto na tela. Utilizar TDD no desenvolvimento de uma Visual Novel é praticamente testar todo o conteúdo da cena, sendo igual a própria cena.
    • Decidimos que iremos tomar três iniciativas para o controle da qualidade do produto:
      •  Inspeção de código: verificação por outra pessoa, que não o desenvolvedor da tarefa, do código fonte, validando, sobretudo, o uso de condicionais e flags;
      • Testes sobre o resultado final da cena: esse teste irá validar principalmente o conteúdo dos textos (como ortografia), posicionamento de botões, imagens e diálogos;
      • Testes de integração: verificação dos resultados do jogo por todas as combinações possíveis de escolhas a serem feitas pelo jogados.
    • Para auxiliar os testes sobre o resultado das cenas, iremos verificar a possibilidade de utilizar uma ferramenta que refaz cliques de usuários baseado em coordenadas em pixel na tela, permitindo testar uma vez e automatizar a reprodução do teste.
    • Iremos também verificar a viabilidade de realizar Testes de Unidade utilizando o próprio renpy, alterando o valor de flags enquanto a cena se desenrola de acordo com as escolhas feitas, capturando o estado final e comparando com o esperado programaticamente.

  • Decidimos que, excepcionalmente na semana a seguir, não haverá a primeira reunião em pé da semana em virtude da prova de Engenharia de Software.

quinta-feira, 27 de março de 2014

upGAME Group - Primeira apresentação


Estamos disponibilizando aos que tiverem interesse, as transparências da nossa primeira apresentação.

Ela pode ser visualizada no no link https://drive.google.com/file/d/0BzM19TpzVHG-S2NRZWhMd2ZMZlk/.

O download pode ser feito sem problema por esse mesmo link.

Obrigado

CF70 - Definição de Tarefas

Tarefas definidas para o desenvolvimento do projeto:

Fases:
   - Cenários
   - Mapeamento

Perguntas:
   - Temas
   - Questões
   - Dicas

Script:
   - História
   - Diálogos

Mini-jogos:
   - Ideias
   - Jogos

Código:
   - Menu
   - Sistema de alinhamento
   - Interação

Recursos Multi-mídia:
   - HUD
   - Audio
   - Personagens

Além disso, cada membro do grupo participará de outras atividades, dentre elas o estudo da disciplina, postagens no blog e participação de reuniões.

quarta-feira, 26 de março de 2014

upGAME - Documento de especificação de requisitos

Porque documentar?


Resolvemos manter e atualizar, quando necessário, um documento com todos os requisitos do nosso sistema. Isso porque assim teremos um maior controle sobre o que devemos fazer e sobre  as prioridades.

Onde acessar?


O acesso pode ser feito através do link https://drive.google.com/file/d/0BzM19TpzVHG-T1hVMjhUdC1OZEk/

Este documento, além dos requisitos, fala mais sobre o sistema, o tema, a origem do tema, os métodos de levantamento de requisitos e por ai vai.

A medida que ele for atualizado, estaremos postando quais alterações foram feitas nos requisitos em relação ao arquivo anterior juntamente com o novo link de acesso.


Quais os requisitos?


Nesta versão, nossos requisitos foram dispostos em Funcionais e Não-Funcionais, sendo eles:
  • Requisitos Funcionais:
    • Deverá ser uma aplicação web;
    • Deverá fazer uso das linguagens de programação HTML5, CSS3 e JavaScript com algumas bibliotecas, que possam auxiliar os desenvolvedores;
    • Será dividido em níveis de dificuldade, cada nível representando um nível especificado pelo CMMI;
    • Os dados do usuário serão salvos para permitir que um usuário possa continuar a jogar de onde parou.

  • Requisitos Não-Funcionais:
    • O jogo deve ter o formato de história;
    • Os níveis dos jogos são dependentes. O jogador não poderá se graduar nem jogar o Nível 3 sem conseguir a graduação do Nível 2, por exemplo;
    • O jogo deverá seguir a história, mesmo que cada nível apresente um estilo de jogo diferente;
    • Ideal ter uma boa jogabilidade e uma interface amigável ao usuário;
    • Todos os códigos, bibliotecas, imagens, documentos, transparências e quaisquer artefatos usados neste projeto, tanto para o desenvolvimento, quanto para a parte gerencial/administrativa, deverão ser de domínio público, além de informar a fonte e os créditos referente a produção.



Definição do nome

O Nome

A partir de agora, o grupo composto por: 
  • Felipe Althoff,
  • Gabriel Poesia,
  • Guilherme Cordeiro,
  • Guilherme Gomes,
  • Lucas Duarte,
  • Marco Antônio,
  • Thiago Prado
Terá o nome de: 


Motivo


A palavra upGAME nos remete a palavra upgrade, que pode ser traduzida como melhoria, o que se encaixa muito bem com o objetivo do CMMI, já que ele visa elevar o nível de maturidade das empresas.

Além da palavra Game em destaque resumir claramente que nosso produto é um jogo, o esquema de cores foi trabalhado para ter as cores da logo do CMMI e do MelonJs.

O detalhe abaixo do nome dá um toque de velocidade, assim como a fonte usada, o que, por sua vez, apresenta o método que estamos usando para desenvolver nosso produto, o Scrum, que é baseado no método ágil

terça-feira, 25 de março de 2014

CF70 – Decisões de projeto e requisitos



Escolha do Kanban:

- Tarefa com tempo de folga, permitindo maior capacidade de resposta para solicitações urgentes.
- Capacidade de mudança no que diz respeito a prioridade do projeto.
- Capacidade de identificar gargalos.
- Boa visibilidade melhora confiança entre desenvolvedores e clientes.
- Boa visibilidade também ajuda na identificação de riscos, e riscos geridos de forma adequada trazem resultados previsíveis.
- Alta predicabilidade, obtida graças a limitação da quantidade de trabalho em progresso, aumento da visibilidade do projeto e rápida identificação/eliminação de gargalos no processo gera confiança no cliente e tende a gerar software com menos erros (foco em qualidade).

Listagem dos requisitos propostos: 

- Jogo para PC
- Jogo para um jogador
- Voltado para estudantes de Engenharia de Software
- Gênero Puzzle
- Jogador deve responder perguntas sobre temas relevantes de E.S
- Diversas fases, cada uma sobre um tema específico da engenharia de software (cmmi, xp, scrum, pmbok, etc)
- Perguntas selecionadas aleatoriamente de um banco de perguntas
- Lista de perguntas por fase não pode ser muito extensa, nem muito pequena
- Busca das respostas a partir de interação com o ambiente do jogo
- Personagens não-jogáveis (NPCs) interagem com o jogador
- NPCs tem atributos que indicam o quanto eles irão ajudar ou atrapalhar o jogador
- Respostas para as perguntas não devem ser entregues de forma direta ao jogador
- Possíveis mini-games, também relacionados a E.S, para a obtenção das respostas
- Limite de tempo por fase

Protótipo Descartavel:

Contém:

- Ideia de movimentação
- Ideia de cenários
- Transição de cenário (“Pátio” para “Cantina” do ICEX)
- Sistema de perguntas (Ao pressionar ENTER)




domingo, 23 de março de 2014

Reunião Semanal 23/03 esofteacher@sHoRTcut

sHoRTcut.png


Segue abaixo um resumo do pontos discutidos na última reunião semanal da equipe:


  •  Definição do escopo do jogo:

Decidimos ampliar o escopo da história do jogo para contrastar todo o processo de desenvolvimento de software utilizando metodologias ágeis e tradicionais, não apenas limitado à Engenharia de Requisitos.

  • Montar uma história com o conteúdo de Engenharia de Software que será abordado:

Emergiu a ideia de colocar o nosso personagem-jogador em uma empresa tendo que lidar com dois projetos simultaneamente, um ágil e outro tradicional.

  • Motivação das escolhas: As escolhas pelas quais o jogador irá passar determinarão o sucesso dos projetos.
  • Finais possíveis: É possível que os dois projetos falhem, que algum dê sucesso ou que ambos sejam um sucesso. Dependendo da quantidade de acertos/falhas o personagem também pode ser promovido ou demitido.

  • Decisões de implementação:

Para facilitar o controle e a paralelização das tarefas, foi decidido que:

  • Cenas serão construídas em arquivos separados, para que seja um trabalho modularizado e independente das outras cenas.
  • Algumas cenas que não possuem relação direta com o tema do jogo serão inseridas posteriormente.
  • Cenas devem começar e terminar em algum lugar comum da empresa, como o corredor. Possibilitando a troca de ordem ou corte de alguma cena.

  • Proximas tarefas:
    Discutimos sobre as tarefas principais a serem desenvolvidas a seguir:
  • Obter sprites para quatro colegas de trabalho, dois para gerentes e outro para dono do bolo.
  • Definir todas as cenas que o jogo obrigatoriamente terá.
  • Definir cenas / momentos que podem ter quiz e escolhas.
  • Definir quais escolhas o personagem pode fazer que sejam consideradas erradas.
  • Definir quizzes que ocorrerão no decorrer do jogo.
  • Apresentar cenas definidas para o cliente priorizar.

Artefatos da Primeira Entrega esofteacher@sHoRTcut



Postando, postumamente, os artefatos da primeira corrida e reserva do produto esofteacher:

 

 

quinta-feira, 20 de março de 2014

Resumo das reuniões em pé da semana - esofteacher@sHoRTcut

Segue abaixo um resumo do pontos discutidos nas reuniões rápidas da equipe nessa semana:

  • Definir o limite de cartões nas listas do Trello (tarefas nas colunas do Kanban):
    Foi decidido que a quantidade máxima de cartões em cada coluna/lista será 5. Uma exceção será feita para listas de cartões com recursos de referência para todo o projeto, que não terão um limite estabelecido.
  • Avaliar viabilidade da entrega de instruções de ajuda dentro do jogo na primeira entrega (apresentação na quinta):
    Foi decidido que essa tarefa deveria passar para alguma sprint futura, que não teríamos tempo hábil para desenvolvimento e teste antes da primeira entrega.
  • Discutir sobre estruturação dos testes no nosso processo e na ferramenta de gerenciamento (Trello):
    Será criado um cartão da história vinculado ao cartão das tarefas e também a uma tarefa de teste, que será, necessariamente, executado por alguém que não tenha participado daquele desenvolvimento. O cartão da história permanece na lista “Revisando” até a execução com sucesso dos testes (aceitação pelo testador), sendo movido depois para “Finalizado”, para, enfim, ser arquivada após o tempo necessário para que todos da equipe saibam do término.
  • Avaliar a utilização das estatísticas do github como medida de produção:
    Foi decidido que é melhor contabilizar pelo esforço concluído nas tarefas de cada sprint, gerando o burndown chart que acompanhará o desenvolvimento.
  • Verificar a viabilidade de contagem de Pontos de Função das histórias:
    Foi decidido que é melhor não contarmos os Pontos de Função e mensurarmos através de estimativas de hora, uma vez que o nosso programa não se assemelha com CRUDs, estando bem distante do domínio onde a contagem de PFs se mostra assertiva.
  • Definir como separar tarefas do TP e do projeto do jogo:
    Foi decidido tratar igualmente no Trello (mas com marcadores próprios), visto que ambos tipos de tarefa consomem tempo e frequentemente necessitam de participação de mais de um membro da equipe. Para facilitar o acompanhamento dos esforços gastos / previstos da empresa, decidimos gerar dois Burndown Charts, um para o TP como um todo e outro para o desenvolvimento do jogo.
  • Definir modo de levantar histórias e suas priorizações:
    Após troca de e-mail com a monitora (cliente), decidiu-se que nós mesmos iremos levantar os requisitos / histórias, simulando a sua chegada através do cliente, agindo como se a monitora e o “Dono do Produto” tivessem concordado com eles. Tentaremos priorizar as histórias com o cliente, definindo cada sprint (“corrida”), para depois dividirmos as tarefas.

Para ver mais: cartões das reuniões em pé um e dois.

Apresentação 20/03 - esofteacher@sHoRTcut

quarta-feira, 19 de março de 2014

As primeiras decisões do nosso projeto foram tomadas, depois de algumas brigas chegamos a um consenso sobre como será o jogo e quais as tecnologias vamos usar. 

Tema:

 -CMMI

Cada nível do CMMI será um nível do jogo. O jogador começa no nível 1, que representa o estágio em que sua empresa desenvolve software de forma caótica, e progride até o nível 5, em que deve garantir que seu processo está em melhoria contínua, mesmo depois de chegar ao nível de maturidade máximo do CMMI.
    Cada nível do jogo, por sua vez, terá um formato independente (jogo de plataforma, texto, puzzle, etc), e poderá ser completamente diferente dos demais. Em um nível, estarão representados os desafios encontrados no nível correspondente do CMMI. O jogador avança quando tiver vencido esses desafios e estiver pronto para tentar a certificação no próximo nível. Assim, o jogador no nível 1 deve vencer os desafios do nível 1 e, então, estará pronto para tentar se certificar no nível 2 do CMMI. Ao passar do nível 2, ele obterá certificação CMMI nível 2, e estará pronto para se preparar para a certificação nível 3, e assim por diante. O único cuidado deve ser no nível 1, já que, por definição, toda empresa que não possui certificação já está no nível 1 do CMMI. Assim, neste nível, o jogo deve apenas ilustrar a empresa no nível 1, sem que o usuário ganhe alguma certificação.
    Em um nível, o jogador poderá ganhar itens que serão úteis nos níveis seguintes.

Para orientar o desenvolvimento de cada nível, teremos os objetivos específicos e gerais do CMMI: http://en.wikipedia.org/wiki/Process_area_(CMMI)

A ideia é que cada nível ilustre pelo menos alguns dos objetivos associados ao nível correspondente do CMMI. Esses objetivos são bem claros e fáceis de usar. Por exemplo, no nível 2 de desenvolvimento do CMMI, um dos objetivos é "Configuration Management" (CM). Isso está dividido pelo CMMI nos seguintes objetivos:

  • SG 1 Establish Baselines
    • SP 1.1 Identify Configuration Items
    • SP 1.2 Establish a Configuration Management System
    • SP 1.3 Create or Release Baselines
  • SG 2 Track and Control Changes
    • SP 2.1 Track Change Requests
    • SP 2.2 Control Configuration Items
  • SG 3 Establish Integrity
    • SP 3.1 Establish Configuration Management Records
    • SP 3.2 Perform Configuration Audits

Tecnologia Utilizada:

O jogo será implementado em HTML5 e JavaScript. Cada grupo poderá também usar outras bibliotecas para JavaScript que achar que podem ser úteis.
    As informações do jogador serão armazenadas em um Cookie, contendo um objeto JSON. Assim, cada nível poderá facilmente obter e modificar as informações compartilhadas entre os níveis. Os campos do JSON ainda serão definidos. Cada grupo pode decidir quais informações irá salvar nele e comunicar a todos, para que os níveis seguintes possam usar essas informações (como que um determinado item foi obtido).
    Uma sugestão de game engine para JavaScript é o MelonJS (http://melonjs.org/). Outra biblioteca que poderá ser útil é o AngularJS (http://angularjs.org/). Porém, cada grupo será livre para usar o que quiser.

Gestão de código:

Utilizaremos repositório do tipo git para fazer o controle de versão. Ainda estamos para definir onde hospedar o repositório.

Demais decisões ainda serão postadas.

P.S.: Texto do Gabriel Poesia


Tentem "simular" um "learning by doing" :-)

Dentro do arcabouço do "aprender fazendo" uma pessoa aprende um processo de software participando de uma equipe onde a maior parte dos participantes entende e conhece o processo. Infelizmente é muito difícil mobilizar uma equipe de desenvolvedores para trabalhar com cada aluno da disciplina... Mas nada impede que vocês tentem teatralizar entre vocês uma equipe experiente e sábia :-) Um dos aspectos importantes dete "teatro" é vocês questionarem sempre o que está sendo feito :-) 
Por que estamos fazendo este TP?
Por que vamos fazer testes?
Por que vamos levantar requisitos?
Por que vamos usar o método X?

Boa sorte!