Como você se lembra onde no seu código deseja continuar na próxima vez? [fechadas]

Quando você interrompe o trabalho em algum código (seja porque você precisa trabalhar em outra coisa ou sair de férias ou simplesmente porque é o fim do dia), depois de fechar o projeto do Visual Studio, qual é a sua maneira preferida de lembrar o que você quer fazer a seguir quando começar a trabalhar nesse código novamente.

Você define um marcador do Visual Studio ou escreve algo parecido // TODO: continue here next time? Talvez você tenha uma etiqueta especial como // NEXT:? Você coloca uma nota no seu monitor? Você usa uma ferramenta legal ou o plug-in do Visual Studio que eu deveria saber?

Você tem algum truque pessoal que ajuda a encontrar o local do código em que você parou na última vez em que trabalhou no código?

Corrijo os testes de unidade que não estão funcionando. Se todos estão passando, escrevo um novo.

No início de cada dia, tenho um arquivo de texto chamado Todays Goals.txt e, a cada dia, adiciono a data dessa forma.

Sexta-feira 25/02/2011 Gols

Depois, escrevo cada projeto em que estou trabalhando e o que tenho que fazer hoje ou concluí-lo.

Então, no final do dia, escrevo as coisas a serem feitas amanhã.

Esse processo diário me ajuda a lembrar exatamente o que preciso fazer e garantir que cada dia seja bem planejado.

Basicamente, nunca esqueço o que estou trabalhando. O Visual Studio é aberto no último arquivo em que você estava trabalhando, ou eu nunca encerro o Visual Studio e hiberna.

Lugar que eu NotImplementedExceptions em abstrações / implementações que não são necessariamente importante para continuar a desenvolver o que eu estava trabalhando.

Coloco muitos TODOs no meu código, mas não como você afirmou. Coloco-os onde sei que uma determinada abordagem seria mais agradável / com melhor desempenho, mas não é necessária no momento. Isso fornece uma boa indicação para mim e futuros desenvolvedores sobre onde há espaço para melhorias.

Usando a Lista de tarefas do Visual Studio, você pode visualizar facilmente todos os lugares onde deixou essas indicações e até adicionar outras personalizadas.

ATUALIZAR:

" HACK :" também é legal quando você escreve algo que funciona, mas você não está nem um pouco satisfeito.

No final de cada dia, escrevo em minha pasta de trabalho sobre o que realizei naquele dia, o que espero realizar no dia seguinte e as coisas que ainda faltam fazer.

No início de cada dia, refiro-me às minhas anotações anteriores para me atualizar com o que preciso fazer. Depois, passo mais alguns minutos fazendo mais anotações com base no que aconteceu desde que saí para descobrir o que mais preciso fazer e quais são minhas prioridades.

Acho que isso me ajuda a relaxar e deixar ir no final do dia e acelerar no início. Além disso, quando chegar a hora das revisões anuais ou trimestrais, basta consultar minha pasta de trabalho para determinar o que estava fazendo durante o período em análise.

Eu uso o Productivity Power Tools para VS. Com isso, posso fixar as guias e agrupá-las. = D Dessa forma, nunca esqueço o que estava trabalhando.

Além disso, também adiciono muito // TODO'sao meu código.

http://visualstudiogallery.msdn.microsoft.com/d0d33361-18e2-46c0-8ff2-4adea1e34fef/

Em uma das entrevistas em "Os Masterminds of Programming", (acho que foi Guido van Rossum, criador do Python), o entrevistado disse que adicionou um //HIERcomentário semelhante no local em que terminou na última vez. "HIER" é holandês (?) Por aqui e ele o escolhe porque, se procurar essa sequência, é improvável encontrar outras ocorrências

De longe, minha maneira favorita é através do TDD. É bastante óbvio onde você está quando seu conjunto de testes falha.

Mas nem todos os projetos permitem o TDD, então eu costumo quebrar o código com um comentário não comentado de onde parei.

// Some Comment

Becomes Some Comment // Which Produces Some Fatal Error

Esse erro fatal garante que eu não deixe esse código intocado antes de liberá-lo.

Por fim, sempre posso verificar meus vcs para ver o que foi alterado desde meu último commit e isso me dará uma boa idéia de para onde devo ir a seguir ...

Eu uso duas técnicas modernas muito sofisticadas com uma curva de aprendizado muito acentuada:

• Não desligue o seu computador . Vá para casa e na manhã seguinte você verá na tela o local exato em que parou de invadir ontem. Mas os riscos de perder seu posto de controle são muito maiores se você sair de férias.

