Nesse dia, partimos de Ribeirão Preto - SP bem cedo, por volta das 3am, em direção a Ourinhos - SP. Havíamos selecionados cinco equipes para a fase final, mas como tivemos uma desistência, o que seria um mini ônibus, acabou virando uma van bem cheia (com Wi-Fi :p). Tirando as equipes que dormiram na Fatec Ourinhos, fomos uma das primeiras Fatecs a chegar. A competição seguiu a agenda: credenciamento, café da manhã, aquecimento, abertura, almoço, competição, lanche, premiação e volta para casa. Ao todo foram quase 24h dedicadas à competição até voltarmos com duas equipes no #Top10 e outras duas focadas em subir no próximo ano. É, houve também uma bela discussão sobre uma questão que durou boa parte da volta.

Na verdade, desde 2017, primeiro ano em que a Fatec Ribeirão Preto enviou equipes para o InterFatecs, a unidade mantém um resultado expressivo na competição. Este ano a Fatec Ribeirão Preto finalizou a competição com o 5º, 7º, 40º e 44º lugar. Vale lembrar que a competição este ano começou com cerca de 2,4 mil alunos de 73 Fatecs, o que demonstra uma excelente consistência nos resultados alcançados na competição. Para quem não sabe, eu atuo com técnico voluntário das equipes de Ribeirão Preto e fiquei bastante feliz com o resultado, mesmo este ano não podendo ser o técnico que essa galera merece :/. Porém, promessa foram feitas e ano que vem o caneco volta para casa. Sim, em 2017, nosso primeiro ano, a equipe TEAM 171 finalizou a competição em primeiro lugar em ambas as fases e o troféu passou um ano por aqui (alguém sabia disso?).

Infelizmente ainda não tive acesso aos casos de teste deste ano. Minha ideia era fazer um post mais extenso, detalhando minhas soluções e destacando alguns casos de teste. Na verdade, não temos disponível publicamente (pelo menos eu não encontrei) todas as provas e casos de teste das edições anteriores, mas sei que algumas delas estão disponíveis no uCoder. Isso é importante para sentirmos o nível da competição, além de ser obrigatório a resolução das edições anteriores no treinamento (não acha?). No meu ponto de vista, a tendência é o nível subir cada vez mais nos próximos anos, juntamente com o nível das equipes, algo que já vem acontecendo, e, quem sabe, se aproximar das questões e exigências da Maratona de Programação, que certamente no futuro estará na agenda dessas equipes juntamente com o InterFatecs.

Bom, até ter acesso aos arquivos da competição, resolvi falar um pouco das equipes, resultados e os próximos passo. Mas, caso queiram adiantar alguma coisa, basta entrar em contato (ou comentar no post).

Equipes

As equipes de Ribeirão Preto selecionadas para a fase final foram:

Python acima de tudo, C acima de todos (5º lugar)

• Eric Monteiro Galotti de Souza
• Júlio Cesar Yoshimine
• André Luan dos Santos Pavanelli
• Bruna Danielle de Oliveira Gobi

TEAM 171 (7º lugar)

• Cainã Paulosso Bonfiglioli (não está na foto)
• John Lennon Grisostomo Barbosa
• Welton Antonio Gomes
• Carlos Eduardo de Oliveira Silva

CAFÉ# (40º lugar)

• Alessa Maria de Carvalho Almeida Moreira
• Iago de Carvalho Butignon
• Thiago de Barros Nabruzzi
• Felipe Tamassia Luzenti

KVM ZIKA (44º lugar)

• Kauan Costa Santos
• Victor William Paulini
• Michel dos Santos Kuguio
• Carlos Vinicius Macedo de Sousa

American PY (não pode ir)

• Pablo Henrique Aguilar
• Pedro Trajano Contart de Oliveira
• William Kenji Hiraoka
• Victor Azevedo

Resultado

Este ano a prova contou com 9 questões, todas elas com solução na competição. As equipes campeãs, #Top2, chegaram a resolver 8 questões dentro das 5h, tendo uma das equipes de Ribeirão Preto assumindo a ponta em alguns momentos. Na verdade, o #Top5 sofreu bastante alteração durante a competição o que rendeu um ambiente acirrado e tenso para quem estava de olho no placar. Como disse, ainda estou aguardando a liberação dos casos de teste para minhas soluções e espero não deixar ninguém com raiva por conta disso (sempre ficava assim após descobrir a solução da questão que passei horas travado durante a competição).

