From cce8a9970fd83e75416875b70d8cd5cb257f4285 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20Catarino=20Fran=C3=A7a?= Date: Wed, 13 Jan 2021 09:52:59 -0300 Subject: [PATCH 01/25] homepage portuguese --- content/_index.pt.md | 155 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 155 insertions(+) create mode 100644 content/_index.pt.md diff --git a/content/_index.pt.md b/content/_index.pt.md new file mode 100644 index 000000000..feb2d2091 --- /dev/null +++ b/content/_index.pt.md @@ -0,0 +1,155 @@ +--- +title: Home +mobile_menu_title: "Home" +--- +{{< slogan get_started="COMECE AGORA" docs="Documentação" notes="Mudanças">}} +Zig é uma linguagem de programação de propósito geral e um conjunto de ferramentas para manter o seu software **robusto**, **otimizado**, e **usável***. +{{< /slogan >}} + +{{< flexrow class="container" style="padding: 20px 0; justify-content: space-between;" >}} +{{% div class="features" %}} + +# ⚡ Uma linguagem simples +Concentre-se na depuração de sua aplicação em vez de depurar seus conhecimentos em uma linguagem de programação. + +- Sem fluxos de controle ocultas. +- Sem alocações de memórias ocultas. +- Sem preprocessador, nem macros. + +# ⚡ Tempo de Compilação (Comptime) +Uma nova abordagem de metaprogramação baseada na execução do código em tempo de compilação e avaliação preguiçosa. + +- Chame qualquer função em tempo de compilação. +- Manipular tipos como valores sem sobrecarga de tempo de execução. +- O Comptime emula a arquitetura alvo. + +# ⚡ Desempenho que se enquadra na segurança +Escreva um código rápido e claro, capaz de lidar com todas as condições de erro. + +- A linguagem guia graciosamente sua lógica de tratamento de erros. +- As verificações configuráveis de tempo de execução ajudam a encontrar um equilíbrio entre desempenho e garantias de segurança. +- Aproveite os tipos vetoriais para expressar as instruções SIMD de forma portátil. + +{{% flexrow style="justify-content:center;" %}} +{{% div %}} +

+ Visão geral em profundidade +

+{{% /div %}} +{{% div style="margin-left: 5px;" %}} +

+ Mais exemplos de código +

+{{% /div %}} +{{% /flexrow %}} +{{% /div %}} +{{< div class="codesample" >}} + +{{% zigdoctest "assets/zig-code/index.zig" %}} + +{{< /div >}} +{{< /flexrow >}} + + +{{% div class="alt-background" %}} +{{% div class="container" style="display:flex;flex-direction:column;justify-content:center;text-align:center; padding: 20px 0;" title="Community" %}} + +{{< flexrow class="container" style="justify-content: center;" >}} +{{% div style="width:25%" %}} + +{{% /div %}} + +{{% div class="community-message" %}} +# A comunidade Zig é descentralizada +Qualquer pessoa é livre para começar e manter seu próprio espaço para que a comunidade se reúna. +Não existe o conceito de "oficial" ou "não-oficial", entretanto, cada local de reunião tem seus próprios moderadores e regras. + +
+

+ Veja todas as comunidades +

+
+{{% /div %}} +{{< /flexrow >}} +
+ +{{< flexrow class="container" style="justify-content: center;" >}} +{{% div class="main-development-message" %}} +# Principal desenvolvimento +O repositório Zig pode ser encontrado em [https://github.com/ziglang/zig](https://github.com/ziglang/zig), onde também discutimos sobre os problemas e propostas. +Espera-se que os contribuidores sigam o Zig [Código de Conduta](https://github.com/ziglang/zig/blob/master/CODE_OF_CONDUCT.md). +{{% /div %}} +{{% div style="width:40%" %}} + +{{% /div %}} +{{< /flexrow >}} +{{% /div %}} +{{% /div %}} + + +{{% div class="container" style="display:flex;flex-direction:column;justify-content:center;text-align:center; padding: 20px 0;" title="Zig Software Foundation" %}} +## A ZSF é uma corporação sem fins lucrativos 501(c)(3). + +A Fundação Zig Software é uma corporação sem fins lucrativos fundada em 2020 por Andrew Kelley, o criador do Zig, com o objetivo de apoiar o desenvolvimento da linguagem. Atualmente, a ZSF é capaz de oferecer trabalho remunerado a taxas competitivas para um pequeno número de colaboradores principais. Esperamos ser capazes de estender esta oferta a mais colaboradores centrais no futuro. + +A Zig Software Foundation é sustentada por doações. + +

+ Mais informações +

