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

18

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?

bitbonk
fonte
3
Alguns IDEs podem ser configurados para lembrar que os últimos arquivos são abertos e a posição de rolagem para esses arquivos.
FrustratedWithFormsDesigner
8
// CHEGOU AQUI. (Também, que fecha a sua IDE?)
Alex Feinman
2
O Vim lembrará onde você estava em todos os arquivos quando receber instruções para fazê-lo.~/.vimrc
alternativa
O Eclipse abre todos os arquivos que eu tinha aberto quando o fechei, na mesma posição. Se isso não ajudar, git status git diff` e git logseus amigos.
Ingo
O Emacs fará isso se você ativar o Save Place: emacswiki.org/emacs/SavePlace
Luke Girvin

Respostas:

17

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

Kevin Cline
fonte
1
Vale destacar a consequência lógica: intencionalmente deixando um teste falhando quando terminar para o dia é uma boa maneira de lembrar-se o que você queria trabalhar no dia seguinte ...
Jules
9

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.

crosenblum
fonte
2
Eu faço o mesmo, mas basta escrever no meu bloco de notas com um lápis
Zachary K
Também faço isso com um bloco de notas e, toda semana, me livre da página antiga e começo uma nova.
Configurador
1
Eu mantenho todos os meus objetivos todos os dias, me dá uma aparência histórica de todo o trabalho que fiz e vamos revisar o que contribuí para a empresa.
precisa saber é o seguinte
O complemento tomboy "Nota do dia" é muito bom para isso. Você pode configurar um modelo com um cabeçalho como "Todos de hoje". Você pode começar todos os dias observando as anotações do dia anterior. live.gnome.org/Tomboy/PluginList
Tim Abell
8

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.

Steven Jeuris
fonte
Mas e se você parasse de trabalhar no projeto (por mais tempo) porque precisaria trabalhar em outro projeto?
bitbonk
1
@bitbonk: Eu não pararia de trabalhar em um projeto, bem no meio da implementação de uma determinada função. Provavelmente nem mesmo uma turma, então não há "aqui".
Steven Jeuris
Bem, sorte sua! :)
bitbonk
5

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.

Sparky
fonte
1

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

Anto
fonte
"HIER" (alemão)
bitbonk 25/02
"HIER" também em holandês, não "HEIR"
Steven Jeuris
3
//HIERARCHY DOCUMENTATION... opa!
Mason Wheeler
@Mason: Uma pesquisa "apenas palavra inteira" evitará esse problema.
dan04
1

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 ...

bitsoflogic
fonte
1

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.

P Shved
fonte
1

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

softveda
fonte
0

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

bitbonk
fonte
0

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

Steven A. Lowe
fonte
0

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 ...

Mason Wheeler
fonte
Em c, #error preenche a mesma necessidade. O Java não oferece suporte imediato, mas você pode adicionar uma anotação processada em tempo de compilação ao seu projeto: é um pouco de trabalho para configurar, mas relativamente simples de usar, uma vez feito. Tenho certeza de que existem abordagens semelhantes para outros idiomas ... #
317 Jules
0

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.

Steve Jackson
fonte
0

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.

Paul Nathan
fonte
0

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.

Peter Taylor
fonte
0

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á?

Dima
fonte
2
-1 Nunca se comprometa apenas para se comprometer! E se você não tivesse terminado o que estava fazendo? Mesmo se você estiver usando DVCS, ainda é um incômodo. Confirme com base na mudança lógica, não no dia.
alternativa
Eu discordo respeitosamente. Você deve cometer frequentemente. Se você não tiver terminado, crie uma ramificação temporária e se comprometa com isso, para não quebrar o tronco. Mais tarde, quando tiver terminado, você mescla sua ramificação novamente. A confirmação no final do dia também cria um backup do seu trabalho, caso o computador morra.
Dima
Mas incluir o que você pretende ser no dia seguinte é abusar das mensagens de confirmação. Lembre-se de que essas mensagens devem formar um log meses úteis abaixo da linha.
Ben Voigt
@ Ben Voigt: como eu disse, se você precisar interromper seu trabalho no meio de uma tarefa, faça-o em um ramo separado. Então sua mensagem de confirmação estará apenas nesse ramo, e não no tronco principal. Além disso, o que você pretende fazer no dia seguinte é uma descrição muito boa do estado atual do seu código. Apenas pode ser meses úteis abaixo da linha.
Dima
0

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

user18513
fonte
0

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.

JeffO
fonte
0

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.

wildpeaks
fonte
+1: Eu absolutamente amamos este: "Além disso, essa marca é vermelho brilhante para mim graças a sinestesia ..."
Peter Rowell
0

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.

Kevin Hsu
fonte
0

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" )

Jan Doggen
fonte