Bom, no final, as 5 melhores equipes foram:

Um detalhe interessante é que mais da metade das submissões foram em python (53%) e o índice de equipes que zeraram foi mínimo. A segunda maior linguagem utilizada foi o C/C++ (33%), seguida do Java (15%). Isso mostra o cenário bem dominante do python, que acredito ser a tendência (também) nesse ambiente de programação competitiva. Para quem não está acostumado, a taxa de submissão seguiu o padrão: picos no início (10-20min) e término (290-300min) da competição. Uma dica importante é não esquecer de adaptar as estratégias e comportamento da equipe conforme os minutos vão avançando, daí a necessidade de periodicamente reavaliar o plano de ação (ordem de resolução dos problemas), considerando o status da equipe (exaustão), tempo de competição (min) e o plano de ação utilizado pelas outras equipes.

Estou me organizando para publicar alguns posts relacionados à programação competitiva. Assim, posso detalhar uma série de dicas e orientações que passo para as equipes.

Próximos passos

Atualmente as equipes estão em processo de renovação (os alunos se formam, Graças a Deus, certo?), mas o clima não poderia estar melhor. Nessa final já contamos com alunos dos primeiros períodos e a volta de uma final sempre anima os outros alunos da unidade. Assim, o plano é montar um treinamento bem especial e, vejam só, aqueles que estão se formando estarão envolvidos também no treinamento. Sem muitos detalhes, acredito termos grandes chances ano que vem e em 2020 o InterFatecs acontecerá aqui em Ribeirão Preto, onde com certeza não deixaremos o caneco passar.

Até mais.

A isbdesigner é o resultado do meu trabalho de mestrado no laboratório TeleMídia da PUC-Rio sob orientação do Prof. Luiz Fernando Gomes Soares. A ferramenta procura facilitar o projeto e criação de aplicações interativas para a TV digital através de storyboards interativos. Com isso, deixei público apresentações e organizei os downloads (logos, modelos etc.), que em algum momento se tornaram indisponíveis.

Sempre foi um projeto que adorei trabalhar e ainda vejo potencial de evolução da ferramenta. Cheguei a pincelar tópicos relacionados à aplicações transmidiáticas durante o início do doutorado nesse sentido, mas acabou tomando outros caminhos até o projeto estacionar. Espero que seja útil de alguma forma e, agora que as bases estão estabelecidas, nova publicações seguirão em um ritmo forte.

Qualquer dúvida ou sugestão, por favor, aguardo o seu comentário.

Até mais.

No entanto, o primeiro passo para isso é completar as lacunas do site. Mesmo para os conteúdos já disponíveis no site, existem várias informações ainda não publicadas, especialmente relacionadas aos projetos, seja apresentações, documentos, links, releases, demos etc. Normalmente essas lacunas estão identificadas pelo o texto abaixo:

Meu comeu esta seção. :)

A mensagem que quero passar com o lembrete é que há conteúdo para publicar ali, porém ainda está sendo organizado, formatado ou coletado. Para quem já tentou, clicar no leva você diretamente para um artigo aleatório no Wikipedia. É uma tentativa de encontrar um conteúdo interessante até disponibilizar o meu :).

De qualquer forma, o recado que fica é que nas próximas semana vários conteúdos serão disponibilizados e pretendo manter essa rotina, tirando algumas coisas da gaveta.

Até lá.

Dessa forma, recomendamos que todos aqueles que estão desenvolvendo, estudando, brincando ou passando um tempo com o NCL Composer, que migrem para o CMake. Nossa intenção é aos poucos remover completamente os arquivos de projeto do qmake (.pro). Então, para não ser pego de surpresa, aproveite as dicas deste post e dê as boas vindas ao CMake.

Antes de continuar, quero alertar que este post é do interesse daqueles que querem ou estão trabalhando no desenvolvimento do NCL Composer ou de plugins para o mesmo. Caso esteja interessado apenas em utilizar o NCL Composer, visite a página oficial do NCL Composer para fazer o download da release mais recente. Mas, mesmo que você seja apenas um curioso, é bem-vindo a ficar por aqui.