+{{% /div %}} + + +{{< div class="alt-background" style="padding: 20px 0;">}} +{{% div class="container" title="Sponsors" %}} +# Patrocinadores corporativos +As seguintes empresas estão fornecendo suporte financeiro direto para a fundação Zig Software. + +{{% sponsor-logos "monetary" %}} + + + + + + +{{% /sponsor-logos %}} + +# Patrocinadores GitHub +Graças a pessoas que [Patrocine Zig](zsf/), o projeto é responsável perante a comunidade de código aberto e não perante os acionistas corporativos. Em particular, essas pessoas de boa reputação patrocinam o Zig por US$ 200/mês ou mais: + +- [Karrick McDermott](https://github.com/karrick) +- [Raph Levien](https://raphlinus.github.io/) +- [ryanworl](https://github.com/ryanworl) +- [Stevie Hryciw](https://www.hryx.net/) +- [Josh Wolfe](https://github.com/thejoshwolfe) +- [SkunkWerks, GmbH](https://skunkwerks.at/) +- [drfuchs](https://github.com/drfuchs) +- Eleanor Bartle + +Esta seção é atualizada no início de cada mês. +{{% /div %}} +{{< /div >}} + + + + + + + + + + + + + + + + + + + + + + + + From 50f177b5ea0006fcef89b83bdee898d591f45b32 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20Catarino=20Fran=C3=A7a?= Date: Wed, 13 Jan 2021 11:57:16 -0300 Subject: [PATCH 02/25] more pages on portuguese --- config.toml | 2 + content/learn/_index.pt.md | 56 +++ content/learn/getting-started.pt.md | 147 +++++++ content/learn/overview.pt.md | 590 ++++++++++++++++++++++++++++ content/translations/index.md | 1 + 5 files changed, 796 insertions(+) create mode 100644 content/learn/_index.pt.md create mode 100644 content/learn/getting-started.pt.md create mode 100644 content/learn/overview.pt.md diff --git a/config.toml b/config.toml index dd2a11b5f..361de15a1 100644 --- a/config.toml +++ b/config.toml @@ -49,3 +49,5 @@ DefaultContentLanguage = "en" weight = 1 [languages.it] weight = 2 + [languages.pt] + weight = 2 diff --git a/content/learn/_index.pt.md b/content/learn/_index.pt.md new file mode 100644 index 000000000..d3db721bf --- /dev/null +++ b/content/learn/_index.pt.md @@ -0,0 +1,56 @@ +--- +title: "Learn" +menu_title: "Learn" +mobile_menu_title: "Learn" +toc: false +layout: single +--- + +# Aprender +Esta seção lista recursos úteis para ir desde não saber nada sobre Zig até a compreensão de sua filosofia. + +## Introdução +Todas estas páginas são introduções ao Zig destinadas a programadores com diferentes formações. + +- [Visão geral em profundidade](overview/) +Aqui está uma visão aprofundada do Zig do ponto de vista da programação de sistemas. +- [Por que Zig quando já existe C++, D, e Rust?](why_zig_rust_d_cpp/) +Uma introdução a Zig para programadores de C++, D, e Rust. +- [Exemplos de Código](samples/) +Uma lista de trechos para ter uma idéia de como o código Zig se parece. +- [Ferramentas](tools/) +Uma lista de ferramentas úteis que podem ajudá-lo a escrever o código Zig. + + +## Começando +Se você estiver pronto para começar a programar em Zig, este guia o ajudará a configurar seu ambiente. + +- [Comece Agora]({{< ref "getting-started.md" >}}) + +## Recursos de aprendizado online +- [Aprenda Zig](https://ziglearn.org) +Uma introdução estruturada ao Zig, por [Sobeston](https://github.com/sobeston). + +## Vídeos e posts relevantes no blog +- [Zig a caminho do 1.0 (inglês)](https://www.youtube.com/watch?v=Gv2I7qTux7g) [video] +Vídeo de [Andrew Kelley](https://andrewkelley.me) apresentando Zig e sua filosofia. +- [Nova relação de Zig com a LLVM (inglês)](https://kristoff.it/blog/zig-new-relationship-llvm/) +Um post no blog sobre o trabalho para a construção do compilador auto-hospedado Zig, também apresentado em [um artigo no lwn.net (inglês)](https://lwn.net/Articles/833400/). + + + + + + + + + + + + + + + + + + diff --git a/content/learn/getting-started.pt.md b/content/learn/getting-started.pt.md new file mode 100644 index 000000000..e6282cdfc --- /dev/null +++ b/content/learn/getting-started.pt.md @@ -0,0 +1,147 @@ +--- +title: Getting Started +mobile_menu_title: "Getting Started" +toc: true +--- + +{{% div class="box thin"%}} +**
Note for Apple Silicon users
** +Zig has experimental support for codesigning. You will be able to use Zig with your M1 Mac, +but the only way at the moment to get Zig for arm64 macOS is to compile it yourself. +Make sure to check the [Building from source](#building-from-source) section. +{{% /div %}} + + +## Tagged release or nightly build? +Zig has not yet reached v1.0 and the current release cycle is tied to new releases of LLVM, which have a ~6 months cadence. +In practical terms, **Zig releases tend to be far apart and eventually become stale given the current speed of development**. + +It's fine to evaluate Zig using a tagged version, but if you decide that you like Zig and +want to dive deeper, **we encourage you to upgrade to a nightly build**, mainly because +that way it will be easier for you to get help: most of the community and sites like +[ziglearn.org](https://ziglearn.org) track the master branch for the reasons stated above. + +The good news is that it's very easy to switch from one Zig version to another, or even have multiple versions present on the system at the same time: Zig releases are self-contained archives that can be placed anywhere in your system. + + +## Installing Zig +### Direct download +This is the most straight-forward way of obtaining Zig: grab a Zig bundle for your platform from the [Downloads](/download) page, +extract it in a directory and add it to your `PATH` to be able to call `zig` from any location. + +#### Setting up PATH on Windows +To setup your path on Windows run **one** of the following snippets of code in a Powershell instance. +Choose if you want to apply this change on a system-wide level (requires running Powershell with admin priviledges) +or just for your user, and **make sure to change the snippet to point at the location where your copy of Zig lies**. +The `;` before `C:` is not a typo. + +System wide (**admin** Powershell): +``` +[Environment]::SetEnvironmentVariable( + "Path", + [Environment]::GetEnvironmentVariable("Path", "Machine") + ";C:\your-path\zig-windows-x86_64-your-version", + "Machine" +) +``` + +User level (Powershell): +``` +[Environment]::SetEnvironmentVariable( + "Path", + [Environment]::GetEnvironmentVariable("Path", "User") + ";C:\your-path\zig-windows-x86_64-your-version", + "User" +) +``` +After you're done, restart your Powershell instance. + +#### Setting up PATH on Linux, macOS, BSD +Add the location of your zig binary to your PATH environment variable. + +This is generally done by adding an export line to your shell startup script (`.profile`, `.zshrc`, ...) +```bash +export PATH=$PATH:~/path/to/zig +``` +After you're done, either `source` your startup file or restart your shell. + + + + +### Package managers +#### Windows +Zig is available on [Chocolatey](https://chocolatey.org/packages/zig). +``` +choco install zig +``` + +#### macOS + +**Homebrew** +NOTE: Homebrew doesn't have a bottle for Apple Silicon yet. If you have a M1 Mac, you must build Zig from source. + +Latest tagged release: +``` +brew install zig +``` + +Latest build from Git master branch: +``` +brew install zig --HEAD +``` + +**MacPorts** +``` +port install zig +``` +#### Linux +Zig is also present in many package managers for Linux. [Here](https://github.com/ziglang/zig/wiki/Install-Zig-from-a-Package-Manager) +you can find an updated list but keep in mind that some packages might bundle outdated versions of Zig. + +### Building from source +[Here](https://github.com/ziglang/zig/wiki/Building-Zig-From-Source) +you can find more information on how to build Zig from source for Linux, macOS and Windows. + +## Recommended tools +### Syntax Higlighters and LSP +All major text editors have syntax highlight support for Zig. +Some bundle it, some others require installing a plugin. + +If you're interested in a deeper integration beween Zig and your editor, +checkout [zigtools/zls](https://github.com/zigtools/zls). + +If you're interested in what else is available, checkout the [Tools](../tools/) section. + +## Run Hello World +If you completed the installation process correctly, you should now be able to invoke the Zig compiler from your shell. +Let's test this by creating your first Zig program! + +Navigate to your projects directory and run: +```bash +mkdir hello-world +cd hello-world +zig init-exe +``` + +This should output: +``` +info: Created build.zig +info: Created src/main.zig +info: Next, try `zig build --help` or `zig build run` +``` + +Running `zig build run` should then compile the executable and run it, ultimately resulting in: +``` +info: All your codebase are belong to us. +``` + +Congratulations, you have a working Zig installation! + +## Next steps +**Check out other resources present in the [Learn](../) section**, make sure to find the Documentation for your version +of Zig (note: nightly builds should use `master` docs) and consider giving [ziglearn.org](https://ziglearn.org) a read. + +Zig is a young project and unfortunately we don't have yet the capacity to produce extensive documentation and learning +materials for everything, so you should consider [joining one of the existing Zig communities](https://github.com/ziglang/zig/wiki/Community) +to get help when you get stuck, as well as checking out initiatives like [Zig SHOWTIME](https://zig.show). + +Finally, if you enjoy Zig and want to help speed up the development, [consider donating to the Zig Software Foundation](../../zsf) +. diff --git a/content/learn/overview.pt.md b/content/learn/overview.pt.md new file mode 100644 index 000000000..69f35e895 --- /dev/null +++ b/content/learn/overview.pt.md @@ -0,0 +1,590 @@ +--- +title: "In-depth Overview" +mobile_menu_title: "Overview" +toc: true +--- +# Destaques +## Linguagem simples e pequena + +Concentre-se na depuração de sua aplicação em vez de depurar seus conhecimentos em uma linguagem de programação. + +Toda a sintaxe do Zig é especificada com um [500-line PEG grammar file](https://ziglang.org/documentation/master/#Grammar). + +Não há **nenhum fluxo de controle oculto**, nenhuma alocação de memória oculta, nenhum pré-processador, e nenhuma macros. Se o código Zig não parece estar pulando para chamar uma função, então não está. Isto significa que você pode ter certeza de que o seguinte código chama apenas `foo()` e depois `bar()`, e isto é garantido sem a necessidade de saber os tipos de nada: + +```zig +var a = b + c.d; +foo(); +bar(); +``` + +Examples of hidden control flow: + +- D has `@property` functions, which are methods that you call with what looks like field access, so in the above example, `c.d` might call a function. +- C++, D, and Rust have operator overloading, so the `+` operator might call a function. +- C++, D, and Go have throw/catch exceptions, so `foo()` might throw an exception, and prevent `bar()` from being called. + + Zig promotes code maintenance and readability by making all control flow managed exclusively with language keywords and function calls. + +## Performance and Safety: Choose Two + +Zig has four [build modes](https://ziglang.org/documentation/master/#Build-Mode), and they can all be mixed and matched all the way down to [scope granularity](https://ziglang.org/documentation/master/#setRuntimeSafety). + +| Parameter | [Debug](/documentation/master/#Debug) | [ReleaseSafe](/documentation/master/#ReleaseSafe) | [ReleaseFast](/documentation/master/#ReleaseFast) | [ReleaseSmall](/documentation/master/#ReleaseSmall) | +|-----------|-------|-------------|-------------|--------------| +Optimizations - improve speed, harm debugging, harm compile time | | -O3 | -O3| -Os | +Runtime Safety Checks - harm speed, harm size, crash instead of undefined behavior | On | On | | | + +Here is what [Integer Overflow](https://ziglang.org/documentation/master/#Integer-Overflow) looks like at compile time, regardless of the build mode: + +{{< zigdoctest "assets/zig-code/features/1-integer-overflow.zig" >}} + +Here is what it looks like at runtime, in safety-checked builds: + +{{< zigdoctest "assets/zig-code/features/2-integer-overflow-runtime.zig" >}} + + +Those [stack traces work on all targets](https://ziglang.org/#Stack-traces-on-all-targets), including [freestanding](https://andrewkelley.me/post/zig-stack-traces-kernel-panic-bare-bones-os.html). + +With Zig one can rely on a safety-enabled build mode, and selectively disable safety at the performance bottlenecks. For example the previous example could be modified like this: + +{{< zigdoctest "assets/zig-code/features/3-undefined-behavior.zig" >}} + +Zig uses [undefined behavior](https://ziglang.org/documentation/master/#Undefined-Behavior) as a razor sharp tool for both bug prevention and performance enhancement. + +Speaking of performance, Zig is faster than C. + +- The reference implementation uses LLVM as a backend for state of the art optimizations. +- What other projects call "Link Time Optimization" Zig does automatically. +- For native targets, advanced CPU features are enabled (-march=native), thanks to the fact that [Cross-compiling is a first-class use case](https://ziglang.org/#Cross-compiling-is-a-first-class-use-case). +- Carefully chosen undefined behavior. For example, in Zig both signed and unsigned integers have undefined behavior on overflow, contrasted to only signed integers in C. This [facilitates optimizations that are not available in C](https://godbolt.org/z/n_nLEU). +- Zig directly exposes a [SIMD vector type](https://ziglang.org/documentation/master/#Vectors), making it easy to write portable vectorized code. + +Please note that Zig is not a fully safe language. For those interested in following Zig's safety story, subscribe to these issues: + +- [enumerate all kinds of undefined behavior, even that which cannot be safety-checked](https://github.com/ziglang/zig/issues/1966) +- [make Debug and ReleaseSafe modes fully safe](https://github.com/ziglang/zig/issues/2301) + +## Zig compete com C, em vez de depender dele + +A biblioteca padrão do Zig se integra com a libc, mas não depende dela. Aqui está o "Hello World": + +{{< zigdoctest "assets/zig-code/features/4-hello.zig" >}} + +Quando compilado com `-O ReleaseSmall`, símbolos de depuração são removidos (stripped), modo de thread única, isto produz um executável estático de 9,8 KiB para o alvo x86_64-linux: +``` +$ zig build-exe hello.zig --release-small --strip --single-threaded +$ wc -c hello +9944 hello +$ ldd hello + not a dynamic executable +``` + +No Windows é ainda menor, gerando um binário de 4096 bytes: +``` +$ zig build-exe hello.zig --release-small --strip --single-threaded -target x86_64-windows +$ wc -c hello.exe +4096 hello.exe +$ file hello.exe +hello.exe: PE32+ executable (console) x86-64, for MS Windows +``` + +## Pedir declarações independentes de alto nível + +Declarações de alto nível, tais como variáveis globais, são independentes de ordem e analisadas preguiçosamente. O valor de inicialização das variáveis globais é [avaliado em tempo de compilação](https://ziglang.org/#Compile-time-reflection-and-compile-time-code-execution). + +{{< zigdoctest "assets/zig-code/features/5-global-variables.zig" >}} + +## Tipo optional em vez de ponteiros nulos + +Em outras linguagens de programação, referências nulas são a fonte de muitas exceções de tempo de execução, e até mesmo são acusadas de ser [o pior erro da ciência da computação](https://www.lucidchart.com/techblog/2015/08/31/the-worst-mistake-of-computer-science/). + +As indicações Unadorned Zig não podem ser nulas: + +{{< zigdoctest "assets/zig-code/features/6-null-to-ptr.zig" >}} + +Entretanto, qualquer tipo pode ser transformado em um [tipo optional](https://ziglang.org/documentation/master/#Optionals) prefixando-o com ?: + +{{< zigdoctest "assets/zig-code/features/7-optional-syntax.zig" >}} + +Para utilizar um valor opcional, pode-se utilizar `orelse` para fornecer um valor padrão: + +{{< zigdoctest "assets/zig-code/features/8-optional-orelse.zig" >}} + +Outra opção é usar `if`: + +{{< zigdoctest "assets/zig-code/features/9-optional-if.zig" >}} + + A mesma sintaxe funciona com [while](https://ziglang.org/documentation/master/#while): + +{{< zigdoctest "assets/zig-code/features/10-optional-while.zig" >}} + +## Gerenciamento manual de memória + +Uma biblioteca escrita em Zig é elegível para ser usada em qualquer lugar: + +- [Aplicações desktop](https://github.com/TM35-Metronome/) & [Jogos](https://github.com/dbandstra/oxid) +- Servidores de baixa latência +- [Kernel do Sistema Operacional](https://github.com/AndreaOrru/zen) +- [Dispositívos Embarcados](https://github.com/skyfex/zig-nrf-demo/) +- Software em tempo real, por exemplo, apresentações ao vivo, aviões, marcapassos +- [Em navegadores web ou outros plugins com WebAssembly](https://shritesh.github.io/zigfmt-web/) +- Por outras linguagens de programação, utilizando a C ABI + +Para conseguir isto, os programadores Zig devem gerenciar sua própria memória e devem lidar com falhas na alocação de memória. + +Isto também é verdade para a Biblioteca Padrão Zig. Qualquer função que precise alocar memória aceita um parâmetro do alocador. Como resultado, a Biblioteca Padrão Zig pode ser usada até mesmo para o alvo freestanding. + +Além de [Uma nova tomada de controle de erros](https://ziglang.org/#A-fresh-take-on-error-handling), Zig fornece [defer](https://ziglang.org/documentation/master/#defer) e [errdefer](https://ziglang.org/documentation/master/#errdefer) para tornar a gestão de todos os recursos - não apenas a memória - simples e facilmente verificável. + +Por exemplo o `defer`, veja [Integração com bibliotecas C sem FFI/bindings](https://ziglang.org/#Integration-with-C-libraries-without-FFIbindings). Aqui está um exemplo de utilização de `errdefer`: +{{< zigdoctest "assets/zig-code/features/11-errdefer.zig" >}} + + +## Uma nova tomada de controle de erros + +Os erros são valores, e não podem ser ignorados: + +{{< zigdoctest "assets/zig-code/features/12-errors-as-values.zig" >}} + +Os erros podem ser tratados com [catch](https://ziglang.org/documentation/master/#catch): + +{{< zigdoctest "assets/zig-code/features/13-errors-catch.zig" >}} + +A palavra-chave [try](https://ziglang.org/documentation/master/#try) é um atalho para `catch |err| return err`: + +{{< zigdoctest "assets/zig-code/features/14-errors-try.zig" >}} + +Note que é um [Rastreamento do retorno de erro](https://ziglang.org/documentation/master/#Error-Return-Traces), não um [rastreamento da pilha](https://ziglang.org/#Stack-traces-on-all-targets). O código não pagou o preço de desenrolar a pilha para chegar a esse rastreamento. + +O [switch](https://ziglang.org/documentation/master/#switch) palavra-chave utilizada em um erro garante que todos os erros possíveis sejam tratados: + +{{< zigdoctest "assets/zig-code/features/15-errors-switch.zig" >}} + +A palavra-chave [unreachable](https://ziglang.org/documentation/master/#unreachable) é usado para afirmar que não ocorrerão erros: + +{{< zigdoctest "assets/zig-code/features/16-unreachable.zig" >}} + +Isto invoca um [comportamento indefinido](https://ziglang.org/#Performance-and-Safety-Choose-Two) nos modos de construção inseguros, portanto, certifique-se de usá-lo somente quando o sucesso for garantido. + +### Rastreamento de pilha em todos os alvos + +O rastreamento da pilha e [rastreamento do retorno de erros](https://ziglang.org/documentation/master/#Error-Return-Traces) mostram que nesta página funcionam todos os alvos da [Tier 1 Support](https://ziglang.org/#Tier-1-Support) e alguns da [Tier 2 Support](https://ziglang.org/#Tier-2-Support). [Even freestanding](https://andrewkelley.me/post/zig-stack-traces-kernel-panic-bare-bones-os.html)! + +Além disso, a biblioteca padrão tem a capacidade de capturar um traço de pilha em qualquer ponto e depois despejá-la em erro padrão mais tarde: + +{{< zigdoctest "assets/zig-code/features/17-stack-traces.zig" >}} + +Você pode ver esta técnica sendo utilizada no projeto [GeneralPurposeDebugAllocator](https://github.com/andrewrk/zig-general-purpose-allocator/#current-status). + +## Estruturas e funções genéricas de dados + +Os tipos são valores que devem ser conhecidos em tempo de compilação: + +{{< zigdoctest "assets/zig-code/features/18-types.zig" >}} + +Uma estrutura de dados genérica é simplesmente uma função que retorna um `type`: + +{{< zigdoctest "assets/zig-code/features/19-generics.zig" >}} + +## Compilar o tempo de reflexão e compilar o tempo de execução do código + +A função de construção [@typeInfo](https://ziglang.org/documentation/master/#typeInfo) proporciona reflexão: + +{{< zigdoctest "assets/zig-code/features/20-reflection.zig" >}} + +A Biblioteca Padrão Zig usa esta técnica para implementar a impressão formatada. Apesar de ser uma [Linguagem simples e pequena](https://ziglang.org/#Small-simple-language), A impressão formatada em Zig é implementada inteiramente em Zig. Enquanto isso, em C, os erros de compilação para impressão são codificados pelo compilador de forma arcaica. Da mesma forma, em Rust a macro de impressão formatada é codificada de forma arcaica e complexa pelo compilador. + +Zig também pode avaliar funções e blocos de código em tempo de compilação. Em alguns contextos, tais como inicializações globais de variáveis, a expressão é implicitamente avaliada em tempo de compilação. Caso contrário, é possível avaliar explicitamente o código em tempo de compilação com a palavra-chave [comptime](https://ziglang.org/documentation/master/#comptime). Isto pode ser especialmente poderoso quando combinado com afirmações: + +{{< zigdoctest "assets/zig-code/features/21-comptime.zig" >}} + +## Integration with C libraries without FFI/bindings + +[@cImport](https://ziglang.org/documentation/master/#cImport) importa diretamente tipos, variáveis, funções e macros simples para uso em Zig. Ele até traduz funções em linha de C para Zig. + +Aqui está um exemplo de emissão de uma onda sinusoidal usando [libsoundio](http://libsound.io/): + +sine.zig +{{< zigdoctest "assets/zig-code/features/22-sine-wave.zig" >}} + +``` +$ zig build-exe sine.zig -lsoundio -lc +$ ./sine +Output device: Built-in Audio Analog Stereo +^C +``` + +[This Zig code is significantly simpler than the equivalent C code](https://gist.github.com/andrewrk/d285c8f912169329e5e28c3d0a63c1d8), bem como ter mais proteções de segurança, e tudo isso é conseguido através da importação direta do arquivo de cabeçalho C - sem ligações de API. + +*Zig é melhor no uso de bibliotecas C do que C é no uso de bibliotecas C.* + +### O Zig também é um compilador C + +Aqui está um exemplo de Zig compilando código C: + +hello.c +```c +#include + +int main(int argc, char **argv) { + printf("Hello world\n"); + return 0; +} +``` + +``` +$ zig build-exe --c-source hello.c --library c +$ ./hello +Hello world +``` + +Você pode utilizar `--verbose-cc` para ver quais os comandos que o compilador C executará: +``` +$ zig build-exe --c-source hello.c --library c --verbose-cc +zig cc -MD -MV -MF zig-cache/tmp/42zL6fBH8fSo-hello.o.d -nostdinc -fno-spell-checking -isystem /home/andy/dev/zig/build/lib/zig/include -isystem /home/andy/dev/zig/build/lib/zig/libc/include/x86_64-linux-gnu -isystem /home/andy/dev/zig/build/lib/zig/libc/include/generic-glibc -isystem /home/andy/dev/zig/build/lib/zig/libc/include/x86_64-linux-any -isystem /home/andy/dev/zig/build/lib/zig/libc/include/any-linux-any -march=native -g -fstack-protector-strong --param ssp-buffer-size=4 -fno-omit-frame-pointer -o zig-cache/tmp/42zL6fBH8fSo-hello.o -c hello.c -fPIC +``` + +Note que se eu executar o comando novamente, não há saída, e ele termina instantaneamente: +``` +$ time zig build-exe --c-source hello.c --library c --verbose-cc + +real 0m0.027s +user 0m0.018s +sys 0m0.009s +``` + +Isto se deve a [Cache de Compilação](https://ziglang.org/download/0.4.0/release-notes.html#Build-Artifact-Caching). Zig analisa automaticamente o arquivo .d usando um sistema de cache robusto para evitar duplicação de trabalho. + +O Zig não só pode compilar o código C, mas há uma razão muito boa para usar Zig como um compilador C: [Zig embarca com a libc](https://ziglang.org/#Zig-ships-with-libc). + +### Exportar funções, variáveis e tipos definidos pelo código C para depender de + +Um dos casos de uso primário para Zig é a exportação de uma biblioteca com a ABI C para outras linguagens de programação a serem utilizadas. A palavra-chave `export` em frente às funções, variáveis e tipos faz com que elas façam parte da API da biblioteca: + +mathtest.zig +{{< zigdoctest "assets/zig-code/features/23-math-test.zig" >}} + +Fazer uma biblioteca estática: +``` +$ zig build-lib mathtest.zig +``` + +Fazer uma biblioteca dinâmica: +``` +$ zig build-lib mathtest.zig -dynamic +``` + +Eis um exemplo com o [Sistema de Construção do Zig](https://ziglang.org/#Zig-Build-System): + +test.c +```c +#include "mathtest.h" +#include + +int main(int argc, char **argv) { + int32_t result = add(42, 1337); + printf("%d\n", result); + return 0; +} +``` + +build.zig +{{< zigdoctest "assets/zig-code/features/24-build.zig" >}} + +``` +$ zig build test +1379 +``` + +## A compilação cruzada é um caso de uso de primeira classe + +Zig pode construir para qualquer um dos alvos a partir da [Tabela de Suporte](https://ziglang.org/#Support-Table) com [Tier 3 Support](https://ziglang.org/#Tier-3-Support) ou melhor. Nenhum "conjunto de ferramentas cruzada" precisa ser instalada ou algo parecido. Aqui está um "Hello World" nativo: + +{{< zigdoctest "assets/zig-code/features/4-hello.zig" >}} + +Você pode compilar para: x86_64-windows, x86_64-macosx, e aarch64v8-linux: +``` +$ zig build-exe hello.zig -target x86_64-windows +$ file hello.exe +hello.exe: PE32+ executable (console) x86-64, for MS Windows +$ zig build-exe hello.zig -target x86_64-macosx +$ file hello +hello: Mach-O 64-bit x86_64 executable, flags: +$ zig build-exe hello.zig -target aarch64v8-linux +$ file hello +hello: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), statically linked, with debug_info, not stripped +``` + +Isto funciona em qualquer [Tier 3](https://ziglang.org/#Tier-3-Support)+ alvos, para qualquer [Tier 3](https://ziglang.org/#Tier-3-Support)+ alvos. + +### Zig embarca com libc + +Você pode encontrar os alvos libc disponíveis com `zig targets`: +``` +... + "libc": [ + "aarch64_be-linux-gnu", + "aarch64_be-linux-musl", + "aarch64_be-windows-gnu", + "aarch64-linux-gnu", + "aarch64-linux-musl", + "aarch64-windows-gnu", + "armeb-linux-gnueabi", + "armeb-linux-gnueabihf", + "armeb-linux-musleabi", + "armeb-linux-musleabihf", + "armeb-windows-gnu", + "arm-linux-gnueabi", + "arm-linux-gnueabihf", + "arm-linux-musleabi", + "arm-linux-musleabihf", + "arm-windows-gnu", + "i386-linux-gnu", + "i386-linux-musl", + "i386-windows-gnu", + "mips64el-linux-gnuabi64", + "mips64el-linux-gnuabin32", + "mips64el-linux-musl", + "mips64-linux-gnuabi64", + "mips64-linux-gnuabin32", + "mips64-linux-musl", + "mipsel-linux-gnu", + "mipsel-linux-musl", + "mips-linux-gnu", + "mips-linux-musl", + "powerpc64le-linux-gnu", + "powerpc64le-linux-musl", + "powerpc64-linux-gnu", + "powerpc64-linux-musl", + "powerpc-linux-gnu", + "powerpc-linux-musl", + "riscv64-linux-gnu", + "riscv64-linux-musl", + "s390x-linux-gnu", + "s390x-linux-musl", + "sparc-linux-gnu", + "sparcv9-linux-gnu", + "wasm32-freestanding-musl", + "x86_64-linux-gnu", + "x86_64-linux-gnux32", + "x86_64-linux-musl", + "x86_64-windows-gnu" + ], + ``` + +O que isto significa é que `--library c` para estes alvos *não depende de nenhum arquivo do sistema*! + +Vejamos o [exemplo hello world em C](https://ziglang.org/#Zig-is-also-a-C-compiler) novamente: +``` +$ zig build-exe --c-source hello.c --library c +$ ./hello +Hello world +$ ldd ./hello + linux-vdso.so.1 (0x00007ffd03dc9000) + libc.so.6 => /lib/libc.so.6 (0x00007fc4b62be000) + libm.so.6 => /lib/libm.so.6 (0x00007fc4b5f29000) + libpthread.so.0 => /lib/libpthread.so.0 (0x00007fc4b5d0a000) + libdl.so.2 => /lib/libdl.so.2 (0x00007fc4b5b06000) + librt.so.1 => /lib/librt.so.1 (0x00007fc4b58fe000) + /lib/ld-linux-x86-64.so.2 => /lib64/ld-linux-x86-64.so.2 (0x00007fc4b6672000) +``` + +[glibc](https://www.gnu.org/software/libc/) não suporta estaticamente a construção, mas [musl](https://www.musl-libc.org/) suporta: +``` +$ zig build-exe --c-source hello.c --library c -target x86_64-linux-musl +$ ./hello +Hello world +$ ldd hello + not a dynamic executable +``` + +Neste exemplo, Zig construiu musl libc a partir da fonte e depois ligou-se a ela. A construção da musl libc para x86_64-linux continua disponível graças ao [sistema de caching](https://ziglang.org/download/0.4.0/release-notes.html#Build-Artifact-Caching), portanto, a qualquer momento esta libc é necessária novamente, ela estará disponível instantaneamente. + +Isto significa que esta funcionalidade está disponível em qualquer plataforma. Os usuários de Windows e macOS podem criar códigos Zig e C, e vincular-se a libc, para qualquer um dos alvos listados acima. Da mesma forma, o código pode ser compilado de forma cruzada para outras arquiteturas: +``` +$ zig build-exe --c-source hello.c --library c -target aarch64v8-linux-gnu +$ file hello +hello: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux-aarch64.so.1, for GNU/Linux 2.0.0, with debug_info, not stripped +``` + +Em alguns aspectos, Zig é um compilador C melhor do que os próprios compiladores C! + +Esta funcionalidade é mais do que o agrupamento de um conjunto de ferramentas de compilação cruzada junto ao Zig. Por exemplo, o tamanho total dos cabeçalhos da libc que o Zig envia é de 22 MiB sem compressão. Enquanto isso, os cabeçalhos para musl libc + linux em x86_64 são 8 MiB, e para glibc são 3,1 MiB (falta no glibc os cabeçalhos linux), ainda assim Zig atualmente envia com 40 libcs. Com um agrupamento ingênuo que seria de 444 MiB. No entanto, graças a isto, a [ferramenta process_headers](https://github.com/ziglang/zig/blob/0.4.0/libc/process_headers.zig) que eu fiz, e algum [bom e velho trabalho manual](https://github.com/ziglang/zig/wiki/Updating-libc), Os tarballs binários Zig permanecem em torno de 30 MiB no total, apesar de apoiar a libc para todos esses alvos, bem como a compiler-rt, libunwind e libcxx, e apesar de ser um compilador C compatível com o clang. Para comparação, a construção binária do próprio Windows do clang 8.0.0 do llvm.org é de 132 MiB. + +Note que apenas no [Tier 1 Support](https://ziglang.org/#Tier-1-Support) os alvos foram exaustivamente testados. Está previsto [acrescentar mais libcs](https://github.com/ziglang/zig/issues/514) (inclusive para o Windows), e para [adicionar cobertura de testes para construção em relação a todas as libcs](https://github.com/ziglang/zig/issues/2058). + +Já está sendo [planejado para ter um Gerenciador de Pacotes do Zig](https://github.com/ziglang/zig/issues/943), mas isso ainda não está pronto. Uma das coisas que será possível é criar um pacote para as bibliotecas C. Isto fará com que o [Sistema de Construção do Zig](https://ziglang.org/#Zig-Build-System) tornando mais atraente tanto para programadores Zig como para programadores C. + +## Zig Build System + +O Zig vem com um sistema de construção, por isso você não precisa fazer, fabricar ou qualquer coisa do gênero. +``` +$ zig init-exe +Created build.zig +Created src/main.zig + +Next, try `zig build --help` or `zig build run` +``` + +src/main.zig +{{< zigdoctest "assets/zig-code/features/25-all-bases.zig" >}} + + +build.zig +{{< zigdoctest "assets/zig-code/features/26-build.zig" >}} + + +Vamos dar uma olhada nesse menu `--help`. +``` +$ zig build --help +Usage: zig build [steps] [options] + +Steps: + install (default) Copy build artifacts to prefix path + uninstall Remove build artifacts from prefix path + run Run the app + +General Options: + --help Print this help and exit + --verbose Print commands before executing them + --prefix [path] Override default install prefix + --search-prefix [path] Add a path to look for binaries, libraries, headers + +Project-Specific Options: + -Dtarget=[string] The CPU architecture, OS, and ABI to build for. + -Drelease-safe=[bool] optimizations on and safety on + -Drelease-fast=[bool] optimizations on and safety off + -Drelease-small=[bool] size optimizations on and safety off + +Advanced Options: + --build-file [file] Override path to build.zig + --cache-dir [path] Override path to zig cache directory + --override-lib-dir [arg] Override path to Zig lib directory + --verbose-tokenize Enable compiler debug output for tokenization + --verbose-ast Enable compiler debug output for parsing into an AST + --verbose-link Enable compiler debug output for linking + --verbose-ir Enable compiler debug output for Zig IR + --verbose-llvm-ir Enable compiler debug output for LLVM IR + --verbose-cimport Enable compiler debug output for C imports + --verbose-cc Enable compiler debug output for C compilation + --verbose-llvm-cpu-features Enable compiler debug output for LLVM CPU features +``` + +Você pode ver que uma das etapas disponíveis é executada. +``` +$ zig build run +All your base are belong to us. +``` + +Aqui estão alguns exemplos de scripts de construção: + +- [Construção do jogo Tetris - OpenGL](https://github.com/andrewrk/tetris/blob/master/build.zig) +- [Construção do jogo arcade no Raspberry Pi 3 (bare-metal)](https://github.com/andrewrk/clashos/blob/master/build.zig) +- [Construção do compilador auto-hospedado Zig](https://github.com/ziglang/zig/blob/master/build.zig) + +## Concorrência via funções Async + +Zig v0.5.0 [introduziu funções assíncronas](https://ziglang.org/download/0.5.0/release-notes.html#Async-Functions). Esta característica não depende de um sistema operacional host ou mesmo de uma memória alocada em pilha. Isso significa que funções assimétricas estão disponíveis para o alvo freestanding. + +Zig infere se uma função é assimétrica, e permite `async`/`await` em funções não assíncronas, o que significa que **as bibliotecas Zig são agnósticos de bloqueio ao invés de E/S assíncrona**. [Zig evita as cores das funções (inglês)](http://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/). + + + +A Biblioteca Padrão Zig implementa um loop de eventos que multiplexam as funções assimétricas em um pool de threads para concorrência M:N. A segurança multithreading e a detecção de corrida são áreas de pesquisa ativa. + +## Ampla gama de alvos suportados + +Zig utiliza um sistema de "tiers" para comunicar o nível de suporte para diferentes alvos. Note que a barra para [Tier 1 Support](https://ziglang.org/#Tier-1-Support) é maior - [Tier 2 Support](https://ziglang.org/#Tier-2-Support) é ainda bastante útil. + +### Tabela de Suporte + +| | free standing | Linux 3.16+ | macOS 10.13+ | Windows 8.1+ | FreeBSD 12.0+ | NetBSD 8.0+ | DragonFly​BSD 5.8+ | UEFI | +|-|---------------|-------------|--------------|--------------|---------------|-------------|-------------------|------| +| x86_64 | [Tier 1](https://ziglang.org/#Tier-1-Support) | [Tier 1](https://ziglang.org/#Tier-1-Support) | [Tier 1](https://ziglang.org/#Tier-1-Support) | [Tier 2](https://ziglang.org/#Tier-2-Support) | [Tier 2](https://ziglang.org/#Tier-2-Support) | [Tier 2](https://ziglang.org/#Tier-2-Support) | [Tier 2](https://ziglang.org/#Tier-2-Support) | [Tier 2](https://ziglang.org/#Tier-2-Support) | +| arm64 | [Tier 1](https://ziglang.org/#Tier-1-Support) | [Tier 2](https://ziglang.org/#Tier-2-Support) | [Tier 2](https://ziglang.org/#Tier-2-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | [Tier 3](https://ziglang.org/#Tier-3-Support) | +| arm32 | [Tier 1](https://ziglang.org/#Tier-1-Support) | [Tier 2](https://ziglang.org/#Tier-2-Support) | N/A | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | [Tier 3](https://ziglang.org/#Tier-3-Support) | +| mips32 LE | [Tier 1](https://ziglang.org/#Tier-1-Support) | [Tier 2](https://ziglang.org/#Tier-2-Support) | N/A | N/A | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | +| i386 | [Tier 1](https://ziglang.org/#Tier-1-Support) | [Tier 2](https://ziglang.org/#Tier-2-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 2](https://ziglang.org/#Tier-2-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | [Tier 2](https://ziglang.org/#Tier-2-Support) | +| riscv64 | [Tier 1](https://ziglang.org/#Tier-1-Support) | [Tier 2](https://ziglang.org/#Tier-2-Support) | N/A | N/A | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | [Tier 3](https://ziglang.org/#Tier-3-Support) | +| bpf | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | +| hexagon | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | +| mips32 BE | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | +| mips64 | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | +| amdgcn | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | +| sparc | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | +| s390x | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | +| lanai | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | +| powerpc32 | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | +| powerpc64 | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | N/A | N/A | +| avr | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | +| riscv32 | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | [Tier 4](https://ziglang.org/#Tier-4-Support) | +| xcore | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | +| nvptx | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | +| msp430 | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | +| r600 | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | +| arc | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | +| tce | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | +| le | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | +| amdil | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | +| hsail | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | +| spir | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | +| kalimba | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | +| shave | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | +| renderscript | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | N/A | N/A | + + +### Tabela de suporte para WebAssembly + +| | free standing | emscripten | WASI | +|--------|---------------|------------|--------| +| wasm32 | [Tier 1](https://ziglang.org/#Tier-1-Support) | [Tier 3](https://ziglang.org/#Tier-3-Support) | [Tier 1](https://ziglang.org/#Tier-1-Support) | +| wasm64 | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | [Tier 4](https://ziglang.org/#Tier-4-Support) | + + +### Tier System + +#### Tier 1 Support +- Not only can Zig generate machine code for these targets, but the standard library cross-platform abstractions have implementations for these targets. Thus it is practical to write a pure Zig application with no dependency on libc. +- The CI server automatically tests these targets on every commit to master branch, and updates [the download page](https://ziglang.org/download) with links to pre-built binaries. +- These targets have debug info capabilities and therefore produce [stack traces](https://ziglang.org/#Stack-traces-on-all-targets) on failed assertions. +- [libc is available for this target even when cross compiling](https://ziglang.org/#Zig-ships-with-libc). +- All the behavior tests and applicable standard library tests pass for this target. All language features are known to work correctly. + +#### Tier 2 Support +- The standard library supports this target, but it's possible that some APIs will give an "Unsupported OS" compile error. One can link with libc or other libraries to fill in the gaps in the standard library. +- These targets are known to work, but may not be automatically tested, so there are occasional regressions. +- Some tests may be disabled for these targets as we work toward [Tier 1 Support](https://ziglang.org/#Tier-1-Support). + +#### Tier 3 Support + +- The standard library has little to no knowledge of the existence of this target. +- Because Zig is based on LLVM, it has the capability to build for these targets, and LLVM has the target enabled by default. +- These targets are not frequently tested; one will likely need to contribute to Zig in order to build for these targets. +- The Zig compiler might need to be updated with a few things such as + - what sizes are the C integer types + - C ABI calling convention for this target + - bootstrap code and default panic handler +- zig targets is guaranteed to include this target. + +#### Tier 4 Support + +- Support for these targets is entirely experimental. +- LLVM may have the target as an experimental target, which means that you need to use Zig-provided binaries for the target to be available, or build LLVM from source with special configure flags. zig targets will display the target if it is available. +- This target may be considered deprecated by an official party, such as [macosx/i386](https://support.apple.com/en-us/HT208436) in which case this target will remain forever stuck in Tier 4. +- This target may only support `--emit` asm and cannot emit object files. + +## Colaboradores de pacotes + +O compilador Zig ainda não é completamente auto-hospedado, mas não importa o, [permanecerá exatamente 3 etapas](https://github.com/ziglang/zig/issues/853) para deixar de usar um compilador C++ no sistema para ter um compilador Zig totalmente auto-hospedado para qualquer alvo. Como observa Maya Rashish, [portando o Zig para outras plataformas é divertido e rápido](http://coypu.sdf.org/porting-zig.html). + +Os [modos de contrução](https://ziglang.org/documentation/master/#Build-Mode) sem depuração (non-debug) são reprodutíveis/determináveis. + +Há um [JSON version of the download page](https://ziglang.org/download/index.json). + +Vários membros da equipe Zig têm experiência na manutenção de pacotes. + +- [Daurnimator](https://github.com/daurnimator) mantém o [Arch Linux package](https://www.archlinux.org/packages/community/x86_64/zig/) +- [Marc Tiehuis](https://tiehuis.github.io/) mantém o pacote Visual Studio Code. +- [Andrew Kelley](https://andrewkelley.me/) passou cerca de um ano ou mais fazendo [pacotes do Debian e Ubuntu](https://qa.debian.org/developer.php?login=superjoe30%40gmail.com&comaint=yes), e contribui casualmente para [nixpkgs](https://github.com/NixOS/nixpkgs/). +- [Jeff Fowler](https://blog.jfo.click/) mantém o pacote Homebrew e iniciou o [Sublime package](https://github.com/ziglang/sublime-zig-language) (agora mantido por [emekoi](https://github.com/emekoi)). diff --git a/content/translations/index.md b/content/translations/index.md index 45b37106a..288d40b92 100644 --- a/content/translations/index.md +++ b/content/translations/index.md @@ -11,3 +11,4 @@ The original content is written in [English](/). ## Available translations - [Italiano](../it/) +- [Português](../pt/) From d6bae62df517b0ce0428a3b76337460a7ebbf694 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20C=2E=20Fran=C3=A7a?= Date: Wed, 13 Jan 2021 12:41:46 -0300 Subject: [PATCH 03/25] Getting Started translated --- content/learn/getting-started.pt.md | 110 +++++++++++++--------------- 1 file changed, 52 insertions(+), 58 deletions(-) diff --git a/content/learn/getting-started.pt.md b/content/learn/getting-started.pt.md index e6282cdfc..c103e6d0e 100644 --- a/content/learn/getting-started.pt.md +++ b/content/learn/getting-started.pt.md @@ -5,37 +5,34 @@ toc: true --- {{% div class="box thin"%}} -**
Note for Apple Silicon users
** -Zig has experimental support for codesigning. You will be able to use Zig with your M1 Mac, -but the only way at the moment to get Zig for arm64 macOS is to compile it yourself. -Make sure to check the [Building from source](#building-from-source) section. +**
Nota para usuários do Apple Silicon
** +ig tem suporte experimental para a assinatura de códigos. Você poderá usar Zig com seu M1 Mac, +mas a única maneira de conseguir Zig para macOS em ARM64 é compilá-lo você mesmo. +Certifique-se de verificar a seção [Building from source](#building-from-source). {{% /div %}} -## Tagged release or nightly build? -Zig has not yet reached v1.0 and the current release cycle is tied to new releases of LLVM, which have a ~6 months cadence. -In practical terms, **Zig releases tend to be far apart and eventually become stale given the current speed of development**. +## Marcar (Tags) as versões de lançamento e nightly? +Zig ainda não atingiu a v1.0 e o atual ciclo de liberação está ligado a novas liberações de LLVM, que têm uma cadência de ~6 meses. +Em termos práticos, **As versões Zig tendem a ser muito distantes e eventualmente se tornam obsoletas, dada a velocidade atual de desenvolvimento**. -It's fine to evaluate Zig using a tagged version, but if you decide that you like Zig and -want to dive deeper, **we encourage you to upgrade to a nightly build**, mainly because -that way it will be easier for you to get help: most of the community and sites like -[ziglearn.org](https://ziglearn.org) track the master branch for the reasons stated above. +É bom avaliar o Zig usando uma versão com tags, mas se você decidir que gosta do Zig e quer mergulhar mais fundo, **nós o encorajamos a atualizar para versão nightly**, principalmente porque dessa forma será mais fácil para você obter ajuda: a maioria da comunidade e sites como +[ziglearn.org](https://ziglearn.org) se baseiam no *master branch* pelas razões acima expostas. -The good news is that it's very easy to switch from one Zig version to another, or even have multiple versions present on the system at the same time: Zig releases are self-contained archives that can be placed anywhere in your system. +A boa notícia é que é muito fácil mudar de uma versão Zig para outra, ou mesmo ter várias versões presentes no sistema ao mesmo tempo: As versões Zig são arquivos autocontidos que podem ser colocados em qualquer lugar em seu sistema. -## Installing Zig -### Direct download -This is the most straight-forward way of obtaining Zig: grab a Zig bundle for your platform from the [Downloads](/download) page, -extract it in a directory and add it to your `PATH` to be able to call `zig` from any location. +## Instalando Zig +### Baixar diretamente +Esta é a maneira mais direta de obter o Zig: pegue um pacote Zig para sua plataforma a partir da página [Downloads](/download), +extrair em um diretório qualquer e adicioná-lo ao seu `PATH` para poder utilizar o executável `zig` de qualquer lugar. -#### Setting up PATH on Windows -To setup your path on Windows run **one** of the following snippets of code in a Powershell instance. -Choose if you want to apply this change on a system-wide level (requires running Powershell with admin priviledges) -or just for your user, and **make sure to change the snippet to point at the location where your copy of Zig lies**. -The `;` before `C:` is not a typo. +#### Configurando PATH no Windows +Para configurar seu caminho no Windows, execute **um** dos seguintes trechos de código em uma instância Powershell. +Escolha se você deseja aplicar esta mudança em nível de sistema (requer a execução de Powershell com privilégios administrativos) ou apenas para seu usuário, e ** certifique-se de mudar o trecho para apontar para o local onde se encontra sua cópia do Zig***. +O `;` antes do `C:` não é um erro de tipo. -System wide (**admin** Powershell): +Modo privilegiado do sistema (**admin** no Powershell): ``` [Environment]::SetEnvironmentVariable( "Path", @@ -44,7 +41,7 @@ System wide (**admin** Powershell): ) ``` -User level (Powershell): +Modo usuário (**sem privilégio** no Powershell): ``` [Environment]::SetEnvironmentVariable( "Path", @@ -52,23 +49,23 @@ User level (Powershell): "User" ) ``` -After you're done, restart your Powershell instance. +Depois de terminar, reinicie sua instância do Powershell. -#### Setting up PATH on Linux, macOS, BSD -Add the location of your zig binary to your PATH environment variable. +#### Configurando PATH no Linux, macOS, BSD +Adicione a localização de seu binário zig à sua variável de ambiente `PATH`. -This is generally done by adding an export line to your shell startup script (`.profile`, `.zshrc`, ...) +Isso geralmente é feito adicionando uma linha de exportação ao seu script de inicialização do shell. (`.profile`, `.zshrc`, ...) ```bash export PATH=$PATH:~/path/to/zig ``` -After you're done, either `source` your startup file or restart your shell. +Depois de feito, seu arquivo inicial ou `source`, reinicie o shell. -### Package managers +### Gerenciadores de pacotes #### Windows -Zig is available on [Chocolatey](https://chocolatey.org/packages/zig). +Zig está disponível no [Chocolatey](https://chocolatey.org/packages/zig). ``` choco install zig ``` @@ -76,14 +73,14 @@ choco install zig #### macOS **Homebrew** -NOTE: Homebrew doesn't have a bottle for Apple Silicon yet. If you have a M1 Mac, you must build Zig from source. +NOTA: Homebrew ainda não possui os pacotes para Apple Silicon. Se você tem um M1 Mac, você deve compilar o Zig a partir da fonte. -Latest tagged release: +Última versão de lançamento: ``` brew install zig ``` -Latest build from Git master branch: +Última construção do *master branch* de Git: ``` brew install zig --HEAD ``` @@ -93,55 +90,52 @@ brew install zig --HEAD port install zig ``` #### Linux -Zig is also present in many package managers for Linux. [Here](https://github.com/ziglang/zig/wiki/Install-Zig-from-a-Package-Manager) -you can find an updated list but keep in mind that some packages might bundle outdated versions of Zig. +Zig também está presente em muitos gerentes de pacotes para Linux. [Aqui](https://github.com/ziglang/zig/wiki/Install-Zig-from-a-Package-Manager) +você pode encontrar uma lista atualizada, mas tenha em mente que alguns pacotes podem conter versões desatualizadas do Zig. -### Building from source -[Here](https://github.com/ziglang/zig/wiki/Building-Zig-From-Source) -you can find more information on how to build Zig from source for Linux, macOS and Windows. +### Compilando da Fonte +[Aqui](https://github.com/ziglang/zig/wiki/Building-Zig-From-Source) +você pode encontrar mais informações sobre como construir Zig a partir da fonte para Linux, MacOS e Windows. -## Recommended tools -### Syntax Higlighters and LSP -All major text editors have syntax highlight support for Zig. -Some bundle it, some others require installing a plugin. +## Ferramentas recomendadas +### Sintaxe dos Higlighters e LSP +Todos os principais editores de texto têm suporte de destaque de sintaxe para Zig. +Alguns o empacotam, outros requerem a instalação de um plugin. -If you're interested in a deeper integration beween Zig and your editor, -checkout [zigtools/zls](https://github.com/zigtools/zls). +Se você estiver interessado em uma integração mais profunda entre o Zig e seu editor, confira [zigtools/zls](https://github.com/zigtools/zls). -If you're interested in what else is available, checkout the [Tools](../tools/) section. +Se você estiver interessado no que mais está disponível, confira a seção [Tools](../tools/). ## Run Hello World -If you completed the installation process correctly, you should now be able to invoke the Zig compiler from your shell. -Let's test this by creating your first Zig program! +Se você completou o processo de instalação corretamente, agora você deverá ser capaz de invocar o compilador Zig a partir do shell. +Vamos testar isso criando seu primeiro programa Zig! -Navigate to your projects directory and run: +Navegue até o diretório de seus projetos e execute: ```bash mkdir hello-world cd hello-world zig init-exe ``` -This should output: +Isto deve sair: ``` info: Created build.zig info: Created src/main.zig info: Next, try `zig build --help` or `zig build run` ``` -Running `zig build run` should then compile the executable and run it, ultimately resulting in: +Executando `zig build run` deve então compilar o executável e executá-lo, resultando em última instância: ``` info: All your codebase are belong to us. ``` -Congratulations, you have a working Zig installation! +Parabéns, você tem uma instalação Zig funcionando! -## Next steps -**Check out other resources present in the [Learn](../) section**, make sure to find the Documentation for your version -of Zig (note: nightly builds should use `master` docs) and consider giving [ziglearn.org](https://ziglearn.org) a read. +## Próximos passos +**Verifique outros recursos presentes na seção** [Aprender](../), certifique-se de encontrar a Documentação de sua versão do Zig (nota: as construções nightly devem utilizar documentação `master`) e considerar dar uma lida no [ziglearn.org](https://ziglearn.org) também. -Zig is a young project and unfortunately we don't have yet the capacity to produce extensive documentation and learning -materials for everything, so you should consider [joining one of the existing Zig communities](https://github.com/ziglang/zig/wiki/Community) -to get help when you get stuck, as well as checking out initiatives like [Zig SHOWTIME](https://zig.show). +Zig é um projeto jovem e infelizmente ainda não temos a capacidade de produzir extensa documentação e materiais de aprendizagem para tudo, portanto, você deve considerar [juntando-se a uma das comunidades Zig existentes](https://github.com/ziglang/zig/wiki/Community) +para obter ajuda quando você ficar confuso, bem como para verificar iniciativas como [Zig SHOWTIME](https://zig.show). -Finally, if you enjoy Zig and want to help speed up the development, [consider donating to the Zig Software Foundation](../../zsf) +Finalmente, se você gosta de Zig e quer ajudar a acelerar o desenvolvimento, [considere fazer uma doação para a Zig Software Foundation](../../zsf) . From 8097894f3db95bc15092818533b26d5d4123d496 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20C=2E=20Fran=C3=A7a?= Date: Wed, 13 Jan 2021 12:45:51 -0300 Subject: [PATCH 04/25] Zig name fixed MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ig => Zig 😅 --- content/learn/getting-started.pt.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/content/learn/getting-started.pt.md b/content/learn/getting-started.pt.md index c103e6d0e..d3043f9c7 100644 --- a/content/learn/getting-started.pt.md +++ b/content/learn/getting-started.pt.md @@ -6,9 +6,9 @@ toc: true {{% div class="box thin"%}} **
Nota para usuários do Apple Silicon
** -ig tem suporte experimental para a assinatura de códigos. Você poderá usar Zig com seu M1 Mac, +Zig tem suporte experimental para a assinatura de códigos. Você poderá usar Zig com seu M1 Mac, mas a única maneira de conseguir Zig para macOS em ARM64 é compilá-lo você mesmo. -Certifique-se de verificar a seção [Building from source](#building-from-source). +Certifique-se de verificar a seção [Compilando da Fonte](#building-from-source). {{% /div %}} From 5ffa16ed1ec17e34acee00f8a902754d57a45381 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20C=2E=20Fran=C3=A7a?= Date: Wed, 13 Jan 2021 12:54:53 -0300 Subject: [PATCH 05/25] Don't to translate the foundation name - HomePage It should not be translated, otherwise it may uncharacterize it. --- content/_index.pt.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/content/_index.pt.md b/content/_index.pt.md index feb2d2091..ca9fc232e 100644 --- a/content/_index.pt.md +++ b/content/_index.pt.md @@ -90,7 +90,7 @@ Espera-se que os contribuidores sigam o Zig [Código de Conduta](https://github. {{% div class="container" style="display:flex;flex-direction:column;justify-content:center;text-align:center; padding: 20px 0;" title="Zig Software Foundation" %}} ## A ZSF é uma corporação sem fins lucrativos 501(c)(3). -A Fundação Zig Software é uma corporação sem fins lucrativos fundada em 2020 por Andrew Kelley, o criador do Zig, com o objetivo de apoiar o desenvolvimento da linguagem. Atualmente, a ZSF é capaz de oferecer trabalho remunerado a taxas competitivas para um pequeno número de colaboradores principais. Esperamos ser capazes de estender esta oferta a mais colaboradores centrais no futuro. +A Zig Software Foundation é uma corporação sem fins lucrativos fundada em 2020 por Andrew Kelley, o criador do Zig, com o objetivo de apoiar o desenvolvimento da linguagem. Atualmente, a ZSF é capaz de oferecer trabalho remunerado a taxas competitivas para um pequeno número de colaboradores principais. Esperamos ser capazes de estender esta oferta a mais colaboradores centrais no futuro. A Zig Software Foundation é sustentada por doações. @@ -103,7 +103,7 @@ A Zig Software Foundation é sustentada por doações. {{< div class="alt-background" style="padding: 20px 0;">}} {{% div class="container" title="Sponsors" %}} # Patrocinadores corporativos -As seguintes empresas estão fornecendo suporte financeiro direto para a fundação Zig Software. +As seguintes empresas estão fornecendo suporte financeiro direto para a Zig Software Foundation. {{% sponsor-logos "monetary" %}} From cdfe40c1c77e35c62b792267b32a61cb6fa80c25 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20C=2E=20Fran=C3=A7a?= Date: Wed, 13 Jan 2021 13:04:12 -0300 Subject: [PATCH 06/25] Create pt.toml --- themes/ziglang-original/i18n/pt.toml | 37 ++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 themes/ziglang-original/i18n/pt.toml diff --git a/themes/ziglang-original/i18n/pt.toml b/themes/ziglang-original/i18n/pt.toml new file mode 100644 index 000000000..b078b7489 --- /dev/null +++ b/themes/ziglang-original/i18n/pt.toml @@ -0,0 +1,37 @@ + +[menu-source] +other = "Código Fonte" + +[menu-community] +other = "Junte-se a Comunidade" + +[back-to-parent] +other = "← Volte para seção {{ . }}" + +[back-to-home] +other = "← Volte para página Home" + + +[download-filename] +other = "Nome do Arquivo" + +[download-kind] +other = "Gênero" + +[download-size] +other = "Tamanho" + +[download-source] +other = "Fonte" + +[download-binary] +other = "Binário" + +[download-documentation] +other = "Documentação da Linguagem" + +[download-release-notes] +other = "Notas de Mudanças" + +[download-stdlib-docs] +other = "Documentação da Biblioteca Padrão (experimental)" From c3ffe00196b536b5b5a9fa8731a30c2bf5014120 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20Catarino=20Fran=C3=A7a?= Date: Wed, 13 Jan 2021 13:44:24 -0300 Subject: [PATCH 07/25] more translation --- content/download/_index.pt.md | 6 ++ content/learn/_index.pt.md | 6 +- content/learn/overview.pt.md | 4 +- content/learn/why_zig_rust_d_cpp.pt.md | 87 ++++++++++++++++++++++++++ content/news/_index.pt.md | 6 ++ content/zsf/index.pt.md | 79 +++++++++++++++++++++++ 6 files changed, 183 insertions(+), 5 deletions(-) create mode 100644 content/download/_index.pt.md create mode 100644 content/learn/why_zig_rust_d_cpp.pt.md create mode 100644 content/news/_index.pt.md create mode 100644 content/zsf/index.pt.md diff --git a/content/download/_index.pt.md b/content/download/_index.pt.md new file mode 100644 index 000000000..1d4ea321b --- /dev/null +++ b/content/download/_index.pt.md @@ -0,0 +1,6 @@ +--- +title: "Baixar" +menu_title: "Baixar" +mobile_menu_title: "Baixar" +layout: downloads +--- diff --git a/content/learn/_index.pt.md b/content/learn/_index.pt.md index d3db721bf..e6a3befbb 100644 --- a/content/learn/_index.pt.md +++ b/content/learn/_index.pt.md @@ -1,7 +1,7 @@ --- -title: "Learn" -menu_title: "Learn" -mobile_menu_title: "Learn" +title: "Aprender" +menu_title: "Aprender" +mobile_menu_title: "Aprender" toc: false layout: single --- diff --git a/content/learn/overview.pt.md b/content/learn/overview.pt.md index 69f35e895..1ed50e3be 100644 --- a/content/learn/overview.pt.md +++ b/content/learn/overview.pt.md @@ -1,6 +1,6 @@ --- -title: "In-depth Overview" -mobile_menu_title: "Overview" +title: "Visão Geral em Profundidade" +mobile_menu_title: "Visão Geral" toc: true --- # Destaques diff --git a/content/learn/why_zig_rust_d_cpp.pt.md b/content/learn/why_zig_rust_d_cpp.pt.md new file mode 100644 index 000000000..89169cee2 --- /dev/null +++ b/content/learn/why_zig_rust_d_cpp.pt.md @@ -0,0 +1,87 @@ +--- +title: "Por que Zig quando já existe C++, D, e Rust?" +mobile_menu_title: "Por que Zig quando..." +toc: true +--- + + +## Sem fluxo de controle oculto + +Se o código Zig não parece estar pulando para chamar uma função, então não está. Isto significa que você pode ter certeza de que o seguinte código chama apenas `foo()` e depois `bar()`, e isto é garantido sem a necessidade de saber os tipos de nada: + +```zig +var a = b + c.d; +foo(); +bar(); +``` + +Exemplos de fluxo de controle oculto: + +- D tem funções `@property`, que são métodos que você chama com o que parece ser acesso de campo, então no exemplo acima, `c.d` poderia chamar uma função. +- C++, D, e Rust têm sobrecarga do operador, portanto o operador `+` pode chamar uma função. +- C++, D, e Go têm exceções de `throw/catch`, portanto `foo()` pode lançar uma exceção, e impedir que `bar()` seja chamado. (Claro que, mesmo em Zig `foo()` poderia bloquear e impedir que `bar()` fosse chamado, mas isso pode acontecer em qualquer linguagem Completude-Turing). + +O objetivo desta decisão de projeto é melhorar a legibilidade. + +## Sem alocações ocultas + +De modo mais geral, ter uma abordagem de mãos livres quando se trata de alocação de pilhas. Não há nenhuma "nova" palavra-chave ou qualquer outro recurso de linguagem que utilize um alocador de pilha (por exemplo, operador de concatenação de strings[1]). Todo o conceito da pilha está estritamente no espaço do usuário. Há algumas características padrão de biblioteca que fornecem e funcionam com alocadores de pilha, mas essas são características opcionais de biblioteca padrão, não incorporadas no próprio idioma. Se você nunca inicializa um alocador de pilhas, então você pode ter certeza de que seu programa nunca vai causar alocações de pilhas. + +A biblioteca padrão do Zig ainda é muito jovem, mas o objetivo é que cada recurso que usa um alocador aceite um alocador em tempo de execução, ou possivelmente em tempo de compilação ou de execução. + +A motivação para esta filosofia de projeto é permitir aos usuários escrever qualquer tipo de estratégia de alocação personalizada que considerem necessária, em vez de forçá-los ou mesmo encorajá-los a uma estratégia particular que pode não ser adequada às suas necessidades. Por exemplo, a Ferrugem parece encorajar uma única estratégia de alocação global, que não é adequada para muitos casos de uso, tais como desenvolvimento de SO e desenvolvimento de jogos de alto desempenho. Zig está recebendo sugestões da postura de [Jai](https://www.youtube.com/watch?v=ciGQCP6HgqI) sobre alocadores, uma vez que essa linguagem está sendo desenvolvida por um designer de jogos de alto desempenho para o uso de jogos de alto desempenho. + +Como afirmado antes, este tópico ainda é um pouco confuso e se tornará mais concreto conforme a biblioteca padrão do Zig amadurece. O importante é que a alocação de heap seja um conceito de espaço do usuário, e não embutido na linguagem. + +Nem é preciso dizer que não existe um coletor de lixo embutido como há na linguagem Go. + +[O pânico da biblioteca padrão do Rust quando está Sem Memória (Out Of Memory)](https://github.com/rust-lang/rust/issues/29802) + +[1]: Na verdade, existe um operador de concatenação de cordas (geralmente um operador de concatenação de matriz), mas ele só funciona em tempo de compilação, de modo que ainda não há alocação de pilha de tempo de execução com isso. + +## Autonomia + +Zig tem uma biblioteca padrão inteiramente opcional que só é compilada em seu programa se você a utilizar. O mesmo ocorre com a libc, a utilização dela é opcional, exceto em casos de interoperabilidade com linguagem C. O Zig é amigável ao desenvolvimento de sistemas de alto desempenho e bare-metal. + + +## Uma linguagem portátil para bibliotecas + +Um dos santo graal da programação é a reutilização de código. Infelizmente, na prática, acabamos reinventando a roda várias vezes. Muitas vezes é justificado. + + * Se um aplicativo tem requisitos de tempo real, qualquer biblioteca que usa coleta de lixo ou qualquer outro comportamento não determinístico é desqualificada como dependência. + * Se uma linguagem torna muito fácil ignorar erros e, portanto, verificar se uma biblioteca trata corretamente e gera bolhas de erros, pode ser tentador ignorar a biblioteca e implementá-la novamente, sabendo que todos os erros relevantes foram tratados corretamente. O Zig é projetado de forma que a coisa mais preguiçosa que um programador pode fazer é lidar com os erros corretamente e, portanto, pode-se estar razoavelmente confiante de que uma biblioteca irá propagar erros. + * Atualmente, é pragmaticamente verdade que C é a linguagem mais versátil e portátil. Qualquer linguagem que não tenha a capacidade de interagir com o código C corre o risco de ser obscurecida. O Zig está tentando se tornar a nova linguagem portátil para bibliotecas, tornando-o simultaneamente direto para a conformidade com a C ABI para funções externas e introduzindo segurança e design de linguagem que evita bugs comuns nas implementações. + +## Um Gerenciador de Pacotes e um Sistema de Construção para projetos existentes + +Zig é uma linguagem de programação, mas também é enviada com um sistema de construção e um gerenciador de pacotes que se destinam a ser úteis mesmo no contexto de um projeto C/C++ tradicional. + +Você não só pode escrever o código Zig em vez do código C ou C++, mas também pode usar Zig como um substituto para ferramentas automáticas, fazer, fazer, scons, ninja, etc. E além disso, ele (irá) fornecer um gerenciador de pacotes para dependências nativas. Este sistema de construção é destinado a ser apropriado mesmo que a base de código de um projeto esteja totalmente em C ou C++. + +Gerentes de pacotes de sistema como apt-get, pacman, homebrew, e outros são fundamentais para a experiência do usuário final, mas eles podem ser insuficientes para as necessidades dos desenvolvedores. Um gerenciador de pacotes de idioma específico pode ser a diferença entre não ter contribuidores e ter dezenas. Para projetos de código aberto, a dificuldade de conseguir que o projeto seja construído é um enorme obstáculo para os potenciais contribuintes. Para projetos C/C++, ter dependências pode ser fatal, especialmente no Windows, onde não há um gerenciador de pacotes. Mesmo quando se trata apenas de construir o Zig, a maioria dos colaboradores em potencial tem dificuldades com a dependência da LLVM. O Zig está (estará) oferecendo uma forma de os projetos dependerem diretamente de bibliotecas nativas - sem depender do gerenciador de pacotes do sistema dos usuários para ter a versão correta disponível, e de uma forma que é praticamente garantida para construir projetos com sucesso na primeira tentativa, independentemente do sistema que está sendo usado e independente da plataforma que está sendo visada. + +Zig está oferecendo a substituição do sistema de construção de um projeto por uma linguagem razoável usando uma API declarativa para a construção de projetos, que também fornece o gerenciamento de pacotes e, portanto, a capacidade de realmente depender de outras bibliotecas C. A capacidade de ter dependências permite abstrações de maior nível e, portanto, a proliferação de códigos reutilizáveis de alto nível. + +## Simplicidade + +C++, Rust, e D têm um grande número de características e podem distrair do significado real da aplicação em que você está trabalhando. A pessoa se vê depurando seu conhecimento da linguagem de programação ao invés de depurar a aplicação em si. + +Zig não tem macros nem metaprogramação, mas ainda é poderoso o suficiente para expressar programas complexos de uma forma clara e não repetitiva. Mesmo Rust, que tem macros com casos especiais `format!`, implementando-o no próprio compilador. Enquanto isso, em Zig, a função equivalente é implementada na biblioteca padrão, sem código de caso especial no compilador. + +Quando você observa o código Zig, tudo é uma simples expressão ou uma chamada de função. Não há sobrecarga de operador, métodos de propriedade, despacho de tempo de execução, macros ou fluxo de controle oculto. Zig está indo para toda a bela simplicidade do C, menos as armadilhas. + + * [Struggles With Rust](https://compileandrun.com/stuggles-with-rust.html) + * [Way Cooler gives up on Rust due to complexity](http://way-cooler.org/blog/2019/04/29/rewriting-way-cooler-in-c.html) + * [Moving to Zig for ARM Development](https://www.jishuwen.com/d/2Ap9) + +## Ferramentas + +Zig pode ser baixado na seção [Baixar](/downloads/). Zig fornece arquivos binários para linux, janelas, macos e freebsd. O seguinte descreve o que você obtém com este arquivo: + +* instalado após baixar e extrair de um único arquivo, sem necessidade de configuração do sistema +* compilado estaticamente para que não haja dependências de tempo de execução +* utiliza a infra-estrutura madura e bem suportada da LLVM que permite uma profunda otimização e suporte para a maioria das principais plataformas +* out of the box cross-compilation to most major platforms +* vincula código fonte com libc que será compilado dinamicamente quando necessário para qualquer plataforma suportada +* inclui sistema de construção com caching +* compila o código C com o suporte da libc diff --git a/content/news/_index.pt.md b/content/news/_index.pt.md new file mode 100644 index 000000000..5bfbb2ccb --- /dev/null +++ b/content/news/_index.pt.md @@ -0,0 +1,6 @@ +--- +title: Novidades +menu_title: "Novidades" +mobile_menu_title: "Novidades" +layout: news-list +--- diff --git a/content/zsf/index.pt.md b/content/zsf/index.pt.md new file mode 100644 index 000000000..eaed43820 --- /dev/null +++ b/content/zsf/index.pt.md @@ -0,0 +1,79 @@ +--- +title: "Patrocinadores da ZSF" +menu_title: "Patrocinadores da Zig Software Foundation" +mobile_menu_title: "Patrocinadores da ZSF" +date: 2020-10-20T16:29:51+02:00 +--- +{{< sponsor-title-cta "Patrocinadores da Zig Software Foundation" >}} + +## Missão +A missão da Zig Software Foundation é promover, proteger e fazer avançar a linguagem de programação Zig, apoiar e facilitar o crescimento de uma comunidade diversificada e internacional de programadores Zig, e fornecer educação e orientação aos estudantes, ensinando a próxima geração de programadores a serem competentes, éticos e a manterem uns aos outros com padrões elevados. + +**ZSF é uma corporação 501(c)(3) sem fins lucrativos.** As finanças, atas de reuniões e outros detalhes estão [disponíveis ao público](https://drive.google.com/drive/folders/1ucHARxVbhrBbuZDbhrGHYDTsYAs8_bMH?usp=sharing). + +## Membros do Conselho Administrativo + +- [Andrew Kelley](https://andrewkelley.me/) (Presidente) +- [Josh Wolfe](https://github.com/thejoshwolfe/) (Secretário) +- [Mason Remaley](https://twitter.com/masonremaley/) (Tesoureiro) + +## Patrocínios + +Ao fazer uma doação ao ZSF, você está financiando o desenvolvimento da linguagem de programação Zig e seu ecossistema, o que por sua vez beneficia a maior comunidade de código aberto em geral. Os membros da comunidade Zig conseguiram consertos de bugs em [LLVM](https://llvm.org/), [Wine](https://winehq.org/), [QEMU](https://qemu.org/), [musl libc](https://musl.libc.org/), [GDB](https://www.gnu.org/software/gdb/) e outros. + +ZSF é uma pequena organização e faz uso eficiente de recursos monetários. O plano é mantê-la assim, mas queremos transformar nossos voluntários não remunerados em mantenedores remunerados para ajudar na fusão de pedidos e fazer progressos mais rápidos em direção ao 1.0. O objetivo do ZSF ser sem fins lucrativos é beneficiar as pessoas. Estamos tentando fazer com que os mantenedores de código aberto sejam pagos pelo seu tempo. + +A maneira mais fácil de nos apoiar é doar através dos [Patrocinadores do GitHub](https://github.com/sponsors/ziglang). + +## Informações das doaçoes +Aqui estão informações úteis para doar por outros meios que não os Patrocinadores do GitHub. +Certifique-se de verificar sua legislação local para ver se você pode deduzir doações de seus impostos. + +| **EIN** | **Endereço** | +|-------------|-------------| +| 84-5105214 | Zig Software Foundation
1732 1st Ave #21385
New York, NY 10128| + +### Métodos de doação adicionais apoiados +- Verificações físicas (ver o endereço de correio do caracol listado acima) +- Transferências bancárias (inclusive de fora dos EUA, entre em contato conosco para mais informações) +- [Benevity](https://benevity.com) (recomendado se seu empregador fizer doações!) + +**Por favor, não hesite em nos contatar em donations@ziglang.org se você tiver dúvidas ou necessidades específicas.** + +## Patrocinadores corporativos + +### Doações monetárias +As seguintes empresas estão fornecendo apoio financeiro direto à Zig Software Foundation doando mais de US$ 1000/mês. + +{{% sponsor-logos "monetary" %}} + + + + + + +{{% /sponsor-logos %}} + +### Infraestrutura +As seguintes empresas estão oferecendo alguns de seus serviços para a Zig Software Foundation gratuitamente. + +{{% sponsor-logos "services" %}} +![](../lavatech.png) +![](../dropbox.png) +![](../aws.png) +{{% /sponsor-logos %}} + + + + + + + + + + + + + + + From 680df3e260651a3134a206821b86777ac565889e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20Catarino=20Fran=C3=A7a?= Date: Wed, 13 Jan 2021 13:47:36 -0300 Subject: [PATCH 08/25] loading the SVG --- content/_index.en.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/content/_index.en.md b/content/_index.en.md index 622db9e94..2fced0fb3 100644 --- a/content/_index.en.md +++ b/content/_index.en.md @@ -108,8 +108,8 @@ The following companies are providing direct financial support to the Zig Softwa {{% sponsor-logos "monetary" %}} - - + + {{% /sponsor-logos %}} From ea6e287e617595919947000a37a036c6839cdf00 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20Catarino=20Fran=C3=A7a?= Date: Wed, 13 Jan 2021 13:51:43 -0300 Subject: [PATCH 09/25] loading the SVG in pt - fixed --- content/_index.en.md | 4 ++-- content/_index.pt.md | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/content/_index.en.md b/content/_index.en.md index 2fced0fb3..622db9e94 100644 --- a/content/_index.en.md +++ b/content/_index.en.md @@ -108,8 +108,8 @@ The following companies are providing direct financial support to the Zig Softwa {{% sponsor-logos "monetary" %}} - - + + {{% /sponsor-logos %}} diff --git a/content/_index.pt.md b/content/_index.pt.md index ca9fc232e..1dd413717 100644 --- a/content/_index.pt.md +++ b/content/_index.pt.md @@ -108,8 +108,8 @@ As seguintes empresas estão fornecendo suporte financeiro direto para a Zig Sof {{% sponsor-logos "monetary" %}} - - + + {{% /sponsor-logos %}} From 2c3c5afcea5aad3ded1f8a2d1491645e433dd1c8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20Catarino=20Fran=C3=A7a?= Date: Wed, 13 Jan 2021 14:30:54 -0300 Subject: [PATCH 10/25] Tools section - translated and fix --- content/learn/tools.pt.md | 33 ++++++++++++++++++++++++++ content/learn/why_zig_rust_d_cpp.pt.md | 6 ++--- 2 files changed, 36 insertions(+), 3 deletions(-) create mode 100644 content/learn/tools.pt.md diff --git a/content/learn/tools.pt.md b/content/learn/tools.pt.md new file mode 100644 index 000000000..e1f073e52 --- /dev/null +++ b/content/learn/tools.pt.md @@ -0,0 +1,33 @@ +--- +title: "Ferramentas" +menu_title: "Ferramentas" +mobile_menu_title: "Ferramentas" +toc: true +--- + +## Servidores de Linguagem +Os servidores de linguagem são ferramentas de editor-agnóstica para obter destaque de sintaxe, autocompletar e muitas outras características. Considere o uso de um servidor de idiomas sobre uma extensão de realce de sintaxe para uma experiência de desenvolvimento mais rica. + +- [zigtools/zls](https://github.com/zigtools/zls) + +## Editores de texto +Ferramentas específicas do editor, em sua maioria marcadores de sintaxe. + +### VS Code +- [ziglang/vscode-zig](https://github.com/ziglang/vscode-zig) + +### Sublime Text +- [ziglang/sublime-zig-language](https://github.com/ziglang/sublime-zig-language) + +### Vim +- [ziglang/zig.vim](https://github.com/ziglang/zig.vim) + +### Emacs +- [ziglang/zig-mode](https://github.com/ziglang/zig-mode) + +### Kate +- [ziglang/kde-syntax-highlighting](https://github.com/ziglang/kde-syntax-highlighting) + +## Documentação e Teste +- [kristoff-it/zig-doctest](https://github.com/kristoff-it/zig-doctest) + diff --git a/content/learn/why_zig_rust_d_cpp.pt.md b/content/learn/why_zig_rust_d_cpp.pt.md index 89169cee2..9b4021b91 100644 --- a/content/learn/why_zig_rust_d_cpp.pt.md +++ b/content/learn/why_zig_rust_d_cpp.pt.md @@ -29,13 +29,13 @@ De modo mais geral, ter uma abordagem de mãos livres quando se trata de alocaç A biblioteca padrão do Zig ainda é muito jovem, mas o objetivo é que cada recurso que usa um alocador aceite um alocador em tempo de execução, ou possivelmente em tempo de compilação ou de execução. -A motivação para esta filosofia de projeto é permitir aos usuários escrever qualquer tipo de estratégia de alocação personalizada que considerem necessária, em vez de forçá-los ou mesmo encorajá-los a uma estratégia particular que pode não ser adequada às suas necessidades. Por exemplo, a Ferrugem parece encorajar uma única estratégia de alocação global, que não é adequada para muitos casos de uso, tais como desenvolvimento de SO e desenvolvimento de jogos de alto desempenho. Zig está recebendo sugestões da postura de [Jai](https://www.youtube.com/watch?v=ciGQCP6HgqI) sobre alocadores, uma vez que essa linguagem está sendo desenvolvida por um designer de jogos de alto desempenho para o uso de jogos de alto desempenho. +A motivação para esta filosofia de projeto é permitir aos usuários escrever qualquer tipo de estratégia de alocação personalizada que considerem necessária, em vez de forçá-los ou mesmo encorajá-los a uma estratégia particular que pode não ser adequada às suas necessidades. Por exemplo, Rust parece encorajar uma única estratégia de alocação global, que não é adequada para muitos casos de uso, tais como desenvolvimento de SO e desenvolvimento de jogos de alto desempenho. Zig está recebendo sugestões da postura de [Jai](https://www.youtube.com/watch?v=ciGQCP6HgqI) sobre alocadores, uma vez que essa linguagem está sendo desenvolvida por um designer de jogos de alto desempenho para o uso de jogos de alto desempenho. Como afirmado antes, este tópico ainda é um pouco confuso e se tornará mais concreto conforme a biblioteca padrão do Zig amadurece. O importante é que a alocação de heap seja um conceito de espaço do usuário, e não embutido na linguagem. Nem é preciso dizer que não existe um coletor de lixo embutido como há na linguagem Go. -[O pânico da biblioteca padrão do Rust quando está Sem Memória (Out Of Memory)](https://github.com/rust-lang/rust/issues/29802) +[O pânico emitido pela biblioteca padrão do Rust quando está Sem Memória (Out Of Memory)](https://github.com/rust-lang/rust/issues/29802) [1]: Na verdade, existe um operador de concatenação de cordas (geralmente um operador de concatenação de matriz), mas ele só funciona em tempo de compilação, de modo que ainda não há alocação de pilha de tempo de execução com isso. @@ -76,7 +76,7 @@ Quando você observa o código Zig, tudo é uma simples expressão ou uma chamad ## Ferramentas -Zig pode ser baixado na seção [Baixar](/downloads/). Zig fornece arquivos binários para linux, janelas, macos e freebsd. O seguinte descreve o que você obtém com este arquivo: +Zig pode ser baixado na seção [Baixar](/downloads/). Zig fornece arquivos binários para linux, windows, macos e freebsd. O seguinte descreve o que você obtém com este arquivo: * instalado após baixar e extrair de um único arquivo, sem necessidade de configuração do sistema * compilado estaticamente para que não haja dependências de tempo de execução From 4fddffb8db226c172b28b82a8d7ddd83cd6d553c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20Catarino=20Fran=C3=A7a?= Date: Wed, 13 Jan 2021 15:56:07 -0300 Subject: [PATCH 11/25] Overview - missing translation --- content/learn/getting-started.pt.md | 2 +- content/learn/overview.pt.md | 42 ++++++++++++++--------------- 2 files changed, 22 insertions(+), 22 deletions(-) diff --git a/content/learn/getting-started.pt.md b/content/learn/getting-started.pt.md index d3043f9c7..6652239be 100644 --- a/content/learn/getting-started.pt.md +++ b/content/learn/getting-started.pt.md @@ -106,7 +106,7 @@ Se você estiver interessado em uma integração mais profunda entre o Zig e seu Se você estiver interessado no que mais está disponível, confira a seção [Tools](../tools/). -## Run Hello World +## Executar Hello World Se você completou o processo de instalação corretamente, agora você deverá ser capaz de invocar o compilador Zig a partir do shell. Vamos testar isso criando seu primeiro programa Zig! diff --git a/content/learn/overview.pt.md b/content/learn/overview.pt.md index 1ed50e3be..1b49da6fc 100644 --- a/content/learn/overview.pt.md +++ b/content/learn/overview.pt.md @@ -8,7 +8,7 @@ toc: true Concentre-se na depuração de sua aplicação em vez de depurar seus conhecimentos em uma linguagem de programação. -Toda a sintaxe do Zig é especificada com um [500-line PEG grammar file](https://ziglang.org/documentation/master/#Grammar). +Toda a sintaxe do Zig é especificada com um [Arquivo gramatical PEG de 500 linhas](https://ziglang.org/documentation/master/#Grammar). Não há **nenhum fluxo de controle oculto**, nenhuma alocação de memória oculta, nenhum pré-processador, e nenhuma macros. Se o código Zig não parece estar pulando para chamar uma função, então não está. Isto significa que você pode ter certeza de que o seguinte código chama apenas `foo()` e depois `bar()`, e isto é garantido sem a necessidade de saber os tipos de nada: @@ -18,49 +18,49 @@ foo(); bar(); ``` -Examples of hidden control flow: +Exemplos de fluxo de controle oculto: -- D has `@property` functions, which are methods that you call with what looks like field access, so in the above example, `c.d` might call a function. -- C++, D, and Rust have operator overloading, so the `+` operator might call a function. -- C++, D, and Go have throw/catch exceptions, so `foo()` might throw an exception, and prevent `bar()` from being called. +- D tem funções `@property`, que são métodos que você chama com o que parece ser acesso de campo, então no exemplo acima, `c.d` poderia chamar uma função. +- C++, D, e Rust têm sobrecarga do operador, portanto o operador `+` pode chamar uma função. +- C++, D, e Go têm exceções do tipo `throw/catch`, portanto `foo()` pode lançar uma exceção, e impedir que `bar()` seja chamado. - Zig promotes code maintenance and readability by making all control flow managed exclusively with language keywords and function calls. +Zig promove a manutenção do código e a legibilidade, fazendo com que todo o fluxo de controle seja gerenciado exclusivamente com palavras-chave do idioma e chamadas de função. ## Performance and Safety: Choose Two -Zig has four [build modes](https://ziglang.org/documentation/master/#Build-Mode), and they can all be mixed and matched all the way down to [scope granularity](https://ziglang.org/documentation/master/#setRuntimeSafety). +Zig tem quatro [modos de construção](https://ziglang.org/documentation/master/#Build-Mode), e todas elas podem ser misturadas e combinadas até a [granularidade do escopo](https://ziglang.org/documentation/master/#setRuntimeSafety). -| Parameter | [Debug](/documentation/master/#Debug) | [ReleaseSafe](/documentation/master/#ReleaseSafe) | [ReleaseFast](/documentation/master/#ReleaseFast) | [ReleaseSmall](/documentation/master/#ReleaseSmall) | +| Parametro | [Debug](/documentation/master/#Debug) | [ReleaseSafe](/documentation/master/#ReleaseSafe) | [ReleaseFast](/documentation/master/#ReleaseFast) | [ReleaseSmall](/documentation/master/#ReleaseSmall) | |-----------|-------|-------------|-------------|--------------| -Optimizations - improve speed, harm debugging, harm compile time | | -O3 | -O3| -Os | -Runtime Safety Checks - harm speed, harm size, crash instead of undefined behavior | On | On | | | +Otimizações - melhorar a velocidade, depuração de danos, tempo de compilação de danos | | -O3 | -O3| -Os | +Verificações de segurança em tempo de execução - velocidade do dano, tamanho do dano, acidente ao invés de comportamento indefinido | On | On | | | -Here is what [Integer Overflow](https://ziglang.org/documentation/master/#Integer-Overflow) looks like at compile time, regardless of the build mode: +Aqui temos [Sobrecarga de Inteiros (Integer Overflow)](https://ziglang.org/documentation/master/#Integer-Overflow) que parece estar em tempo de compilação, independentemente do modo de construção: {{< zigdoctest "assets/zig-code/features/1-integer-overflow.zig" >}} -Here is what it looks like at runtime, in safety-checked builds: +Aqui está o que parece em tempo de execução, em construções verificadas em termos de segurança: {{< zigdoctest "assets/zig-code/features/2-integer-overflow-runtime.zig" >}} -Those [stack traces work on all targets](https://ziglang.org/#Stack-traces-on-all-targets), including [freestanding](https://andrewkelley.me/post/zig-stack-traces-kernel-panic-bare-bones-os.html). +Esses [rastreamentos de pilhas funcionam em todos os alvos](https://ziglang.org/#Stack-traces-on-all-targets), incluindo [freestanding](https://andrewkelley.me/post/zig-stack-traces-kernel-panic-bare-bones-os.html). -With Zig one can rely on a safety-enabled build mode, and selectively disable safety at the performance bottlenecks. For example the previous example could be modified like this: +Com Zig pode-se confiar em um modo de construção `safe-enabled`, e desativar seletivamente a segurança nos gargalos de desempenho. Por exemplo, o exemplo anterior poderia ser modificado desta forma: {{< zigdoctest "assets/zig-code/features/3-undefined-behavior.zig" >}} -Zig uses [undefined behavior](https://ziglang.org/documentation/master/#Undefined-Behavior) as a razor sharp tool for both bug prevention and performance enhancement. +Zig utiliza [comportamento indefinido](https://ziglang.org/documentation/master/#Undefined-Behavior) com inteligência tanto para a prevenção de bugs quanto para a melhoria do desempenho. -Speaking of performance, Zig is faster than C. +Por falar em desempenho, Zig é mais rápido que C. -- The reference implementation uses LLVM as a backend for state of the art optimizations. -- What other projects call "Link Time Optimization" Zig does automatically. +- A implementação de referência utiliza LLVM como um backend para as otimizações de ponta. +- O que outros projetos chamam de "Link Time Optimization" e Zig faz automaticamente. - For native targets, advanced CPU features are enabled (-march=native), thanks to the fact that [Cross-compiling is a first-class use case](https://ziglang.org/#Cross-compiling-is-a-first-class-use-case). -- Carefully chosen undefined behavior. For example, in Zig both signed and unsigned integers have undefined behavior on overflow, contrasted to only signed integers in C. This [facilitates optimizations that are not available in C](https://godbolt.org/z/n_nLEU). -- Zig directly exposes a [SIMD vector type](https://ziglang.org/documentation/master/#Vectors), making it easy to write portable vectorized code. +- Comportamento cuidadosamente escolhido e indefinido. Por exemplo, em Zig, tanto os inteiros assinados como os não assinados têm um comportamento indefinido no transbordamento, ao contrário de apenas os inteiros assinados em C. Isto [facilitates optimizations that are not available in C](https://godbolt.org/z/n_nLEU). +- Zig expõe diretamente a [vetores tipo SIMD](https://ziglang.org/documentation/master/#Vectors), facilitando a escrita de código vetorizado portátil. -Please note that Zig is not a fully safe language. For those interested in following Zig's safety story, subscribe to these issues: +Favor notar que Zig não é uma linguagem totalmente segura. Para aqueles interessados em seguir a história de segurança do Zig, inscrevam-se para estas questões: - [enumerate all kinds of undefined behavior, even that which cannot be safety-checked](https://github.com/ziglang/zig/issues/1966) - [make Debug and ReleaseSafe modes fully safe](https://github.com/ziglang/zig/issues/2301) From 62f208b41f53eee1943afe3491a395d4616d7d22 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20Catarino=20Fran=C3=A7a?= Date: Wed, 13 Jan 2021 16:18:40 -0300 Subject: [PATCH 12/25] Words changed - build translation --- content/learn/overview.pt.md | 100 ++++++++++++------------- content/learn/why_zig_rust_d_cpp.pt.md | 10 +-- 2 files changed, 55 insertions(+), 55 deletions(-) diff --git a/content/learn/overview.pt.md b/content/learn/overview.pt.md index 1b49da6fc..af892f34b 100644 --- a/content/learn/overview.pt.md +++ b/content/learn/overview.pt.md @@ -28,14 +28,14 @@ Zig promove a manutenção do código e a legibilidade, fazendo com que todo o f ## Performance and Safety: Choose Two -Zig tem quatro [modos de construção](https://ziglang.org/documentation/master/#Build-Mode), e todas elas podem ser misturadas e combinadas até a [granularidade do escopo](https://ziglang.org/documentation/master/#setRuntimeSafety). +Zig tem quatro [modos de compilação](https://ziglang.org/documentation/master/#Build-Mode), e todas elas podem ser misturadas e combinadas até a [granularidade do escopo](https://ziglang.org/documentation/master/#setRuntimeSafety). | Parametro | [Debug](/documentation/master/#Debug) | [ReleaseSafe](/documentation/master/#ReleaseSafe) | [ReleaseFast](/documentation/master/#ReleaseFast) | [ReleaseSmall](/documentation/master/#ReleaseSmall) | |-----------|-------|-------------|-------------|--------------| Otimizações - melhorar a velocidade, depuração de danos, tempo de compilação de danos | | -O3 | -O3| -Os | Verificações de segurança em tempo de execução - velocidade do dano, tamanho do dano, acidente ao invés de comportamento indefinido | On | On | | | -Aqui temos [Sobrecarga de Inteiros (Integer Overflow)](https://ziglang.org/documentation/master/#Integer-Overflow) que parece estar em tempo de compilação, independentemente do modo de construção: +Aqui temos [Sobrecarga de Inteiros (Integer Overflow)](https://ziglang.org/documentation/master/#Integer-Overflow) que parece estar em tempo de compilação, independentemente do modo de compilação: {{< zigdoctest "assets/zig-code/features/1-integer-overflow.zig" >}} @@ -46,7 +46,7 @@ Aqui está o que parece em tempo de execução, em construções verificadas em Esses [rastreamentos de pilhas funcionam em todos os alvos](https://ziglang.org/#Stack-traces-on-all-targets), incluindo [freestanding](https://andrewkelley.me/post/zig-stack-traces-kernel-panic-bare-bones-os.html). -Com Zig pode-se confiar em um modo de construção `safe-enabled`, e desativar seletivamente a segurança nos gargalos de desempenho. Por exemplo, o exemplo anterior poderia ser modificado desta forma: +Com Zig pode-se confiar em um modo de compilação `safe-enabled`, e desativar seletivamente a segurança nos gargalos de desempenho. Por exemplo, o exemplo anterior poderia ser modificado desta forma: {{< zigdoctest "assets/zig-code/features/3-undefined-behavior.zig" >}} @@ -56,8 +56,8 @@ Por falar em desempenho, Zig é mais rápido que C. - A implementação de referência utiliza LLVM como um backend para as otimizações de ponta. - O que outros projetos chamam de "Link Time Optimization" e Zig faz automaticamente. -- For native targets, advanced CPU features are enabled (-march=native), thanks to the fact that [Cross-compiling is a first-class use case](https://ziglang.org/#Cross-compiling-is-a-first-class-use-case). -- Comportamento cuidadosamente escolhido e indefinido. Por exemplo, em Zig, tanto os inteiros assinados como os não assinados têm um comportamento indefinido no transbordamento, ao contrário de apenas os inteiros assinados em C. Isto [facilitates optimizations that are not available in C](https://godbolt.org/z/n_nLEU). +- Para alvos nativos, recursos avançados de CPU são habilitados (-march=native), graças ao fato da [compilação cruzada ser um caso de uso de primeira classe](https://ziglang.org/#Cross-compiling-is-a-first-class-use-case). +- Comportamento cuidadosamente escolhido e indefinido. Por exemplo, em Zig, tanto os inteiros assinados como os não assinados têm um comportamento indefinido no transbordamento, ao contrário de apenas os inteiros assinados em C. Isto [facilita as otimizações que não estão disponíveis em C](https://godbolt.org/z/n_nLEU). - Zig expõe diretamente a [vetores tipo SIMD](https://ziglang.org/documentation/master/#Vectors), facilitando a escrita de código vetorizado portátil. Favor notar que Zig não é uma linguagem totalmente segura. Para aqueles interessados em seguir a história de segurança do Zig, inscrevam-se para estas questões: @@ -165,11 +165,11 @@ A palavra-chave [unreachable](https://ziglang.org/documentation/master/#unreacha {{< zigdoctest "assets/zig-code/features/16-unreachable.zig" >}} -Isto invoca um [comportamento indefinido](https://ziglang.org/#Performance-and-Safety-Choose-Two) nos modos de construção inseguros, portanto, certifique-se de usá-lo somente quando o sucesso for garantido. +Isto invoca um [comportamento indefinido](https://ziglang.org/#Performance-and-Safety-Choose-Two) nos modos de compilação inseguros, portanto, certifique-se de usá-lo somente quando o sucesso for garantido. ### Rastreamento de pilha em todos os alvos -O rastreamento da pilha e [rastreamento do retorno de erros](https://ziglang.org/documentation/master/#Error-Return-Traces) mostram que nesta página funcionam todos os alvos da [Tier 1 Support](https://ziglang.org/#Tier-1-Support) e alguns da [Tier 2 Support](https://ziglang.org/#Tier-2-Support). [Even freestanding](https://andrewkelley.me/post/zig-stack-traces-kernel-panic-bare-bones-os.html)! +O rastreamento da pilha e [rastreamento do retorno de erros](https://ziglang.org/documentation/master/#Error-Return-Traces) mostram que nesta página funcionam todos os alvos da [Suporte Tier 1](https://ziglang.org/#Tier-1-Support) e alguns da [Suporte Tier 2](https://ziglang.org/#Tier-2-Support). [Até mesmo freestanding](https://andrewkelley.me/post/zig-stack-traces-kernel-panic-bare-bones-os.html)! Além disso, a biblioteca padrão tem a capacidade de capturar um traço de pilha em qualquer ponto e depois despejá-la em erro padrão mais tarde: @@ -189,7 +189,7 @@ Uma estrutura de dados genérica é simplesmente uma função que retorna um `ty ## Compilar o tempo de reflexão e compilar o tempo de execução do código -A função de construção [@typeInfo](https://ziglang.org/documentation/master/#typeInfo) proporciona reflexão: +A função de compilação [@typeInfo](https://ziglang.org/documentation/master/#typeInfo) proporciona reflexão: {{< zigdoctest "assets/zig-code/features/20-reflection.zig" >}} @@ -215,7 +215,7 @@ Output device: Built-in Audio Analog Stereo ^C ``` -[This Zig code is significantly simpler than the equivalent C code](https://gist.github.com/andrewrk/d285c8f912169329e5e28c3d0a63c1d8), bem como ter mais proteções de segurança, e tudo isso é conseguido através da importação direta do arquivo de cabeçalho C - sem ligações de API. +[Este código Zig é significativamente mais simples do que o equivalente ao código C](https://gist.github.com/andrewrk/d285c8f912169329e5e28c3d0a63c1d8), bem como ter mais proteções de segurança, e tudo isso é conseguido através da importação direta do arquivo de cabeçalho C - sem ligações de API. *Zig é melhor no uso de bibliotecas C do que C é no uso de bibliotecas C.* @@ -256,7 +256,7 @@ sys 0m0.009s Isto se deve a [Cache de Compilação](https://ziglang.org/download/0.4.0/release-notes.html#Build-Artifact-Caching). Zig analisa automaticamente o arquivo .d usando um sistema de cache robusto para evitar duplicação de trabalho. -O Zig não só pode compilar o código C, mas há uma razão muito boa para usar Zig como um compilador C: [Zig embarca com a libc](https://ziglang.org/#Zig-ships-with-libc). +O Zig não só pode compilar o código C, mas há uma razão muito boa para usar Zig como um compilador C: [Zig vincula-se com a libc](https://ziglang.org/#Zig-ships-with-libc). ### Exportar funções, variáveis e tipos definidos pelo código C para depender de @@ -275,7 +275,7 @@ Fazer uma biblioteca dinâmica: $ zig build-lib mathtest.zig -dynamic ``` -Eis um exemplo com o [Sistema de Construção do Zig](https://ziglang.org/#Zig-Build-System): +Eis um exemplo com o [Sistema de Compilação do Zig](https://ziglang.org/#Zig-Build-System): test.c ```c @@ -299,7 +299,7 @@ $ zig build test ## A compilação cruzada é um caso de uso de primeira classe -Zig pode construir para qualquer um dos alvos a partir da [Tabela de Suporte](https://ziglang.org/#Support-Table) com [Tier 3 Support](https://ziglang.org/#Tier-3-Support) ou melhor. Nenhum "conjunto de ferramentas cruzada" precisa ser instalada ou algo parecido. Aqui está um "Hello World" nativo: +Zig pode compilar para qualquer um dos alvos a partir da [Tabela de Suporte](https://ziglang.org/#Support-Table) com [Suporte Tier 3](https://ziglang.org/#Tier-3-Support) ou melhor. Nenhum "conjunto de ferramentas cruzada" precisa ser instalada ou algo parecido. Aqui está um "Hello World" nativo: {{< zigdoctest "assets/zig-code/features/4-hello.zig" >}} @@ -375,7 +375,7 @@ Você pode encontrar os alvos libc disponíveis com `zig targets`: O que isto significa é que `--library c` para estes alvos *não depende de nenhum arquivo do sistema*! -Vejamos o [exemplo hello world em C](https://ziglang.org/#Zig-is-also-a-C-compiler) novamente: +Vejamos o [exemplo do hello world em C](https://ziglang.org/#Zig-is-also-a-C-compiler) novamente: ``` $ zig build-exe --c-source hello.c --library c $ ./hello @@ -390,7 +390,7 @@ $ ldd ./hello /lib/ld-linux-x86-64.so.2 => /lib64/ld-linux-x86-64.so.2 (0x00007fc4b6672000) ``` -[glibc](https://www.gnu.org/software/libc/) não suporta estaticamente a construção, mas [musl](https://www.musl-libc.org/) suporta: +[glibc](https://www.gnu.org/software/libc/) não suporta a compilação estática, mas [musl](https://www.musl-libc.org/) suporta: ``` $ zig build-exe --c-source hello.c --library c -target x86_64-linux-musl $ ./hello @@ -399,7 +399,7 @@ $ ldd hello not a dynamic executable ``` -Neste exemplo, Zig construiu musl libc a partir da fonte e depois ligou-se a ela. A construção da musl libc para x86_64-linux continua disponível graças ao [sistema de caching](https://ziglang.org/download/0.4.0/release-notes.html#Build-Artifact-Caching), portanto, a qualquer momento esta libc é necessária novamente, ela estará disponível instantaneamente. +Neste exemplo, Zig construiu musl libc a partir da fonte e depois ligou-se a ela. A compilação da musl libc para x86_64-linux continua disponível graças ao [sistema de caching](https://ziglang.org/download/0.4.0/release-notes.html#Build-Artifact-Caching), portanto, a qualquer momento esta libc é necessária novamente, ela estará disponível instantaneamente. Isto significa que esta funcionalidade está disponível em qualquer plataforma. Os usuários de Windows e macOS podem criar códigos Zig e C, e vincular-se a libc, para qualquer um dos alvos listados acima. Da mesma forma, o código pode ser compilado de forma cruzada para outras arquiteturas: ``` @@ -410,15 +410,15 @@ hello: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), dynamically lin Em alguns aspectos, Zig é um compilador C melhor do que os próprios compiladores C! -Esta funcionalidade é mais do que o agrupamento de um conjunto de ferramentas de compilação cruzada junto ao Zig. Por exemplo, o tamanho total dos cabeçalhos da libc que o Zig envia é de 22 MiB sem compressão. Enquanto isso, os cabeçalhos para musl libc + linux em x86_64 são 8 MiB, e para glibc são 3,1 MiB (falta no glibc os cabeçalhos linux), ainda assim Zig atualmente envia com 40 libcs. Com um agrupamento ingênuo que seria de 444 MiB. No entanto, graças a isto, a [ferramenta process_headers](https://github.com/ziglang/zig/blob/0.4.0/libc/process_headers.zig) que eu fiz, e algum [bom e velho trabalho manual](https://github.com/ziglang/zig/wiki/Updating-libc), Os tarballs binários Zig permanecem em torno de 30 MiB no total, apesar de apoiar a libc para todos esses alvos, bem como a compiler-rt, libunwind e libcxx, e apesar de ser um compilador C compatível com o clang. Para comparação, a construção binária do próprio Windows do clang 8.0.0 do llvm.org é de 132 MiB. +Esta funcionalidade é mais do que o agrupamento de um conjunto de ferramentas de compilação cruzada junto ao Zig. Por exemplo, o tamanho total dos cabeçalhos da libc que o Zig envia é de 22 MiB sem compressão. Enquanto isso, os cabeçalhos para musl libc + linux em x86_64 são 8 MiB, e para glibc são 3,1 MiB (falta no glibc os cabeçalhos linux), ainda assim Zig atualmente envia com 40 libcs. Com um agrupamento ingênuo que seria de 444 MiB. No entanto, graças a isto, a [ferramenta process_headers](https://github.com/ziglang/zig/blob/0.4.0/libc/process_headers.zig) que eu fiz, e algum [bom e velho trabalho manual](https://github.com/ziglang/zig/wiki/Updating-libc), Os tarballs binários Zig permanecem em torno de 30 MiB no total, apesar de apoiar a libc para todos esses alvos, bem como a compiler-rt, libunwind e libcxx, e apesar de ser um compilador C compatível com o clang. Para comparação, a compilação do binária no próprio Windows usando clang 8.0.0 do llvm.org é de 132 MiB. -Note que apenas no [Tier 1 Support](https://ziglang.org/#Tier-1-Support) os alvos foram exaustivamente testados. Está previsto [acrescentar mais libcs](https://github.com/ziglang/zig/issues/514) (inclusive para o Windows), e para [adicionar cobertura de testes para construção em relação a todas as libcs](https://github.com/ziglang/zig/issues/2058). +Note que apenas no [Suporte Tier 1](https://ziglang.org/#Tier-1-Support) os alvos foram exaustivamente testados. Está previsto [acrescentar mais libcs](https://github.com/ziglang/zig/issues/514) (inclusive para o Windows), e para [adicionar cobertura de testes para compilação em relação a todas as libcs](https://github.com/ziglang/zig/issues/2058). -Já está sendo [planejado para ter um Gerenciador de Pacotes do Zig](https://github.com/ziglang/zig/issues/943), mas isso ainda não está pronto. Uma das coisas que será possível é criar um pacote para as bibliotecas C. Isto fará com que o [Sistema de Construção do Zig](https://ziglang.org/#Zig-Build-System) tornando mais atraente tanto para programadores Zig como para programadores C. +Já está sendo [planejado para ter um Gerenciador de Pacotes do Zig](https://github.com/ziglang/zig/issues/943), mas isso ainda não está pronto. Uma das coisas que será possível é criar um pacote para as bibliotecas C. Isto fará com que o [Sistema de Compilação do Zig](https://ziglang.org/#Zig-Build-System) tornando mais atraente tanto para programadores Zig como para programadores C. -## Zig Build System +## Sistema de Compilação do Zig -O Zig vem com um sistema de construção, por isso você não precisa fazer, fabricar ou qualquer coisa do gênero. +O Zig vem com um sistema de compilação, por isso você não precisa fazer, fabricar ou qualquer coisa do gênero. ``` $ zig init-exe Created build.zig @@ -477,11 +477,11 @@ $ zig build run All your base are belong to us. ``` -Aqui estão alguns exemplos de scripts de construção: +Aqui estão alguns exemplos de scripts de compilação: -- [Construção do jogo Tetris - OpenGL](https://github.com/andrewrk/tetris/blob/master/build.zig) -- [Construção do jogo arcade no Raspberry Pi 3 (bare-metal)](https://github.com/andrewrk/clashos/blob/master/build.zig) -- [Construção do compilador auto-hospedado Zig](https://github.com/ziglang/zig/blob/master/build.zig) +- [Compilação do jogo Tetris - OpenGL](https://github.com/andrewrk/tetris/blob/master/build.zig) +- [Compilação do jogo arcade no Raspberry Pi 3 (bare-metal)](https://github.com/andrewrk/clashos/blob/master/build.zig) +- [Compilação do compilador auto-hospedado Zig](https://github.com/ziglang/zig/blob/master/build.zig) ## Concorrência via funções Async @@ -495,7 +495,7 @@ A Biblioteca Padrão Zig implementa um loop de eventos que multiplexam as funç ## Ampla gama de alvos suportados -Zig utiliza um sistema de "tiers" para comunicar o nível de suporte para diferentes alvos. Note que a barra para [Tier 1 Support](https://ziglang.org/#Tier-1-Support) é maior - [Tier 2 Support](https://ziglang.org/#Tier-2-Support) é ainda bastante útil. +Zig utiliza um sistema de "tiers" para comunicar o nível de suporte para diferentes alvos. Note que a barra para [Suporte Tier 1](https://ziglang.org/#Tier-1-Support) é maior - [Suporte Tier 2](https://ziglang.org/#Tier-2-Support) é ainda bastante útil. ### Tabela de Suporte @@ -544,43 +544,43 @@ Zig utiliza um sistema de "tiers" para comunicar o nível de suporte para difere ### Tier System -#### Tier 1 Support -- Not only can Zig generate machine code for these targets, but the standard library cross-platform abstractions have implementations for these targets. Thus it is practical to write a pure Zig application with no dependency on libc. -- The CI server automatically tests these targets on every commit to master branch, and updates [the download page](https://ziglang.org/download) with links to pre-built binaries. -- These targets have debug info capabilities and therefore produce [stack traces](https://ziglang.org/#Stack-traces-on-all-targets) on failed assertions. -- [libc is available for this target even when cross compiling](https://ziglang.org/#Zig-ships-with-libc). -- All the behavior tests and applicable standard library tests pass for this target. All language features are known to work correctly. +#### Suporte Tier 1 +- O Zig não só pode gerar código de máquina para estes alvos, mas a biblioteca padrão de abstrações entre plataformas tem implementações para estes alvos. Assim, é prático escrever uma aplicação Zig pura, sem dependência da libc. +- O servidor CI testa automaticamente estes alvos em cada compromisso com o ramo mestre, e atualiza a página [Baixar](https://ziglang.org/download) com links para binários pré-construídos. +- Estes alvos têm capacidade de depuração e, portanto, produzem [rastreamento de pilha](https://ziglang.org/#Stack-traces-on-all-targets) sobre asserções fracassadas. +- [libc está disponível para este alvo, mesmo quando a compilação cruzada](https://ziglang.org/#Zig-ships-with-libc). +- Todos os testes de comportamento e testes de biblioteca padrão aplicáveis são aprovados para este alvo. Todas as características da linguagem são conhecidas por funcionarem corretamente. -#### Tier 2 Support -- The standard library supports this target, but it's possible that some APIs will give an "Unsupported OS" compile error. One can link with libc or other libraries to fill in the gaps in the standard library. -- These targets are known to work, but may not be automatically tested, so there are occasional regressions. -- Some tests may be disabled for these targets as we work toward [Tier 1 Support](https://ziglang.org/#Tier-1-Support). +#### Suporte Tier 2 +- A biblioteca padrão suporta este alvo, mas é possível que algumas APIs dêem um erro de compilação "Unsupported OS". Pode-se fazer uma vinculação com a libc ou outras bibliotecas para preencher as lacunas da biblioteca padrão. +- Estes alvos são conhecidos por funcionarem, mas podem não ser testados automaticamente, portanto, há regressões ocasionais. +- Alguns testes podem ser desativados para estes alvos enquanto trabalhamos para [Suporte Tier 1](https://ziglang.org/#Tier-1-Support). -#### Tier 3 Support +#### Suporte Tier 3 - The standard library has little to no knowledge of the existence of this target. -- Because Zig is based on LLVM, it has the capability to build for these targets, and LLVM has the target enabled by default. -- These targets are not frequently tested; one will likely need to contribute to Zig in order to build for these targets. -- The Zig compiler might need to be updated with a few things such as - - what sizes are the C integer types - - C ABI calling convention for this target - - bootstrap code and default panic handler -- zig targets is guaranteed to include this target. +- Como Zig é baseado em LLVM, ele tem a capacidade de construir para esses alvos, e LLVM tem o alvo habilitado por padrão. +- Estes alvos não são testados com freqüência; provavelmente será necessário contribuir para o Zig a fim de compilar para estes alvos. +- O compilador Zig pode precisar ser atualizado com algumas coisas, tais como + - quais são os tamanhos dos tipos C inteiros + - C ABI convoca convenção para este alvo + - código bootstrap e manipulador de pânico padrão +- zig garante incluir este alvo. -#### Tier 4 Support +#### Suporte Tier 4 -- Support for these targets is entirely experimental. -- LLVM may have the target as an experimental target, which means that you need to use Zig-provided binaries for the target to be available, or build LLVM from source with special configure flags. zig targets will display the target if it is available. -- This target may be considered deprecated by an official party, such as [macosx/i386](https://support.apple.com/en-us/HT208436) in which case this target will remain forever stuck in Tier 4. -- This target may only support `--emit` asm and cannot emit object files. +- O apoio a esses objetivos é inteiramente experimental. +- LLVM pode ter o alvo como um alvo experimental, o que significa que você precisa usar binários fornecidos em Zig para que o alvo esteja disponível, ou construir LLVM a partir da fonte com bandeiras de configuração especiais. +- Esta alvo pode ser considerada depreciada por uma parte oficial, como por exemplo [macosx/i386](https://support.apple.com/en-us/HT208436), neste caso, esta meta permanecerá para sempre presa no Nível 4. +- Este alvo só pode suportar `--emit` asm e não pode emitir arquivos objeto. ## Colaboradores de pacotes O compilador Zig ainda não é completamente auto-hospedado, mas não importa o, [permanecerá exatamente 3 etapas](https://github.com/ziglang/zig/issues/853) para deixar de usar um compilador C++ no sistema para ter um compilador Zig totalmente auto-hospedado para qualquer alvo. Como observa Maya Rashish, [portando o Zig para outras plataformas é divertido e rápido](http://coypu.sdf.org/porting-zig.html). -Os [modos de contrução](https://ziglang.org/documentation/master/#Build-Mode) sem depuração (non-debug) são reprodutíveis/determináveis. +Os [modos de compilação](https://ziglang.org/documentation/master/#Build-Mode) sem depuração (non-debug) são reprodutíveis/determináveis. -Há um [JSON version of the download page](https://ziglang.org/download/index.json). +Há um [Versão JSON da página de download](https://ziglang.org/download/index.json). Vários membros da equipe Zig têm experiência na manutenção de pacotes. diff --git a/content/learn/why_zig_rust_d_cpp.pt.md b/content/learn/why_zig_rust_d_cpp.pt.md index 9b4021b91..4b0d2a9ce 100644 --- a/content/learn/why_zig_rust_d_cpp.pt.md +++ b/content/learn/why_zig_rust_d_cpp.pt.md @@ -52,15 +52,15 @@ Um dos santo graal da programação é a reutilização de código. Infelizmente * Se uma linguagem torna muito fácil ignorar erros e, portanto, verificar se uma biblioteca trata corretamente e gera bolhas de erros, pode ser tentador ignorar a biblioteca e implementá-la novamente, sabendo que todos os erros relevantes foram tratados corretamente. O Zig é projetado de forma que a coisa mais preguiçosa que um programador pode fazer é lidar com os erros corretamente e, portanto, pode-se estar razoavelmente confiante de que uma biblioteca irá propagar erros. * Atualmente, é pragmaticamente verdade que C é a linguagem mais versátil e portátil. Qualquer linguagem que não tenha a capacidade de interagir com o código C corre o risco de ser obscurecida. O Zig está tentando se tornar a nova linguagem portátil para bibliotecas, tornando-o simultaneamente direto para a conformidade com a C ABI para funções externas e introduzindo segurança e design de linguagem que evita bugs comuns nas implementações. -## Um Gerenciador de Pacotes e um Sistema de Construção para projetos existentes +## Um Gerenciador de Pacotes e um Sistema de Compilação para projetos existentes -Zig é uma linguagem de programação, mas também é enviada com um sistema de construção e um gerenciador de pacotes que se destinam a ser úteis mesmo no contexto de um projeto C/C++ tradicional. +Zig é uma linguagem de programação, mas também é enviada com um sistema de compilação e um gerenciador de pacotes que se destinam a ser úteis mesmo no contexto de um projeto C/C++ tradicional. -Você não só pode escrever o código Zig em vez do código C ou C++, mas também pode usar Zig como um substituto para ferramentas automáticas, fazer, fazer, scons, ninja, etc. E além disso, ele (irá) fornecer um gerenciador de pacotes para dependências nativas. Este sistema de construção é destinado a ser apropriado mesmo que a base de código de um projeto esteja totalmente em C ou C++. +Você não só pode escrever o código Zig em vez do código C ou C++, mas também pode usar Zig como um substituto para ferramentas automáticas, fazer, fazer, scons, ninja, etc. E além disso, ele (irá) fornecer um gerenciador de pacotes para dependências nativas. Este sistema de compilação é destinado a ser apropriado mesmo que a base de código de um projeto esteja totalmente em C ou C++. Gerentes de pacotes de sistema como apt-get, pacman, homebrew, e outros são fundamentais para a experiência do usuário final, mas eles podem ser insuficientes para as necessidades dos desenvolvedores. Um gerenciador de pacotes de idioma específico pode ser a diferença entre não ter contribuidores e ter dezenas. Para projetos de código aberto, a dificuldade de conseguir que o projeto seja construído é um enorme obstáculo para os potenciais contribuintes. Para projetos C/C++, ter dependências pode ser fatal, especialmente no Windows, onde não há um gerenciador de pacotes. Mesmo quando se trata apenas de construir o Zig, a maioria dos colaboradores em potencial tem dificuldades com a dependência da LLVM. O Zig está (estará) oferecendo uma forma de os projetos dependerem diretamente de bibliotecas nativas - sem depender do gerenciador de pacotes do sistema dos usuários para ter a versão correta disponível, e de uma forma que é praticamente garantida para construir projetos com sucesso na primeira tentativa, independentemente do sistema que está sendo usado e independente da plataforma que está sendo visada. -Zig está oferecendo a substituição do sistema de construção de um projeto por uma linguagem razoável usando uma API declarativa para a construção de projetos, que também fornece o gerenciamento de pacotes e, portanto, a capacidade de realmente depender de outras bibliotecas C. A capacidade de ter dependências permite abstrações de maior nível e, portanto, a proliferação de códigos reutilizáveis de alto nível. +Zig está oferecendo a substituição do sistema de compilação de um projeto por uma linguagem razoável usando uma API declarativa para a compilação de projetos, que também fornece o gerenciamento de pacotes e, portanto, a capacidade de realmente depender de outras bibliotecas C. A capacidade de ter dependências permite abstrações de maior nível e, portanto, a proliferação de códigos reutilizáveis de alto nível. ## Simplicidade @@ -83,5 +83,5 @@ Zig pode ser baixado na seção [Baixar](/downloads/). Zig fornece arquivos bin * utiliza a infra-estrutura madura e bem suportada da LLVM que permite uma profunda otimização e suporte para a maioria das principais plataformas * out of the box cross-compilation to most major platforms * vincula código fonte com libc que será compilado dinamicamente quando necessário para qualquer plataforma suportada -* inclui sistema de construção com caching +* inclui sistema de compilação com caching * compila o código C com o suporte da libc From f6c94c5d08fb8e68ed4df076cff58fd44d80e435 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20Catarino=20Fran=C3=A7a?= Date: Wed, 13 Jan 2021 16:22:05 -0300 Subject: [PATCH 13/25] tier-3 missing --- content/learn/overview.pt.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/content/learn/overview.pt.md b/content/learn/overview.pt.md index af892f34b..5593dac34 100644 --- a/content/learn/overview.pt.md +++ b/content/learn/overview.pt.md @@ -410,7 +410,7 @@ hello: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), dynamically lin Em alguns aspectos, Zig é um compilador C melhor do que os próprios compiladores C! -Esta funcionalidade é mais do que o agrupamento de um conjunto de ferramentas de compilação cruzada junto ao Zig. Por exemplo, o tamanho total dos cabeçalhos da libc que o Zig envia é de 22 MiB sem compressão. Enquanto isso, os cabeçalhos para musl libc + linux em x86_64 são 8 MiB, e para glibc são 3,1 MiB (falta no glibc os cabeçalhos linux), ainda assim Zig atualmente envia com 40 libcs. Com um agrupamento ingênuo que seria de 444 MiB. No entanto, graças a isto, a [ferramenta process_headers](https://github.com/ziglang/zig/blob/0.4.0/libc/process_headers.zig) que eu fiz, e algum [bom e velho trabalho manual](https://github.com/ziglang/zig/wiki/Updating-libc), Os tarballs binários Zig permanecem em torno de 30 MiB no total, apesar de apoiar a libc para todos esses alvos, bem como a compiler-rt, libunwind e libcxx, e apesar de ser um compilador C compatível com o clang. Para comparação, a compilação do binária no próprio Windows usando clang 8.0.0 do llvm.org é de 132 MiB. +Esta funcionalidade é mais do que o agrupamento de um conjunto de ferramentas de compilação cruzada junto ao Zig. Por exemplo, o tamanho total dos cabeçalhos da libc que o Zig envia é de 22 MiB sem compressão. Enquanto isso, os cabeçalhos para musl libc + linux em x86_64 são 8 MiB, e para glibc são 3,1 MiB (falta no glibc os cabeçalhos linux), ainda assim Zig atualmente envia com 40 libcs. Com um agrupamento ingênuo que seria de 444 MiB. No entanto, graças a isto, a [ferramenta process_headers](https://github.com/ziglang/zig/blob/0.4.0/libc/process_headers.zig) que eu fiz, e algum [bom e velho trabalho manual](https://github.com/ziglang/zig/wiki/Updating-libc), Os tarballs binários Zig permanecem em torno de 30 MiB no total, apesar de apoiar a libc para todos esses alvos, bem como a compiler-rt, libunwind e libcxx, e apesar de ser um compilador C compatível com o clang. Para comparação, a compilação do binário no próprio Windows usando clang 8.0.0 do llvm.org é de 132 MiB. Note que apenas no [Suporte Tier 1](https://ziglang.org/#Tier-1-Support) os alvos foram exaustivamente testados. Está previsto [acrescentar mais libcs](https://github.com/ziglang/zig/issues/514) (inclusive para o Windows), e para [adicionar cobertura de testes para compilação em relação a todas as libcs](https://github.com/ziglang/zig/issues/2058). @@ -558,7 +558,7 @@ Zig utiliza um sistema de "tiers" para comunicar o nível de suporte para difere #### Suporte Tier 3 -- The standard library has little to no knowledge of the existence of this target. +- A biblioteca padrão tem pouco ou nenhum conhecimento da existência deste alvo. - Como Zig é baseado em LLVM, ele tem a capacidade de construir para esses alvos, e LLVM tem o alvo habilitado por padrão. - Estes alvos não são testados com freqüência; provavelmente será necessário contribuir para o Zig a fim de compilar para estes alvos. - O compilador Zig pode precisar ser atualizado com algumas coisas, tais como From e5f62474ce099699e73b71242896d8e9a202530c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20Catarino=20Fran=C3=A7a?= Date: Thu, 14 Jan 2021 11:24:35 -0300 Subject: [PATCH 14/25] Corrections requested --- content/_index.pt.md | 6 +++--- content/learn/_index.pt.md | 6 +++--- content/learn/getting-started.pt.md | 8 +++---- content/learn/overview.pt.md | 2 +- content/learn/samples.pt.md | 33 +++++++++++++++++++++++++++++ 5 files changed, 44 insertions(+), 11 deletions(-) create mode 100644 content/learn/samples.pt.md diff --git a/content/_index.pt.md b/content/_index.pt.md index 1dd413717..725ee6312 100644 --- a/content/_index.pt.md +++ b/content/_index.pt.md @@ -3,7 +3,7 @@ title: Home mobile_menu_title: "Home" --- {{< slogan get_started="COMECE AGORA" docs="Documentação" notes="Mudanças">}} -Zig é uma linguagem de programação de propósito geral e um conjunto de ferramentas para manter o seu software **robusto**, **otimizado**, e **usável***. +Zig é uma linguagem de programação de propósito geral e um conjunto de ferramentas para manter o seu software **robusto**, **otimizado**, e **usável**. {{< /slogan >}} {{< flexrow class="container" style="padding: 20px 0; justify-content: space-between;" >}} @@ -33,12 +33,12 @@ Escreva um código rápido e claro, capaz de lidar com todas as condições de e {{% flexrow style="justify-content:center;" %}} {{% div %}}

- Visão geral em profundidade + }}" class="button" style="display: inline;">Visão Geral

{{% /div %}} {{% div style="margin-left: 5px;" %}}

- Mais exemplos de código + }}" class="button" style="display: inline;">Mais exemplos de código

