Inglês para devs · Pair programming

Pair programming em inglês: frases para a sessão

Resposta rápida

Em pair programming em inglês você fala enquanto programa, e isso pede frases curtas: explicar o que está fazendo, sugerir uma ideia, trocar quem digita e pedir uma pausa. Selecionamos 300 frases do app Devlingo, com tradução, contexto e áudio, para usar na próxima sessão de pair.

Atualizado em

Os dois papéis têm nome: quem digita é o driver e quem orienta é o navigator. Para trocar, Do you want to drive?; para pensar em voz alta, I'm going to try….

Frases fáceis (128)

  1. Do you want to drive or navigate?

    Você quer dirigir ou navegar?

    Quando usar: Deciding roles at the start of a pair programming session

  2. I'll drive first, and we can switch in 20 minutes.

    Eu dirijo primeiro, e podemos trocar em 20 minutos.

    Quando usar: Setting up a rotation schedule for pair programming roles

  3. Can you share your screen?

    Você pode compartilhar sua tela?

    Quando usar: Asking your pair to share their screen for a remote session

  4. Let me think out loud for a second.

    Deixa eu pensar em voz alta por um momento.

    Quando usar: Pausing to verbalize your thought process to your pair

  5. What do you think about this approach?

    O que você acha dessa abordagem?

    Quando usar: Asking your pair for feedback on a proposed solution

  6. Can you explain what this function does?

    Você pode explicar o que essa função faz?

    Quando usar: Asking your pair to walk you through unfamiliar code

  7. Let's write a test for this before we move on.

    Vamos escrever um teste para isso antes de continuar.

    Quando usar: Suggesting to add a test while pairing before proceeding

  8. Good catch! I wouldn't have noticed that.

    Boa observação! Eu não teria percebido isso.

    Quando usar: Acknowledging when your pair spots a mistake or improvement

  9. Can you zoom in? I can't read the code from here.

    Pode aumentar o zoom? Não consigo ler o código daqui.

    Quando usar: Asking to increase font size during a remote or in-person pairing session

  10. You're going too fast. Can you slow down a bit so I can follow along?

    Você está indo muito rápido. Pode ir um pouco mais devagar para eu acompanhar?

    Quando usar: Asking your pair to reduce their pace during collaborative coding

  11. Can you walk me through this function before we start refactoring it?

    Pode me explicar essa função antes de começarmos a refatorá-la?

    Quando usar: Asking your pair to explain existing code before making changes

  12. Let's write the test first and then figure out the implementation together.

    Vamos escrever o teste primeiro e depois descobrir a implementação juntos.

    Quando usar: Starting with TDD approach during a pair programming session

  13. I'm lost — can you scroll back up to where we defined that variable?

    Me perdi — pode rolar pra cima até onde definimos aquela variável?

    Quando usar: Asking your pair to navigate back to a previous section of code

  14. Nice catch! I totally missed that edge case.

    Boa observação! Eu tinha passado totalmente por esse caso limite.

    Quando usar: Acknowledging when your pair spots a bug or oversight you missed

  15. I have an idea but I'm not sure it'll work. Mind if I try it real quick?

    Tenho uma ideia mas não sei se vai funcionar. Se importa se eu tentar rapidinho?

    Quando usar: Proposing an experimental approach during pairing

  16. Let's swap — you've been driving for a while and I want to try something.

    Vamos trocar — você está dirigindo há um tempo e eu quero tentar algo.

    Quando usar: Requesting to switch roles during a pairing session

  17. Before we write any code, let's sketch out the approach on a whiteboard.

    Antes de escrevermos código, vamos esboçar a abordagem no quadro branco.

    Quando usar: Planning before coding during a pair programming session

  18. Let me share my VS Code session so we can both edit in real time.

    Deixa eu compartilhar minha sessão do VS Code para editarmos em tempo real.

    Quando usar: Setting up a Live Share session for remote pair programming

  19. I learned a new keyboard shortcut — watch this, it'll save us a lot of time.

    Aprendi um novo atalho de teclado — olha isso, vai nos economizar muito tempo.

    Quando usar: Sharing productivity tips with your pair during coding

  20. Can you zoom in a bit? The font is too small for me to read from here.

    Pode dar um zoom? A fonte está muito pequena para eu ler daqui.

    Quando usar: Asking your pair to adjust display settings during remote pairing

  21. Let me pull up the acceptance criteria so we don't miss anything.

    Deixa eu abrir os critérios de aceitação para não esquecermos nada.

    Quando usar: Referencing requirements during pairing to stay on track

  22. We've been going for two hours. Let's take a break and come back with fresh eyes.

    Já estamos há duas horas. Vamos fazer uma pausa e voltar com olhos frescos.

    Quando usar: Recognizing fatigue and suggesting a break during a long pairing session

  23. Your approach is interesting. I've never used that pattern before — can you explain how it works?

    Sua abordagem é interessante. Nunca usei esse padrão antes — pode explicar como funciona?

    Quando usar: Learning from your pair's different technique or pattern

  24. Let's commit what we have so far and continue in a new branch.

    Vamos commitar o que temos até agora e continuar em uma nova branch.

    Quando usar: Saving progress by committing incrementally during pairing

  25. I keep getting a type mismatch here. Can you take over and see if you spot the issue?

    Estou recebendo um tipo incompatível aqui. Pode assumir e ver se encontra o problema?

    Quando usar: Handing the keyboard over when you're stuck on a specific error

  26. Let's review the git diff together before pushing to make sure everything looks right.

    Vamos revisar o git diff juntos antes de fazer push para garantir que tudo está certo.

    Quando usar: Doing a final review of changes before submitting code

  27. I'm going to mute my mic for a minute while I read through this code block.

    Vou mutar meu microfone por um minuto enquanto leio esse bloco de código.

    Quando usar: Taking a moment to silently read code during remote pairing

  28. I've never worked with this framework before — this is a great learning opportunity for me.

    Nunca trabalhei com esse framework antes — essa é uma ótima oportunidade de aprendizado para mim.

    Quando usar: Acknowledging a knowledge gap and being open to learning during pairing

  29. I'm going to type while you dictate — tell me what to write next.

    Vou digitar enquanto você dita — me diga o que escrever.

    Quando usar: Adopting a dictation style of pair programming

  30. Let's use the Pomodoro technique — 25 minutes of focused pairing, then a five-minute break.

    Vamos usar a técnica Pomodoro — 25 minutos de pairing focado, depois 5 minutos de pausa.

    Quando usar: Structuring a pairing session with timed intervals

  31. Can you open the terminal in a split view? I want to see the logs while we make changes.

    Pode abrir o terminal em tela dividida? Quero ver os logs enquanto fazemos alterações.

    Quando usar: Optimizing the screen layout for simultaneous coding and monitoring

  32. The connection is lagging — let me restart the Live Share session.

    A conexão está com lag — deixa eu reiniciar a sessão de Live Share.

    Quando usar: Troubleshooting remote pairing tools when they're not performing well

  33. Let's create a TODO comment here and come back to it — this is a separate concern.

    Vamos criar um comentário TODO aqui e voltar depois — isso é uma preocupação separada.

    Quando usar: Deferring tangential work to stay focused on the current task

  34. The build is taking too long. Let's review the PR description while we wait.

    O build está demorando demais. Vamos revisar a descrição do PR enquanto esperamos.

    Quando usar: Making productive use of wait time during pairing

  35. I just realized this component already exists in our shared library. We don't need to rewrite it.

    Acabei de perceber que esse componente já existe na nossa biblioteca compartilhada. Não precisamos reescrevê-lo.

    Quando usar: Discovering existing reusable code that avoids duplication

  36. Do you have a preference for how we name this function? I'm torn between two options.

    Você tem preferência de como nomear essa função? Estou em dúvida entre duas opções.

    Quando usar: Collaborating on naming decisions during development

  37. Let's annotate the code with comments for now and clean them up later.

    Vamos anotar o código com comentários por agora e limpar depois.

    Quando usar: Using temporary comments to track thoughts during complex implementation

  38. I like how you structured that. Can you explain the thought process so I can apply it elsewhere?

    Gostei de como você estruturou isso. Pode explicar o processo de pensamento para eu aplicar em outros lugares?

    Quando usar: Actively learning from your pair's problem-solving approach

  39. I just noticed the CI is failing on our branch. Let's check the logs before we continue.

    Acabei de notar que o CI está falhando na nossa branch. Vamos checar os logs antes de continuar.

    Quando usar: Responding to CI failures during a pairing session

  40. Let's pair on the code review — we can go through the diff together and leave comments.

    Vamos fazer o code review juntos — podemos percorrer o diff e deixar comentários.

    Quando usar: Doing code reviews collaboratively as a form of pairing

  41. I'm going to rename this variable to something more descriptive — currentUserPermissions instead of just perms.

    Vou renomear essa variável para algo mais descritivo — currentUserPermissions em vez de só perms.

    Quando usar: Improving code readability during collaborative coding

  42. That was a tough one. Nice job figuring it out together — I don't think I could've solved it alone.

    Esse foi difícil. Bom trabalho resolvendo juntos — acho que não teria conseguido sozinho.

    Quando usar: Celebrating collaborative problem solving after a difficult challenge

  43. Let's do a quick code walkthrough of the existing module before we start making changes.

    Vamos fazer um walkthrough rápido do módulo existente antes de começar a fazer mudanças.

    Quando usar: Understanding legacy code before modifying it during pairing

  44. Let's look at how other teams solved this by checking the internal codebase.

    Vamos ver como outras equipes resolveram isso verificando a codebase interna.

    Quando usar: Researching existing solutions within the organization during pairing

  45. I'm going to copy the curl command from Postman so we can test the endpoint from the terminal.

    Vou copiar o comando curl do Postman para testarmos o endpoint pelo terminal.

    Quando usar: Using API tools during collaborative testing

  46. You handle the frontend changes and I'll update the backend to match.

    Você cuida das mudanças no frontend e eu atualizo o backend para combinar.

    Quando usar: Splitting full-stack work across the pair for parallel development

  47. I have a feeling this is a caching issue. Let's clear the cache and try again.

    Tenho a sensação de que isso é um problema de cache. Vamos limpar o cache e tentar de novo.

    Quando usar: Troubleshooting intermittent issues during collaborative debugging

  48. Let's not fix the formatting manually — just run the code formatter and let it handle everything.

    Não vamos corrigir a formatação manualmente — basta rodar o formatador de código e deixar ele resolver.

    Quando usar: Using automated tools instead of manual formatting during pairing

  49. Great pairing session today. I feel like I learned a lot about how you approach architecture decisions.

    Ótima sessão de pairing hoje. Sinto que aprendi muito sobre como você aborda decisões de arquitetura.

    Quando usar: Giving positive feedback after a productive pairing session

  50. Can you check Stack Overflow for that error while I try a different approach?

    Pode procurar esse erro no Stack Overflow enquanto eu tento uma abordagem diferente?

    Quando usar: Dividing research and coding work during troubleshooting

  51. Thanks for pairing with me today — next time let's tackle the authentication flow together.

    Obrigado por parear comigo hoje — na próxima vez vamos atacar o fluxo de autenticação juntos.

    Quando usar: Wrapping up a session and planning the next pairing topic

  52. Can you walk me through what you're thinking here?

    Pode me explicar o que você está pensando aqui?

    Quando usar: Asking for explanation while pairing

  53. Let me take over the keyboard for a bit.

    Deixa eu pegar o teclado por um momento.

    Quando usar: Switching driver role

  54. That's a clever solution, I wouldn't have thought of that.

    Essa é uma solução inteligente, eu não teria pensado nisso.

    Quando usar: Giving positive feedback

  55. Let's break this problem down into smaller pieces.

    Vamos dividir esse problema em partes menores.

    Quando usar: Suggesting approach

  56. Should we commit what we have so far before continuing?

    Devemos commitar o que temos até agora antes de continuar?

    Quando usar: Suggesting incremental progress

  57. Can you zoom in on that part of the code? I can't read it clearly.

    Pode dar zoom nessa parte do código? Não consigo ler claramente.

    Quando usar: Asking for visibility

  58. Let's add a comment here to explain why we're doing this.

    Vamos adicionar um comentário aqui para explicar por que estamos fazendo isso.

    Quando usar: Suggesting documentation

  59. I think there's a simpler way to do this, let me show you.

    Acho que tem uma forma mais simples de fazer isso, deixa eu te mostrar.

    Quando usar: Suggesting alternative

  60. Wait, I think we introduced a bug. Let me scroll back.

    Espera, acho que introduzimos um bug. Deixa eu voltar.

    Quando usar: Catching a mistake

  61. Good catch! I completely missed that null check.

    Boa pegada! Eu perdi completamente essa verificação de nulo.

    Quando usar: Acknowledging partner's contribution

  62. Let me run the tests to make sure we didn't break anything.

    Deixa eu rodar os testes para ter certeza que não quebramos nada.

    Quando usar: Verifying changes

  63. Let's use the debugger to step through this code.

    Vamos usar o debugger para percorrer esse código passo a passo.

    Quando usar: Suggesting debugging approach

  64. Can you explain the business logic behind this feature?

    Pode explicar a lógica de negócio por trás dessa funcionalidade?

    Quando usar: Asking for context

  65. Let's look at the documentation for this library before using it.

    Vamos olhar a documentação dessa biblioteca antes de usá-la.

    Quando usar: Suggesting research

  66. Your idea is better than mine, let's go with your approach.

    Sua ideia é melhor que a minha, vamos seguir sua abordagem.

    Quando usar: Deferring to partner

  67. I'm getting a compile error on this line, can you spot the issue?

    Estou recebendo um erro de compilação nessa linha, consegue ver o problema?

    Quando usar: Asking for help with error

  68. Let's take a five-minute break, I need to clear my head.

    Vamos fazer uma pausa de cinco minutos, preciso clarear a mente.

    Quando usar: Suggesting a break

  69. I learned something new from you today, thanks for sharing.

    Aprendi algo novo com você hoje, obrigado por compartilhar.

    Quando usar: Expressing gratitude for learning

  70. Can you share your screen? The audio is fine but I can't see the code.

    Pode compartilhar sua tela? O áudio está bom mas não consigo ver o código.

    Quando usar: Technical setup

  71. Let's try the other approach and see if the tests pass.

    Vamos tentar a outra abordagem e ver se os testes passam.

    Quando usar: Suggesting experimentation

  72. I noticed a typo in the variable name, should be camelCase.

    Percebi um typo no nome da variável, deveria ser camelCase.

    Quando usar: Catching naming error

  73. Nice, the test is green. Let's move on to the next scenario.

    Legal, o teste está verde. Vamos para o próximo cenário.

    Quando usar: Celebrating progress

  74. I don't think we need this import, it's unused.

    Acho que não precisamos desse import, está sem uso.

    Quando usar: Catching unnecessary code

  75. Let me draw a diagram to explain what I'm thinking.

    Deixa eu desenhar um diagrama para explicar o que estou pensando.

    Quando usar: Visual communication

  76. Let's look at how the existing code handles this case.

    Vamos ver como o código existente trata esse caso.

    Quando usar: Suggesting reference

  77. This is a good learning opportunity, take your time with it.

    Essa é uma boa oportunidade de aprendizado, leve o seu tempo.

    Quando usar: Encouraging learning

  78. Let's timebox this to 30 minutes and reassess if we're stuck.

    Vamos limitar isso a 30 minutos e reavaliar se estivermos travados.

    Quando usar: Managing time

  79. I think the naming could be more descriptive, what about calling it processPayment?

    Acho que o nome poderia ser mais descritivo, que tal chamar de processPayment?

    Quando usar: Suggesting naming improvement

  80. Can you explain this algorithm to me? I want to make sure I understand it.

    Pode me explicar esse algoritmo? Quero ter certeza que entendi.

    Quando usar: Asking for knowledge transfer

  81. Let's use print statements to debug this quickly.

    Vamos usar prints para debugar isso rapidamente.

    Quando usar: Suggesting quick debugging

  82. That's a great refactoring, the code reads much better now.

    Ótima refatoração, o código lê muito melhor agora.

    Quando usar: Giving positive feedback

  83. Should we add a guard clause at the top of this function?

    Devemos adicionar uma guard clause no topo dessa função?

    Quando usar: Suggesting defensive coding

  84. Let's commit this working version and then optimize later.

    Vamos commitar essa versão funcional e otimizar depois.

    Quando usar: Prioritizing progress

  85. Interesting approach, I've never seen it done that way before.

    Abordagem interessante, nunca vi feito dessa forma antes.

    Quando usar: Acknowledging novelty

  86. The linter is complaining about the line length, can we split this?

    O linter está reclamando do tamanho da linha, podemos dividir isso?

    Quando usar: Following code standards

  87. I'll type the test, you tell me what assertions we need.

    Eu escrevo o teste, você me diz quais asserções precisamos.

    Quando usar: Dividing pairing tasks

  88. We should probably create a feature branch for this.

    Provavelmente devemos criar uma feature branch para isso.

    Quando usar: Suggesting git workflow

  89. Let me look up the API docs for this method real quick.

    Deixa eu consultar a documentação da API desse método rapidamente.

    Quando usar: Researching during pairing

  90. The UI looks great, but I think we should add some accessibility labels.

    A UI está ótima, mas acho que devemos adicionar alguns labels de acessibilidade.

    Quando usar: Suggesting accessibility improvement

  91. That error message isn't very helpful, let's make it more descriptive.

    Essa mensagem de erro não é muito útil, vamos torná-la mais descritiva.

    Quando usar: Improving error messages

  92. I think we should validate the input before processing it.

    Acho que devemos validar o input antes de processá-lo.

    Quando usar: Suggesting validation

  93. Can you try resizing the window to see if the layout adapts?

    Pode tentar redimensionar a janela para ver se o layout se adapta?

    Quando usar: Testing responsive design

  94. Great pairing session today! I feel like we made solid progress.

    Ótima sessão de pair hoje! Sinto que fizemos um progresso sólido.

    Quando usar: Wrapping up

  95. Should we use a constant for this magic number?

    Devemos usar uma constante para esse número mágico?

    Quando usar: Suggesting code clarity

  96. I'm going to rubber duck this problem with you.

    Vou explicar esse problema em voz alta para você.

    Quando usar: Describing debugging technique

  97. Let's revert that last change, it introduced a regression.

    Vamos reverter essa última mudança, ela introduziu uma regressão.

    Quando usar: Suggesting revert

  98. This code is really clean, we should keep this standard going forward.

    Esse código está muito limpo, devemos manter esse padrão daqui pra frente.

    Quando usar: Praising code quality

  99. Let me quickly search for similar implementations in our codebase.

    Deixa eu buscar rapidamente implementações similares na nossa codebase.

    Quando usar: Researching existing code

  100. Let's add a breakpoint here and inspect the state at runtime.

    Vamos colocar um breakpoint aqui e inspecionar o estado em runtime.

    Quando usar: Debugging technique

  101. Should we switch who's driving? Fresh eyes might help.

    Devemos trocar quem está pilotando? Olhos frescos podem ajudar.

    Quando usar: Suggesting role swap

  102. Let's create a separate branch so we can experiment without risk.

    Vamos criar uma branch separada para podermos experimentar sem risco.

    Quando usar: Managing risk

  103. Nice, we just saved ourselves hours of debugging with that test.

    Legal, acabamos de nos poupar horas de debugging com esse teste.

    Quando usar: Appreciating test value

  104. This is a common pattern in our codebase, let me show you an example.

    Esse é um padrão comum na nossa codebase, deixa eu te mostrar um exemplo.

    Quando usar: Teaching by example

  105. I'm going to add a TODO here so we remember to come back to this.

    Vou adicionar um TODO aqui para lembrarmos de voltar a isso.

    Quando usar: Marking work for later

  106. Let's add some logging here to help us debug this in production.

    Vamos adicionar algum logging aqui para nos ajudar a debugar isso em produção.

    Quando usar: Suggesting observability

  107. Let's add some inline comments to clarify the logic

    Vamos adicionar alguns comentários inline para esclarecer a lógica

    Quando usar: Improving code readability

  108. Let's create a branch before we start experimenting

    Vamos criar uma branch antes de começar a experimentar

    Quando usar: Setting up version control for experimentation

  109. We forgot to update the changelog after merging

    Esquecemos de atualizar o changelog depois do merge

    Quando usar: Maintaining project documentation

  110. Let me zoom out and explain the big picture first

    Deixa eu dar um zoom out e explicar o panorama geral primeiro

    Quando usar: Providing context before diving into details

  111. Can you pair with me on this migration script?

    Pode parear comigo nesse script de migração?

    Quando usar: Requesting help with database migration

  112. Let's pair on the code review for this pull request

    Vamos parear na revisão de código desse pull request

    Quando usar: Reviewing code together before merge

  113. I'll navigate while you drive for the next thirty minutes

    Eu navego enquanto você dirige nos próximos trinta minutos

    Quando usar: Switching pair programming roles

  114. This looks correct but let's verify with a print statement

    Isso parece correto mas vamos verificar com um print statement

    Quando usar: Quick debugging technique

  115. Shall we set up a quick standup before diving into the code?

    Devemos fazer uma reunião rápida antes de mergulhar no código?

    Quando usar: Aligning before starting a pairing session

  116. Let's commit this working state before we start the refactor

    Vamos commitar esse estado funcional antes de começar a refatoração

    Quando usar: Saving progress before making changes

  117. I just pushed the fix, can you pull and verify it works?

    Acabei de fazer push do fix, pode fazer pull e verificar se funciona?

    Quando usar: Asking pair to validate a fix

  118. This switch statement needs a default case for safety

    Esse switch statement precisa de um case default por segurança

    Quando usar: Adding exhaustive handling in switch

  119. Let's use the debugger breakpoints instead of print statements

    Vamos usar breakpoints do debugger em vez de print statements

    Quando usar: Using proper debugging tools

  120. Nice solution, I wouldn't have thought of using that approach

    Boa solução, eu não teria pensado em usar essa abordagem

    Quando usar: Praising creative problem solving

  121. We're going in circles, let's take a step back and rethink

    Estamos andando em círculos, vamos dar um passo atrás e repensar

    Quando usar: Recognizing when to change approach

  122. This looks good to me, let's move on to the next task

    Isso parece bom pra mim, vamos para a próxima tarefa

    Quando usar: Approving code and progressing

  123. Let me create a playground to prototype this algorithm

    Deixa eu criar um playground para prototipar esse algoritmo

    Quando usar: Using Swift Playgrounds for quick experiments

  124. Can we run the test suite before we push these changes?

    Podemos rodar a suíte de testes antes de fazer push dessas mudanças?

    Quando usar: Ensuring quality before sharing code

  125. I think there's a simpler way to achieve the same result

    Acho que existe uma forma mais simples de alcançar o mesmo resultado

    Quando usar: Suggesting code simplification

  126. Let's document the expected behavior in a comment block

    Vamos documentar o comportamento esperado em um bloco de comentários

    Quando usar: Adding documentation for complex logic

  127. I'll set up the project while you read the specifications

    Eu configuro o projeto enquanto você lê as especificações

    Quando usar: Efficiently dividing prep work

  128. Let's make sure the dark mode colors look right on this screen

    Vamos garantir que as cores do modo escuro estejam corretas nessa tela

    Quando usar: Verifying dark mode visual consistency