Outro detalhe é que neste post tratarei somente dos detalhes envolvendo o Ubuntu (Linux). Prometo fazer um post semelhante para o Windows e, quem sabe, macOS. Caso esteja interessado em adiantar alguma informação com relação aos outros SO, deixe um comentário ou entre em contato.

Como referência, estou utilizando: Ubuntu 16.04 LTS, Qt 5.7, Qt Creator 4.0.2 e CMake 3.5.1.

Ótimo! Agora chegou a hora de colocar a mão na massa. :)

Nossa tarefa será dividida em 4 etapas:

• Download das dependências
• Download do código
• Configuração do Projeto
• Configuração da execução

Como deve ter percebido pelos tópicos, não estou considerando que o código do NCL Composer tenha sido baixado, ou seja, que você é um desenvolvedor antigo do projeto. Se esse é o caso, lembre-se de desinstalar a versão atual, limpar os arquivos gerados a partir da compilação anterior e atualizar o código. Para isso, primeiramente, navegue para diretório onde o código do NCL Composer está localizado. Faça isso através do comando abaixo.

cd /path/to/nclcomposer/

Lembre-se de substituir o '/path/to/nclcomposer' pelo caminho correto no seu ambiente. No meu caso, por exemplo, eu executei comando da seguinte forma:

cd /home/edcaraujo/Workspace/cpp/nclcomposer/

Em seguida, execute os comandos para limpeza e atualização do código conforme descritos abaixo.

sudo make uninstall
sudo make clean
sudo make distclean

git pull

Feito isso, sendo você um desenvolvedor antigo, podemos pular diretamente para terceira etapa.

Download das dependências

Para baixar e compilar o NCL Composer é preciso instalar o Git e Qt. Porém, para fazer valer o próposito deste post, também precisaremos do Qt Creator e do CMake. Assim, abra um terminal e execute o seguinte comando:

sudo apt-get -y install git qt5 qtcreator cmake

Terminado a instalação já podemos ir para a próxima etapa.

Para mais detalhes sobre as dependências acesse a página oficial do NCL Composer.

Download do código

O código do NCL Composer está hopedado no GitHub. Portanto, para baixar o código, abra um terminal e execute o seguinte comando:

git clone https://github.com/telemidia/nclcomposer.git

Lembre-se de guardar o local em que você está baixando o código. Usaremos essa informação nas próximas etapas.

Configuração do Projeto

Para configurar o projeto, primeiro devemos importá-lo para o Qt Creator. Para importar o projeto, abra o Qt Creator e siga para o menu File > Open File or Project... (Figura 1).

Figura 1 - Abrindo o NCL Composer com o Qt Creator

Após clicar o menu File > Open File or Project... o Qt Creator irá abrir uma janela para seleção do arquivo. Selecione o arquivo CMakeList.txt na raiz do projeto do NCL Composer (Figura 2) e clique em Open. O arquivo CMakeList.txt é o arquivo de projeto do CMake.

Figura 2 - Abrindo o NCL Composer com o Qt Creator (Diálogo)

Com isso terminamos de importar o projeto. Agora vamos ao próximo passo, a configuração do projeto de fato. Logo após abrir o arquivo CMakeList.txt o Qt Creator irá apresentar a aba de Configuração de Projeto (Figura 3).

Figura 3 - Configurando o NCL Composer no Qt Creator

Clique em Details para visualizar todas as configuração de build (Figura 4).

Figura 4 - Configurando o NCL Composer no Qt Creator (Detalhes)

Em cada uma das configurações (Default, Debug, Release, etc.) altere o diretório de build. No nosso caso, vamos alterar a parte final de cada caminho para '/nclomposer/build', ou seja, o local onde você baixou o código na etapa anterior + '/nclomposer/build'. Assim, no meu caso, por exemplo, alterarei o diretório de build de cada uma das configurações para:

/home/edcaraujo/Workspace/cpp/nclcomposer/build

Feito isso (Figura 5), clique em Configure Project pra finalizar. É importante dizer que estamos fazer isso por simplicidade, dado que o correto é manter um diretório de build diferente para cada configuração.