{{% /div %}} {{% /flexrow %}} diff --git a/content/learn/_index.pt.md b/content/learn/_index.pt.md index e6a3befbb..133fdc8c5 100644 --- a/content/learn/_index.pt.md +++ b/content/learn/_index.pt.md @@ -12,7 +12,7 @@ Esta seção lista recursos úteis para ir desde não saber nada sobre Zig até ## Introdução Todas estas páginas são introduções ao Zig destinadas a programadores com diferentes formações. -- [Visão geral em profundidade](overview/) +- [Visão Geral](overview/) Aqui está uma visão aprofundada do Zig do ponto de vista da programação de sistemas. - [Por que Zig quando já existe C++, D, e Rust?](why_zig_rust_d_cpp/) Uma introdução a Zig para programadores de C++, D, e Rust. @@ -28,14 +28,14 @@ Se você estiver pronto para começar a programar em Zig, este guia o ajudará a - [Comece Agora]({{< ref "getting-started.md" >}}) ## Recursos de aprendizado online -- [Aprenda Zig](https://ziglearn.org) +- [Zig Learn](https://ziglearn.org) Uma introdução estruturada ao Zig, por [Sobeston](https://github.com/sobeston). ## Vídeos e posts relevantes no blog - [Zig a caminho do 1.0 (inglês)](https://www.youtube.com/watch?v=Gv2I7qTux7g) [video] Vídeo de [Andrew Kelley](https://andrewkelley.me) apresentando Zig e sua filosofia. - [Nova relação de Zig com a LLVM (inglês)](https://kristoff.it/blog/zig-new-relationship-llvm/) -Um post no blog sobre o trabalho para a construção do compilador auto-hospedado Zig, também apresentado em [um artigo no lwn.net (inglês)](https://lwn.net/Articles/833400/). +Um post no blog sobre o trabalho para a compilação do compilador auto-hospedado Zig, também apresentado em [um artigo no lwn.net (inglês)](https://lwn.net/Articles/833400/). diff --git a/content/learn/getting-started.pt.md b/content/learn/getting-started.pt.md index 6652239be..963837ca1 100644 --- a/content/learn/getting-started.pt.md +++ b/content/learn/getting-started.pt.md @@ -1,6 +1,6 @@ --- -title: Getting Started -mobile_menu_title: "Getting Started" +title: Começando +mobile_menu_title: "Começando" toc: true --- @@ -8,7 +8,7 @@ toc: true **
Nota para usuários do Apple Silicon
** Zig tem suporte experimental para a assinatura de códigos. Você poderá usar Zig com seu M1 Mac, mas a única maneira de conseguir Zig para macOS em ARM64 é compilá-lo você mesmo. -Certifique-se de verificar a seção [Compilando da Fonte](#building-from-source). +Certifique-se de verificar a seção [Compilando da Fonte](#compilando-da-fonte). {{% /div %}} @@ -80,7 +80,7 @@ NOTA: Homebrew ainda não possui os pacotes para Apple Silicon. Se você tem um brew install zig ``` -Última construção do *master branch* de Git: +Última compilação do *master branch* de Git: ``` brew install zig --HEAD ``` diff --git a/content/learn/overview.pt.md b/content/learn/overview.pt.md index 5593dac34..e6ee75ca8 100644 --- a/content/learn/overview.pt.md +++ b/content/learn/overview.pt.md @@ -1,5 +1,5 @@ --- -title: "Visão Geral em Profundidade" +title: "Visão Geral" mobile_menu_title: "Visão Geral" toc: true --- diff --git a/content/learn/samples.pt.md b/content/learn/samples.pt.md new file mode 100644 index 000000000..016abd7c7 --- /dev/null +++ b/content/learn/samples.pt.md @@ -0,0 +1,33 @@ +--- +title: "Examplos de Código" +mobile_menu_title: "Examplos de Código" +toc: true +--- + +## Detecção de vazamento de memória +Utilizando `std.GeneralPurposeAllocator` você pode detectar liberação dupla e vazamentos de memória. + +{{< zigdoctest "assets/zig-code/samples/1-memory-leak.zig" >}} + + +## Interoperabilidade com C +Exemplo de importação de um arquivo de cabeçalho C e vinculação tanto à libc como à raylib. + +{{< zigdoctest "assets/zig-code/samples/2-c-interop.zig" >}} + + +## Zigg Zagg +Zig é *optimizado* para codificar declarações (não exatamente!!). + +{{< zigdoctest "assets/zig-code/samples/3-ziggzagg.zig" >}} + + +## Tipos Genéricos +Os tipos em Zig são valores comptime e usamos funções que retornam um tipo para implementar algoritmos genéricos e estruturas de dados. Neste exemplo, implementamos uma fila (qeue) genérica simples e testamos seu comportamento. + +{{< zigdoctest "assets/zig-code/samples/4-generic-type.zig" >}} + + +## Utilizando o código do cURL (escrito em C) em Zig + +{{< zigdoctest "assets/zig-code/samples/5-curl.zig" >}} From 2a60e812e1648d2958dd829c4c5501aa9b3460dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20Catarino=20Fran=C3=A7a?= Date: Thu, 14 Jan 2021 11:27:37 -0300 Subject: [PATCH 15/25] zsf-index_pt fixed --- content/learn/getting-started.pt.md | 4 ++-- content/zsf/index.pt.md | 6 +++--- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/content/learn/getting-started.pt.md b/content/learn/getting-started.pt.md index 963837ca1..41d115231 100644 --- a/content/learn/getting-started.pt.md +++ b/content/learn/getting-started.pt.md @@ -24,7 +24,7 @@ A boa notícia é que é muito fácil mudar de uma versão Zig para outra, ou me ## Instalando Zig ### Baixar diretamente -Esta é a maneira mais direta de obter o Zig: pegue um pacote Zig para sua plataforma a partir da página [Downloads](/download), +Esta é a maneira mais direta de obter o Zig: pegue um pacote Zig para sua plataforma a partir da página [Baixar](../../download), extrair em um diretório qualquer e adicioná-lo ao seu `PATH` para poder utilizar o executável `zig` de qualquer lugar. #### Configurando PATH no Windows @@ -138,4 +138,4 @@ Zig é um projeto jovem e infelizmente ainda não temos a capacidade de produzir para obter ajuda quando você ficar confuso, bem como para verificar iniciativas como [Zig SHOWTIME](https://zig.show). Finalmente, se você gosta de Zig e quer ajudar a acelerar o desenvolvimento, [considere fazer uma doação para a Zig Software Foundation](../../zsf) -. +. diff --git a/content/zsf/index.pt.md b/content/zsf/index.pt.md index eaed43820..fdd5ad754 100644 --- a/content/zsf/index.pt.md +++ b/content/zsf/index.pt.md @@ -58,9 +58,9 @@ As seguintes empresas estão fornecendo apoio financeiro direto à Zig Software As seguintes empresas estão oferecendo alguns de seus serviços para a Zig Software Foundation gratuitamente. {{% sponsor-logos "services" %}} -![](../lavatech.png) -![](../dropbox.png) -![](../aws.png) +![](/lavatech.png) +![](/dropbox.png) +![](/aws.png) {{% /sponsor-logos %}} From 569436684613a6061a8e620bafc0837eade83cd4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20Catarino=20Fran=C3=A7a?= Date: Thu, 14 Jan 2021 12:26:46 -0300 Subject: [PATCH 16/25] Implicit translation - target --- content/_index.pt.md | 2 +- content/learn/overview.pt.md | 68 ++++++++++++++++++------------------ 2 files changed, 35 insertions(+), 35 deletions(-) diff --git a/content/_index.pt.md b/content/_index.pt.md index 725ee6312..18d130f9c 100644 --- a/content/_index.pt.md +++ b/content/_index.pt.md @@ -21,7 +21,7 @@ Uma nova abordagem de metaprogramação baseada na execução do código em temp - Chame qualquer função em tempo de compilação. - Manipular tipos como valores sem sobrecarga de tempo de execução. -- O Comptime emula a arquitetura alvo. +- O Comptime emula a arquitetura de saida. # ⚡ Desempenho que se enquadra na segurança Escreva um código rápido e claro, capaz de lidar com todas as condições de erro. diff --git a/content/learn/overview.pt.md b/content/learn/overview.pt.md index e6ee75ca8..f2c3cea65 100644 --- a/content/learn/overview.pt.md +++ b/content/learn/overview.pt.md @@ -44,7 +44,7 @@ Aqui está o que parece em tempo de execução, em construções verificadas em {{< zigdoctest "assets/zig-code/features/2-integer-overflow-runtime.zig" >}} -Esses [rastreamentos de pilhas funcionam em todos os alvos](https://ziglang.org/#Stack-traces-on-all-targets), incluindo [freestanding](https://andrewkelley.me/post/zig-stack-traces-kernel-panic-bare-bones-os.html). +Esses [rastreamentos de pilhas funcionam em todos os dispositivos](https://ziglang.org/#Stack-traces-on-all-targets), incluindo [freestanding](https://andrewkelley.me/post/zig-stack-traces-kernel-panic-bare-bones-os.html). Com Zig pode-se confiar em um modo de compilação `safe-enabled`, e desativar seletivamente a segurança nos gargalos de desempenho. Por exemplo, o exemplo anterior poderia ser modificado desta forma: @@ -56,7 +56,7 @@ Por falar em desempenho, Zig é mais rápido que C. - A implementação de referência utiliza LLVM como um backend para as otimizações de ponta. - O que outros projetos chamam de "Link Time Optimization" e Zig faz automaticamente. -- Para alvos nativos, recursos avançados de CPU são habilitados (-march=native), graças ao fato da [compilação cruzada ser um caso de uso de primeira classe](https://ziglang.org/#Cross-compiling-is-a-first-class-use-case). +- Compila de forma nativa para qualquer dispositivo, utilizando recursos avançados da CPU que são habilitados (-march=native), graças ao fato da [compilação cruzada ser um caso de uso de primeira classe](https://ziglang.org/#Cross-compiling-is-a-first-class-use-case). - Comportamento cuidadosamente escolhido e indefinido. Por exemplo, em Zig, tanto os inteiros assinados como os não assinados têm um comportamento indefinido no transbordamento, ao contrário de apenas os inteiros assinados em C. Isto [facilita as otimizações que não estão disponíveis em C](https://godbolt.org/z/n_nLEU). - Zig expõe diretamente a [vetores tipo SIMD](https://ziglang.org/documentation/master/#Vectors), facilitando a escrita de código vetorizado portátil. @@ -71,7 +71,7 @@ A biblioteca padrão do Zig se integra com a libc, mas não depende dela. Aqui e {{< zigdoctest "assets/zig-code/features/4-hello.zig" >}} -Quando compilado com `-O ReleaseSmall`, símbolos de depuração são removidos (stripped), modo de thread única, isto produz um executável estático de 9,8 KiB para o alvo x86_64-linux: +Quando compilado com `-O ReleaseSmall`, símbolos de depuração são removidos (stripped), modo de thread única, isto produz um executável estático de 9,8 KiB para a plataforma x86_64-linux: ``` $ zig build-exe hello.zig --release-small --strip --single-threaded $ wc -c hello @@ -133,7 +133,7 @@ Uma biblioteca escrita em Zig é elegível para ser usada em qualquer lugar: Para conseguir isto, os programadores Zig devem gerenciar sua própria memória e devem lidar com falhas na alocação de memória. -Isto também é verdade para a Biblioteca Padrão Zig. Qualquer função que precise alocar memória aceita um parâmetro do alocador. Como resultado, a Biblioteca Padrão Zig pode ser usada até mesmo para o alvo freestanding. +Isto também é verdade para a Biblioteca Padrão Zig. Qualquer função que precise alocar memória aceita um parâmetro do alocador. Como resultado, a Biblioteca Padrão Zig pode ser usada até mesmo para o dispositivo freestanding. Além de [Uma nova tomada de controle de erros](https://ziglang.org/#A-fresh-take-on-error-handling), Zig fornece [defer](https://ziglang.org/documentation/master/#defer) e [errdefer](https://ziglang.org/documentation/master/#errdefer) para tornar a gestão de todos os recursos - não apenas a memória - simples e facilmente verificável. @@ -167,9 +167,9 @@ A palavra-chave [unreachable](https://ziglang.org/documentation/master/#unreacha Isto invoca um [comportamento indefinido](https://ziglang.org/#Performance-and-Safety-Choose-Two) nos modos de compilação inseguros, portanto, certifique-se de usá-lo somente quando o sucesso for garantido. -### Rastreamento de pilha em todos os alvos +### Rastreamento de pilha em todos os dispositivos -O rastreamento da pilha e [rastreamento do retorno de erros](https://ziglang.org/documentation/master/#Error-Return-Traces) mostram que nesta página funcionam todos os alvos da [Suporte Tier 1](https://ziglang.org/#Tier-1-Support) e alguns da [Suporte Tier 2](https://ziglang.org/#Tier-2-Support). [Até mesmo freestanding](https://andrewkelley.me/post/zig-stack-traces-kernel-panic-bare-bones-os.html)! +O rastreamento da pilha e [rastreamento do retorno de erros](https://ziglang.org/documentation/master/#Error-Return-Traces) mostram que nesta página funcionam todos os dispositivos da tabela [Suporte Tier 1](https://ziglang.org/#Tier-1-Support) e alguns da [Suporte Tier 2](https://ziglang.org/#Tier-2-Support). [Até mesmo freestanding](https://andrewkelley.me/post/zig-stack-traces-kernel-panic-bare-bones-os.html)! Além disso, a biblioteca padrão tem a capacidade de capturar um traço de pilha em qualquer ponto e depois despejá-la em erro padrão mais tarde: @@ -299,7 +299,7 @@ $ zig build test ## A compilação cruzada é um caso de uso de primeira classe -Zig pode compilar para qualquer um dos alvos a partir da [Tabela de Suporte](https://ziglang.org/#Support-Table) com [Suporte Tier 3](https://ziglang.org/#Tier-3-Support) ou melhor. Nenhum "conjunto de ferramentas cruzada" precisa ser instalada ou algo parecido. Aqui está um "Hello World" nativo: +Zig pode compilar para qualquer um dos dispositivos listados na [Tabela de Suporte](https://ziglang.org/#Support-Table) com [Suporte Tier 3](https://ziglang.org/#Tier-3-Support) ou melhor. Nenhum "conjunto de ferramentas cruzada" precisa ser instalada ou algo parecido. Aqui está um "Hello World" nativo: {{< zigdoctest "assets/zig-code/features/4-hello.zig" >}} @@ -316,11 +316,11 @@ $ file hello hello: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), statically linked, with debug_info, not stripped ``` -Isto funciona em qualquer [Tier 3](https://ziglang.org/#Tier-3-Support)+ alvos, para qualquer [Tier 3](https://ziglang.org/#Tier-3-Support)+ alvos. +Isto funciona em qualquer [Tier 3](https://ziglang.org/#Tier-3-Support)+ dispositivos, para qualquer [Tier 3](https://ziglang.org/#Tier-3-Support)+ plataformas. -### Zig embarca com libc +### Zig vinculado com libc -Você pode encontrar os alvos libc disponíveis com `zig targets`: +Você pode encontrar as plataformas disponíveis que suportam libc, através do comando `zig targets`: ``` ... "libc": [ @@ -373,7 +373,7 @@ Você pode encontrar os alvos libc disponíveis com `zig targets`: ], ``` -O que isto significa é que `--library c` para estes alvos *não depende de nenhum arquivo do sistema*! +O que isto significa é que `--library c` para estas plataformas *não depende de nenhum arquivo do sistema*! Vejamos o [exemplo do hello world em C](https://ziglang.org/#Zig-is-also-a-C-compiler) novamente: ``` @@ -401,7 +401,7 @@ $ ldd hello Neste exemplo, Zig construiu musl libc a partir da fonte e depois ligou-se a ela. A compilação da musl libc para x86_64-linux continua disponível graças ao [sistema de caching](https://ziglang.org/download/0.4.0/release-notes.html#Build-Artifact-Caching), portanto, a qualquer momento esta libc é necessária novamente, ela estará disponível instantaneamente. -Isto significa que esta funcionalidade está disponível em qualquer plataforma. Os usuários de Windows e macOS podem criar códigos Zig e C, e vincular-se a libc, para qualquer um dos alvos listados acima. Da mesma forma, o código pode ser compilado de forma cruzada para outras arquiteturas: +Isto significa que esta funcionalidade está disponível em qualquer plataforma. Os usuários de Windows e macOS podem criar códigos Zig e C, e vincular-se a libc, para qualquer uma das plataformas listados acima. Da mesma forma, o código pode ser compilado de forma cruzada para outras arquiteturas: ``` $ zig build-exe --c-source hello.c --library c -target aarch64v8-linux-gnu $ file hello @@ -410,9 +410,9 @@ hello: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), dynamically lin Em alguns aspectos, Zig é um compilador C melhor do que os próprios compiladores C! -Esta funcionalidade é mais do que o agrupamento de um conjunto de ferramentas de compilação cruzada junto ao Zig. Por exemplo, o tamanho total dos cabeçalhos da libc que o Zig envia é de 22 MiB sem compressão. Enquanto isso, os cabeçalhos para musl libc + linux em x86_64 são 8 MiB, e para glibc são 3,1 MiB (falta no glibc os cabeçalhos linux), ainda assim Zig atualmente envia com 40 libcs. Com um agrupamento ingênuo que seria de 444 MiB. No entanto, graças a isto, a [ferramenta process_headers](https://github.com/ziglang/zig/blob/0.4.0/libc/process_headers.zig) que eu fiz, e algum [bom e velho trabalho manual](https://github.com/ziglang/zig/wiki/Updating-libc), Os tarballs binários Zig permanecem em torno de 30 MiB no total, apesar de apoiar a libc para todos esses alvos, bem como a compiler-rt, libunwind e libcxx, e apesar de ser um compilador C compatível com o clang. Para comparação, a compilação do binário no próprio Windows usando clang 8.0.0 do llvm.org é de 132 MiB. +Esta funcionalidade é mais do que o agrupamento de um conjunto de ferramentas de compilação cruzada junto ao Zig. Por exemplo, o tamanho total dos cabeçalhos da libc que o Zig envia é de 22 MiB sem compressão. Enquanto isso, os cabeçalhos para musl libc + linux em x86_64 são 8 MiB, e para glibc são 3,1 MiB (falta no glibc os cabeçalhos linux), ainda assim Zig atualmente envia com 40 libcs. Com um agrupamento ingênuo que seria de 444 MiB. No entanto, graças a isto, a [ferramenta process_headers](https://github.com/ziglang/zig/blob/0.4.0/libc/process_headers.zig) que eu fiz, e algum [bom e velho trabalho manual](https://github.com/ziglang/zig/wiki/Updating-libc), Os tarballs binários Zig permanecem em torno de 30 MiB no total, apesar de apoiar a libc para todos essas plataformas, bem como a compiler-rt, libunwind e libcxx, e apesar de ser um compilador C compatível com o clang. Para comparação, a compilação do binário no próprio Windows usando clang 8.0.0 do llvm.org é de 132 MiB. -Note que apenas no [Suporte Tier 1](https://ziglang.org/#Tier-1-Support) os alvos foram exaustivamente testados. Está previsto [acrescentar mais libcs](https://github.com/ziglang/zig/issues/514) (inclusive para o Windows), e para [adicionar cobertura de testes para compilação em relação a todas as libcs](https://github.com/ziglang/zig/issues/2058). +Note que apenas no [Suporte Tier 1](https://ziglang.org/#Tier-1-Support) os dispositivos foram exaustivamente testados. Está previsto [acrescentar mais libcs](https://github.com/ziglang/zig/issues/514) (inclusive para o Windows), e para [adicionar cobertura de testes para compilação em relação a todas as libcs](https://github.com/ziglang/zig/issues/2058). Já está sendo [planejado para ter um Gerenciador de Pacotes do Zig](https://github.com/ziglang/zig/issues/943), mas isso ainda não está pronto. Uma das coisas que será possível é criar um pacote para as bibliotecas C. Isto fará com que o [Sistema de Compilação do Zig](https://ziglang.org/#Zig-Build-System) tornando mais atraente tanto para programadores Zig como para programadores C. @@ -485,7 +485,7 @@ Aqui estão alguns exemplos de scripts de compilação: ## Concorrência via funções Async -Zig v0.5.0 [introduziu funções assíncronas](https://ziglang.org/download/0.5.0/release-notes.html#Async-Functions). Esta característica não depende de um sistema operacional host ou mesmo de uma memória alocada em pilha. Isso significa que funções assimétricas estão disponíveis para o alvo freestanding. +Zig v0.5.0 [introduziu funções assíncronas](https://ziglang.org/download/0.5.0/release-notes.html#Async-Functions). Esta característica não depende de um sistema operacional host ou mesmo de uma memória alocada em pilha. Isso significa que funções assimétricas estão disponíveis para os dispositivos freestanding. Zig infere se uma função é assimétrica, e permite `async`/`await` em funções não assíncronas, o que significa que **as bibliotecas Zig são agnósticos de bloqueio ao invés de E/S assíncrona**. [Zig evita as cores das funções (inglês)](http://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/). @@ -493,9 +493,9 @@ Zig infere se uma função é assimétrica, e permite `async`/`await` em funçõ A Biblioteca Padrão Zig implementa um loop de eventos que multiplexam as funções assimétricas em um pool de threads para concorrência M:N. A segurança multithreading e a detecção de corrida são áreas de pesquisa ativa. -## Ampla gama de alvos suportados +## Ampla gama de dispositivos suportados -Zig utiliza um sistema de "tiers" para comunicar o nível de suporte para diferentes alvos. Note que a barra para [Suporte Tier 1](https://ziglang.org/#Tier-1-Support) é maior - [Suporte Tier 2](https://ziglang.org/#Tier-2-Support) é ainda bastante útil. +Zig utiliza um sistema de "tiers" para comunicar o nível de suporte para diferentes dispositivos. Note que a barra para [Suporte Tier 1](https://ziglang.org/#Tier-1-Support) é maior - [Suporte Tier 2](https://ziglang.org/#Tier-2-Support) é ainda bastante útil. ### Tabela de Suporte @@ -545,38 +545,38 @@ Zig utiliza um sistema de "tiers" para comunicar o nível de suporte para difere ### Tier System #### Suporte Tier 1 -- O Zig não só pode gerar código de máquina para estes alvos, mas a biblioteca padrão de abstrações entre plataformas tem implementações para estes alvos. Assim, é prático escrever uma aplicação Zig pura, sem dependência da libc. -- O servidor CI testa automaticamente estes alvos em cada compromisso com o ramo mestre, e atualiza a página [Baixar](https://ziglang.org/download) com links para binários pré-construídos. -- Estes alvos têm capacidade de depuração e, portanto, produzem [rastreamento de pilha](https://ziglang.org/#Stack-traces-on-all-targets) sobre asserções fracassadas. -- [libc está disponível para este alvo, mesmo quando a compilação cruzada](https://ziglang.org/#Zig-ships-with-libc). -- Todos os testes de comportamento e testes de biblioteca padrão aplicáveis são aprovados para este alvo. Todas as características da linguagem são conhecidas por funcionarem corretamente. +- O Zig não só pode gerar código de máquina para estes dispositivos, mas a biblioteca padrão de abstrações entre plataformas tem implementações para estes dispositivos. Assim, é prático escrever uma aplicação Zig pura, sem dependência da libc. +- O servidor CI testa automaticamente estes dispositivos de saida em cada compromisso com o *master branch*, e atualiza a página [Baixar](https://ziglang.org/download) com links para binários pré-construídos. +- Estes dispositivos têm capacidade de depuração e, portanto, produzem [rastreamento de pilha](https://ziglang.org/#Stack-traces-on-all-targets) sobre asserções fracassadas. +- [libc está disponível para este dispositivo, mesmo quando a compilação cruzada](https://ziglang.org/#Zig-ships-with-libc). +- Todos os testes de comportamento e testes de biblioteca padrão aplicáveis são aprovados para esta plataforma. Todas as características da linguagem são conhecidas por funcionarem corretamente. #### Suporte Tier 2 -- A biblioteca padrão suporta este alvo, mas é possível que algumas APIs dêem um erro de compilação "Unsupported OS". Pode-se fazer uma vinculação com a libc ou outras bibliotecas para preencher as lacunas da biblioteca padrão. -- Estes alvos são conhecidos por funcionarem, mas podem não ser testados automaticamente, portanto, há regressões ocasionais. -- Alguns testes podem ser desativados para estes alvos enquanto trabalhamos para [Suporte Tier 1](https://ziglang.org/#Tier-1-Support). +- A biblioteca padrão suporta esta plataforma, mas é possível que algumas APIs dêem um erro de compilação "Unsupported OS". Pode-se fazer uma vinculação com a libc ou outras bibliotecas para preencher as lacunas da biblioteca padrão. +- Estes dispositivos são conhecidos por funcionarem, mas podem não ser testados automaticamente, portanto, há regressões ocasionais. +- Alguns testes podem ser desativados para estes dispositivos enquanto trabalhamos para [Suporte Tier 1](https://ziglang.org/#Tier-1-Support). #### Suporte Tier 3 -- A biblioteca padrão tem pouco ou nenhum conhecimento da existência deste alvo. -- Como Zig é baseado em LLVM, ele tem a capacidade de construir para esses alvos, e LLVM tem o alvo habilitado por padrão. -- Estes alvos não são testados com freqüência; provavelmente será necessário contribuir para o Zig a fim de compilar para estes alvos. +- A biblioteca padrão tem pouco ou nenhum conhecimento da existência desta palataforma. +- Como Zig é baseado em LLVM, ele tem a capacidade de construir para esses dispositivos, e LLVM tendo a plataforma habilitado por padrão. +- Estas plataformas não são testadas com freqüência; provavelmente será necessário contribuir para o Zig a fim de compilar para estes dispositivos. - O compilador Zig pode precisar ser atualizado com algumas coisas, tais como - quais são os tamanhos dos tipos C inteiros - - C ABI convoca convenção para este alvo + - C ABI convoca convenção para esta plataforma - código bootstrap e manipulador de pânico padrão -- zig garante incluir este alvo. +- zig garante incluir estas plataformas listadas. #### Suporte Tier 4 - O apoio a esses objetivos é inteiramente experimental. -- LLVM pode ter o alvo como um alvo experimental, o que significa que você precisa usar binários fornecidos em Zig para que o alvo esteja disponível, ou construir LLVM a partir da fonte com bandeiras de configuração especiais. -- Esta alvo pode ser considerada depreciada por uma parte oficial, como por exemplo [macosx/i386](https://support.apple.com/en-us/HT208436), neste caso, esta meta permanecerá para sempre presa no Nível 4. -- Este alvo só pode suportar `--emit` asm e não pode emitir arquivos objeto. +- LLVM pode ter a paltaforma como experimental, o que significa que você precisa usar binários fornecidos em Zig para que a paltaforma esteja disponível, ou construir LLVM a partir da fonte com bandeiras de configuração especiais. +- Esta plataforma pode ser considerada depreciada por uma parte oficial, como por exemplo [macosx/i386](https://support.apple.com/en-us/HT208436), neste caso, esta meta permanecerá para sempre presa no Nível 4. +- Esta plataforma só pode suportar `--emit` asm e não pode emitir arquivos objeto. ## Colaboradores de pacotes -O compilador Zig ainda não é completamente auto-hospedado, mas não importa o, [permanecerá exatamente 3 etapas](https://github.com/ziglang/zig/issues/853) para deixar de usar um compilador C++ no sistema para ter um compilador Zig totalmente auto-hospedado para qualquer alvo. Como observa Maya Rashish, [portando o Zig para outras plataformas é divertido e rápido](http://coypu.sdf.org/porting-zig.html). +O compilador Zig ainda não é completamente auto-hospedado, mas não importa o, [permanecerá exatamente 3 etapas](https://github.com/ziglang/zig/issues/853) para deixar de usar um compilador C++ no sistema para ter um compilador Zig totalmente auto-hospedado para qualquer plataforma. Como observa Maya Rashish, [portando o Zig para outras plataformas é divertido e rápido](http://coypu.sdf.org/porting-zig.html). Os [modos de compilação](https://ziglang.org/documentation/master/#Build-Mode) sem depuração (non-debug) são reprodutíveis/determináveis. From 0f637b37b10256eeefb0fe16872fab87ae095303 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20C=2E=20Fran=C3=A7a?= Date: Thu, 14 Jan 2021 15:09:43 -0300 Subject: [PATCH 17/25] Update content/zsf/index.pt.md Co-authored-by: Loris Cro --- content/zsf/index.pt.md | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/content/zsf/index.pt.md b/content/zsf/index.pt.md index fdd5ad754..80151d516 100644 --- a/content/zsf/index.pt.md +++ b/content/zsf/index.pt.md @@ -48,8 +48,8 @@ As seguintes empresas estão fornecendo apoio financeiro direto à Zig Software {{% sponsor-logos "monetary" %}} - - + + {{% /sponsor-logos %}} @@ -76,4 +76,3 @@ As seguintes empresas estão oferecendo alguns de seus serviços para a Zig Soft - From 6e9e789980bd1133c0d12f18419296abb5515e64 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20C=2E=20Fran=C3=A7a?= Date: Thu, 14 Jan 2021 15:14:49 -0300 Subject: [PATCH 18/25] Update content/_index.pt.md Co-authored-by: Loris Cro --- content/_index.pt.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/content/_index.pt.md b/content/_index.pt.md index 18d130f9c..cb68588f3 100644 --- a/content/_index.pt.md +++ b/content/_index.pt.md @@ -2,7 +2,7 @@ title: Home mobile_menu_title: "Home" --- -{{< slogan get_started="COMECE AGORA" docs="Documentação" notes="Mudanças">}} +{{< slogan get_started="COMECE AGORA" docs="Documentação" notes="Mudanças" lang="pt">}} Zig é uma linguagem de programação de propósito geral e um conjunto de ferramentas para manter o seu software **robusto**, **otimizado**, e **usável**. {{< /slogan >}} @@ -150,6 +150,5 @@ Esta seção é atualizada no início de cada mês. - From 698036d57f96417b08e568d8c339107db8973f68 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20C=2E=20Fran=C3=A7a?= Date: Thu, 14 Jan 2021 15:15:08 -0300 Subject: [PATCH 19/25] Update content/_index.pt.md Co-authored-by: Loris Cro --- content/_index.pt.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/content/_index.pt.md b/content/_index.pt.md index cb68588f3..2cdaf3fed 100644 --- a/content/_index.pt.md +++ b/content/_index.pt.md @@ -33,7 +33,7 @@ Escreva um código rápido e claro, capaz de lidar com todas as condições de e {{% flexrow style="justify-content:center;" %}} {{% div %}}

- }}" class="button" style="display: inline;">Visão Geral + }}" class="button" style="display: inline;">Visão Geral

