Skip to contentSkip to conversation

docs: pt_BR: process: translation updates and additions

PATCH In review Daniel Pereira 2 participants 9 messages Jul 3 – Jul 10

Subsystems (2)
lore
Share & tools
lore

Daniel Pereira

author maintainer
#0 lore raw

v2 cover docs: pt_BR: process: translation updates and additions

This patch series updates the Brazilian Portuguese (pt_BR) translation for the core Linux kernel development process documentation.

The goal is to expand accessibility for Portuguese-speaking developers, bringing over crucial guides ranging from subsystem-specific rules to organizational maturity frameworks.

All documents have been strictly formatted to adhere to the 80-column line length limit to ensure proper Sphinx HTML rendering and consistency with the existing pt_BR infrastructure.

Changes in v2:
- Patch 7: Added adding-syscalls.rst to the index.rst toctree to resolve a Sphinx build warning.

Summary of translations included in this series:
- process/adding-syscalls.rst (Adding System Calls guide)
- process/contribution-maturity-model.rst (TAB Upstream Maturity framework)
- process/botching-up-ioctls.rst (Driver-private API and ioctl design)
- process/backporting.rst (Stable tree backporting and conflict resolution)
- process/applying-patches.rst (Patch application workflows)
- process/development-process.rst (Advanced Topics and Conclusion sections)
- process/6.Followthrough.rst (Patch life-cycle followthrough guide)

Thanks!

Daniel Pereira (7):
docs: pt_BR: process: Translate the patch followthrough guide
docs: pt_BR: process: translate 7.AdvancedTopics and 8.Conclusion
docs: pt_BR: Add translation for applying-patches and update index
docs: pt_BR: translate backporting.rst documentation
docs: pt_BR: process: translate botching-up-ioctls guide
docs: pt_BR: process: translate contribution maturity model
docs: pt_BR: translate process/adding-syscalls.rst

Documentation/translations/pt_BR/index.rst   |   5 +
.../pt_BR/process/6.Followthrough.rst        | 220 ++++++
.../pt_BR/process/7.AdvancedTopics.rst       | 201 +++++
.../pt_BR/process/8.Conclusion.rst           |  73 ++
.../pt_BR/process/adding-syscalls.rst        | 700 ++++++++++++++++++
.../pt_BR/process/applying-patches.rst       | 447 +++++++++++
.../pt_BR/process/backporting.rst            | 598 +++++++++++++++
.../pt_BR/process/botching-up-ioctls.rst     | 256 +++++++
.../process/contribution-maturity-model.rst  | 111 +++
.../pt_BR/process/development-process.rst    |   3 +
10 files changed, 2614 insertions(+)

create mode 100644 Documentation/translations/pt_BR/process/6.Followthrough.rst create mode 100644 Documentation/translations/pt_BR/process/7.AdvancedTopics.rst create mode 100644 Documentation/translations/pt_BR/process/8.Conclusion.rst create mode 100644 Documentation/translations/pt_BR/process/adding-syscalls.rst create mode 100644 Documentation/translations/pt_BR/process/applying-patches.rst create mode 100644 Documentation/translations/pt_BR/process/backporting.rst create mode 100644 Documentation/translations/pt_BR/process/botching-up-ioctls.rst create mode 100644 Documentation/translations/pt_BR/process/contribution-maturity-model.rst

--
2.47.3

author maintainer
#1 lore raw

PATCH v2 1/7 docs: pt_BR: process: Translate the patch followthrough guide

Translates the section 6.followthrough.rst to Brazilian Portuguese for the process directory.

---
 .../pt_BR/process/6.Followthrough.rst         | 220 ++++++++++++++++++
 .../pt_BR/process/development-process.rst     |   1 +
 2 files changed, 221 insertions(+)
 create mode 100644 Documentation/translations/pt_BR/process/6.Followthrough.rst