Figura 5 - Configurando o NCL Composer no Qt Creator (Nova Configuração)

Uma vez finalizado, os arquivos do projeto são listados (Figura 6) e estamos prontos para brincar com o código. Porém, antes que a diversão comece é interessante que compilemos o código para saber se está tudo certo.

Figura 6 - Configurando o NCL Composer no Qt Creator (Resultado)

Para compilar basta clicar no ícone de build (Figura 7) na barra de ferramentas do Qt Creator. Outra forma é usar o atalho ctrl+b.

Figura 7 - Compilando o NCL Composer com o Qt Creator

Passado alguns minutos a compilação deve terminar. Depois disso podemos executar o NCL Composer e nossa tarefa estará concluída. Portanto, vamos para última etapa!

Configuração da execução

De forma resumida, o que vamos fazer aqui é dizer para o Qt Creator onde está localizado o binário gerado a partir da compilação. Para fazermos isso, clicamos em Project na barra de ferramentas do NCL Composer (Figura 8). Em seguida, selecionamos a aba Run e alteramos o Working directory para o local na qual o binário é gerado.

Figura 8 - Configurando a Execução do NCL Composer

O caminho para binário será '/path/to/build' + '/bin'. O '/path/to/build' foi o que definimos na etapa anterior. Portanto, no meu caso, devo alterar o Working directory para:

/home/edcaraujo/Workspace/cpp/nclcomposer/build/bin

Feito isso (Figura 9) estamos prontos para executar o NCL Composer.

Figura 9 - Configurando a Execução do NCL Composer (Nova Configuração)

Para executar o NCL Composer basta clicar no ícone de run (Figura 10) na barra de ferramentas do Qt Creator. Outra forma mais fácil é usar o atalho ctrl+r.

Figura 10 - Executando o do NCL Composer

Pronto! Terminamos a nossa tarefa. Agora é possível contribuir com o projeto ou desenvolver seu próprio plugin. Se estiver curioso em como contribuir ou criar um novo plugin é só acessar a página oficial do NCL Composer.

Caso ainda restam dúvidas, comente ou entre em contato. Não precisa se limitar ao assunto deste post.

TV Digital de faz com Ginga! :)

Figura 1 - Nova Visão Estrutural no NCL Composer

Além de todas as funcionalidades da versão anterior, a nova Visão Estrutural inclui também:

• suporte à undo/redo;
• suporte à organização automática das entidades da visão (esta opção está desabilitada por padrão);
• novos diálogos para criação e edição dos <link/>, <bind/>, <linkParam/> e <bindParam/>;
• barra de ferramentas para facilitar o acesso as funcinalidades da visão.

Antes e depois

Figura 2 - Visão Estrutural (0.2.1) no NCL Composer

Figura 3 - Visão Estrutural (0.3.0) no NCL Composer

Através das figuras acima é possível observar algumas das mudanças trazidas pela nova versão da Visão Estrutual. Além da barra de ferramentas, mencionada anteriormente, a partir das figuras é possível identificar também uma nova organização do menu contextual e a utilização de novos ícones para algumas das entidades.

Existem ainda outras novidades, então, para entender melhor as mudanças entre as versões, abaixo são detalhadas como algumas tarefas eram realizadas na versão 0.2.1 e como são realizadas agora na 0.3.0.

• Adicionando entidades
• Adicionando relacionamentos

Adicionando entidades

Figura 4 - Adicionando Entidades com a Visão Estrutural (0.2.1) no NCL Composer

Figura 5 - Adicionando Entidades com a Visão Estrutural (0.3.0) no NCL Composer

A partir da barra de ferramentas, a versão 0.3.0 da Visão Estrutural possibilita a adição de novas entidades de maneira bem mais rápida. No caso da versão anterior, 0.2.1, novas entidades só poderiam ser adicionadas por meio do menu contextual, exigindo do autor um número muito maior de interações para realizar, por exemplo, a tarefa de inserir uma nova mídia.

Além, da barra de ferramentas, a versão 0.3.0 permite que as entidades possam ser adicionadas também através de atalhos de teclado. Assim:

