Uma trilha completa do Exercism tem dois tipos de exercícios: Exercícios de Conceito e Exercícios de Prática.
Eles são fundamentalmente diferentes e se complementam muito bem.
Os Exercícios de Conceito de uma trilha são exercícios feitos para ensinar conceitos individuais que formam a base de uma linguagem de programação específica.
Esses conceitos formam uma ementa.
Esta documentação traz orientações e dicas sobre como planejar uma boa ementa para a sua trilha.
O objetivo de uma ementa
O objetivo final de uma ementa é fazer com que os estudantes se sintam à vontade para ler e escrever código idiomático na linguagem-alvo.
Cada Exercício de Conceito é extremamente focado.
É um passo pequeno e bem direcionado que leva o estudante a entender algo sobre a linguagem.
Ele se apoia apenas em conceitos que já foram apresentados antes.
Ao resolver o exercício, o estudante começa a se familiarizar com o conceito.
O entendimento vem principalmente da prática, e bem menos das explicações.
O conteúdo explicativo serve para apresentar ao estudante as ideias de que ele precisa para resolver o exercício (daí a escolha do nome do arquivo: "introduction.md")
Queremos que os estudantes comecem a escrever código imediatamente, sem precisar entender tudo de antemão.
Para isso, passamos por cima de alguns detalhes e deixamos muita coisa sem explicação.
Simplificamos e fornecemos esqueletos de código quando possível.
Isso reduz o esforço cognitivo de começar e dá tempo e espaço para o conhecimento se consolidar.
Com essa abordagem, não estamos dizendo que o estudante não precisa saber essas coisas, estamos dizendo que ele não precisa sabê-las por enquanto.
Muitas vezes, os primeiros exercícios precisam conter código não idiomático.
Isso acontece porque, no começo, a maior parte da linguagem ainda é desconhecida para o estudante, e a maioria dos conceitos ainda não foi apresentada.
Ao permitir código não idiomático nos primeiros exercícios, os estudantes podem dar muitos passos menores em terreno conhecido, em vez de alguns passos grandes em terreno desconhecido.
O resultado é que eles chegam à etapa do código idiomático mais rápido e com menos atrito.
Estrutura básica
Os exercícios são organizados como uma árvore, com um exercício introdutório no topo como ponto de partida.
Os exercícios seguintes ensinam conceitos que dependem da compreensão de conceitos ensinados antes.
Portar e emprestar
Pode valer a pena ver como outras trilhas de linguagens montaram os seus exercícios de conceito.
Você encontra exemplos de Exercícios de Conceito de outras trilhas de linguagens aqui.
Dito isso, se você decidir usar outros exercícios como ponto de partida para os seus, tome cuidado para garantir que o exercício resultante seja sobre o conceito como ele existe na sua linguagem.
Às vezes os conceitos diferem de forma sutil, às vezes de forma radical.
Às vezes os conceitos nem existem em outras linguagens.
A ementa, e portanto a árvore de conceitos, deve representar os conceitos que existem nessa linguagem específica.
Não inclua conceitos só porque outras trilhas os incluem.
Em alguns casos, pode ser tentador incluir um conceito porque as pessoas costumam contornar a ausência dele usando conceitos que existem.
Em vez disso, apresente o conceito que a linguagem de fato usa, e considere adicionar um exercício que explique como usá-lo nesse tipo de situação.
Por exemplo, em Go não existem enums.
Em vez disso, a árvore de conceitos de Go apresenta as constantes e ensina a usá-las no tipo de situação em que você usaria enums em outras linguagens.
Pedindo ajuda
Não hesite em pedir ajuda.
É melhor perguntar logo no início, ou enquanto você trabalha em um exercício, do que discutir durante a revisão de código.
No GitHub, você pode marcar a equipe @exercism/learning-mode.
No fórum do Exercism, abra uma issue na categoria Exercism Support.
Primeiros passos
A nossa experiência mostra que a forma mais pragmática de desenvolver uma ementa é fazer a árvore de conceitos crescer de forma orgânica, começando pelos conceitos mais simples.
Não precisamos planejar tudo de antemão, e na verdade costuma ser útil não pensar tão à frente.
Começamos com o mínimo possível de conceitos: os mais fundamentais para escrever qualquer coisa na linguagem.
Também procuramos começar pelos conceitos mais familiares para o desenvolvedor médio.
Familiar é bom.
Familiar não confunde.
Lembre-se: o objetivo final é escrever código idiomático, mas as pedras do caminho até lá nem sempre são idiomáticas.
Usar o que é familiar, mesmo que não seja um grande exemplo de código naquela linguagem, ajuda o estudante a chegar mais rápido ao objetivo de escrever um código mais típico da linguagem.
Desenvolvendo o primeiro exercício
Em vez de tentar mapear a árvore de conceitos inteira de antemão, comece apenas pelo primeiro exercício.
O objetivo do primeiro exercício é permitir que o estudante comece a aprender com o mínimo de atrito possível.
Ele está dando o primeiríssimo passo para se familiarizar com a cara do código nessa linguagem.
Pode ser que ele escreva um pequeno trecho de código, ou talvez apenas faça algumas adições a um esqueleto para completar o exercício.
Os estudantes já resolveram "Hello, World!" para acessar esse exercício.
Mas, em "Hello, World!", eles só estão mudando o texto.
Toda a sintaxe da linguagem ainda pode ser desconhecida.
Procure otimizar para uma vitória rápida e para deixar os estudantes familiarizados o suficiente com o básico da sintaxe para seguir em frente com confiança.
Leia mais sobre como desenvolver o primeiro exercício.
Os próximos exercícios
O primeiro exercício deve desbloquear alguns exercícios que apresentam conceitos fundamentais.
Serão coisas como primitivas ou tipos básicos e operações simples sobre esses tipos.
Leia mais sobre como desenvolver os próximos exercícios.
E depois?
É aqui que as coisas costumam começar a ficar interessantes.
Há tanta coisa que você poderia apresentar neste ponto.
Como você decide quais conceitos abordar em seguida?
Na verdade, pouco importa.
Desde que você comece por algum lugar que pareça razoável, vai dar certo.
Leia mais sobre o que consideramos "razoável" no contexto de expandir a árvore de conceitos.
Não converta exercícios de prática
Um bom Exercício de Conceito é extremamente focado e, idealmente, ensina apenas um conceito.
Normalmente há apenas uma abordagem esperada para resolvê-lo.
Isso contrasta com os Exercícios de Prática, que são abertos e convidam à exploração.
Um bom Exercício de Conceito costuma ser um mau Exercício de Prática, e vice-versa.
Como os objetivos dos Exercícios de Prática e dos Exercícios de Conceito são completamente diferentes, não pegamos Exercícios de Prática e os convertemos em Exercícios de Conceito.
Escrevemos todos os Exercícios de Conceito do zero ou nos baseamos em histórias criadas especificamente para ensinar conceitos simples.
Incentivamos passar por cima de detalhes
Às vezes você vai sentir que há um impasse.
O conceito A exige entender o conceito B, e o B exige entender o A.
Nesse caso, simplifique.
Passe por cima de um pouco da complexidade de um deles para que os estudantes se familiarizem com o outro.
Não há problema nenhum em dizer que algo será apresentado com mais profundidade depois e que, por enquanto, o estudante só precisa entender aquele ponto.
Os conceitos são compreendidos com mais profundidade por etapas e ao longo do tempo.
Escolhendo histórias
Um exercício de conceito sempre tem uma história.
Se você estiver fazendo um fork de um exercício de outra trilha, o exercício já terá uma história.
Nesse caso, está tudo pronto.
Para ver se existem histórias que você possa usar ou exercícios que você possa fazer fork, dê uma olhada na lista de histórias.
Se você tem um conceito mas não tem história, a nossa recomendação é escrever um exemplo de código pequeno e simples que use o conceito que você está apresentando.
Depois, faça o caminho inverso e crie uma história em cima do código.
Mantenha a história absurdamente simples.
Não precisa ser uma boa ficção.
Não precisa de um enredo forte nem de desenvolvimento de personagens.
Pode ter só algumas linhas.
Troque ideias de histórias com a equipe do Exercism.
Temos muita experiência em criar histórias adequadas.
Depois de ter uma história, provavelmente você vai precisar ajustar um pouco o código para que ele se encaixe nela.
Contribuições da comunidade
Trabalhar em uma ementa envolve duas atividades separadas, mas entrelaçadas:
- Planejamento da ementa: selecionar e ordenar os conceitos
- Implementação dos exercícios: escrever a documentação e criar exercícios para ensinar esses conceitos
Descobrimos que é divertido e enriquecedor fazer com que a comunidade em geral contribua com a implementação dos exercícios.
Já o planejamento da ementa em si é mais fácil de tocar com uma equipe pequena de contribuidores, todos envolvidos em construir uma compreensão da ementa inteira, com todas as suas minúcias.
Dito isso, recomendamos que a equipe de planejamento da ementa implemente os primeiros cinco ou seis conceitos antes de abrir espaço para contribuições da comunidade.
Isso ajuda a garantir que as pessoas do time principal de planejadores da ementa entendam o processo elas mesmas antes de precisarem revisar pull requests de pessoas da comunidade em geral.
Também é mais fácil criar issues para esses conceitos de nível mais alto, e costuma ser mais divertido para os membros da comunidade trabalhar neles, já que há menos restrições com que se preocupar.
Criando issues
Ainda não descobrimos a melhor forma de criar issues para a criação de exercícios de conceito.
Em algumas trilhas, tentamos criar issues separadas para o conceito em si e para o exercício.
Em outras, tentamos criar issues com uma lista de tarefas para ir seguindo.
No geral, achamos que isso ainda é intimidador demais, e gostaríamos de encontrar uma forma melhor.
Fale com a gente sobre o processo quando você começar a criar issues, e faremos o possível para ajudar a definir como seguir.
Vamos atualizar a documentação conforme aprendermos formas melhores de lidar com isso.