Documentation/translations/pt_BR/process/6.Followthrough.rst new file +220 -0
new file mode 100644
index 000000000..d6bdaa2cb
@@ -0,0 +1,220 @@
+.. SPDX-License-Identifier: GPL-2.0
+
+Acompanhamento
+==============
+
+Neste ponto, você seguiu as diretrizes apresentadas até aqui e, com a
+adição de suas próprias habilidades de engenharia, enviou uma série perfeita
+de patches. Um dos maiores erros que até mesmo desenvolvedores experientes
+do kernel podem cometer é concluir que o seu trabalho agora está concluído.
+Na verdade, o envio de patches indica uma transição para a próxima etapa
+do processo, possivelmente com uma quantidade considerável de trabalho
+ainda por fazer.
+
+É raro um patch ser tão bom em seu primeiro envio que não haja margem para
+melhorias. O processo de desenvolvimento do kernel reconhece esse fato e,
+como resultado, é fortemente orientado para o aprimoramento do código
+enviado. Espera-se que você, como autor desse código, trabalhe junto à
+comunidade do kernel para garantir que seu código esteja de acordo com os
+padrões de qualidade do kernel. A falha em participar desse processo muito
+provavelmente impedirá a inclusão de seus patches na árvore principal
+(*mainline*).
+
+
+Trabalhando com revisores
+-------------------------
+
+Um patch de qualquer relevância resultará em uma série de comentários de outros
+desenvolvedores à medida que eles revisam o código. Trabalhar com revisores
+pode ser, para muitos desenvolvedores, a parte mais intimidadora do processo
+de desenvolvimento do kernel. No entanto, a vida pode se tornar muito mais
+fácil se você mantiver algumas coisas em mente:
+
+* Se você explicou bem o seu patch, os revisores entenderão o seu valor
+  e o porquê de você ter tido o trabalho de escrevê-lo. Contudo, esse valor
+  não os impedirá de fazer uma pergunta fundamental: como será manter um
+  kernel com este código inserido nele daqui a cinco ou dez anos? Muitas das
+  mudanças que podem lhe pedir para fazer — desde ajustes de estilo de código
+  até reescritas substanciais — vêm do entendimento de que o Linux ainda estará
+  por aqui e sob desenvolvimento daqui a uma década.
+
+* A revisão de código é um trabalho árduo e uma ocupação relativamente
+  ingrata; as pessoas lembram quem escreveu o código do kernel, mas há pouca
+  fama duradoura para aqueles que o revisaram. Portanto, os revisores podem
+  ficar ranzinzas, especialmente quando veem os mesmos erros sendo cometidos
+  repetidamente. Se você receber uma revisão que pareça irritada, insultuosa
+  ou abertamente ofensiva, resista ao impulso de responder à altura. A revisão
+  de código diz respeito ao código, não às pessoas, e os revisores de código
+  não estão atacando você pessoalmente.
+
+* Da mesma forma, os revisores de código não estão tentando promover os
+  interesses de seus empregadores em detrimento dos seus. Os desenvolvedores
+  do kernel geralmente esperam continuar trabalhando no kernel daqui a muitos
+  anos, mas entendem que seu empregador pode mudar. Quase sem exceção, eles
+  estão verdadeiramente trabalhando em prol da criação do melhor kernel possível;
+  eles não estão tentando causar desconforto aos concorrentes de seus empregadores.
+
+* Esteja preparado para solicitações aparentemente tolas de mudanças no estilo
+  de codificação e pedidos para refatorar parte do seu código em seções
+  compartilhadas do kernel. Uma das funções dos mantenedores é manter as coisas
+  com a mesma aparência. Às vezes, isso significa que aquele truque inteligente
+  (*clever hack*) em seu driver para contornar um problema
+
+Note que você não precisa concordar com todas as mudanças sugeridas pelos
+revisores. Se você acredita que o revisor entendeu mal o seu código, explique
+o que realmente está acontecendo. Se tiver uma objeção técnica a uma mudança
+sugerida, descreva-a e justifique a sua solução para o problema. Se as suas
+explicações fizerem sentido, o revisor as aceitará. Contudo, caso a sua
+explicação não seja persuasiva — especialmente se outros começarem a concordar
+com o revisor —, reserve um tempo para repensar as coisas. Pode ser fácil ficar
+ceguificado por sua própria solução para um problema, a ponto de não perceber
+que algo está fundamentalmente errado ou que, talvez, você não esteja sequer
+resolvendo o problema certo.
+
+Andrew Morton sugeriu que todo comentário de revisão que não resulte em uma
+alteração de código deveria, em vez disso, resultar em um comentário adicional
+no próprio código; isso pode ajudar os futuros revisores a evitar as dúvidas
+que surgiram da primeira vez.
+
+Um erro fatal é ignorar os comentários de revisão na esperança de que eles
+desapareçam. Eles não vão desaparecer. Se você reenviar o código sem ter
+respondido aos comentários que recebeu da vez anterior, é provável que descubra
+que os seus patches não vão a lugar nenhum.
+
+Por falar em reenviar código: tenha em mente que os revisores não vão se
+lembrar de todos os detalhes do código que você enviou da última vez. Portanto,
+é sempre uma boa ideia lembrar os revisores dos problemas levantados
+anteriormente e de como você lidou com eles; o registro de alterações
+(*changelog*) do patch é um bom lugar para esse tipo de informação. Os revisores
+não deveriam ter que vasculhar os arquivos das listas de discussão para se
+familiarizarem com o que foi dito na última vez; se você ajudá-los a começar
+com o pé direito, eles estarão de melhor humor quando revisitarem o seu código.
+
+E se você tentou fazer tudo certo e as coisas ainda não estão avançando? A
+maioria das divergências técnicas pode ser resolvida por meio de discussão,
+mas há momentos em que alguém simplesmente precisa tomar uma decisão. Se você
+acredita genuinamente que essa decisão está indo contra você de forma errada,
+você sempre pode tentar recorrer a uma instância superior. Até o momento em
+que este texto foi escrito, essa instância superior costuma ser Andrew Morton.
+Andrew goza de um enorme respeito na comunidade de desenvolvimento do kernel;
+ele frequentemente consegue destravar uma situação que parece desesperadoramente
+bloqueada. Recorrer a Andrew, no entanto, não deve ser feito de ânimo leve e nem
+antes que todas as outras alternativas tenham sido esgotadas. E tenha em mente,
+é claro, que ele também pode não concordar com você.
+
+O que acontece a seguir
+-----------------------
+
+Se um patch for considerado algo bom para ser adicionado ao kernel, e assim
+que a maioria dos problemas de revisão tiver sido resolvida, o próximo passo
+geralmente é a entrada na árvore de um mantenedor de subsistema. Como isso
+funciona varia de um subsistema para o outro; cada mantenedor tem sua própria
+maneira de fazer as coisas. Em particular, pode haver mais de uma árvore — uma,
+talvez, dedicada a patches planejados para a próxima janela de mesclagem
+(*merge window*), e outra para trabalhos de longo prazo.
+
+Para patches que se aplicam a áreas para quais não há uma árvore de subsistema
+óbvia (patches de gerenciamento de memória, por exemplo), a árvore padrão
+geralmente acaba sendo a *-mm*. Patches que afetam múltiplos subsistemas
+também podem acabar passando pela árvore *-mm*.
+
+A inclusão em uma árvore de subsistema pode trazer um nível mais alto de
+visibilidade para um patch. Agora, outros desenvolvedores que trabalham com
+aquela árvore receberão o patch por padrão. As árvores de subsistemas tipicamente
+alimentam a *linux-next* também, tornando seus conteúdos visíveis para a
+comunidade de desenvolvimento como um todo. Neste ponto, há uma boa chance de
+você receber mais comentários de um novo conjunto de revisores; esses
+comentários precisam ser respondidos da mesma forma que na rodada anterior.
+
+O que também pode acontecer neste ponto, dependendo da natureza do seu patch,
+é surgirem conflitos com o trabalho que está sendo feito por outros. No pior
+dos casos, conflitos pesados de patches podem fazer com que alguns trabalhos
+sejam deixados em segundo plano, para que os patches restantes possam ser
+ajustados e mesclados. Outras vezes, a resolução de conflitos envolverá trabalhar
+junto a outros desenvolvedores e, possivelmente, mover alguns patches entre
+árvores para garantir que tudo se aplique de forma limpa. Este trabalho pode ser
+árduo, mas console-se com uma vantagem: antes do surgimento da árvore *linux-next*,
+esses conflitos frequentemente só apareciam durante a janela de mesclagem e
+tinham que ser resolvidos às pressas. Agora eles podem ser resolvidos com calma,
+antes que a janela de mesclagem se abra.
+
+Um belo dia, se tudo correr bem, você fará login e verá que o seu patch foi
+mesclado ao kernel principal (*mainline*). Parabéns! No entanto, assim que a
+comemoração terminar (e você tiver se adicionado ao arquivo MAINTAINERS), vale
+a pena lembrar de um pequeno fato importante: o trabalho ainda não acabou. A
+mesclagem na árvore principal traz os seus próprios desafios.
+
+Para começar, a visibilidade do seu patch aumentou ainda mais. Pode haver
+uma nova rodada de comentários de desenvolvedores que não estavam cientes do
+patch antes. Pode ser tentador ignorá-los, já que não há mais nenhuma dúvida
+sobre a mesclagem do seu código. No entanto, resista a essa tentação; você
+ainda precisa ser receptivo aos desenvolvedores que tiverem dúvidas ou
+sugestões.
+
+Mais importante ainda: a inclusão na árvore principal coloca o seu código
+nas mãos de um grupo muito maior de testadores. Mesmo que você tenha contribuído
+com um driver para um hardware que ainda não está disponível, você se
+surpreenderá com a quantidade de pessoas que compilarão seu código em seus
+próprios kernels. E, logicamente, onde há testadores, haverá relatórios de
+erros (*bug reports*).
+
+O pior tipo de relatório de erro são as regressões (*regressions*). Se o seu
+patch causar uma regressão, você descobrirá uma quantidade desconfortável de
+olhos voltados para você; as regressões precisam ser corrigidas o mais rápido
+possível. Se você não estiver disposto ou for incapaz de corrigir a regressão
+(e ninguém mais fizer isso por você), seu patch quase certamente será removido
+durante o período de estabilização. Além de anular todo o trabalho que você teve
+para colocar seu patch na árvore principal, ter um patch removido como resultado
+da falha em corrigir uma regressão pode muito bem tornar mais difícil para você
+mesclar trabalhos no futuro.
+
+Depois que todas as regressões tiverem sido tratadas, pode haver outros erros
+comuns com os quais lidar. O período de estabilização é a sua melhor oportunidade
+para corrigir esses problemas e garantir que a estreia do seu código em um
+lançamento do kernel principal seja o mais sólida possível. Portanto, por favor,
+responda aos relatórios de erros e corrija os problemas, se for viável. É para
+isso que serve o período de estabilização; você pode começar a criar novos
+patches fantásticos assim que quaisquer problemas com os antigos tiverem sido
+resolvidos.
+
+E não se esqueça de que existem outros marcos que também podem gerar relatórios
+de erros: o próximo lançamento estável da árvore principal, o momento em que
+distribuidores proeminentes adotarem uma versão do kernel que contenha o seu
+patch, etc. Continuar respondendo a esses relatórios é uma questão de orgulho
+básico pelo seu trabalho. Se isso não for motivação suficiente, contudo, também
+vale a pena considerar que a comunidade de desenvolvimento se lembra dos
+desenvolvedores que perdem o interesse em seu próprio código após a mesclagem.
+A próxima vez que você enviar um patch, eles o avaliarão sob a suposição de
+que você não estará por perto para mantê-lo depois.
+
+
+Outras coisas que podem acontecer
+---------------------------------
+
+Um dia, você poderá abrir o seu cliente de e-mail e ver que alguém lhe enviou
+um patch para o seu código. Afinal, essa é uma das vantagens de ter o seu
+código disponível publicamente. Se você concordar com o patch, poderá encaminhá-lo
+para o mantenedor do subsistema (certifique-se de incluir uma linha ``From:``
+adequada para que a atribuição de autoria esteja correta e adicione a sua
+própria assinatura — *signoff*) ou enviar uma resposta com um ``Acked-by:``
+e deixar que o remetente original o envie para cima.
+
+Se você não concordar com o patch, envie uma resposta educada explicando o
+motivo. Se possível, diga ao autor quais alterações precisam ser feitas para
+que o patch seja aceitável para você. Existe uma certa resistência em mesclar
+patches que sofrem oposição do autor e mantenedor do código, mas isso tem limite.
+Se você for visto como alguém que está bloqueando um bom trabalho sem necessidade,
+esses patches eventualmente seguirão outro fluxo ao seu redor e entrarão na
+árvore principal de qualquer maneira. No kernel do Linux, ninguém tem poder de
+veto absoluto sobre nenhum código. Exceto, talvez, o Linus.
+
+Em ocasiões muito raras, você poderá ver algo completamente diferente: outro
+desenvolvedor envia uma solução diferente para o seu problema. Nesse ponto,
+as chances são de que um dos dois patches não seja mesclado, e o argumento
+"o meu chegou primeiro" não é considerado um argumento técnico convincente.
+Se o patch de outra pessoa deslocar o seu e entrar na árvore principal, existe
+realmente apenas uma maneira de responder: fique satisfeito pelo fato de o seu
+problema ter sido resolvido e siga adiante com o seu trabalho. Ter o próprio
+trabalho deixado de lado dessa maneira pode ser doloroso e desanimador, mas a
+comunidade se lembrará da sua reação muito depois de terem esquecido de quem
+foi o patch que realmente foi mesclado.
Documentation/translations/pt_BR/process/development-process.rst +1 -0
index e9f04df62..ca86b481a 100644
@@ -22,3 +22,4 @@ conhecimento profundo de programação de kernel para ser compreendida.
    3.Early-stage
    4.Coding
    5.Posting