• Tecla 3: - Adiciona uma mídia na entidade selecionada.
• Tecla 4: - Adiciona um contexto na entidade selecionada.
• Tecla 5: - Adiciona um switch na entidade selecionada.
• Tecla 6: - Adiciona um body no projeto.
• Tecla 7: - Adiciona uma área na entidade selecionada.
• Tecla 8: - Adiciona uma propriedade na entidade selecionada.
• Tecla 9: - Adiciona uma porta na entidade selecionada.
• Tecla 0: - Adiciona uma porta de switch na entidade selecionada.

Um detalhe especial, que vale tanto para a barra de ferramentas quanto para os atalhos, é que uma ação de adição pode ser ignorada caso nenhuma entidade esteja selecionada ou se a entidade selecionada não permitir adicionar como um de seus filhos entidades do tipo da ação. Por exemplo, se o autor seleciona uma mídia e aperta a tecla 4 a ação será ignorada, uma vez que o autor está tentando adicionar um contexto como filho de uma mídia. A exceção a essa regra é o body, que só será ignorado caso o projeto já contenha um outro body.

Para evitar qualquer erro nesse sentido, a nova Visão Estrutural desabilita botões na barra de ferramenta e remove atalhos de teclados conforme o tipo da entidade selecionada na visão.

Mesmo na adição de novas entidades através do menu contextual, existem diferenças entre as duas versões. No caso da versão 0.2.1, sempre que uma nova entidade é adicionada através do menu contextual, ela é posicionada automaticamente no centro (ou no espaço livre mais próximo no centro) da entidade de destino, a entidade sob a qual o menu contextual foi exibido. Já na versão 0.3.0, a entidade adicionada é posicionada nas mesmas coordenadas do menu contextual. Isso evita que o autor perca tempo procurando em que posição da entidade de destino a recém adicionada entidade foi posicionada.

Adicionando relacionamentos

Figura 6 - Adicionando Relacionamentos com a Visão Estrutural (0.2.1) no NCL Composer

Figura 7 - Adicionando Relacionamentos com a Visão Estrutural (0.3.0) no NCL Composer

A versão 0.3.0 traz novos atalhos para criar relacionamentos. Além de segurar tecla Shift, meio utilizado pela versão 0.2.1, é possíver habilitar o modo de criação de link através da barra de ferramentas ou através da tecla 2. Uma vez habilitado o modo de criação de link, o autor pode clicar na entidade de origem e arrastar o mouse até a entidade de destino, conforme figuras acima.

Assim que identificados as entidades de origem e destino, caso seja permitido criar um relaciomaneto entre essas entidades, uma caixa de diálogo será apresentada para finalizar o processo de criação do link. É justamente nessa caixa de diálogo que está mais uma novidade da versão 0.3.0. Depois de selecionar o conector e os papeis (role) das entidades do relacionamento, na versão 0.3.0 o autor pode especificar desde já os valores dos parâmetros do link e dos binds. No caso da versão 0.2.1, só é possível especificar os parâmetros do link e dos binds depois da criação do link através de uma outra caixa de diálogo. Observando alguns usuários durante o processo de autoria, frequentemente esses autores esqueciam de editar os parâmetros do link e dos binds na versão 0.2.1.

Outro detalhe, transparente para usuário, é que a partir da versão 0.3.0 as informações dos conectores são carregados diretamente do núcleo do NCL Composer. Isso evita alguns possíveis problemas de sincronização das informações dos conectores encontrados na versão 0.2.1.

Conclusão

A nova versão da Visão Estrutural traz várias novidades, boa parte delas discutidas neste artigo. Para os desenvolvedores as mudanças são ainda maiores, especialmente por conta da reestruturação e refatoração do código. São mais de 6000 linhas de código a menos do que a versão anterior.

O código da nova Visão Estrutural e de todo o projeto do NCL Composer está disponívem em: https://github.com/telemidia/nclcomposer.

É importante lembrar que o NCL Composer ainda está em versão beta, então bugs ainda podem ser encontrados. Para reportar algum problema, entre em contato através do email [nclcomposer-dev@googlegroups.com][nclcomposer-mail] ou acesse o redmine do NCL Composer.

Para próxima versão, novas mudanças estão planejadas. Dentre elas está a remoção do body da Visão Estrutural. Tanto essa quanto outras mudanças podem ser acompanhadas também pelo redmime do NCL Composer.