{{% /div %}} {{% div style="margin-left: 5px;" %}} @@ -149,6 +149,5 @@ Esta seção é atualizada no início de cada mês. - From 2b06fc612fc8de9bee833578cd8251072c35ae97 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20C=2E=20Fran=C3=A7a?= Date: Thu, 14 Jan 2021 15:15:17 -0300 Subject: [PATCH 20/25] Update content/_index.pt.md Co-authored-by: Loris Cro --- content/_index.pt.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/content/_index.pt.md b/content/_index.pt.md index 2cdaf3fed..6a7e01cb1 100644 --- a/content/_index.pt.md +++ b/content/_index.pt.md @@ -38,7 +38,7 @@ Escreva um código rápido e claro, capaz de lidar com todas as condições de e {{% /div %}} {{% div style="margin-left: 5px;" %}}

- }}" class="button" style="display: inline;">Mais exemplos de código + }}" class="button" style="display: inline;">Mais exemplos de código

{{% /div %}} {{% /flexrow %}} @@ -148,6 +148,5 @@ Esta seção é atualizada no início de cada mês. - From 2bb3627874a72ecbc45f72eb720729045ec1eaaf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20C=2E=20Fran=C3=A7a?= Date: Thu, 14 Jan 2021 15:15:51 -0300 Subject: [PATCH 21/25] Update content/learn/overview.pt.md Co-authored-by: Loris Cro --- content/learn/overview.pt.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/learn/overview.pt.md b/content/learn/overview.pt.md index f2c3cea65..26a28985f 100644 --- a/content/learn/overview.pt.md +++ b/content/learn/overview.pt.md @@ -545,7 +545,7 @@ Zig utiliza um sistema de "tiers" para comunicar o nível de suporte para difere ### Tier System #### Suporte Tier 1 -- O Zig não só pode gerar código de máquina para estes dispositivos, mas a biblioteca padrão de abstrações entre plataformas tem implementações para estes dispositivos. Assim, é prático escrever uma aplicação Zig pura, sem dependência da libc. +- O Zig não só pode gerar código de máquina para estes dispositivos, mas a biblioteca padrão de abstrações entre plataformas tem implementações para estes dispositivos. - O servidor CI testa automaticamente estes dispositivos de saida em cada compromisso com o *master branch*, e atualiza a página [Baixar](https://ziglang.org/download) com links para binários pré-construídos. - Estes dispositivos têm capacidade de depuração e, portanto, produzem [rastreamento de pilha](https://ziglang.org/#Stack-traces-on-all-targets) sobre asserções fracassadas. - [libc está disponível para este dispositivo, mesmo quando a compilação cruzada](https://ziglang.org/#Zig-ships-with-libc). From 38af1a3b6598a490b2c4d80ee1916b180efa4c1d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20Catarino=20Fran=C3=A7a?= Date: Fri, 15 Jan 2021 10:15:22 -0300 Subject: [PATCH 22/25] i18n-pt - updated --- themes/ziglang-original/i18n/pt.toml | 47 ++++++++++++++++++---------- 1 file changed, 30 insertions(+), 17 deletions(-) diff --git a/themes/ziglang-original/i18n/pt.toml b/themes/ziglang-original/i18n/pt.toml index b078b7489..18eefbed8 100644 --- a/themes/ziglang-original/i18n/pt.toml +++ b/themes/ziglang-original/i18n/pt.toml @@ -1,37 +1,50 @@ +[slogan-latest-release] +other = "Último Lançamento:   {{ . }}" -[menu-source] -other = "Código Fonte" -[menu-community] -other = "Junte-se a Comunidade" +[back-to-home] +other = "← Voltar a página Inicial" [back-to-parent] -other = "← Volte para seção {{ . }}" +other = "← Voltar a seção {{ . }}" -[back-to-home] -other = "← Volte para página Home" +[menu-community] +other = "Junte-se à Comunidade" -[download-filename] -other = "Nome do Arquivo" +[menu-source] +other = "Código Fonte" -[download-kind] -other = "Gênero" -[download-size] -other = "Tamanho" +[downloads-heading] +other = "Lançamentos" -[download-source] -other = "Fonte" +[downloads-install-from-pkg-manager] +other = "Você também poderá instalar Zig utilizando algum gerenciador de pacote." + +[downloads-json] +other = "Aqui possui um arquivo JSON desta página." [download-binary] other = "Binário" [download-documentation] -other = "Documentação da Linguagem" +other = "Documentação de Referência" + +[download-filename] +other = "Nome do arquivo" + +[download-kind] +other = "Formato" [download-release-notes] -other = "Notas de Mudanças" +other = "Notas de Lançamento" + +[download-size] +other = "Tamanho" + +[download-source] +other = "Fonte" [download-stdlib-docs] other = "Documentação da Biblioteca Padrão (experimental)" From df3c49779131522e8cac4911b02c12ffd05cdea3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20Catarino=20Fran=C3=A7a?= Date: Fri, 15 Jan 2021 10:18:18 -0300 Subject: [PATCH 23/25] i18n-pt - JSON file linked --- themes/ziglang-original/i18n/pt.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/themes/ziglang-original/i18n/pt.toml b/themes/ziglang-original/i18n/pt.toml index 18eefbed8..69ce7135c 100644 --- a/themes/ziglang-original/i18n/pt.toml +++ b/themes/ziglang-original/i18n/pt.toml @@ -23,7 +23,7 @@ other = "Lançamentos" other = "Você também poderá instalar Zig utilizando algum gerenciador de pacote." [downloads-json] -other = "Aqui possui um arquivo JSON desta página." +other = "Aqui possui um arquivo JSON desta página." [download-binary] other = "Binário" From c77dd761a3473483c86d3ea4d591f037ad17fe27 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20Catarino=20Fran=C3=A7a?= Date: Fri, 15 Jan 2021 10:35:25 -0300 Subject: [PATCH 24/25] homepage title translated & more fix --- content/_index.pt.md | 6 +++--- content/learn/why_zig_rust_d_cpp.pt.md | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/content/_index.pt.md b/content/_index.pt.md index 6a7e01cb1..c5b19a525 100644 --- a/content/_index.pt.md +++ b/content/_index.pt.md @@ -1,6 +1,6 @@ --- -title: Home -mobile_menu_title: "Home" +title: Página Inicial +mobile_menu_title: "Inicial" --- {{< slogan get_started="COMECE AGORA" docs="Documentação" notes="Mudanças" lang="pt">}} Zig é uma linguagem de programação de propósito geral e um conjunto de ferramentas para manter o seu software **robusto**, **otimizado**, e **usável**. @@ -88,7 +88,7 @@ Espera-se que os contribuidores sigam o Zig [Código de Conduta](https://github. {{% div class="container" style="display:flex;flex-direction:column;justify-content:center;text-align:center; padding: 20px 0;" title="Zig Software Foundation" %}} -## A ZSF é uma corporação sem fins lucrativos 501(c)(3). +## A ZSF é uma corporação 501(c)(3) sem fins lucrativos. A Zig Software Foundation é uma corporação sem fins lucrativos fundada em 2020 por Andrew Kelley, o criador do Zig, com o objetivo de apoiar o desenvolvimento da linguagem. Atualmente, a ZSF é capaz de oferecer trabalho remunerado a taxas competitivas para um pequeno número de colaboradores principais. Esperamos ser capazes de estender esta oferta a mais colaboradores centrais no futuro. diff --git a/content/learn/why_zig_rust_d_cpp.pt.md b/content/learn/why_zig_rust_d_cpp.pt.md index 4b0d2a9ce..fcf06d341 100644 --- a/content/learn/why_zig_rust_d_cpp.pt.md +++ b/content/learn/why_zig_rust_d_cpp.pt.md @@ -19,7 +19,7 @@ Exemplos de fluxo de controle oculto: - D tem funções `@property`, que são métodos que você chama com o que parece ser acesso de campo, então no exemplo acima, `c.d` poderia chamar uma função. - C++, D, e Rust têm sobrecarga do operador, portanto o operador `+` pode chamar uma função. -- C++, D, e Go têm exceções de `throw/catch`, portanto `foo()` pode lançar uma exceção, e impedir que `bar()` seja chamado. (Claro que, mesmo em Zig `foo()` poderia bloquear e impedir que `bar()` fosse chamado, mas isso pode acontecer em qualquer linguagem Completude-Turing). +- C++, D, e Go têm exceções de `throw/catch`, portanto `foo()` pode lançar uma exceção, e impedir que `bar()` seja chamado. (Claro que, mesmo em Zig `foo()` poderia bloquear e impedir que `bar()` fosse chamado, mas isso pode acontecer em qualquer linguagem que seja Turing-Completude). O objetivo desta decisão de projeto é melhorar a legibilidade. @@ -35,7 +35,7 @@ Como afirmado antes, este tópico ainda é um pouco confuso e se tornará mais c Nem é preciso dizer que não existe um coletor de lixo embutido como há na linguagem Go. -[O pânico emitido pela biblioteca padrão do Rust quando está Sem Memória (Out Of Memory)](https://github.com/rust-lang/rust/issues/29802) +[O erro [panic] emitido pela biblioteca padrão do Rust quando estiver sem Memória (Out Of Memory)](https://github.com/rust-lang/rust/issues/29802) [1]: Na verdade, existe um operador de concatenação de cordas (geralmente um operador de concatenação de matriz), mas ele só funciona em tempo de compilação, de modo que ainda não há alocação de pilha de tempo de execução com isso. From 29c2ecde48058bcf825ccf7b9d43b8168981687d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matheus=20Catarino=20Fran=C3=A7a?= Date: Fri, 15 Jan 2021 10:45:03 -0300 Subject: [PATCH 25/25] ZSF - Vocabulary terms fixed --- content/zsf/index.pt.md | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/content/zsf/index.pt.md b/content/zsf/index.pt.md index 80151d516..53fcfaad6 100644 --- a/content/zsf/index.pt.md +++ b/content/zsf/index.pt.md @@ -1,10 +1,10 @@ --- -title: "Patrocinadores da ZSF" -menu_title: "Patrocinadores da Zig Software Foundation" -mobile_menu_title: "Patrocinadores da ZSF" +title: "Patrocine à ZSF" +menu_title: "Patrocine à Zig Software Foundation" +mobile_menu_title: "Patrocine à ZSF" date: 2020-10-20T16:29:51+02:00 --- -{{< sponsor-title-cta "Patrocinadores da Zig Software Foundation" >}} +{{< sponsor-title-cta "Patrocine à Zig Software Foundation" >}} ## Missão A missão da Zig Software Foundation é promover, proteger e fazer avançar a linguagem de programação Zig, apoiar e facilitar o crescimento de uma comunidade diversificada e internacional de programadores Zig, e fornecer educação e orientação aos estudantes, ensinando a próxima geração de programadores a serem competentes, éticos e a manterem uns aos outros com padrões elevados. @@ -23,10 +23,10 @@ Ao fazer uma doação ao ZSF, você está financiando o desenvolvimento da lingu ZSF é uma pequena organização e faz uso eficiente de recursos monetários. O plano é mantê-la assim, mas queremos transformar nossos voluntários não remunerados em mantenedores remunerados para ajudar na fusão de pedidos e fazer progressos mais rápidos em direção ao 1.0. O objetivo do ZSF ser sem fins lucrativos é beneficiar as pessoas. Estamos tentando fazer com que os mantenedores de código aberto sejam pagos pelo seu tempo. -A maneira mais fácil de nos apoiar é doar através dos [Patrocinadores do GitHub](https://github.com/sponsors/ziglang). +A maneira mais fácil de nos apoiar é doar através dos [Patrocínios do GitHub](https://github.com/sponsors/ziglang). -## Informações das doaçoes -Aqui estão informações úteis para doar por outros meios que não os Patrocinadores do GitHub. +## Informações das doações +Aqui estão informações úteis para doar por outros meios que não os Patrocínios do GitHub. Certifique-se de verificar sua legislação local para ver se você pode deduzir doações de seus impostos. | **EIN** | **Endereço** | @@ -40,7 +40,7 @@ Certifique-se de verificar sua legislação local para ver se você pode deduzir **Por favor, não hesite em nos contatar em donations@ziglang.org se você tiver dúvidas ou necessidades específicas.** -## Patrocinadores corporativos +## Patrocínios corporativos ### Doações monetárias As seguintes empresas estão fornecendo apoio financeiro direto à Zig Software Foundation doando mais de US$ 1000/mês.