Frases intermediárias (112)

  1. Let's take a step back and look at the bigger picture.

    Vamos dar um passo atrás e olhar o panorama geral.

    Quando usar: Suggesting to zoom out and consider the overall design during pairing

  2. Should we switch roles now? I'd like to try driving.

    Devemos trocar de papel agora? Eu gostaria de tentar dirigir.

    Quando usar: Requesting a role swap during a pair programming session

  3. I see a potential bug there. Can you scroll up?

    Vejo um possível bug ali. Pode rolar para cima?

    Quando usar: Spotting an issue while navigating and asking the driver to scroll

  4. I think we should refactor this while we're here.

    Acho que devemos refatorar isso enquanto estamos aqui.

    Quando usar: Suggesting an improvement to the code during a pairing session

  5. Let's put a breakpoint there and debug it together.

    Vamos colocar um breakpoint ali e depurar juntos.

    Quando usar: Proposing to debug an issue collaboratively during pairing

  6. I'm not sure I follow. Can you walk me through your reasoning?

    Não tenho certeza se estou acompanhando. Pode me explicar seu raciocínio?

    Quando usar: Asking the navigator or driver to explain their thought process

  7. I'm going to type this out, and you tell me if you see any issues.

    Vou digitar isso, e você me diz se vir algum problema.

    Quando usar: Driver asking the navigator to actively review code as it's written

  8. Let's commit what we have and continue from here after a break.

    Vamos fazer commit do que temos e continuar daqui depois de uma pausa.

    Quando usar: Suggesting to save progress and take a break during a long pairing session

  9. I have an idea, but I'm not sure it'll work. Let me try it out quickly.

    Tenho uma ideia, mas não tenho certeza se vai funcionar. Deixa eu testar rapidinho.

    Quando usar: Proposing to experiment with an uncertain solution during pairing

  10. Let's trace through this code step by step to find the issue.

    Vamos percorrer esse código passo a passo para encontrar o problema.

    Quando usar: Suggesting a methodical debugging approach during pair programming

  11. Let's try ping pong pairing — I'll write a failing test and you make it pass.

    Vamos tentar ping pong pairing — eu escrevo um teste falhando e você faz passar.

    Quando usar: Proposing the ping pong TDD technique where partners alternate writing tests and implementations

  12. I think we should mob on this — let's pull in the rest of the team.

    Acho que devemos fazer mob programming nisso — vamos chamar o resto da equipe.

    Quando usar: Suggesting mob programming when the problem requires more perspectives

  13. I'm just going to rubber duck this with you for a minute.

    Vou só usar você como meu pato de borracha por um minuto.

    Quando usar: Using your pair as a sounding board to talk through a problem

  14. Let's add a breakpoint here and step through the code together.

    Vamos adicionar um breakpoint aqui e percorrer o código juntos.

    Quando usar: Collaborative debugging during a pair programming session

  15. I notice we keep going back and forth — let's just pick one approach and commit to it.

    Percebi que estamos indo e voltando — vamos escolher uma abordagem e seguir com ela.

    Quando usar: Resolving indecision during pairing by agreeing on a direction

  16. Can you explain why you chose that data structure? I want to understand the reasoning.

    Pode explicar por que escolheu essa estrutura de dados? Quero entender o raciocínio.

    Quando usar: Asking your pair to explain a technical decision for learning purposes

  17. I think we're overcomplicating this — what's the simplest solution that could work?

    Acho que estamos complicando demais — qual é a solução mais simples que funcionaria?

    Quando usar: Encouraging simplicity when the pair is going down a complex path

  18. Great, the tests are green. Let's refactor before moving on.

    Ótimo, os testes estão verdes. Vamos refatorar antes de seguir em frente.

    Quando usar: Following the red-green-refactor TDD cycle during pairing

  19. I'm going to extract this into a helper function while you write the next test.

    Vou extrair isso para uma função auxiliar enquanto você escreve o próximo teste.

    Quando usar: Dividing work during a pairing session for efficiency

  20. I see what you're doing, but wouldn't it be cleaner to use a map instead of a for loop?

    Entendo o que está fazendo, mas não seria mais limpo usar um map em vez de um for loop?

    Quando usar: Suggesting a more idiomatic approach while navigating

  21. I just realized we're solving the wrong problem. Let's re-read the ticket.

    Acabei de perceber que estamos resolvendo o problema errado. Vamos reler o ticket.

    Quando usar: Course-correcting when the pair has gone off track

  22. Let's run the linter before we commit — I want to keep the diff clean.

    Vamos rodar o linter antes de commitar — quero manter o diff limpo.

    Quando usar: Maintaining code quality standards during pair programming

  23. I'll handle the API integration part while you set up the database schema.

    Eu cuido da parte de integração com a API enquanto você configura o schema do banco.

    Quando usar: Splitting work between partners on independent tasks

  24. I think the bug is in the callback. Let's add some console logs and trace the data flow.

    Acho que o bug está no callback. Vamos adicionar alguns console logs e rastrear o fluxo de dados.

    Quando usar: Collaborative debugging with logging during pair programming

  25. Good idea. Let's spike on that for fifteen minutes and see if it's viable.

    Boa ideia. Vamos fazer um spike de quinze minutos e ver se é viável.

    Quando usar: Agreeing to timebox an experimental investigation during pairing

  26. The navigator should be thinking about the big picture while the driver focuses on the code.

    O navegador deve pensar no panorama geral enquanto o piloto foca no código.

    Quando usar: Explaining the responsibilities of each role in pair programming

  27. That's a clever use of destructuring. I'm going to start using that in my own code.

    Uso inteligente de destructuring. Vou começar a usar isso no meu próprio código.

    Quando usar: Complimenting and learning from your pair's coding style

  28. Let's not gold-plate this. It meets the requirements — we can optimize later if needed.

    Não vamos polir demais. Atende aos requisitos — podemos otimizar depois se necessário.

    Quando usar: Preventing over-engineering during a pairing session

  29. I notice we have some code duplication between these two methods. Should we extract a shared helper?

    Percebi que temos código duplicado entre esses dois métodos. Devemos extrair um helper compartilhado?

    Quando usar: Identifying DRY violations during collaborative code review

  30. I think we should write a unit test for this edge case before we forget about it.

    Acho que devemos escrever um teste unitário para esse caso limite antes de esquecermos.

    Quando usar: Proactively adding test coverage during collaborative development

  31. We should document this workaround with a comment explaining why it's necessary.

    Devemos documentar esse workaround com um comentário explicando por que é necessário.

    Quando usar: Ensuring non-obvious code decisions are documented during pairing

  32. I disagree with that approach, but let's try it your way first. If it doesn't work, we'll pivot.

    Discordo dessa abordagem, mas vamos tentar do seu jeito primeiro. Se não funcionar, mudamos.

    Quando usar: Constructively disagreeing while remaining collaborative

  33. I see you're using an extension method there. Can you show me how you defined it?

    Vejo que está usando um método de extensão ali. Pode me mostrar como você o definiu?

    Quando usar: Learning about a language feature from your pair partner

  34. I'm going to stash my changes so we can start from a clean state.

    Vou fazer stash das minhas mudanças para começarmos de um estado limpo.

    Quando usar: Resetting the working directory during collaborative debugging

  35. Can we step through this with the debugger? I want to inspect the state at each step.

    Podemos percorrer isso com o debugger? Quero inspecionar o estado em cada passo.

    Quando usar: Using a debugger collaboratively to understand program behavior

  36. Let's write the happy path first, then handle the error cases one by one.

    Vamos escrever o caminho feliz primeiro, depois tratamos os casos de erro um por um.

    Quando usar: Prioritizing the main flow before edge cases during implementation

  37. I think we're in a rabbit hole. Let's time-box this to ten more minutes and then reassess.

    Acho que entramos numa toca de coelho. Vamos limitar isso a mais dez minutos e reavaliar.

    Quando usar: Recognizing when the pair is spending too long on a tangent

  38. Can you explain the business logic behind this requirement? I want to make sure our implementation is correct.

    Pode explicar a lógica de negócio por trás desse requisito? Quero garantir que nossa implementação está correta.

    Quando usar: Seeking domain understanding during collaborative implementation

  39. Let's use a feature branch and make small, atomic commits as we go.

    Vamos usar uma branch de feature e fazer commits pequenos e atômicos conforme avançamos.

    Quando usar: Setting up version control strategy for a pairing session

  40. I'll set up the database migration while you scaffold the new endpoint.

    Eu configuro a migração do banco enquanto você cria o scaffold do novo endpoint.

    Quando usar: Efficiently dividing parallel tasks during a pairing session

  41. I've seen this pattern cause issues in production before. Let me tell you what happened.

    Já vi esse padrão causar problemas em produção antes. Deixa eu te contar o que aconteceu.

    Quando usar: Sharing past experience to prevent potential problems

  42. That null check won't be enough — what if the array is empty but not null?

    Essa verificação de null não será suficiente — e se o array estiver vazio mas não nulo?

    Quando usar: Catching subtle bugs by questioning assumptions during pairing

  43. Let's compare our local changes against main to make sure we haven't drifted too far.

    Vamos comparar nossas mudanças locais contra a main para garantir que não nos afastamos demais.

    Quando usar: Keeping the branch in sync during extended pairing sessions

  44. Let's keep the scope tight. If we find something unrelated, we file a separate ticket.

    Vamos manter o escopo restrito. Se encontrarmos algo não relacionado, abrimos um ticket separado.

    Quando usar: Maintaining focus and avoiding scope creep during pairing

  45. The response payload is huge. Let's add pagination to avoid loading everything at once.

    O payload da resposta é enorme. Vamos adicionar paginação para evitar carregar tudo de uma vez.

    Quando usar: Identifying performance improvements during collaborative API development

  46. I think we should write the test first before implementing.

    Acho que devemos escrever o teste primeiro antes de implementar.

    Quando usar: Suggesting TDD approach

  47. I see what you're doing, but what about the edge case where the input is empty?

    Entendo o que você está fazendo, mas e o caso de borda onde o input é vazio?

    Quando usar: Identifying edge case

  48. This function is getting too long, should we extract a helper?

    Essa função está ficando longa demais, devemos extrair uma auxiliar?

    Quando usar: Suggesting refactoring

  49. I'm not sure about this approach, can we discuss the trade-offs?

    Não tenho certeza sobre essa abordagem, podemos discutir os trade-offs?

    Quando usar: Opening discussion

  50. I think we're overcomplicating this. Let's step back and simplify.

    Acho que estamos complicando demais. Vamos dar um passo atrás e simplificar.

    Quando usar: Suggesting simplification

  51. What if we mock this dependency to make the test simpler?

    E se mockarmos essa dependência para tornar o teste mais simples?

    Quando usar: Suggesting test strategy

  52. I'm following your logic, but I think we need to handle the error case too.

    Estou seguindo sua lógica, mas acho que precisamos tratar o caso de erro também.

    Quando usar: Adding to partner's thinking

  53. We should handle both the success and failure callbacks.

    Devemos tratar tanto os callbacks de sucesso quanto de falha.

    Quando usar: Identifying missing logic

  54. I'm confused about the data flow here, can we trace it step by step?

    Estou confuso sobre o fluxo de dados aqui, podemos rastreá-lo passo a passo?

    Quando usar: Asking for clarification

  55. Before we refactor, let's make sure we have tests covering the current behavior.

    Antes de refatorar, vamos garantir que temos testes cobrindo o comportamento atual.

    Quando usar: Ensuring safety

  56. I'm thinking out loud here, but what if we used a protocol for this?

    Estou pensando em voz alta aqui, mas e se usássemos um protocolo para isso?

    Quando usar: Brainstorming

  57. Let's look at the stack trace to find where the error originates.

    Vamos olhar o stack trace para encontrar onde o erro origina.

    Quando usar: Debugging together

  58. I think we need to think about the performance implications of this.

    Acho que precisamos pensar nas implicações de performance disso.

    Quando usar: Raising performance concern

  59. I agree with the overall design, but I have a suggestion for the error handling.

    Concordo com o design geral, mas tenho uma sugestão para o tratamento de erros.

    Quando usar: Providing nuanced feedback

  60. I see you're using a for loop here, would a map be more readable?

    Vejo que você está usando um for loop aqui, um map seria mais legível?

    Quando usar: Suggesting functional approach

  61. Let's write a quick spike to validate our approach before going all in.

    Vamos escrever um spike rápido para validar nossa abordagem antes de ir fundo.

    Quando usar: Suggesting validation

  62. Interesting, the API returns different formats depending on the locale.

    Interessante, a API retorna formatos diferentes dependendo do locale.

    Quando usar: Discovering unexpected behavior

  63. Let me share my screen so you can see the issue

    Deixa eu compartilhar minha tela para você ver o problema

    Quando usar: Starting a debugging session together

  64. Can you walk me through how this middleware works?

    Pode me explicar como esse middleware funciona?

    Quando usar: Understanding middleware layer together

  65. I think we should add a guard clause here

    Acho que devemos adicionar uma cláusula de guarda aqui

    Quando usar: Suggesting early return pattern

  66. This function is doing too many things at once

    Essa função está fazendo muitas coisas ao mesmo tempo

    Quando usar: Identifying single responsibility violations

  67. Let me pull up the API documentation for this endpoint

    Deixa eu abrir a documentação da API para esse endpoint

    Quando usar: Referencing docs during implementation

  68. We should extract this into a utility function

    Devemos extrair isso para uma função utilitária

    Quando usar: Suggesting code reuse

  69. I'll handle the UI while you work on the data layer

    Eu cuido da UI enquanto você trabalha na camada de dados

    Quando usar: Dividing work in parallel pairing

  70. Can you double-check that the error handling covers all edge cases?

    Pode verificar se o tratamento de erros cobre todos os casos extremos?

    Quando usar: Reviewing error scenarios together

  71. This regex is getting complex, let's break it down

    Essa regex está ficando complexa, vamos decompô-la

    Quando usar: Simplifying regular expressions together

  72. The naming convention here doesn't match the rest of the codebase

    A convenção de nomenclatura aqui não corresponde ao resto do código

    Quando usar: Maintaining code consistency

  73. Should we add a loading state indicator while this processes?

    Devemos adicionar um indicador de estado de carregamento enquanto isso processa?

    Quando usar: Discussing UX improvements

  74. I notice we're not handling the optional unwrapping safely here

    Notei que não estamos desembrulhando o optional com segurança aqui

    Quando usar: Pointing out force unwrap risks

  75. Let's write the test first and then implement the feature

    Vamos escrever o teste primeiro e depois implementar a funcionalidade

    Quando usar: Doing test-driven development

  76. This method signature is getting too long, can we simplify it?

    A assinatura desse método está ficando muito longa, podemos simplificar?

    Quando usar: Refactoring method parameters

  77. I think we need to add input validation before processing

    Acho que precisamos adicionar validação de entrada antes de processar

    Quando usar: Adding data validation checks

  78. Can you show me how you'd approach this algorithm?

    Pode me mostrar como você abordaria esse algoritmo?

    Quando usar: Learning from pair's problem-solving approach

  79. Let's review the database schema before writing the queries

    Vamos revisar o esquema do banco de dados antes de escrever as queries

    Quando usar: Planning database work together

  80. Let me trace through the data flow to find the bug

    Deixa eu rastrear o fluxo de dados para encontrar o bug

    Quando usar: Debugging by following data transformation

  81. I see redundant code here, let's DRY it up

    Vejo código redundante aqui, vamos aplicar DRY

    Quando usar: Removing code duplication

  82. Can you check if this endpoint handles pagination correctly?

    Pode verificar se esse endpoint lida com paginação corretamente?

    Quando usar: Verifying API pagination implementation

  83. Let's add proper logging before deploying this

    Vamos adicionar logging adequado antes de fazer deploy disso

    Quando usar: Ensuring observability in production

  84. This component should be more reusable across the app

    Esse componente deveria ser mais reutilizável no app

    Quando usar: Improving component reusability

  85. I found the root cause, it's in the data mapping layer

    Encontrei a causa raiz, está na camada de mapeamento de dados

    Quando usar: Identifying bug source during debugging

  86. We need to handle the case where the API returns an empty response

    Precisamos tratar o caso em que a API retorna uma resposta vazia

    Quando usar: Adding empty state handling

  87. This enum should be exhaustive to prevent future bugs

    Esse enum deveria ser exaustivo para prevenir bugs futuros

    Quando usar: Ensuring complete switch case coverage

  88. Let's make sure this works with VoiceOver enabled

    Vamos garantir que isso funciona com o VoiceOver ativado

    Quando usar: Testing accessibility features

  89. Can we add a feature flag so we can toggle this safely?

    Podemos adicionar uma feature flag para que possamos alternar isso com segurança?

    Quando usar: Implementing gradual rollout

  90. Let's sketch out the class diagram on the whiteboard first

    Vamos esboçar o diagrama de classes no quadro branco primeiro

    Quando usar: Planning before coding

  91. We should mock this external service for the unit tests

    Devemos mockar esse serviço externo para os testes unitários

    Quando usar: Setting up test doubles

  92. Let's refactor this before adding the new feature on top

    Vamos refatorar isso antes de adicionar a nova funcionalidade em cima

    Quando usar: Preparing codebase for new feature

  93. I think we should split this view into smaller subviews

    Acho que devemos dividir essa view em subviews menores

    Quando usar: Breaking down large SwiftUI views

  94. We need to update the snapshot tests after this UI change

    Precisamos atualizar os snapshot tests depois dessa mudança de UI

    Quando usar: Maintaining visual regression tests

  95. Great catch, I didn't notice that off-by-one error

    Boa pegada, eu não tinha notado esse erro off-by-one

    Quando usar: Acknowledging pair's contribution during debugging

  96. This error message isn't helpful for debugging, let's improve it

    Essa mensagem de erro não ajuda na depuração, vamos melhorá-la

    Quando usar: Making error messages more descriptive

  97. We should add accessibility labels to these custom controls

    Devemos adicionar labels de acessibilidade a esses controles personalizados

    Quando usar: Improving accessibility in custom UI

  98. Let's discuss the tradeoffs between these two approaches

    Vamos discutir as compensações entre essas duas abordagens

    Quando usar: Comparing implementation strategies

  99. The localization keys are inconsistent, let's standardize them

    As chaves de localização estão inconsistentes, vamos padronizá-las

    Quando usar: Cleaning up i18n key naming

  100. We should wrap this network call in a do-catch block

    Devemos envolver essa chamada de rede em um bloco do-catch

    Quando usar: Adding proper error handling to async code

  101. I'll document the decision we just made in the ADR

    Vou documentar a decisão que acabamos de tomar no ADR

    Quando usar: Recording architectural decisions

  102. Should we use @StateObject or @ObservedObject here?

    Devemos usar @StateObject ou @ObservedObject aqui?

    Quando usar: Choosing the right SwiftUI property wrapper

  103. Let's add unit tests for these edge cases we just found

    Vamos adicionar testes unitários para esses casos extremos que encontramos

    Quando usar: Writing tests for discovered edge cases

  104. Can you verify that the data persistence works after force quit?

    Pode verificar se a persistência de dados funciona após forçar encerramento?

    Quando usar: Testing data durability

  105. We need to handle the keyboard dismissal properly in this form

    Precisamos tratar a dispensa do teclado corretamente nesse formulário

    Quando usar: Managing keyboard behavior in iOS forms

  106. This extension method would be useful in other parts of the app too

    Esse método de extensão seria útil em outras partes do app também

    Quando usar: Recognizing reusable utility code

  107. Let's add a debug overlay to visualize the layout frames

    Vamos adicionar um overlay de debug para visualizar os frames do layout

    Quando usar: Using visual debugging for layout issues

  108. The animation timing doesn't feel right, let's tweak the curve

    O timing da animação não parece certo, vamos ajustar a curva

    Quando usar: Fine-tuning animation parameters

  109. We should sanitize this user input before storing it

    Devemos sanitizar essa entrada do usuário antes de armazená-la

    Quando usar: Preventing injection attacks

  110. Let's align on the acceptance criteria before coding

    Vamos alinhar nos critérios de aceitação antes de codificar

    Quando usar: Ensuring shared understanding of requirements

  111. This JSON parsing could fail silently, let's add error logging

    Esse parsing de JSON pode falhar silenciosamente, vamos adicionar log de erros

    Quando usar: Improving error visibility in data parsing

  112. Let's use environment values instead of passing this through every view

    Vamos usar valores de ambiente em vez de passar isso por cada view

    Quando usar: Using SwiftUI environment for dependency injection