• Deixe um erro de compilação e faça check-out para outra ramificação. Portanto, seu código C ++ seria assim:

  for (i=0; i<N; i++){
    int j = i + oh, no, my boss wants me to fix text on the front page!
    why? why should I do it?  Jimmy could have done it faster, but
    of course, my office is closer to the boss', and he doesn't want to
    take longer walks, that lazy fat bastard...
  

  Dessa forma, o projeto não será desenvolvido quando você ligar o computador ou voltar para a filial onde estava executando o desenvolvimento ativo. Seu compilador mostrará a linha e o arquivo exatos onde encontrou os seus comentários.

Essas técnicas me ajudaram a reconhecer o local em que deixei o desenvolvimento e são apoiadas por estudos e experiências abrangentes de muitos programadores em todo o mundo. Eu sugiro que você os experimente.

Agora, esse é um recurso integrado do Visual Studio 2012, onde você pode suspender e retomar sua área de trabalho. Suspender fará um instantâneo de seus arquivos abertos, pontos de interrupção, lista de observação, itens de trabalho etc. e o currículo o trará de volta. Basicamente, todo o seu contexto de trabalho é salvo e será retomado exatamente como você saiu.
http://msdn.microsoft.com/en-us/library/ms181403.aspx

Um pequeno vídeo mostrando o recurso está aqui
http://channel9.msdn.com/Series/Visual-Studio-2012-Premium-and-Ultimate-Overview/Visual-Studio-Ultimate-2012-How-to-multi-task- with-My-Work

Minha atual opção preferida é a // NEXT:etiqueta especial . Juntamente com o TODO Explorer do ReSharper , é muito fácil descobrir e manter.

Eu mantenho um log de desenvolvimento para cada iteração em um subprojeto de documentos não criado no visual studio; a última linha do log é sempre a próxima tarefa.

eu também não fecho o visual studio com muita frequência, basta colocar o computador no modo de espera

Para encontrar o que preciso retornar imediatamente, costumo colocar um comentário em:

//TODO: figure out why the widget doesn't unfrob properly

Eu o envolvo com linhas em branco e chama minha atenção facilmente quando a vejo novamente. Para problemas de longo prazo nos quais precisarei voltar, eu uso uma diretiva de compilador Delphi que permite emitir mensagens durante a compilação:

{$MESSAGE WARN 'This method is not yet implemented'}

Não tenho certeza se outros idiomas podem fazer isso ...

As listas TODO não funcionam quando se trata de voltar a um projeto meses antes. Os comentários no código não funcionam bem para mim, é muito fácil ignorar ou lembrar se eu terminei completamente o projeto X e devo procurar todos primeiro. E se você tiver uma equipe maior, cada pessoa com sua própria frase TODO ... ugh.

Desde que meu dia começa com update / merge / build, algo que tentei ocasionalmente é colocar um erro de compilação intencional em um arquivo (mas não o check-in). Infelizmente, parei de fazer isso depois de uma visita inesperada ao escritório que queria ver uma demonstração de algo em que trabalhei na semana anterior. "Aqui, deixe-me abrir isso ... espera ... o que isso significa ... ok então ..."

Então, mudei disso para escrever um caso de teste com falha intencional.

Deixo o emacs com o código em que estava trabalhando na tela no dia seguinte.

Às vezes, escrevo uma nota não compilável no código, dizendo-me o que fazer a seguir.

Para um widget realmente complicado em que eu possa ficar confuso sobre as coisas, escreverei notas para mim mesmo em um caderno ou como comentário.

Se é apenas para manter meu lugar em um arquivo enquanto acompanho uma pesquisa, às vezes eu abro pontos de interrupção.

Para acompanhar o fim de semana de onde eu estava, deixo uma nota com o número do problema do rastreador de erros.

Você está usando um sistema de controle de versão? Se sim, você deve confirmar suas alterações no final do dia e descrever o que fez e o que precisa fazer a seguir no comentário. E se não, então por que você não está?

Apenas não fecho o Visual Studio e hiberno o Windows no final do dia.

Sou um dos poucos que reinicia todas as noites (ainda no Win XP no trabalho e sinto que o desempenho é melhor.), Então crio uma tarefa do Outlook com um lembrete definido para a manhã seguinte. Posso colocar o nome do arquivo, uma cópia da linha de código ou uma nota suficiente para me informar o que estava fazendo.

Várias coisas ajudam:

• Eu procuro o texto "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", que possui os benefícios que o código não pode executar (seja ele compilado ou interpretado), então não posso faltar. Além disso, essa tag é vermelha brilhante para mim, graças à sinestesia , por isso é realmente fácil identificá-la, mesmo em um grande pedaço de código.

• O IDE reabre os arquivos no local em que cada um estava aberto (e quais linhas foram destacadas / pontos de interrupção), para que eu possa lembrar rapidamente o que estava fazendo.

• Posso ver na minha lista de tarefas qual problema estava tentando resolver / recurso a ser implementado.

Como você não disse que precisa codificar para realmente compilar na depuração e no lançamento, um truque que eu costumo fazer é:

#if DEBUG
#error "YOU LEFT OFF HERE"
#endif

Muito difícil esquecer isso. Caso contrário, eu colocaria um aviso de #pragma no código para que ele apareça sempre que você compilar.

Eu uso vários truques:

• Coloque @@ nos comentários do código ou em um documento para itens que precisam ser feitos na iteração atual, mas não imediatamente. Nenhum código ou documento sai da minha máquina se contiver @@.

• Nesse local específico que preciso continuar trabalhando amanhã de manhã, marque @@ HERE. Isso raramente é necessário porque meu IDE abrirá onde eu fecho mais cedo, e você pode até pedir ao Word para fazer isso .

• Todas as coisas que devem ser corrigidas / adicionadas posteriormente entram em um sistema adequado de rastreamento de bugs ou estão nos documentos de design.

E você tem certeza de que o Visual Studio não consegue se lembrar do último local em que estava trabalhando? "Suspender o trabalho com o Visual Studio 2012" diz que isso pode ser feito em 2012 (o início do Google for Visual Studio "parou" )