+   6.Followthrough
Signature · 1 line
2.47.3
author maintainer
#2 lore raw

PATCH v2 2/7 docs: pt_BR: process: translate 7.AdvancedTopics and 8.Conclusion

In reply to Daniel Pereira

Translate the "Advanced topics" and "Conclusion" sections into Brazilian Portuguese, creating the 7.AdvancedTopics.rst and 8.Conclusion.rst documents, and updating development-process.rst to include them.

This translation covers patch management practices with Git, community guidelines for patch review, and the closing overview of the kernel development cycle.

Ensure all text conforms to the strict 80-column line length limit to maintain Sphinx rendering alignment.

---
 .../pt_BR/process/7.AdvancedTopics.rst        | 201 ++++++++++++++++++
 .../pt_BR/process/8.Conclusion.rst            |  73 +++++++
 .../pt_BR/process/development-process.rst     |   2 +
 3 files changed, 276 insertions(+)
 create mode 100644 Documentation/translations/pt_BR/process/7.AdvancedTopics.rst
 create mode 100644 Documentation/translations/pt_BR/process/8.Conclusion.rst
Documentation/translations/pt_BR/process/7.AdvancedTopics.rst new file +201 -0
new file mode 100644
index 000000000..97466fad1
@@ -0,0 +1,201 @@
+.. SPDX-License-Identifier: GPL-2.0
+
+Tópicos avançados
+=================
+
+Neste ponto, esperamos que você já tenha uma boa noção de como funciona o
+processo de desenvolvimento. No entanto, ainda há mais a aprender! Esta seção
+cobrirá uma série de tópicos que podem ser úteis para desenvolvedores que
+desejam se tornar parte regular do processo de desenvolvimento do kernel Linux.
+
+Gerenciamento de patches com o git
+----------------------------------
+
+O uso de controle de versão distribuído para o kernel começou no início de
+2002, quando Linus começou a testar o aplicativo proprietário BitKeeper.
+Embora o BitKeeper fosse controverso, a abordagem de gerenciamento de versão
+de software que ele incorporava certamente não era. O controle de versão
+distribuído permitiu uma aceleração imediata do projeto de desenvolvimento do
+kernel. Atualmente, existem várias alternativas gratuitas ao BitKeeper. Para o
+bem ou para o mal, o projeto do kernel adotou o git como sua ferramenta de
+escolha.
+
+Gerenciar patches com o git pode facilitar muito a vida do desenvolvedor,
+especialmente à medida que o volume desses patches cresce. O git também tem suas
+pontas soltas e apresenta certos riscos; é uma ferramenta jovem e poderosa que
+ainda está sendo refinada por seus desenvolvedores. Este documento não tentará
+ensinar o leitor a usar o git; isso seria material suficiente para um documento
+longo por si só. Em vez disso, o foco aqui será em como o git se encaixa
+especificamente no processo de desenvolvimento do kernel. Os desenvolvedores
+que desejam se atualizar com o git encontrarão mais informações em:
+
+	https://git-scm.com/
+
+	https://www.kernel.org/pub/software/scm/git/docs/user-manual.html
+
+e em vários tutoriais encontrados na web.
+
+A primeira ordem do dia é ler os sites acima e obter uma compreensão sólida de
+como o git funciona antes de tentar usá-lo para disponibilizar patches para
+outros. Um desenvolvedor que utiliza o git deve ser capaz de obter uma cópia do
+repositório principal, explorar o histórico de revisões, comitar alterações na
+árvore, usar branches, etc. A compreensão das ferramentas do git para a
+reescrita de histórico (como o rebase) também é útil. O git vem com sua própria
+terminologia e conceitos; um novo usuário do git deve saber sobre refs, remote
+branches, o index, fast-forward merges, pushes e pulls, detached HEADs, etc.
+Tudo isso pode ser um pouco intimidante no início, mas os conceitos não são tão
+difíceis de entender com um pouco de estudo.
+
+Usar o git para gerar patches para submissão por e-mail pode ser um bom exercício
+enquanto você se atualiza.
+
+Quando estiver pronto para começar a disponibilizar árvores git para que outros
+possam examinar, você, logicamente, precisará de um servidor a partir do qual um
+pull possa ser feito. Configurar um servidor desse tipo com o git-daemon é
+relativamente simples se você tiver um sistema acessível à internet. Caso
+contrário, sites de hospedagem públicos e gratuitos (o GitHub, por exemplo)
+estão começando a surgir na rede. Desenvolvedores estabelecidos podem obter uma
+conta no kernel.org, mas estas não são fáceis de conseguir; consulte
+https://kernel.org/faq/ para mais informações.
+
+O fluxo de trabalho normal do git envolve o uso de muitas branches. Cada linha
+de desenvolvimento pode ser separada em uma "topic branch" distinta e mantida de
+forma independente. Branches no git são baratas, não há razão para não fazer um
+uso livre delas. E, em qualquer caso, você não deve fazer o seu desenvolvimento
+em nenhuma branch a partir da qual pretenda pedir para que outros deem pull.
+Branches disponíveis publicamente devem ser criadas com cuidado; mescle patches
+de branches de desenvolvimento quando eles estiverem em sua forma final e prontos
+para seguir em frente — não antes.
+
+O git fornece algumas ferramentas poderosas que podem permitir que você
+reescreva o seu histórico de desenvolvimento. Um patch inconveniente (um que
+quebre o bisection, por exemplo, ou que tenha algum outro tipo de bug óbvio)
+pode ser corrigido localmente ou feito desaparecer completamente do histórico.
+Uma série de patches pode ser reescrita como se tivesse sido escrita no topo da
+linha principal de hoje, mesmo que você esteja trabalhando nela há meses. As
+alterações podem ser movidas de forma transparente de uma branch para outra. E
+assim por diante. O uso criterioso da capacidade do git de revisar o histórico
+pode ajudar na criação de conjuntos de patches limpos e com menos problemas.
+
+O uso excessivo dessa capacidade pode levar a outros problemas, no entanto, além
+de uma simples obsessão pela criação do histórico de projeto perfeito. Reescrever
+o histórico reescreverá as alterações contidas nele, transformando uma árvore do
+kernel testada (assim se espera) em uma não testada. Mas, além disso, os
+desenvolvedores não podem colaborar facilmente se não tiverem uma visão
+compartilhada do histórico do projeto; se você reescrever o histórico que outros
+desenvolvedores já deram pull em seus repositórios, tornará a vida deles muito
+mais difícil. Portanto, uma regra prática simples se aplica aqui: o histórico
+que foi exportado para terceiros deve ser visto geralmente como imutável dali em
+diante.
+
+Sendo assim, uma vez que você faz o push de um conjunto de alterações para o seu
+servidor disponível publicamente, essas alterações não devem ser reescritas. O
+git tentará aplicar essa regra se você tentar dar push em alterações que não
+resultem em um fast-forward merge (ou seja, alterações que não compartilham o
+mesmo histórico). É possível anular essa verificação, e pode haver momentos em
+que seja necessário reescrever uma árvore exportada. Mover changesets entre
+árvores para evitar conflitos na linux-next é um exemplo. No entanto, tais ações
+devem ser raras. Esta é uma das razões pelas quais o desenvolvimento deve ser
+feito em branches privadas (que podem ser reescritas, se necessário) e apenas
+movido para branches públicas quando estiver em um estado razoavelmente avançado.
+
+À medida que a linha principal (ou outra árvore na qual um conjunto de
+alterações se baseia) avança, é tentador fazer o merge com essa árvore para
+permanecer na vanguarda. Para uma branch privada, o rebasing pode ser uma maneira
+fácil de acompanhar outra árvore, mas o rebasing não é uma opção uma vez que uma
+árvore é exportada para o mundo. Quando isso acontece, um merge completo deve
+ser feito. Fazer merges ocasionalmente faz todo o sentido, mas merges excessivamente
+frequentes podem poluir o histórico desnecessariamente. A técnica sugerida neste
+caso é fazer merges raramente, e geralmente apenas em release points específicos
+(como um lançamento -rc da linha principal). Se você estiver inseguro sobre
+mudanças específicas, sempre poderá realizar merges de teste em uma branch
+privada. A ferramenta "rerere" do git pode ser útil nessas situações; ela se
+lembra de como os conflitos de merge foram resolvidos para que você não precise
+fazer o mesmo trabalho duas vezes.
+
+Uma das maiores reclamações recorrentes sobre ferramentas como o git é esta: o
+movimento em massa de patches de um repositório para outro torna fácil a
+inclusão de mudanças desaconselháveis que entram na linha principal abaixo do
+radar de revisão. Os desenvolvedores do kernel costumam ficar descontentes quando
+veem esse tipo de coisa acontecer; disponibilizar uma árvore git com patches não
+revisados ou fora do tópico pode afetar a sua capacidade de ter suas árvores
+puxadas no futuro. Citando Linus:
+
+::
+
+    Você pode me enviar patches, mas para eu puxar um patch git de você, eu
+    preciso saber que você sabe o que está fazendo, e preciso ser capaz de
+    confiar nas coisas *sem* ter que ir lá e verificar cada mudança
+    individualmente à mão.
+
+(https://lwn.net/Articles/224135/).
+
+Para evitar esse tipo de situação, certifique-se de que todos os patches
+dentro de uma determinada branch permaneçam estritamente alinhados ao tópico
+associado; uma branch de "correções de drivers" não deveria fazer alterações no
+código central de gerenciamento de memória. E, acima de tudo, não use uma árvore
+git para burlar o processo de revisão. Publique ocasionalmente um resumo da
+árvore na lista de discussão relevante e, quando for o momento certo, solicite
+que a árvore seja incluída na linux-next.
+
+Se e quando outros começarem a enviar patches para inclusão em sua árvore, não
+se esqueça de revisá-los. Certifique-se também de manter as informações corretas
+de autoria; a ferramenta "am" do git faz o melhor que pode a esse respeito, mas
+você pode ter que adicionar uma linha "From:" ao patch se ele tiver sido
+retransmitido a você por terceiros.
+
+Ao solicitar um pull, certifique-se de fornecer todas as informações
+relevantes: onde está a sua árvore, qual branch deve ser puxada e quais
+alterações resultarão do pull. O comando git request-pull pode ser útil a esse
+respeito; ele formatará a solicitação da maneira que outros desenvolvedores
+esperam e também verificará se você se lembrou de dar push nessas alterações
+para o servidor público.
+
+
+Revisão de patches
+------------------
+
+Alguns leitores certamente objetarão a inclusão desta seção em "tópicos
+avançados" sob o argumento de que mesmo desenvolvedores iniciantes do kernel
+deveriam estar revisando patches. É certamente verdade que não há melhor maneira
+de aprender a programar no ambiente do kernel do que examinando o código
+postado por outros. Além disso, revisores estão sempre em falta; ao examinar o
+código, você pode fazer uma contribuição significativa para o processo como um
+todo.
+
+Revisar código pode ser uma perspectiva intimidadora, especialmente para um novo
+desenvolvedor do kernel que pode se sentir nervoso em questionar — em público —
+um código que foi postado por aqueles com mais experiência. No entanto, mesmo o
+código escrito pelos desenvolvedores mais experientes pode ser aprimorado. Talvez
+o melhor conselho para revisores (todos os revisores) seja este: formule os
+comentários de revisão como perguntas em vez de críticas. Perguntar "como o lock
+é liberado neste caminho?" sempre funcionará melhor do que afirmar "o bloqueio
+aqui está errado."
+
+Outra técnica útil em caso de desacordo é pedir que outros se manifestem. Se uma
+discussão chegar a um impasse após algumas trocas de mensagens, peça a opinião
+de outros revisores ou mantenedores. Frequentemente, aqueles que concordam com
+um revisor permanecem em silêncio, a menos que sejam solicitados. A opinião de
+múltiplas pessoas carrega exponencialmente mais peso.
+
+Diferentes desenvolvedores revisarão o código sob diferentes pontos de vista.
+Alguns estão preocupados principalmente com o estilo de codificação e se as
+linhas de código possuem espaços em branco no final (trailing white space).
+Outros se concentrarão principalmente em saber se a alteração implementada pelo
+patch como um todo é algo bom para o kernel ou não. Ainda assim, outros buscarão
+por bloqueios problemáticos, uso excessivo de pilha (stack usage), possíveis
+problemas de segurança, duplicação de código encontrado em outros lugares,
+documentação adequada, efeitos adversos no desempenho, alterações na ABI do
+espaço do usuário (user-space ABI), etc. Todos os tipos de revisão, se levarem a
+um código melhor entrando no kernel, são bem-vindos e valem a pena.
+
+Não há exigência estrita para o uso de tags específicas como ``Reviewed-by``. Na
+verdade, revisões em texto simples são mais informativas e incentivadas mesmo
+quando uma tag é fornecida, por exemplo: "Analisei os aspectos A, B e C deste
+envio e tudo me parece correto." Alguma forma de mensagem de revisão ou resposta
+é obviamente necessária, caso contrário, os mantenedores não saberão que o
+revisor sequer examinou o patch!
+
+Por último, mas não menos importante, a revisão de patches pode se tornar um
+processo negativo, focado em apontar problemas. Por favor, reserve um elogio de
+vez em quando, particularmente para os novatos!
Documentation/translations/pt_BR/process/8.Conclusion.rst new file +73 -0

73 lines not on this page · raw message

Documentation/translations/pt_BR/process/development-process.rst +2 -0
index ca86b481a..d303ab92b 100644
@@ -23,3 +23,5 @@ conhecimento profundo de programação de kernel para ser compreendida.
    4.Coding
    5.Posting
    6.Followthrough
+   7.AdvancedTopics
+   8.Conclusion
Signature · 1 line
2.47.3
author maintainer
#3 lore raw

PATCH v2 3/7 docs: pt_BR: Add translation for applying-patches and update index

In reply to Daniel Pereira

Translate the 'applying-patches' documentation into Brazilian Portuguese, ensuring alignment with the upstream structural guidelines.

Additionally, add the translated document to the main process index toctree to integrate it into the documentation build tree.

---
 Documentation/translations/pt_BR/index.rst    |   1 +
 .../pt_BR/process/applying-patches.rst        | 447 ++++++++++++++++++
 2 files changed, 448 insertions(+)
 create mode 100644 Documentation/translations/pt_BR/process/applying-patches.rst
Documentation/translations/pt_BR/index.rst +1 -0
index 7a488f662..555bf1d3a 100644
@@ -68,6 +68,7 @@ kernel e sobre como ver seu trabalho integrado.
 
    Introdução <process/1.Intro>
    Guia do Processo de Desenvolvimento <process/development-process>
+   Como aplicar patches <process/applying-patches>
    Index de documentos do Kernel <process/kernel-docs>
    Regras de licenciamento <process/license-rules>
    Como começar <process/howto>
Documentation/translations/pt_BR/process/applying-patches.rst new file +447 -0

448 lines not on this page · raw message

Signature · 1 line
2.47.3
author maintainer
#4 lore raw

PATCH v2 4/7 docs: pt_BR: translate backporting.rst documentation

In reply to Daniel Pereira

Translate the 'backporting' guide into Brazilian Portuguese, ensuring strict alignment with the upstream content and structure.

The translation covers conflict resolution strategies, understanding git conflict markers, and the process of submitting backports to the stable kernel tree.

Additionally, maintain the strict 80-column line length limit across the entire file to ensure proper Sphinx rendering.

---
 Documentation/translations/pt_BR/index.rst    |   1 +
 .../pt_BR/process/backporting.rst             | 598 ++++++++++++++++++
 2 files changed, 599 insertions(+)
 create mode 100644 Documentation/translations/pt_BR/process/backporting.rst
Documentation/translations/pt_BR/index.rst +1 -0
index 555bf1d3a..08faaacf3 100644
@@ -69,6 +69,7 @@ kernel e sobre como ver seu trabalho integrado.
    Introdução <process/1.Intro>
    Guia do Processo de Desenvolvimento <process/development-process>
    Como aplicar patches <process/applying-patches>
+   Backporting e resolução de conflitos <process/backporting>
    Index de documentos do Kernel <process/kernel-docs>
    Regras de licenciamento <process/license-rules>
    Como começar <process/howto>
Documentation/translations/pt_BR/process/backporting.rst new file +598 -0

599 lines not on this page · raw message

Signature · 1 line
2.47.3
author maintainer
#5 lore raw

PATCH v2 5/7 docs: pt_BR: process: translate botching-up-ioctls guide

In reply to Daniel Pereira

Translate the 'botching-up-ioctls' documentation into Brazilian Portuguese, ensuring precise technical alignment with the upstream source guidelines.

The translation covers critical driver-private API design concepts, including fixed-sized integers, structure padding, error path validation rules, and handling asynchronous hardware timeouts.

---
 Documentation/translations/pt_BR/index.rst    |   1 +
 .../pt_BR/process/botching-up-ioctls.rst      | 256 ++++++++++++++++++
 2 files changed, 257 insertions(+)
 create mode 100644 Documentation/translations/pt_BR/process/botching-up-ioctls.rst
Documentation/translations/pt_BR/index.rst +1 -0
index 08faaacf3..4a13b3d14 100644
@@ -70,6 +70,7 @@ kernel e sobre como ver seu trabalho integrado.
    Guia do Processo de Desenvolvimento <process/development-process>
    Como aplicar patches <process/applying-patches>
    Backporting e resolução de conflitos <process/backporting>
+   Como não Deixar as ioctls malfeitas <process/botching-up-ioctls>
    Index de documentos do Kernel <process/kernel-docs>
    Regras de licenciamento <process/license-rules>
    Como começar <process/howto>
Documentation/translations/pt_BR/process/botching-up-ioctls.rst new file +256 -0

257 lines not on this page · raw message

Signature · 1 line
2.47.3
author maintainer
#6 lore raw

PATCH v2 6/7 docs: pt_BR: process: translate contribution maturity model

In reply to Daniel Pereira

Translate the 'contribution-maturity-model' documentation into Brazilian Portuguese, ensuring strict alignment with the upstream source structure and language.

The translation covers the Open Source engagement framework proposed by the Technical Advisory Board (TAB), detailing Levels 0 through 5 of organizational upstream maturity, community metrics, and engineer career alignment.

Additionally, maintain strict 80-column line length restrictions across the entire file to ensure proper Sphinx HTML rendering.

---
 Documentation/translations/pt_BR/index.rst    |   1 +
 .../process/contribution-maturity-model.rst   | 111 ++++++++++++++++++
 2 files changed, 112 insertions(+)
 create mode 100644 Documentation/translations/pt_BR/process/contribution-maturity-model.rst
Documentation/translations/pt_BR/index.rst +1 -0
index 4a13b3d14..749c5fc3f 100644
@@ -76,6 +76,7 @@ kernel e sobre como ver seu trabalho integrado.
    Como começar <process/howto>
    Requisitos mínimos <process/changes>
    Conclave (Continuidade do projeto) <process/conclave>
+   Modelos de Maturidade para Contribuição no Kernel Linux <process/contribution-maturity-model.rst>
    Manuais dos mantenedores <process/maintainer-handbooks>
    Processo do subsistema de rede (netdev) <process/maintainer-netdev>
    Processo do subsistema SoC <process/maintainer-soc>
Documentation/translations/pt_BR/process/contribution-maturity-model.rst new file +111 -0

112 lines not on this page · raw message

Signature · 1 line
2.47.3
author maintainer
#7 lore raw

PATCH v2 7/7 docs: pt_BR: translate process/adding-syscalls.rst

In reply to Daniel Pereira

Translate the adding-syscalls.rst document into Brazilian Portuguese (pt_BR) to improve accessibility for native Portuguese-speaking developers contributing to the Linux kernel ecosystem.

---
Changes in v2:
- Added adding-syscalls.rst to the index.rst toctree to resolve a Sphinx build warning.

 Documentation/translations/pt_BR/index.rst    |   1 +
 .../pt_BR/process/adding-syscalls.rst         | 700 ++++++++++++++++++
 2 files changed, 701 insertions(+)
 create mode 100644 Documentation/translations/pt_BR/process/adding-syscalls.rst
Documentation/translations/pt_BR/index.rst +1 -0
index 749c5fc3f..2ab14c5d6 100644
@@ -82,3 +82,4 @@ kernel e sobre como ver seu trabalho integrado.
    Processo do subsistema SoC <process/maintainer-soc>
    Conformidade de DTS para SoC <process/maintainer-soc-clean-dts>
    Processo do subsistema KVM x86 <process/maintainer-kvm-x86>
+   Adicionando uma nova chamada de Sistema <process/adding-syscalls>
Documentation/translations/pt_BR/process/adding-syscalls.rst new file +700 -0

700 lines not on this page · raw message

Signature · 1 line
2.47.3
maintainer
#8 lore raw
In reply to Daniel Pereira
Quoted 7 lines · Daniel Pereira

This patch series updates the Brazilian Portuguese (pt_BR) translation for the core Linux kernel development process documentation.

The goal is to expand accessibility for Portuguese-speaking developers, bringing over crucial guides ranging from subsystem-specific rules to organizational maturity frameworks.

Quoted 7 lines

All documents have been strictly formatted to adhere to the 80-column line length limit to ensure proper Sphinx HTML rendering and consistency with the existing pt_BR infrastructure.

Changes in v2:
- Patch 7: Added adding-syscalls.rst to the index.rst toctree to resolve a Sphinx build warning.

Series applied, thanks.

jon