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)
Do you want to drive or navigate?
Você quer dirigir ou navegar?
Quando usar: Deciding roles at the start of a pair programming session
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
Can you share your screen?
Você pode compartilhar sua tela?
Quando usar: Asking your pair to share their screen for a remote session
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
What do you think about this approach?
O que você acha dessa abordagem?
Quando usar: Asking your pair for feedback on a proposed solution
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
Let me take over the keyboard for a bit.
Deixa eu pegar o teclado por um momento.
Quando usar: Switching driver role
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
Let's break this problem down into smaller pieces.
Vamos dividir esse problema em partes menores.
Quando usar: Suggesting approach
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
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
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
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
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
Good catch! I completely missed that null check.
Boa pegada! Eu perdi completamente essa verificação de nulo.
Quando usar: Acknowledging partner's contribution
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
Let's use print statements to debug this quickly.
Vamos usar prints para debugar isso rapidamente.
Quando usar: Suggesting quick debugging
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
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
Let's commit this working version and then optimize later.
Vamos commitar essa versão funcional e otimizar depois.
Quando usar: Prioritizing progress
Interesting approach, I've never seen it done that way before.
Abordagem interessante, nunca vi feito dessa forma antes.
Quando usar: Acknowledging novelty
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
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
We should probably create a feature branch for this.
Provavelmente devemos criar uma feature branch para isso.
Quando usar: Suggesting git workflow
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
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
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
I think we should validate the input before processing it.
Acho que devemos validar o input antes de processá-lo.
Quando usar: Suggesting validation
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
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
Should we use a constant for this magic number?
Devemos usar uma constante para esse número mágico?
Quando usar: Suggesting code clarity
I'm going to rubber duck this problem with you.
Vou explicar esse problema em voz alta para você.
Quando usar: Describing debugging technique
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
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
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
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
Should we switch who's driving? Fresh eyes might help.
Devemos trocar quem está pilotando? Olhos frescos podem ajudar.
Quando usar: Suggesting role swap
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
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
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
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
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
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
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
We forgot to update the changelog after merging
Esquecemos de atualizar o changelog depois do merge
Quando usar: Maintaining project documentation
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
Can you pair with me on this migration script?
Pode parear comigo nesse script de migração?
Quando usar: Requesting help with database migration
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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)
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
We should handle both the success and failure callbacks.
Devemos tratar tanto os callbacks de sucesso quanto de falha.
Quando usar: Identifying missing logic
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
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
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
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
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
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
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
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
Interesting, the API returns different formats depending on the locale.
Interessante, a API retorna formatos diferentes dependendo do locale.
Quando usar: Discovering unexpected behavior
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
Can you walk me through how this middleware works?
Pode me explicar como esse middleware funciona?
Quando usar: Understanding middleware layer together
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
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
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
We should extract this into a utility function
Devemos extrair isso para uma função utilitária
Quando usar: Suggesting code reuse
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
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
This regex is getting complex, let's break it down
Essa regex está ficando complexa, vamos decompô-la
Quando usar: Simplifying regular expressions together
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
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
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
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
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
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
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
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
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
I see redundant code here, let's DRY it up
Vejo código redundante aqui, vamos aplicar DRY
Quando usar: Removing code duplication
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
Let's add proper logging before deploying this
Vamos adicionar logging adequado antes de fazer deploy disso
Quando usar: Ensuring observability in production
This component should be more reusable across the app
Esse componente deveria ser mais reutilizável no app
Quando usar: Improving component reusability
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
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
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
Let's make sure this works with VoiceOver enabled
Vamos garantir que isso funciona com o VoiceOver ativado
Quando usar: Testing accessibility features
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
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
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
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
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
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
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
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
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
Let's discuss the tradeoffs between these two approaches
Vamos discutir as compensações entre essas duas abordagens
Quando usar: Comparing implementation strategies
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
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
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
Should we use @StateObject or @ObservedObject here?
Devemos usar @StateObject ou @ObservedObject aqui?
Quando usar: Choosing the right SwiftUI property wrapper
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
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
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
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
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
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
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
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
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
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)
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
This looks like it could cause a race condition
Isso parece que pode causar uma condição de corrida
Quando usar: Identifying concurrency issues
Should we use dependency injection here instead?
Devemos usar injeção de dependência aqui em vez disso?
Quando usar: Discussing testability improvements
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
Have you considered using a protocol-oriented approach?
Você considerou usar uma abordagem orientada a protocolos?
Quando usar: Suggesting Swift design patterns
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
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
I think this would benefit from the strategy pattern
Acho que isso se beneficiaria do padrão strategy
Quando usar: Suggesting design pattern application
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
We should benchmark this before and after the optimization
Devemos fazer benchmark disso antes e depois da otimização
Quando usar: Measuring performance improvements
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
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
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
This seems like a good candidate for memoization
Isso parece um bom candidato para memoização
Quando usar: Optimizing repeated calculations
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
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
We should add a retry mechanism with exponential backoff
Devemos adicionar um mecanismo de retry com backoff exponencial
Quando usar: Implementing resilient network calls
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
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
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
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
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
Can you explain what @MainActor does in this context?
Pode explicar o que @MainActor faz nesse contexto?
Quando usar: Learning about Swift concurrency annotations
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
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
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
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
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
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
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
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
- Daily standup280 frases
- Code review275 frases
- Pull requests300 frases
- Bug reports300 frases
- Reuniões300 frases
- Entrevistas de emprego300 frases
- Slack e chat300 frases
- E-mail298 frases
- Discussões técnicas299 frases
- Frases educadas300 frases
- Documentação300 frases
Guias com mais contexto
- Daily em inglês: 30 frases prontas para o standup
- Entrevista em inglês: 15 perguntas e respostas para devs
- Como se apresentar em inglês na entrevista
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.