Frases avançadas (60)

  1. Let's try a different approach. What if we use a strategy pattern here?

    Vamos tentar uma abordagem diferente. E se usarmos um padrão strategy aqui?

    Quando usar: Suggesting an alternative design pattern during collaborative coding

  2. We should probably extract this into its own method for readability.

    Provavelmente devemos extrair isso para um método separado para melhorar a legibilidade.

    Quando usar: Suggesting a refactoring to improve code readability during pairing

  3. Wait, I think there's a race condition here. Let's look at this more carefully.

    Espera, acho que tem uma condição de corrida aqui. Vamos olhar isso com mais cuidado.

    Quando usar: Catching a concurrency issue during collaborative debugging

  4. The variable naming here is a bit confusing. How about we rename it to something more descriptive?

    O nome da variável aqui está um pouco confuso. Que tal renomear para algo mais descritivo?

    Quando usar: Suggesting better naming conventions during a pairing session

  5. We could try mob programming on this. Let's invite the rest of the team.

    Podemos tentar mob programming nisso. Vamos convidar o restante do time.

    Quando usar: Suggesting to expand the pairing session into a mob programming session

  6. This edge case is tricky. Let's write down all the scenarios before coding.

    Esse caso extremo é complicado. Vamos listar todos os cenários antes de codificar.

    Quando usar: Suggesting to plan edge cases before implementing during pairing

  7. I agree with the logic, but I think we should add some error handling here.

    Concordo com a lógica, mas acho que devemos adicionar tratamento de erro aqui.

    Quando usar: Suggesting improvements while agreeing with the overall approach

  8. Nice, that's much cleaner now. Let's run the tests to make sure we didn't break anything.

    Legal, ficou muito mais limpo agora. Vamos rodar os testes para garantir que não quebramos nada.

    Quando usar: Approving a refactoring and suggesting verification after changes

  9. Hold on, let me check the documentation before we go down that path.

    Espera, deixa eu verificar a documentação antes de seguirmos por esse caminho.

    Quando usar: Pausing to verify an assumption by checking docs during pairing

  10. That was a productive session. Let's summarize what we accomplished and create tickets for the remaining work.

    Foi uma sessão produtiva. Vamos resumir o que realizamos e criar tickets para o trabalho restante.

    Quando usar: Wrapping up a pair programming session and documenting outcomes

  11. Wait, I think there's a race condition here. Let's trace through the execution order.

    Espera, acho que tem uma condição de corrida aqui. Vamos rastrear a ordem de execução.

    Quando usar: Spotting a concurrency bug during collaborative debugging

  12. This is getting complex. Let's draw a sequence diagram to map out the flow.

    Isso está ficando complexo. Vamos desenhar um diagrama de sequência para mapear o fluxo.

    Quando usar: Using diagrams to visualize complex logic during pairing

  13. That if-else chain is getting long. What do you think about using a switch or a strategy pattern?

    Essa cadeia de if-else está ficando longa. O que acha de usar um switch ou um padrão strategy?

    Quando usar: Suggesting a refactoring opportunity while reviewing code together

  14. I think we need to step back and agree on the interface before implementing the details.

    Acho que precisamos dar um passo atrás e concordar na interface antes de implementar os detalhes.

    Quando usar: Advocating for design-first approach during collaborative coding

  15. Let's mock this external API so we can test our code without depending on the third-party service.

    Vamos mockar essa API externa para testar nosso código sem depender do serviço de terceiros.

    Quando usar: Setting up mocks during collaborative test writing

  16. That error message is misleading. The actual problem is two levels deeper in the stack trace.

    Essa mensagem de erro é enganosa. O problema real está dois níveis mais profundo no stack trace.

    Quando usar: Helping your pair identify the root cause during debugging

  17. I think the integration test is more valuable here than a unit test. Let's test the whole flow.

    Acho que o teste de integração é mais valioso aqui do que um teste unitário. Vamos testar o fluxo inteiro.

    Quando usar: Discussing testing strategy during collaborative development

  18. Instead of fixing this bug, let's write a regression test that reproduces it first.

    Em vez de corrigir esse bug, vamos escrever um teste de regressão que o reproduza primeiro.

    Quando usar: Following test-first approach for bug fixing during pairing

  19. This dependency injection setup is getting messy. Let's refactor it before adding more services.

    Essa configuração de injeção de dependência está ficando bagunçada. Vamos refatorar antes de adicionar mais serviços.

    Quando usar: Addressing technical debt during a pairing session

  20. Let's check the performance impact of this change by running the benchmark suite.

    Vamos verificar o impacto de performance dessa mudança rodando a suíte de benchmarks.

    Quando usar: Verifying performance during collaborative optimization work

  21. The API contract says it returns an array, but we're handling it as a single object. That's the bug.

    O contrato da API diz que retorna um array, mas estamos tratando como um objeto único. Esse é o bug.

    Quando usar: Identifying a contract mismatch during collaborative debugging

  22. I think the problem is in how we're serializing the date. Let me check the timezone handling.

    Acho que o problema é como estamos serializando a data. Deixa eu verificar o tratamento de fuso horário.

    Quando usar: Investigating date/time bugs during collaborative debugging

  23. I think we should use dependency injection here so this is easier to test.

    Acho que devemos usar injeção de dependência aqui para facilitar os testes.

    Quando usar: Suggesting architectural improvements for testability during pairing

  24. I think we need to add error boundaries around this component to handle rendering failures gracefully.

    Acho que precisamos adicionar error boundaries em torno desse componente para lidar com falhas de renderização de forma elegante.

    Quando usar: Discussing resilience patterns during UI development in pairing

  25. This pattern reminds me of the strategy pattern, should we formalize it?

    Esse padrão me lembra o strategy pattern, devemos formalizá-lo?

    Quando usar: Identifying design pattern

  26. I think this closure is capturing self strongly, which could cause a retain cycle.

    Acho que essa closure está capturando self de forma strong, o que pode causar um ciclo de retenção.

    Quando usar: Identifying memory issue

  27. This logic would be clearer as a state machine.

    Essa lógica ficaria mais clara como uma máquina de estados.

    Quando usar: Suggesting design pattern

  28. Wait, there's a race condition here. Two threads could modify this at the same time.

    Espera, tem uma condição de corrida aqui. Duas threads podem modificar isso ao mesmo tempo.

    Quando usar: Catching concurrency bug

  29. Can you explain the reasoning behind this design pattern?

    Pode explicar o raciocínio por trás desse design pattern?

    Quando usar: Understanding architectural decisions

  30. I spotted a potential memory leak in this closure

    Identifiquei um possível vazamento de memória nessa closure

    Quando usar: Identifying memory management issues

  31. This looks like it could cause a race condition

    Isso parece que pode causar uma condição de corrida

    Quando usar: Identifying concurrency issues

  32. Should we use dependency injection here instead?

    Devemos usar injeção de dependência aqui em vez disso?

    Quando usar: Discussing testability improvements

  33. Let's step back and think about the overall architecture

    Vamos dar um passo atrás e pensar na arquitetura geral

    Quando usar: Taking a high-level view of the system

  34. Have you considered using a protocol-oriented approach?

    Você considerou usar uma abordagem orientada a protocolos?

    Quando usar: Suggesting Swift design patterns

  35. I think this test is too tightly coupled to the implementation

    Acho que esse teste está muito acoplado à implementação

    Quando usar: Discussing test quality

  36. The cyclomatic complexity of this function is too high

    A complexidade ciclomática dessa função está muito alta

    Quando usar: Identifying overly complex code

  37. I think this would benefit from the strategy pattern

    Acho que isso se beneficiaria do padrão strategy

    Quando usar: Suggesting design pattern application

  38. This async call should have a timeout to prevent hanging

    Essa chamada assíncrona deveria ter um timeout para evitar travamento

    Quando usar: Adding resilience to async operations

  39. We should benchmark this before and after the optimization

    Devemos fazer benchmark disso antes e depois da otimização

    Quando usar: Measuring performance improvements

  40. I think we should use a state machine for this flow

    Acho que deveríamos usar uma máquina de estados para esse fluxo

    Quando usar: Suggesting state management approach

  41. The build is failing because of a circular dependency

    O build está falhando por causa de uma dependência circular

    Quando usar: Diagnosing compilation issues together

  42. I notice this uses a deprecated API that will break in the next version

    Notei que isso usa uma API deprecada que vai quebrar na próxima versão

    Quando usar: Flagging deprecated usage

  43. This seems like a good candidate for memoization

    Isso parece um bom candidato para memoização

    Quando usar: Optimizing repeated calculations

  44. This computed property is being called too frequently in the view

    Essa propriedade computada está sendo chamada com muita frequência na view

    Quando usar: Identifying performance issues in SwiftUI

  45. The animation feels janky, let's check the main thread usage

    A animação está travando, vamos verificar o uso da thread principal

    Quando usar: Debugging UI performance issues

  46. We should add a retry mechanism with exponential backoff

    Devemos adicionar um mecanismo de retry com backoff exponencial

    Quando usar: Implementing resilient network calls

  47. Let me explain what this closure captures and why it matters

    Deixa eu explicar o que essa closure captura e por que importa

    Quando usar: Teaching about capture lists in Swift

  48. Can you help me understand how the generic constraints work here?

    Pode me ajudar a entender como as restrições de generic funcionam aqui?

    Quando usar: Learning about Swift generics together

  49. Let's use the profiler to identify the performance bottleneck

    Vamos usar o profiler para identificar o gargalo de performance

    Quando usar: Using Instruments for performance analysis

  50. We should consider thread safety for this shared resource

    Devemos considerar thread safety para esse recurso compartilhado

    Quando usar: Discussing concurrent access to shared data

  51. I see that the view model is retaining a strong reference to the view

    Vejo que o view model está mantendo uma referência forte para a view

    Quando usar: Identifying retain cycles in MVVM

  52. Can you explain what @MainActor does in this context?

    Pode explicar o que @MainActor faz nesse contexto?

    Quando usar: Learning about Swift concurrency annotations

  53. I suggest we add a caching layer to reduce API calls

    Sugiro adicionarmos uma camada de cache para reduzir chamadas à API

    Quando usar: Optimizing network usage

  54. Let's check the memory graph to find the leak

    Vamos checar o gráfico de memória para encontrar o vazamento

    Quando usar: Using Xcode Memory Graph Debugger

  55. This initializer has too many parameters, let's use a builder pattern

    Esse inicializador tem muitos parâmetros, vamos usar o padrão builder

    Quando usar: Simplifying object creation

  56. I think the issue is related to the view lifecycle timing

    Acho que o problema está relacionado ao timing do ciclo de vida da view

    Quando usar: Debugging SwiftUI view lifecycle issues

  57. This property observer is causing an infinite update loop

    Esse observador de propriedade está causando um loop infinito de atualização

    Quando usar: Debugging didSet/willSet issues

  58. We should consider backward compatibility for users on older iOS versions

    Devemos considerar compatibilidade retroativa para usuários em versões mais antigas do iOS

    Quando usar: Planning for multi-version support

  59. We should use weak self in this closure to avoid retain cycles

    Devemos usar weak self nessa closure para evitar ciclos de retenção

    Quando usar: Preventing memory leaks in closures

  60. I think we should handle the cancellation task properly here

    Acho que devemos tratar o cancelamento de tarefa corretamente aqui

    Quando usar: Managing task cancellation in Swift concurrency

Outras situações do dia a dia de dev

← Inglês para devs

Guias com mais contexto

Leve para o celular

No app Devlingo você recebe 10 frases novas por dia, cada uma com contexto real, pronúncia e exemplos, e o widget mostra a frase do dia na Tela de Início do iPhone.

Perguntas frequentes

O que mais perguntam sobre o assunto, respondido com a fonte.

O que é driver e navigator no pair programming?
Driver é quem está no teclado; navigator revisa e pensa no próximo passo. Troca-se a cada tarefa ou a cada 25 minutos.
Como sugerir algo no pair sem tirar o teclado do outro?
What if we tried…? ou Can I suggest something?, e deixe quem está dirigindo decidir.
DevlingoFrases técnicas e fluência
Usar sem baixarBaixar