From 667174e0caf6fbbb67aa70c9b39060706e568ae6 Mon Sep 17 00:00:00 2001
From: agbohub <14964685+agbohub@users.noreply.github.com>
Date: Wed, 20 Apr 2022 18:12:47 +0800
Subject: =?UTF-8?q?Delete=20repeated=20word=20"one"=20in=20=C2=A7Intro?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 vimscript.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vimscript.html.markdown b/vimscript.html.markdown
index c2934af8..5bcaad45 100644
--- a/vimscript.html.markdown
+++ b/vimscript.html.markdown
@@ -11,7 +11,7 @@ contributors:
 " ##############
 "
 " Vim script (also called VimL) is the subset of Vim's ex-commands which
-" supplies a number of features one one would expect from a scripting language,
+" supplies a number of features one would expect from a scripting language,
 " such as values, variables, functions or loops. Always keep in the back of
 " your mind that a Vim script file is just a sequence of ex-commands. It is
 " very common for a script to mix programming-language features and raw
-- 
cgit v1.2.3


From 524969c42c82e58fe1acf5ebcd9afe67a51142ca Mon Sep 17 00:00:00 2001
From: EmilySeville7cfg <EmilySeville7cf@gmail.com>
Date: Fri, 19 Aug 2022 09:47:37 +1000
Subject: Update bash help: - use snake case - fix examples - add notes to
 expansions

---
 bash.html.markdown | 86 ++++++++++++++++++++++++++++--------------------------
 1 file changed, 44 insertions(+), 42 deletions(-)

diff --git a/bash.html.markdown b/bash.html.markdown
index c9a805ba..4ab800a4 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -18,6 +18,7 @@ contributors:
     - ["Harry Mumford-Turner", "https://github.com/harrymt"]
     - ["Martin Nicholson", "https://github.com/mn113"]
     - ["Mark Grimwood", "https://github.com/MarkGrimwood"]
+    - ["Emily Grace Seville", "https://github.com/EmilySeville7cfg"]
 filename: LearnBash.sh
 translators:
     - ["Dimitri Kokkonis", "https://github.com/kokkonisd"]
@@ -37,67 +38,68 @@ or executed directly in the shell.
 # As you already figured, comments start with #. Shebang is also a comment.
 
 # Simple hello world example:
-echo Hello world! # => Hello world!
+echo "Hello world!" # => Hello world!
 
 # Each command starts on a new line, or after a semicolon:
-echo 'This is the first line'; echo 'This is the second line'
-# => This is the first line
-# => This is the second line
+echo "This is the first command"; echo "This is the second command"
+# => This is the first command 
+# => This is the second command 
 
 # Declaring a variable looks like this:
-Variable="Some string"
+variable="Some string"
 
 # But not like this:
-Variable = "Some string" # => returns error "Variable: command not found"
-# Bash will decide that Variable is a command it must execute and give an error
+variable = "Some string" # => returns error "variable: command not found"
+# Bash will decide that `variable` is a command it must execute and give an error
 # because it can't be found.
 
 # Nor like this:
-Variable= 'Some string' # => returns error: "Some string: command not found"
-# Bash will decide that 'Some string' is a command it must execute and give an
-# error because it can't be found. (In this case the 'Variable=' part is seen
-# as a variable assignment valid only for the scope of the 'Some string'
-# command.)
+variable= "Some string" # => returns error: "Some string: command not found"
+# Bash will decide that "Some string" is a command it must execute and give an
+# error because it can't be found. In this case the "variable=" part is seen
+# as a variable assignment valid only for the scope of the "Some string"
+# command.
 
 # Using the variable:
-echo $Variable # => Some string
-echo "$Variable" # => Some string
-echo '$Variable' # => $Variable
+echo "$variable" # => Some string
+echo '$variable' # => $variable
 # When you use the variable itself — assign it, export it, or else — you write
 # its name without $. If you want to use the variable's value, you should use $.
 # Note that ' (single quote) won't expand the variables!
-
-# Parameter expansion ${ }:
-echo ${Variable} # => Some string
-# This is a simple usage of parameter expansion
-# Parameter Expansion gets a value from a variable.
-# It "expands" or prints the value
-# During the expansion time the value or parameter can be modified
-# Below are other modifications that add onto this expansion
-
-# String substitution in variables
-echo ${Variable/Some/A} # => A string
-# This will substitute the first occurrence of "Some" with "A"
-
-# Substring from a variable
-Length=7
-echo ${Variable:0:Length} # => Some st
+# You can write variable without surrounding quotes but it's not recommended.
+
+# Parameter expansion ${...}:
+echo "${variable}" # => Some string
+# This is a simple usage of parameter expansion such as two examples above.
+# Parameter expansion gets a value from a variable.
+# It "expands" or prints the value.
+# During the expansion time the value or parameter can be modified.
+# Below are other modifications that add onto this expansion.
+
+# String substitution in variables:
+echo "${variable/Some/A}" # => A string
+# This will substitute the first occurrence of "Some" with "A".
+
+# Substring from a variable:
+length=7
+echo "${variable:0:length}" # => Some st
 # This will return only the first 7 characters of the value
-echo ${Variable: -5} # => tring
-# This will return the last 5 characters (note the space before -5)
+echo "${variable: -5}" # => tring
+# This will return the last 5 characters (note the space before -5).
+# The space before minus is mandatory here.
 
-# String length
-echo ${#Variable} # => 11
+# String length:
+echo "${#variable}" # => 11
 
-# Indirect expansion
-OtherVariable="Variable"
-echo ${!OtherVariable} # => Some String
-# This will expand the value of OtherVariable
+# Indirect expansion:
+other_variable="variable"
+echo ${!other_variable} # => Some string
+# This will expand the value of `other_variable`.
 
-# Default value for variable
-echo ${Foo:-"DefaultValueIfFooIsMissingOrEmpty"}
+# Default value for variable:
+echo "${foo:-"DefaultValueIfFooIsMissingOrEmpty"}"
 # => DefaultValueIfFooIsMissingOrEmpty
-# This works for null (Foo=) and empty string (Foo=""); zero (Foo=0) returns 0.
+# This works for null (foo=) and empty string (foo=""); zero (foo=0) returns 0.
 # Note that it only returns default value and doesn't change variable value.
 
 # Declare an array with 6 elements
-- 
cgit v1.2.3


From ed1ca1c70e24dea4b92e7dcb3ac391de6988ca22 Mon Sep 17 00:00:00 2001
From: EmilySeville7cfg <EmilySeville7cf@gmail.com>
Date: Fri, 19 Aug 2022 09:53:55 +1000
Subject: Update bash help: - remove trailing spaces

---
 bash.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bash.html.markdown b/bash.html.markdown
index 4ab800a4..3f1e8b70 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -42,8 +42,8 @@ echo "Hello world!" # => Hello world!
 
 # Each command starts on a new line, or after a semicolon:
 echo "This is the first command"; echo "This is the second command"
-# => This is the first command 
-# => This is the second command 
+# => This is the first command
+# => This is the second command
 
 # Declaring a variable looks like this:
 variable="Some string"
-- 
cgit v1.2.3


From 242d5da837ff2458560431388b4848bae7e52e15 Mon Sep 17 00:00:00 2001
From: EmilySeville7cfg <EmilySeville7cf@gmail.com>
Date: Fri, 19 Aug 2022 10:10:34 +1000
Subject: Update bash help: - update examples of array manipulation - move
 built-in variables section one level up - add note in brace expansion

---
 bash.html.markdown | 50 ++++++++++++++++++++++++++------------------------
 1 file changed, 26 insertions(+), 24 deletions(-)

diff --git a/bash.html.markdown b/bash.html.markdown
index 3f1e8b70..53c3d96c 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -102,39 +102,41 @@ echo "${foo:-"DefaultValueIfFooIsMissingOrEmpty"}"
 # This works for null (foo=) and empty string (foo=""); zero (foo=0) returns 0.
 # Note that it only returns default value and doesn't change variable value.
 
-# Declare an array with 6 elements
-array0=(one two three four five six)
-# Print first element
-echo $array0 # => "one"
-# Print first element
-echo ${array0[0]} # => "one"
-# Print all elements
-echo ${array0[@]} # => "one two three four five six"
-# Print number of elements
-echo ${#array0[@]} # => "6"
-# Print number of characters in third element
-echo ${#array0[2]} # => "5"
-# Print 2 elements starting from fourth
-echo ${array0[@]:3:2} # => "four five"
-# Print all elements. Each of them on new line.
-for i in "${array0[@]}"; do
-    echo "$i"
+# Declare an array with 6 elements:
+array=(one two three four five six)
+# Print the first element:
+echo "${array[0]}" # => "one"
+# Print all elements:
+echo "${array[@]}" # => "one two three four five six"
+# Print the number of elements:
+echo "${#array[@]}" # => "6"
+# Print the number of characters in third element
+echo "${#array[2]}" # => "5"
+# Print 2 elements starting from fourth:
+echo "${array[@]:3:2}" # => "four five"
+# Print all elements each of them on new line.
+for item in "${array[@]}"; do
+    echo "$item"
 done
 
-# Brace Expansion { }
-# Used to generate arbitrary strings
-echo {1..10} # => 1 2 3 4 5 6 7 8 9 10
-echo {a..z} # => a b c d e f g h i j k l m n o p q r s t u v w x y z
-# This will output the range from the start value to the end value
-
 # Built-in variables:
-# There are some useful built-in variables, like
+# There are some useful built-in variables, like:
 echo "Last program's return value: $?"
 echo "Script's PID: $$"
 echo "Number of arguments passed to script: $#"
 echo "All arguments passed to script: $@"
 echo "Script's arguments separated into different variables: $1 $2..."
 
+# Brace Expansion {...}
+# used to generate arbitrary strings:
+echo {1..10} # => 1 2 3 4 5 6 7 8 9 10
+echo {a..z} # => a b c d e f g h i j k l m n o p q r s t u v w x y z
+# This will output the range from the start value to the end value.
+# Note that you can't use variables here:
+from=1
+to=10
+echo {$from..$to} # => {$from..$to}
+
 # Now that we know how to echo and use variables,
 # let's learn some of the other basics of bash!
 
-- 
cgit v1.2.3


From 7bcf933601fcdde118a2e745cb026b8c45910f51 Mon Sep 17 00:00:00 2001
From: EmilySeville7cfg <EmilySeville7cf@gmail.com>
Date: Fri, 19 Aug 2022 10:20:15 +1000
Subject: Update bash help: - small grammar enhancements

---
 bash.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/bash.html.markdown b/bash.html.markdown
index 53c3d96c..bccc5773 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -63,7 +63,7 @@ variable= "Some string" # => returns error: "Some string: command not found"
 # Using the variable:
 echo "$variable" # => Some string
 echo '$variable' # => $variable
-# When you use the variable itself — assign it, export it, or else — you write
+# When you use a variable itself — assign it, export it, or else — you write
 # its name without $. If you want to use the variable's value, you should use $.
 # Note that ' (single quote) won't expand the variables!
 # You can write variable without surrounding quotes but it's not recommended.
@@ -96,7 +96,7 @@ other_variable="variable"
 echo ${!other_variable} # => Some string
 # This will expand the value of `other_variable`.
 
-# Default value for variable:
+# The default value for variable:
 echo "${foo:-"DefaultValueIfFooIsMissingOrEmpty"}"
 # => DefaultValueIfFooIsMissingOrEmpty
 # This works for null (foo=) and empty string (foo=""); zero (foo=0) returns 0.
-- 
cgit v1.2.3


From 42040d6d7dbe4dc57c6ad21c02498b00fff4b596 Mon Sep 17 00:00:00 2001
From: EmilySeville7cfg <EmilySeville7cf@gmail.com>
Date: Fri, 19 Aug 2022 11:09:16 +1000
Subject: Update bash help: - refresh read command sample - fix if examples and
 && with ||

---
 bash.html.markdown | 70 ++++++++++++++++++++++++------------------------------
 1 file changed, 31 insertions(+), 39 deletions(-)

diff --git a/bash.html.markdown b/bash.html.markdown
index bccc5773..e0e4f88a 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -138,7 +138,7 @@ to=10
 echo {$from..$to} # => {$from..$to}
 
 # Now that we know how to echo and use variables,
-# let's learn some of the other basics of bash!
+# let's learn some of the other basics of Bash!
 
 # Our current directory is available through the command `pwd`.
 # `pwd` stands for "print working directory".
@@ -148,33 +148,46 @@ echo "I'm in $(pwd)" # execs `pwd` and interpolates output
 echo "I'm in $PWD" # interpolates the variable
 
 # If you get too much output in your terminal, or from a script, the command
-# `clear` clears your screen
+# `clear` clears your screen:
 clear
-# Ctrl-L also works for clearing output
+# Ctrl-L also works for clearing output.
 
 # Reading a value from input:
 echo "What's your name?"
-read Name # Note that we didn't need to declare a new variable
-echo Hello, $Name!
+read name
+# Note that we didn't need to declare a new variable.
+echo "Hello, $name!"
 
-# We have the usual if structure:
-# use `man test` for more info about conditionals
-if [ $Name != $USER ]
-then
+# We have the usual if structure.
+# Condition is true if the value of $name is not equal to the current user's login username:
+if [[ "$name" != "$USER" ]]; then
     echo "Your name isn't your username"
 else
     echo "Your name is your username"
 fi
-# True if the value of $Name is not equal to the current user's login username
 
-# NOTE: if $Name is empty, bash sees the above condition as:
-if [ != $USER ]
-# which is invalid syntax
-# so the "safe" way to use potentially empty variables in bash is:
-if [ "$Name" != $USER ] ...
-# which, when $Name is empty, is seen by bash as:
-if [ "" != $USER ] ...
-# which works as expected
+# To use && and || with if statements, you need multiple pairs of square brackets:
+read age
+if [[ "$name" == "Steve" ]] && [[ "$age" -eq 15 ]]; then
+    echo "This will run if $name is Steve AND $age is 15."
+fi
+
+if [[ "$name" == "Daniya" ]] || [[ "$name" == "Zach" ]]; then
+    echo "This will run if $name is Daniya OR Zach."
+fi
+# There are other comparison operators for numbers listed below:
+# -ne - not equal
+# -lt - less than
+# -gt - greater than
+# -le - less than or equal to
+# -ge - greater than or equal to
+
+# There is also the `=~` operator, which tests a string against the Regex pattern:
+email=me@example.com
+if [[ "$email" =~ [a-z]+@[a-z]{2,}\.(com|net|org) ]]
+then
+    echo "Valid email!"
+fi
 
 # There is also conditional execution
 echo "Always executed" || echo "Only executed if first command fails"
@@ -197,27 +210,6 @@ bg
 kill %2
 # %1, %2, etc. can be used for fg and bg as well
 
-# To use && and || with if statements, you need multiple pairs of square brackets:
-if [ "$Name" == "Steve" ] && [ "$Age" -eq 15 ]
-then
-    echo "This will run if $Name is Steve AND $Age is 15."
-fi
-
-if [ "$Name" == "Daniya" ] || [ "$Name" == "Zach" ]
-then
-    echo "This will run if $Name is Daniya OR Zach."
-fi
-
-# There is also the `=~` operator, which tests a string against a Regex pattern:
-Email=me@example.com
-if [[ "$Email" =~ [a-z]+@[a-z]{2,}\.(com|net|org) ]]
-then
-    echo "Valid email!"
-fi
-# Note that =~ only works within double [[ ]] square brackets,
-# which are subtly different from single [ ].
-# See https://www.gnu.org/software/bash/manual/bashref.html#Conditional-Constructs for more on this.
-
 # Redefine command `ping` as alias to send only 5 packets
 alias ping='ping -c 5'
 # Escape the alias and use command with this name instead
-- 
cgit v1.2.3


From 44e15f80047d0675c421c38aadb2a8dc09d32d06 Mon Sep 17 00:00:00 2001
From: Yash <yashdodani8@gmail.com>
Date: Mon, 10 Oct 2022 22:27:35 +0530
Subject: Added missing information about scanf

---
 c.html.markdown | 63 ++++++++++++++++++++++++++++++++-------------------------
 1 file changed, 35 insertions(+), 28 deletions(-)

diff --git a/c.html.markdown b/c.html.markdown
index a898f052..cd6b5ad2 100644
--- a/c.html.markdown
+++ b/c.html.markdown
@@ -2,15 +2,15 @@
 language: C
 filename: learnc.c
 contributors:
-    - ["Adam Bard", "http://adambard.com/"]
-    - ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"]
-    - ["Jakub Trzebiatowski", "http://cbs.stgn.pl"]
-    - ["Marco Scannadinari", "https://marcoms.github.io"]
-    - ["Zachary Ferguson", "https://github.io/zfergus2"]
-    - ["himanshu", "https://github.com/himanshu81494"]
-    - ["Joshua Li", "https://github.com/JoshuaRLi"]
-    - ["Dragos B. Chirila", "https://github.com/dchirila"]
-    - ["Heitor P. de Bittencourt", "https://github.com/heitorPB/"]
+  - ["Adam Bard", "http://adambard.com/"]
+  - ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"]
+  - ["Jakub Trzebiatowski", "http://cbs.stgn.pl"]
+  - ["Marco Scannadinari", "https://marcoms.github.io"]
+  - ["Zachary Ferguson", "https://github.io/zfergus2"]
+  - ["himanshu", "https://github.com/himanshu81494"]
+  - ["Joshua Li", "https://github.com/JoshuaRLi"]
+  - ["Dragos B. Chirila", "https://github.com/dchirila"]
+  - ["Heitor P. de Bittencourt", "https://github.com/heitorPB/"]
 ---
 
 Ah, C. Still **the** language of modern high-performance computing.
@@ -101,6 +101,12 @@ int main (int argc, char** argv)
   // %d is an integer, \n is a newline
   printf("%d\n", 0); // => Prints 0
 
+  // take input using scanf
+  // '&' is used to define the location
+  // where we want to store the input value
+  int input;
+  scanf("%d", &input);
+
   ///////////////////////////////////////
   // Types
   ///////////////////////////////////////
@@ -118,7 +124,7 @@ int main (int argc, char** argv)
   // shorts are usually 2 bytes (use the `sizeof` operator to check)
   short x_short = 0;
 
-  // chars are defined as the smallest addressable unit for a processor. 
+  // chars are defined as the smallest addressable unit for a processor.
   // This is usually 1 byte, but for some systems it can be more (ex. for TMS320 from TI it's 2 bytes).
   char x_char = 0;
   char y_char = 'y'; // Char literals are quoted with ''
@@ -167,19 +173,19 @@ int main (int argc, char** argv)
   // where the "{0}" part is called an "array initializer".
   // All elements (if any) past the ones in the initializer are initialized to 0:
   int my_array[5] = {1, 2};
-  // So my_array now has five elements, all but the first two of which are 0: 
+  // So my_array now has five elements, all but the first two of which are 0:
   // [1, 2, 0, 0, 0]
-  // NOTE that you get away without explicitly declaring the size 
+  // NOTE that you get away without explicitly declaring the size
   // of the array IF you initialize the array on the same line:
   int my_array[] = {0};
-  // NOTE that, when not declaring the size, the size of the array is the number 
+  // NOTE that, when not declaring the size, the size of the array is the number
   // of elements in the initializer. With "{0}", my_array is now of size one: [0]
   // To evaluate the size of the array at run-time, divide its byte size by the
   // byte size of its element type:
   size_t my_array_size = sizeof(my_array) / sizeof(my_array[0]);
-  // WARNING You should evaluate the size *before* you begin passing the array 
-  // to functions (see later discussion) because arrays get "downgraded" to 
-  // raw pointers when they are passed to functions (so the statement above 
+  // WARNING You should evaluate the size *before* you begin passing the array
+  // to functions (see later discussion) because arrays get "downgraded" to
+  // raw pointers when they are passed to functions (so the statement above
   // will produce the wrong result inside the function).
 
   // Indexing an array is like other languages -- or,
@@ -247,11 +253,11 @@ int main (int argc, char** argv)
   (float)i1 / i2; // => 0.5f
   i1 / (double)i2; // => 0.5 // Same with double
   f1 / f2; // => 0.5, plus or minus epsilon
-  
+
   // Floating-point numbers are defined by IEEE 754, thus cannot store perfectly
-  // exact values. For instance, the following does not produce expected results 
-  // because 0.1 might actually be 0.099999999999 insided the computer, and 0.3 
-  // might be stored as 0.300000000001. 
+  // exact values. For instance, the following does not produce expected results
+  // because 0.1 might actually be 0.099999999999 insided the computer, and 0.3
+  // might be stored as 0.300000000001.
   (0.1 + 0.1 + 0.1) != 0.3; // => 1 (true)
   // and it is NOT associative due to reasons mentioned above.
   1 + (1e123 - 1e123) != (1 + 1e123) - 1e123; // => 1 (true)
@@ -262,7 +268,7 @@ int main (int argc, char** argv)
   // eventually calls C which uses IEEE 754. It is mentioned this way not to
   // indicate that this is a poor implementation, but instead as a warning
   // that when doing floating point comparisons, a little bit of error (epsilon)
-  // needs to be considered. 
+  // needs to be considered.
 
   // Modulo is there as well, but be careful if arguments are negative
   11 % 3;    // => 2 as 11 = 2 + 3*x (x=3)
@@ -411,7 +417,7 @@ int main (int argc, char** argv)
   */
   /*
     it is generally considered bad practice to do so, except if
-    you really know what you are doing. See 
+    you really know what you are doing. See
     https://en.wikipedia.org/wiki/Spaghetti_code#Meaning
   */
 
@@ -424,7 +430,7 @@ int main (int argc, char** argv)
 
   int x_hex = 0x01; // You can assign vars with hex literals
                     // binary is not in the standard, but allowed by some
-                    // compilers (x_bin = 0b0010010110) 
+                    // compilers (x_bin = 0b0010010110)
 
   // Casting between types will attempt to preserve their numeric values
   printf("%d\n", x_hex); // => Prints 1
@@ -626,7 +632,7 @@ printf("first: %d\nsecond: %d\n", first, second);
 // values will be swapped
 */
 
-// Return multiple values. 
+// Return multiple values.
 // C does not allow for returning multiple values with the return statement. If
 // you would like to return multiple values, then the caller must pass in the
 // variables where they would like the returned values to go. These variables must
@@ -637,9 +643,9 @@ int return_multiple( int *array_of_3, int *ret1, int *ret2, int *ret3)
         return 0; //return error code (false)
 
     //de-reference the pointer so we modify its value
-   *ret1 = array_of_3[0]; 
-   *ret2 = array_of_3[1]; 
-   *ret3 = array_of_3[2]; 
+   *ret1 = array_of_3[0];
+   *ret2 = array_of_3[1];
+   *ret3 = array_of_3[2];
 
    return 1; //return error code (true)
 }
@@ -901,10 +907,11 @@ Node createLinkedList(int *vals, int len);
 #endif /* End of the if precompiler directive. */
 
 ```
+
 ## Further Reading
 
 Best to find yourself a copy of [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language)
-It is *the* book about C, written by Dennis Ritchie, the creator of C, and Brian Kernighan. Be careful, though - it's ancient and it contains some
+It is _the_ book about C, written by Dennis Ritchie, the creator of C, and Brian Kernighan. Be careful, though - it's ancient and it contains some
 inaccuracies (well, ideas that are not considered good anymore) or now-changed practices.
 
 Another good resource is [Learn C The Hard Way](http://learncodethehardway.org/c/) (not free).
-- 
cgit v1.2.3


From 940326953b4b9205e07ac83530eca7fb7c34946b Mon Sep 17 00:00:00 2001
From: Kemel Zaidan <kemelzaidan@gmail.com>
Date: Thu, 27 Oct 2022 15:46:18 -0300
Subject: add pt_br translation for Processing

---
 pt-br/processing-pt.html.markdown | 469 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 469 insertions(+)
 create mode 100644 pt-br/processing-pt.html.markdown

diff --git a/pt-br/processing-pt.html.markdown b/pt-br/processing-pt.html.markdown
new file mode 100644
index 00000000..dab5a98d
--- /dev/null
+++ b/pt-br/processing-pt.html.markdown
@@ -0,0 +1,469 @@
+---
+language: processing
+filename: learnprocessing.pde
+contributors:
+    - ["Phone Thant Ko", "http://github.com/phonethantko"]
+    - ["Divay Prakash", "https://github.com/divayprakash"]
+translators:
+	- ["Kemel Zaidan", "https://github.com/kemelzaidan"]
+lang: pt-br
+---
+
+## Introdução
+
+Processing é uma linguagem de programação para criação de artes digitais e
+conteúdo multimídia, permitindo que não programadores aprendam os fundamentos da 
+programação computacional em um contexto visual.
+
+Embora a linguagem seja baseada na linguagem Java, sua sintaxe foi amplamente
+influenciado por ambas as sintaxes Java e Javascript. [Veja mais aqui](https://processing.org/reference/)
+
+A linguagem é tipada estaticamente e também vem com a sua IDE oficial para
+compilar e executar os scripts.
+
+```
+/* ---------
+   Comentários
+   ---------
+*/
+
+// Comentário de linha única começa com //
+
+/*
+   Como o Processing é baseado em Java,
+   a sintaxe para seus comentários é a mesma do Java (como você deve ter notado acima)!
+   Comentários de várias linhas são agrupados como visto aqui.
+*/
+
+/* ---------------------------------------
+   Escrevendo e executando programas em Processing
+   ---------------------------------------
+*/
+
+// No Processing, o ponto de entrada do programa é uma função chamada setup() com um
+// tipo de retorno void.
+// Observação! A sintaxe é muito semelhante à do C++.
+void setup() {
+  // Isso imprime a saída clássica "Hello World!" para o console quando executado.
+  println("Olá Mundo!"); // Outra linguagem com cilada para ponto-e-vígula, não é?
+}
+
+// Normalmente, colocamos todos os códigos estáticos dentro do método setup() como o próprio nome
+// sugere, uma vez que é executado apenas uma vez.
+// Pode variar da definição das cores de fundo, ou o tamanho da tela.
+background(color); //define a cor do fundo
+size(largura,altura,[renderizador]); // define o tamanho da tela com parâmetro
+// opcional para definir o renderizador
+// Você verá mais sobre isso ao longo deste documento.
+
+// Se você deseja executar os códigos indefinidamente, eles devem ser colocados dentro do método draw()
+// draw() deve existir caso você queira que o código seja executado continuamente e, obviamente,
+// só pode haver um método draw().
+int = 0;
+void draw(){
+  // Este bloco de código faz um loop para sempre até parar
+  imprima(i);
+  i++; // Operador de incremento!
+}
+
+// Agora que sabemos como escrever o script de trabalho e como executá-lo,
+// continuaremos a explorar quais tipos de dados e coleções são suportados no
+// Processing.
+
+/* ------------------------
+   Tipos de dados e coleções
+   ------------------------
+*/
+
+// De acordo com as Referências do Processing, ele suporta 8 tipos primitivos
+// de dados da seguinte forma.
+
+boolean valorBoleano = true; // Boleano
+byte valorByteDeA = 23; // Byte
+char valorCharDeA = 'A'; // Caractere
+color valorDeCorBrancoM = color(255, 255, 255); // Cor (especificada usando
+// método color())
+color valorDeCorBrancoH = #FFFFFF; // Cor (especificada usando valor de hash)
+int valor = 5; // Inteiro (Número sem decimais)
+long valorLongo = 2147483648L; // "L" é adicionado ao número para marcá-lo como um longo
+float valorFloat = 1,12345; // Float (números de ponto flutuante de 32 bits)
+double valorDouble = 1,12345D; // Double (números de ponto flutuante de 64 bits)
+
+// NOTA!
+// Embora os tipos de dados "long" e "double" funcionem na linguagem,
+// funções do Processing não usam esses tipos de dados, portanto
+// eles precisam ser convertidos em tipos de dados "int" e "float", respectivamente,
+// usando a sintaxe (int) e (float) antes de passar para uma função.
+
+// Existem vários tipos de dados compostos que estão disponíveis por padrão para uso
+// no Processing.
+// Primeiramente, farei um resumo dos mais usados ​​para economizar tempo.
+
+// String
+// Enquanto o tipo de dados char usa '', o tipo de dados String usa "" - aspas duplas.
+string stringExemplo = "Olá, Processing!";
+// String também pode ser construída a partir de um array de tipos de dados char. Nós vamos
+// discutir array muito em breve.
+char fonte = {'H', 'E', 'L', 'L', 'O'};
+string stringDeFonte = new String(source); // HELLO
+// Como em Java, strings podem ser concatenadas usando o operador "+".
+print("Olá " + "Mundo!"); // Olá Mundo!
+
+// Array
+// Arrays em Processing podem conter quaisquer tipos de dados, incluindo os próprios objetos.
+// Como os arrays são semelhantes aos objetos, eles devem ser criados com a palavra-chave
+// "new".
+int[] arrayInt = new int[5];
+int[] arrayIntComValores ​​= {1, 2, 3}; // Você também pode preencher com dados.
+
+// Lista de Arrays
+// As funções são semelhantes às do array; arraylists podem conter qualquer tipo de dados.
+// A única diferença é que as listas de matrizes são redimensionadas dinamicamente, pois é uma forma de
+// implementação de matriz redimensionável da interface "List" do Java .
+ArrayList<Integer> intArrayList = new ArrayList<Integer>();
+
+// Objeto
+// Como é baseado em Java, o Processing suporta programação orientada a objetos.
+// Isso significa que você pode basicamente definir quaisquer tipos de dados de sua preferência e manipulá-los
+// para suas necessidades.
+// Claro, uma classe tem que ser definida antes para o objeto que você quer.
+// Formato --> NomeClasse NameInstancia
+UmaClasseQualquer meuObjeto // então instancia mais tarde
+//ou
+UmaClasseQualquer meuObjetoInstanciado = new UmaClasseQualquer();
+
+// O Processing surge com mais coleções (ex. - Dicionários e Listas) por
+// padrão, por uma questão de simplicidade, vou deixá-los fora de discussão aqui.
+
+/* ------------
+   Matemática
+   ------------
+*/
+
+// Aritmética
+1 + 1 // 2
+2 - 1 // 1
+2 * 3 // 6
+3/2 // 1
+3,0 / 2 // 1,5
+3,0% 2 // 1,0
+
+// O Processing também vem com um conjunto de funções que simplificam operações matemáticas.
+float f = sq(3); // f = 9.0
+float p = pow(3, 3); // p = 27.0
+int a = abs(-13); // a = 13
+int r1 = round(3.1); // r1 = 3
+int r2 = round(3.7); // r2 = 4
+float sr = sqrt(25); // sr = 5.0
+
+// Vetores
+// O Processing fornece uma maneira fácil de implementar vetores em seu ambiente
+// usando a classe PVector. Ela pode descrever um vetor bi ou tridimensional e
+// vem com um conjunto de métodos que são úteis para operações com matrizes.
+// Você pode encontrar mais informações sobre a classe PVector e suas funções aqui.
+// (https://processing.org/reference/PVector.html)
+
+// Trigonometria
+// O processamento também suporta operações trigonométricas fornecendo um conjunto de
+// funções. sin(), cos(), tan(), asin(), acos(), atan() e também degrees()
+// e radians() para conversão conveniente.
+// No entanto, essas funções usam o ângulo em radianos como parâmetro, então é necessário
+// converter previamente.
+float um = sin(PI/2); // um = 1.0
+// Como você deve ter notado, existe um conjunto de constantes para usos trigonométricos;
+// PI, HALF_PI, QUARTER_PI e assim por diante...
+
+/* -------------
+   Controle de fluxo
+   -------------
+*/
+
+// Declarações Condicionais
+// Instruções If - A mesma sintaxe das instruções if em Java.
+if (autor.getAppearance().equals("quente")) {
+  print("Narcisismo no seu melhor!");
+} senão {
+  // Você pode verificar outras condições aqui.
+  print("Algo está realmente errado aqui!");
+}
+// Um ​​atalho para instruções if-else também pode ser usado.
+int = 3;
+Valor da string = (i > 5) ? "Grande" : "Pequena"; // "Pequena"
+
+// A estrutura switch-case pode ser usada para verificar várias condições de forma concisa.
+// É importante usar a instrução break. Se a instrução `break`
+// não existe o programa executa todos os casos a seguir após um caso ser verdadeiro.
+int valor = 2;
+switch(valor) {
+  case 0:
+    print("Nada!"); // Isso não é executado.
+    break; // Salta para a próxima instrução
+  case 1:
+    print("Chegando lá..."); // Isso novamente não é executado.
+    break;
+  case 2:
+    print("Bravo!"); // Esta linha é executada.
+    break;
+  default:
+    print("Não encontrado!"); // Esta linha é executada se nosso valor for algum outro valor.
+    break;
+}
+
+// Declarações iterativas
+// Declarações For - Novamente, a mesma sintaxe que em Java
+for(int i = 0; i < 5; i++){
+  print(i); // imprime de 0 a 4
+}
+
+// Declarações While - Novamente, nada de novo se você estiver familiarizado com a sintaxe Java.
+int j = 3;
+while(j > 0) {
+  print(j);
+  j--; // Isso é importante para evitar que o código seja executado indefinidamente.
+}
+
+// loop()| noLoop() | redraw() | exit()
+// Estas são mais funções específicas do Processing para configurar o fluxo do programa.
+loop(); // permite que o método draw() seja executado para sempre enquanto
+noLoop(); // só permite que ele seja executado uma vez.
+redraw(); // executa o método draw() mais uma vez.
+exit(); // Isso para o programa. É útil para programas com draw()
+// rodando continuamente.
+```
+
+## Desenho com Processing
+
+Como você já deve ter entendido o básico da linguagem, vamos agora
+veja a melhor parte do Processing - DESENHAR.
+
+```
+/* ------
+   Formas
+   ------
+*/
+
+// Formas 2D
+
+// Ponto
+point(x, y); // No espaço 2D
+point(x, y, z); // No espaço 3D
+// Desenha um ponto no espaço de coordenadas.
+
+// Linha
+line(x1, y1, x2, y2); // No espaço 2D
+line(x1, y1, z1, x2, y2, z2); // No espaço 3D
+// Desenha uma linha conectando dois pontos definidos por (x1, y1) e (x2, y2).
+
+// Triângulo
+triangle(x1, y1, x2, y2, x3, y3);
+// Desenha um triângulo conectando três pontos definidos por parâmetros de coordenadas.
+
+// Retângulo
+rect(a, b, c, d, [r]); // Com parâmetro opcional definindo o raio de todos os cantos
+rect(a, b, c, d, [tl, tr, br, bl]); // Com conjunto opcional de parâmetros definindo
+// raio de cada canto
+// Desenha um retângulo com {a, b} como coordenada superior esquerda e c e d como largura
+// e altura respectivamente.
+
+// Quad
+quad(x, y, x2, y2, x3, y3, x4, y4);
+// Desenha um quadrilátero com parâmetros que definem as coordenadas de cada canto
+// ponto.
+
+// Elipse
+ellipse(x, y, largura, altura);
+// Desenha um eclipse no ponto {x, y} com largura e altura especificadas.
+
+// Arco
+arc(x, y, largura, altura, inicio, fim, [modo]);
+// Enquanto os primeiros quatro parâmetros são autoexplicativos,
+// início e fim definem os ângulos que o arco começa e termina (em radianos).
+// O parâmetro opcional [mode] define o preenchimento;
+// PIE dá o contorno de torta, CHORD dá o contorno reto e OPEN é como
+// CHORD porém sem contorno
+
+// Curvas
+// O processamento fornece duas implementações de curvas; usando curve() e bezier().
+// Como pretendo manter isso simples, não vou discutir mais detalhes.
+// No entanto, se você quiser implementá-lo em seu sketch, aqui estão as referências:
+// (https://processing.org/reference/curve_.html)
+// (https://processing.org/reference/bezier_.html)
+
+// Formas 3D
+
+// espaço 3D
+pode ser configurado definindo "P3D" para o parâmetro do renderizador no
+// método size().
+size(largura, altura, P3D);
+// No espaço 3D, você terá que traduzir para a coordenada específica para
+// renderiza as formas 3D.
+
+// Caixa
+box(tamanho); // Cubo com o mesmo comprimento definido pelo tamanho
+caixa(w, h, d); // Caixa com largura, altura e profundidade definidas separadamente
+
+// Esfera
+sphere(raio); // Seu tamanho é definido usando o parâmetro raio
+// O mecanismo por trás da renderização das esferas é implementado por triângulos em mosaico.
+// Dito isso, o nível de detalhe sendo renderizado é controlado pela função
+// sphereDetail(res)
+// Mais informações aqui: (https://processing.org/reference/sphereDetail_.html)
+
+// Formas irregulares
+// E se você quiser desenhar algo que não foi disponibilizado pelo Processing
+// funções?
+// Você pode usar beginShape(), endShape(), vertex(x,y) para definir formas por
+// especificando cada ponto. Mais informações aqui:
+// (https://processing.org/reference/beginShape_.html)
+// Você também pode usar formas personalizadas usando a classe PShape:
+// (https://processing.org/reference/PShape.html)
+
+/* ---------------
+   Transformações
+   ---------------
+*/
+
+// As transformações são particularmente úteis para acompanhar o espaço de coordenadas
+// e os vértices das formas que você desenhou. Particularmente;
+// métodos de pilha de matrizes; pushMatrix(), popMatrix() e translate(x,y)
+pushMatriz(); // Salva o sistema de coordenadas atual na pilha
+// ... aplique todas as transformações aqui ...
+popMatriz(); // Restaura o sistema de coordenadas salvo
+// Usando-os, o sistema de coordenadas pode ser preservado e visualizado sem
+// causar qualquer conflito.
+
+// Traduzir
+translate(x,y); // Traduz para o ponto{x, y} ou seja - configurando a origem para esse ponto
+translate(x, y, z); // Contraparte 3D da função
+
+// Rotacionar
+rotate(ângulo); // Gira a quantidade especificada pelo parâmetro ângulo
+// Possui 3 contrapartes 3D para realizar a rotação, uma para cada dimensão: rotateX(ângulo), rotateY(ângulo), rotateZ(ângulo)
+
+// Escala
+scale(s); // Dimensiona o sistema de coordenadas expandindo ou contraindo-o.
+
+/* --------------------
+   Estilo e texturas
+   --------------------
+*/
+
+// Cores
+// Como discuti anteriormente, a cor de fundo pode ser configurada usando a função
+// background(). Você pode definir a cor de um objeto de antemão e depois
+// passar para a função como um argumento.
+color c = cor(255, 255, 255); // BRANCO!
+// Por padrão, o Processing usa o esquema de cores RGB, mas pode ser configurado para
+// HSB usando colorMode(). Leia mais aqui:
+// (https://processing.org/reference/colorMode_.html)
+background(c); // Até agora, a cor de fundo deve ser branca.
+// Você pode usar a função fill() para selecionar a cor para preencher as formas.
+// Tem que ser configurado antes de você começar a desenhar formas para que as cores fiquem
+// aplicadas.
+fill(color(0, 0, 0));
+// Se você quiser apenas colorir os contornos das formas, você pode usar
+// função stroke().
+stroke(255, 255, 0, 200); // cor do traço definida para amarelo com transparência
+// definido para um valor menor.
+
+// Imagens
+// O processamento pode renderizar imagens e usá-las de várias maneiras. Principalmente armazenado como
+// Tipo de dados PImage.
+filter(sombreador); // O processamento suporta várias funções de filtro para manipulação de imagens.
+texture(imagem); // PImage pode ser passado em argumentos para mapeamento de textura das formas.
+```
+
+Se você quiser levar as coisas adiante, há mais coisas que o Processing tem o poder de fazer.
+Renderizar modelos, shaders e outros enfeites. Há muito para se cobrir em uma
+documentação curta, então vou deixá-los aqui. Se você se interessar,
+por favor verifique as referências.
+
+```
+// Antes de prosseguirmos, vou falar um pouco mais sobre como importar bibliotecas
+// para que você possa estender a funcionalidade do Processing para outros horizontes.
+
+/* -------
+   Importações
+   -------
+*/
+
+// As possibilidades do Processing pode ser extendidas ainda mais quando importamos bibliotecas
+// e pacotes em nossos esboços.
+// A instrução de importação pode ser escrita como abaixo na parte superior do código-fonte.
+import processing.something.*;
+```
+
+## VAC?
+
+Vamos ao código? Vamos sujar as mãos!
+
+Vamos ver um exemplo do openprocessing para visualizar o quanto o Processing é
+capaz de fazer com poucas linhas de código.
+
+Copie o código abaixo em seu IDE do Processing e veja a mágica.
+
+```
+// Isenção de responsabilidade: eu não escrevi este programa porque atualmente estou ocupado com meu
+// estágio e este sketch é adaptado do openprocessing pois mostra
+// algo legal com um código simples.
+// Recuperado de: (https://www.openprocessing.org/sketch/559769)
+
+float theta;
+float a;
+float col;
+float num;
+
+void setup() {
+  size(600,600);
+}
+
+void draw() {
+  background(#F2F2F2);
+  translate(width/2, height/2);
+  theta = map(sin(millis()/1000.0), -1, 1, 0, PI/6);
+
+  float num=6;
+  for (int i=0; i<num; i++) {
+    a =350;
+    rotate(TWO_PI/num);
+    branch(a);
+  }
+
+}
+
+void branch(float len) {
+  col=map(len, 0, 90, 150, 255);
+  fill(col, 0, 74);
+  stroke (col, 0, 74);
+  line(0, 0, 0, -len);
+  ellipse(0, -len, 3, 3);
+  len *= 0.7;
+
+  if (len>30) {
+    pushMatrix();
+    translate(0, -30);
+    rotate(theta);
+    branch(len);
+    popMatrix();
+
+    pushMatrix();
+    translate(0, -30);
+    rotate(-theta);
+    branch(len);
+    popMatrix();
+
+  }
+}
+```
+
+O processamento é fácil de aprender e é particularmente útil para criar
+conteúdo (mesmo em 3D) sem ter que digitar muitos códigos. É tão simples
+que você pode ler o código e ter uma ideia aproximada do fluxo do programa.
+
+No entanto, isso não se aplica quando você introduz bibliotecas externas, pacotes
+e até mesmo suas próprias aulas. (Confie em mim! O processamento de projetos pode ficar realmente monstruoso...)
+
+## Alguns recursos úteis
+
+  - [Site de processamento](http://processing.org)
+  - [Processando esboços](http://openprocessing.org)
\ No newline at end of file
-- 
cgit v1.2.3


From 6574a372795ac53147c415ba9511ed88240cbb9b Mon Sep 17 00:00:00 2001
From: Kemel Zaidan <kemelzaidan@gmail.com>
Date: Thu, 27 Oct 2022 16:01:30 -0300
Subject: fixing some typos after review

---
 pt-br/processing-pt.html.markdown | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/pt-br/processing-pt.html.markdown b/pt-br/processing-pt.html.markdown
index dab5a98d..a511000b 100644
--- a/pt-br/processing-pt.html.markdown
+++ b/pt-br/processing-pt.html.markdown
@@ -45,7 +45,7 @@ compilar e executar os scripts.
 // Observação! A sintaxe é muito semelhante à do C++.
 void setup() {
   // Isso imprime a saída clássica "Hello World!" para o console quando executado.
-  println("Olá Mundo!"); // Outra linguagem com cilada para ponto-e-vígula, não é?
+  println("Olá Mundo!"); // Outra linguagem com cilada para ponto e vírgula, não é?
 }
 
 // Normalmente, colocamos todos os códigos estáticos dentro do método setup() como o próprio nome
@@ -105,7 +105,7 @@ string stringExemplo = "Olá, Processing!";
 // String também pode ser construída a partir de um array de tipos de dados char. Nós vamos
 // discutir array muito em breve.
 char fonte = {'H', 'E', 'L', 'L', 'O'};
-string stringDeFonte = new String(source); // HELLO
+String stringDeFonte = new String(source); // HELLO
 // Como em Java, strings podem ser concatenadas usando o operador "+".
 print("Olá " + "Mundo!"); // Olá Mundo!
 
@@ -145,8 +145,8 @@ UmaClasseQualquer meuObjetoInstanciado = new UmaClasseQualquer();
 2 - 1 // 1
 2 * 3 // 6
 3/2 // 1
-3,0 / 2 // 1,5
-3,0% 2 // 1,0
+3.0 / 2 // 1.5
+3.0% 2 // 1.0
 
 // O Processing também vem com um conjunto de funções que simplificam operações matemáticas.
 float f = sq(3); // f = 9.0
@@ -180,15 +180,15 @@ float um = sin(PI/2); // um = 1.0
 
 // Declarações Condicionais
 // Instruções If - A mesma sintaxe das instruções if em Java.
-if (autor.getAppearance().equals("quente")) {
-  print("Narcisismo no seu melhor!");
-} senão {
+if (author.getAppearance().equals("quente")) {
+  print("Narcisismo no máximo!");
+} else {
   // Você pode verificar outras condições aqui.
   print("Algo está realmente errado aqui!");
 }
 // Um ​​atalho para instruções if-else também pode ser usado.
 int = 3;
-Valor da string = (i > 5) ? "Grande" : "Pequena"; // "Pequena"
+String valor = (i > 5) ? "Grande" : "Pequena"; // "Pequena"
 
 // A estrutura switch-case pode ser usada para verificar várias condições de forma concisa.
 // É importante usar a instrução break. Se a instrução `break`
@@ -260,7 +260,7 @@ triangle(x1, y1, x2, y2, x3, y3);
 
 // Retângulo
 rect(a, b, c, d, [r]); // Com parâmetro opcional definindo o raio de todos os cantos
-rect(a, b, c, d, [tl, tr, br, bl]); // Com conjunto opcional de parâmetros definindo
+rect(a, b, c, d, [te, td, bd, be]); // Com conjunto opcional de parâmetros definindo
 // raio de cada canto
 // Desenha um retângulo com {a, b} como coordenada superior esquerda e c e d como largura
 // e altura respectivamente.
@@ -374,7 +374,7 @@ texture(imagem); // PImage pode ser passado em argumentos para mapeamento de tex
 ```
 
 Se você quiser levar as coisas adiante, há mais coisas que o Processing tem o poder de fazer.
-Renderizar modelos, shaders e outros enfeites. Há muito para se cobrir em uma
+Renderizar modelos, shaders e outros efeitos. Há muito para se cobrir em uma
 documentação curta, então vou deixá-los aqui. Se você se interessar,
 por favor verifique as referências.
 
@@ -387,10 +387,10 @@ por favor verifique as referências.
    -------
 */
 
-// As possibilidades do Processing pode ser extendidas ainda mais quando importamos bibliotecas
+// As possibilidades do Processing pode ser estendidas ainda mais quando importamos bibliotecas
 // e pacotes em nossos esboços.
 // A instrução de importação pode ser escrita como abaixo na parte superior do código-fonte.
-import processing.something.*;
+import processing.algumacoisa.*;
 ```
 
 ## VAC?
@@ -465,5 +465,5 @@ e até mesmo suas próprias aulas. (Confie em mim! O processamento de projetos p
 
 ## Alguns recursos úteis
 
-  - [Site de processamento](http://processing.org)
-  - [Processando esboços](http://openprocessing.org)
\ No newline at end of file
+  - [Site do Processing](http://processing.org)
+  - [Sketches em Processing](http://openprocessing.org)
\ No newline at end of file
-- 
cgit v1.2.3


From 6e3ca550f9b6561a193fc95fb40d84b976f9dd01 Mon Sep 17 00:00:00 2001
From: Kemel Zaidan <kemelzaidan@gmail.com>
Date: Thu, 27 Oct 2022 17:10:12 -0300
Subject: fixes the texts which were exceeding 80 collumns

---
 pt-br/processing-pt.html.markdown | 156 ++++++++++++++++++++------------------
 1 file changed, 83 insertions(+), 73 deletions(-)

diff --git a/pt-br/processing-pt.html.markdown b/pt-br/processing-pt.html.markdown
index a511000b..229aec07 100644
--- a/pt-br/processing-pt.html.markdown
+++ b/pt-br/processing-pt.html.markdown
@@ -12,11 +12,12 @@ lang: pt-br
 ## Introdução
 
 Processing é uma linguagem de programação para criação de artes digitais e
-conteúdo multimídia, permitindo que não programadores aprendam os fundamentos da 
-programação computacional em um contexto visual.
+conteúdo multimídia, permitindo que não programadores aprendam os fundamentos 
+da programação computacional em um contexto visual.
 
 Embora a linguagem seja baseada na linguagem Java, sua sintaxe foi amplamente
-influenciado por ambas as sintaxes Java e Javascript. [Veja mais aqui](https://processing.org/reference/)
+influenciado por ambas as sintaxes Java e Javascript.
+[Veja mais aqui](https://processing.org/reference/)
 
 A linguagem é tipada estaticamente e também vem com a sua IDE oficial para
 compilar e executar os scripts.
@@ -31,7 +32,8 @@ compilar e executar os scripts.
 
 /*
    Como o Processing é baseado em Java,
-   a sintaxe para seus comentários é a mesma do Java (como você deve ter notado acima)!
+   a sintaxe para seus comentários é a mesma do Java (como você deve ter notado 
+   acima)!
    Comentários de várias linhas são agrupados como visto aqui.
 */
 
@@ -40,25 +42,26 @@ compilar e executar os scripts.
    ---------------------------------------
 */
 
-// No Processing, o ponto de entrada do programa é uma função chamada setup() com um
-// tipo de retorno void.
+// No Processing, o ponto de entrada do programa é uma função chamada setup() 
+// com um tipo de retorno void.
 // Observação! A sintaxe é muito semelhante à do C++.
 void setup() {
-  // Isso imprime a saída clássica "Hello World!" para o console quando executado.
-  println("Olá Mundo!"); // Outra linguagem com cilada para ponto e vírgula, não é?
+  // Isso imprime a saída clássica "Hello World!" no console quando executado.
+  println("Olá Mundo!"); // Outra linguagem cilada para ponto e vírgula, não é?
 }
 
-// Normalmente, colocamos todos os códigos estáticos dentro do método setup() como o próprio nome
-// sugere, uma vez que é executado apenas uma vez.
+// Normalmente, colocamos todos os códigos estáticos dentro do método setup() 
+// como o próprio nome sugere, uma vez que é executado apenas uma vez.
 // Pode variar da definição das cores de fundo, ou o tamanho da tela.
 background(color); //define a cor do fundo
 size(largura,altura,[renderizador]); // define o tamanho da tela com parâmetro
 // opcional para definir o renderizador
 // Você verá mais sobre isso ao longo deste documento.
 
-// Se você deseja executar os códigos indefinidamente, eles devem ser colocados dentro do método draw()
-// draw() deve existir caso você queira que o código seja executado continuamente e, obviamente,
-// só pode haver um método draw().
+// Se você deseja executar os códigos indefinidamente, eles devem ser colocados 
+// dentro do método draw()
+// draw() deve existir caso você queira que o código seja executado 
+// continuamente e, obviamente, só pode haver um método draw().
 int = 0;
 void draw(){
   // Este bloco de código faz um loop para sempre até parar
@@ -92,40 +95,43 @@ double valorDouble = 1,12345D; // Double (números de ponto flutuante de 64 bits
 // NOTA!
 // Embora os tipos de dados "long" e "double" funcionem na linguagem,
 // funções do Processing não usam esses tipos de dados, portanto
-// eles precisam ser convertidos em tipos de dados "int" e "float", respectivamente,
-// usando a sintaxe (int) e (float) antes de passar para uma função.
+// eles precisam ser convertidos em tipos de dados "int" e "float", 
+// respectivamente, usando a sintaxe (int) e (float) antes de passar para uma 
+// função.
 
-// Existem vários tipos de dados compostos que estão disponíveis por padrão para uso
-// no Processing.
+// Existem vários tipos de dados compostos que estão disponíveis por padrão para 
+// uso no Processing.
 // Primeiramente, farei um resumo dos mais usados ​​para economizar tempo.
 
 // String
-// Enquanto o tipo de dados char usa '', o tipo de dados String usa "" - aspas duplas.
+// Enquanto o tipo de dados char usa '', o tipo de dados String usa "" - aspas 
+// duplas.
 string stringExemplo = "Olá, Processing!";
-// String também pode ser construída a partir de um array de tipos de dados char. Nós vamos
-// discutir array muito em breve.
+// String também pode ser criada a partir de um array de tipos de dados char.
+// Nós vamos discutir array muito em breve.
 char fonte = {'H', 'E', 'L', 'L', 'O'};
 String stringDeFonte = new String(source); // HELLO
 // Como em Java, strings podem ser concatenadas usando o operador "+".
 print("Olá " + "Mundo!"); // Olá Mundo!
 
 // Array
-// Arrays em Processing podem conter quaisquer tipos de dados, incluindo os próprios objetos.
-// Como os arrays são semelhantes aos objetos, eles devem ser criados com a palavra-chave
-// "new".
+// Arrays em Processing podem conter quaisquer tipos de dados, incluindo os 
+// próprios objetos. Como os arrays são semelhantes aos objetos, eles devem 
+// ser criados com a palavra-chave "new".
 int[] arrayInt = new int[5];
 int[] arrayIntComValores ​​= {1, 2, 3}; // Você também pode preencher com dados.
 
 // Lista de Arrays
-// As funções são semelhantes às do array; arraylists podem conter qualquer tipo de dados.
-// A única diferença é que as listas de matrizes são redimensionadas dinamicamente, pois é uma forma de
-// implementação de matriz redimensionável da interface "List" do Java .
+// As funções são semelhantes às do array; arraylists podem conter qualquer 
+// tipo de dados. A única diferença é que as listas de matrizes são 
+// redimensionadas dinamicamente, pois é uma forma de implementação de matriz 
+// redimensionável da interface "List" do Java .
 ArrayList<Integer> intArrayList = new ArrayList<Integer>();
 
 // Objeto
 // Como é baseado em Java, o Processing suporta programação orientada a objetos.
-// Isso significa que você pode basicamente definir quaisquer tipos de dados de sua preferência e manipulá-los
-// para suas necessidades.
+// Isso significa que você pode basicamente definir quaisquer tipos de dados de 
+// sua preferência e manipulá-los para suas necessidades.
 // Claro, uma classe tem que ser definida antes para o objeto que você quer.
 // Formato --> NomeClasse NameInstancia
 UmaClasseQualquer meuObjeto // então instancia mais tarde
@@ -133,7 +139,7 @@ UmaClasseQualquer meuObjeto // então instancia mais tarde
 UmaClasseQualquer meuObjetoInstanciado = new UmaClasseQualquer();
 
 // O Processing surge com mais coleções (ex. - Dicionários e Listas) por
-// padrão, por uma questão de simplicidade, vou deixá-los fora de discussão aqui.
+// padrão, por uma questão de simplicidade, vou deixá-los fora da discussão aqui.
 
 /* ------------
    Matemática
@@ -148,7 +154,8 @@ UmaClasseQualquer meuObjetoInstanciado = new UmaClasseQualquer();
 3.0 / 2 // 1.5
 3.0% 2 // 1.0
 
-// O Processing também vem com um conjunto de funções que simplificam operações matemáticas.
+// O Processing também vem com um conjunto de funções que simplificam operações 
+// matemáticas.
 float f = sq(3); // f = 9.0
 float p = pow(3, 3); // p = 27.0
 int a = abs(-13); // a = 13
@@ -160,18 +167,18 @@ float sr = sqrt(25); // sr = 5.0
 // O Processing fornece uma maneira fácil de implementar vetores em seu ambiente
 // usando a classe PVector. Ela pode descrever um vetor bi ou tridimensional e
 // vem com um conjunto de métodos que são úteis para operações com matrizes.
-// Você pode encontrar mais informações sobre a classe PVector e suas funções aqui.
-// (https://processing.org/reference/PVector.html)
+// Você pode encontrar mais informações sobre a classe PVector e suas funções 
+// aqui. (https://processing.org/reference/PVector.html)
 
 // Trigonometria
-// O processamento também suporta operações trigonométricas fornecendo um conjunto de
-// funções. sin(), cos(), tan(), asin(), acos(), atan() e também degrees()
-// e radians() para conversão conveniente.
-// No entanto, essas funções usam o ângulo em radianos como parâmetro, então é necessário
-// converter previamente.
+// O processamento também suporta operações trigonométricas fornecendo um 
+// conjunto de funções. sin(), cos(), tan(), asin(), acos(), atan() e também 
+// degrees() e radians() para conversão conveniente.
+// No entanto, essas funções usam o ângulo em radianos como parâmetro, então é 
+// necessário converter previamente.
 float um = sin(PI/2); // um = 1.0
-// Como você deve ter notado, existe um conjunto de constantes para usos trigonométricos;
-// PI, HALF_PI, QUARTER_PI e assim por diante...
+// Como você deve ter notado, existe um conjunto de constantes para usos 
+// trigonométricos; PI, HALF_PI, QUARTER_PI e assim por diante...
 
 /* -------------
    Controle de fluxo
@@ -190,9 +197,10 @@ if (author.getAppearance().equals("quente")) {
 int = 3;
 String valor = (i > 5) ? "Grande" : "Pequena"; // "Pequena"
 
-// A estrutura switch-case pode ser usada para verificar várias condições de forma concisa.
-// É importante usar a instrução break. Se a instrução `break`
-// não existe o programa executa todos os casos a seguir após um caso ser verdadeiro.
+// A estrutura switch-case pode ser usada para verificar várias condições de 
+// forma concisa. É importante usar a instrução break. Se a instrução `break`
+// não existe o programa executa todos os casos a seguir após um caso ser 
+// verdadeiro.
 int valor = 2;
 switch(valor) {
   case 0:
@@ -215,7 +223,8 @@ for(int i = 0; i < 5; i++){
   print(i); // imprime de 0 a 4
 }
 
-// Declarações While - Novamente, nada de novo se você estiver familiarizado com a sintaxe Java.
+// Declarações While - Novamente, nada de novo se você estiver familiarizado com
+// a sintaxe Java.
 int j = 3;
 while(j > 0) {
   print(j);
@@ -223,7 +232,8 @@ while(j > 0) {
 }
 
 // loop()| noLoop() | redraw() | exit()
-// Estas são mais funções específicas do Processing para configurar o fluxo do programa.
+// Estas são mais funções específicas do Processing para configurar o fluxo do 
+// programa.
 loop(); // permite que o método draw() seja executado para sempre enquanto
 noLoop(); // só permite que ele seja executado uma vez.
 redraw(); // executa o método draw() mais uma vez.
@@ -283,10 +293,10 @@ arc(x, y, largura, altura, inicio, fim, [modo]);
 // CHORD porém sem contorno
 
 // Curvas
-// O processamento fornece duas implementações de curvas; usando curve() e bezier().
-// Como pretendo manter isso simples, não vou discutir mais detalhes.
-// No entanto, se você quiser implementá-lo em seu sketch, aqui estão as referências:
-// (https://processing.org/reference/curve_.html)
+// O processamento fornece duas implementações de curvas; usando curve() e 
+// bezier(). Como pretendo manter isso simples, não vou discutir mais detalhes.
+// No entanto, se você quiser implementá-lo em seu sketch, aqui estão as 
+// referências: (https://processing.org/reference/curve_.html)
 // (https://processing.org/reference/bezier_.html)
 
 // Formas 3D
@@ -300,13 +310,13 @@ size(largura, altura, P3D);
 
 // Caixa
 box(tamanho); // Cubo com o mesmo comprimento definido pelo tamanho
-caixa(w, h, d); // Caixa com largura, altura e profundidade definidas separadamente
+box(w, h, d); // Caixa com largura, altura e profundidade definidas separadamente
 
 // Esfera
 sphere(raio); // Seu tamanho é definido usando o parâmetro raio
-// O mecanismo por trás da renderização das esferas é implementado por triângulos em mosaico.
-// Dito isso, o nível de detalhe sendo renderizado é controlado pela função
-// sphereDetail(res)
+// O mecanismo por trás da renderização das esferas é implementado por 
+// triângulos em mosaico. Dito isso, o nível de detalhe sendo renderizado é 
+// controlado pela função sphereDetail(res)
 // Mais informações aqui: (https://processing.org/reference/sphereDetail_.html)
 
 // Formas irregulares
@@ -323,8 +333,8 @@ sphere(raio); // Seu tamanho é definido usando o parâmetro raio
    ---------------
 */
 
-// As transformações são particularmente úteis para acompanhar o espaço de coordenadas
-// e os vértices das formas que você desenhou. Particularmente;
+// As transformações são particularmente úteis para acompanhar o espaço de 
+// coordenadas e os vértices das formas que você desenhou. Particularmente;
 // métodos de pilha de matrizes; pushMatrix(), popMatrix() e translate(x,y)
 pushMatriz(); // Salva o sistema de coordenadas atual na pilha
 // ... aplique todas as transformações aqui ...
@@ -338,7 +348,8 @@ translate(x, y, z); // Contraparte 3D da função
 
 // Rotacionar
 rotate(ângulo); // Gira a quantidade especificada pelo parâmetro ângulo
-// Possui 3 contrapartes 3D para realizar a rotação, uma para cada dimensão: rotateX(ângulo), rotateY(ângulo), rotateZ(ângulo)
+// Possui 3 contrapartes 3D para realizar a rotação, uma para cada dimensão: 
+// rotateX(ângulo), rotateY(ângulo), rotateZ(ângulo)
 
 // Escala
 scale(s); // Dimensiona o sistema de coordenadas expandindo ou contraindo-o.
@@ -349,17 +360,17 @@ scale(s); // Dimensiona o sistema de coordenadas expandindo ou contraindo-o.
 */
 
 // Cores
-// Como discuti anteriormente, a cor de fundo pode ser configurada usando a função
-// background(). Você pode definir a cor de um objeto de antemão e depois
+// Como discuti anteriormente, a cor de fundo pode ser configurada usando a 
+// função background(). Você pode definir a cor de um objeto de antemão e depois
 // passar para a função como um argumento.
 color c = cor(255, 255, 255); // BRANCO!
-// Por padrão, o Processing usa o esquema de cores RGB, mas pode ser configurado para
-// HSB usando colorMode(). Leia mais aqui:
+// Por padrão, o Processing usa o esquema de cores RGB, mas pode ser configurado
+//  para HSB usando colorMode(). Leia mais aqui:
 // (https://processing.org/reference/colorMode_.html)
 background(c); // Até agora, a cor de fundo deve ser branca.
 // Você pode usar a função fill() para selecionar a cor para preencher as formas.
-// Tem que ser configurado antes de você começar a desenhar formas para que as cores fiquem
-// aplicadas.
+// Tem que ser configurado antes de você começar a desenhar formas para que as 
+// cores fiquem aplicadas.
 fill(color(0, 0, 0));
 // Se você quiser apenas colorir os contornos das formas, você pode usar
 // função stroke().
@@ -367,16 +378,14 @@ stroke(255, 255, 0, 200); // cor do traço definida para amarelo com transparên
 // definido para um valor menor.
 
 // Imagens
-// O processamento pode renderizar imagens e usá-las de várias maneiras. Principalmente armazenado como
-// Tipo de dados PImage.
+// O processamento pode renderizar imagens e usá-las de várias maneiras. 
+// Principalmente armazenado como Tipo de dados PImage.
 filter(sombreador); // O processamento suporta várias funções de filtro para manipulação de imagens.
 texture(imagem); // PImage pode ser passado em argumentos para mapeamento de textura das formas.
 ```
 
-Se você quiser levar as coisas adiante, há mais coisas que o Processing tem o poder de fazer.
-Renderizar modelos, shaders e outros efeitos. Há muito para se cobrir em uma
-documentação curta, então vou deixá-los aqui. Se você se interessar,
-por favor verifique as referências.
+Se você quiser levar as coisas adiante, há mais coisas que o Processing tem o poder de fazer. Renderizar modelos, shaders e outros efeitos. Há muito para se cobrir em uma
+documentação curta, então vou deixá-los aqui. Se você se interessar, por favor verifique as referências.
 
 ```
 // Antes de prosseguirmos, vou falar um pouco mais sobre como importar bibliotecas
@@ -387,9 +396,10 @@ por favor verifique as referências.
    -------
 */
 
-// As possibilidades do Processing pode ser estendidas ainda mais quando importamos bibliotecas
-// e pacotes em nossos esboços.
-// A instrução de importação pode ser escrita como abaixo na parte superior do código-fonte.
+// As possibilidades do Processing pode ser estendidas ainda mais quando 
+// importamos bibliotecas e pacotes em nossos esboços.
+// A instrução de importação pode ser escrita como abaixo na parte superior 
+// do código-fonte.
 import processing.algumacoisa.*;
 ```
 
@@ -403,9 +413,9 @@ capaz de fazer com poucas linhas de código.
 Copie o código abaixo em seu IDE do Processing e veja a mágica.
 
 ```
-// Isenção de responsabilidade: eu não escrevi este programa porque atualmente estou ocupado com meu
-// estágio e este sketch é adaptado do openprocessing pois mostra
-// algo legal com um código simples.
+// Isenção de responsabilidade: eu não escrevi este programa porque atualmente 
+// estou ocupado com meu estágio e este sketch é adaptado do openprocessing pois
+//  mostra algo legal com um código simples.
 // Recuperado de: (https://www.openprocessing.org/sketch/559769)
 
 float theta;
-- 
cgit v1.2.3


From 75b0cfb4ab74aa11adee90a820366c18be6b185b Mon Sep 17 00:00:00 2001
From: Norwid Behrnd <nbehrnd@yahoo.com>
Date: Mon, 14 Nov 2022 12:14:46 +0100
Subject: trim trailing spaces

An instance of `sed -i 's/ *$//' vim-de.html.markdown`.
---
 de-de/vim-de.html.markdown | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/de-de/vim-de.html.markdown b/de-de/vim-de.html.markdown
index 93fd9773..40e5afe5 100644
--- a/de-de/vim-de.html.markdown
+++ b/de-de/vim-de.html.markdown
@@ -12,7 +12,7 @@ filename: LearnVim-de.txt
 
 [Vim](http://www.vim.org)
 (Vi IMproved) ist ein Klon von vi, dem bekannten Editor für Unix. Es ist ein
-Texteditor, welcher mit Fokus auf Geschwindigkeit und Prouktivität entwickelt 
+Texteditor, welcher mit Fokus auf Geschwindigkeit und Prouktivität entwickelt
 wurde.
 Vim hat viele Keybindings für ein schnelles navigieren und schnelles bearbeiten
 einer Datei.
@@ -168,7 +168,7 @@ Einige wichtige Beispiele von 'Verb', 'Modifier' und 'Nouns':
 
     d2w              # lösche zwei Wörter
     cis              # Ändere innerhalb des Satzes.
-    yip              # Kopiere innerhalb des Abschnitts (kopiere den Abschnitt, 
+    yip              # Kopiere innerhalb des Abschnitts (kopiere den Abschnitt,
                      # in welchem du bist)
     ct<              # Ändere bis zur spitzen Klammer
                      # Ändere den Text von deiner aktuellen Cursorposition bis
@@ -181,7 +181,7 @@ Einige wichtige Beispiele von 'Verb', 'Modifier' und 'Nouns':
 ```
     >                # Rücke die Auswahl um einen Block ein
     <                # Lösche eine Einrückung der Auswahl
-    :earlier 15m     # Stellt das Dokument so wieder her, wie es vor 15 
+    :earlier 15m     # Stellt das Dokument so wieder her, wie es vor 15
                      # Minuten war
     :later 15m       # den oberen Befehl rückgängig machen
     ddp              # Vertauschen zweier aufeinanderfolgenden Zeilen
@@ -195,7 +195,7 @@ Einige wichtige Beispiele von 'Verb', 'Modifier' und 'Nouns':
     ~                # Umschalten der Groß-/Kleinschreibung des ausgewählten Textes
     u                # Ausgewählten Text zu Kleinschreibung ändern
     U                # Ausgewählten Text zu Großschreibung ändern
-    
+
     # Text-Folding (Textfaltung)
     zf               # Erstelle eine Faltung des ausgewählten Textes
     zo               # Öffne die aktuelle Faltung
-- 
cgit v1.2.3


From 8dd734971d05c1a7d9b0709df546ce8ae11fc34b Mon Sep 17 00:00:00 2001
From: Norwid Behrnd <nbehrnd@yahoo.com>
Date: Mon, 14 Nov 2022 12:15:37 +0100
Subject: trim leading spaces (needs manual correction)

An instance of `sed -i 's/^ *//' vim-de.html.markdown`.
---
 de-de/vim-de.html.markdown | 292 ++++++++++++++++++++++-----------------------
 1 file changed, 146 insertions(+), 146 deletions(-)

diff --git a/de-de/vim-de.html.markdown b/de-de/vim-de.html.markdown
index 40e5afe5..707bae5b 100644
--- a/de-de/vim-de.html.markdown
+++ b/de-de/vim-de.html.markdown
@@ -3,9 +3,9 @@ category: tool
 tool: vim
 lang: de-de
 contributors:
-    - ["RadhikaG", "https://github.com/RadhikaG"]
+- ["RadhikaG", "https://github.com/RadhikaG"]
 translators:
-    - ["caminsha", "https://github.com/caminsha"]
+- ["caminsha", "https://github.com/caminsha"]
 filename: LearnVim-de.txt
 ---
 
@@ -20,74 +20,74 @@ einer Datei.
 ## Grundlagen, um in Vim zu navigieren
 
 ```
-    vim <filename>   # Öffne <filename> in Vim
-    :help <topic>    # Öffne die eingebaute Hilfe zum Thema  <topic>, wenn
-                     # es existiert
-    :q               # Schließe vim
-    :w               # Speichere diese Datei
-    :wq              # Speichere diese Datei und schließe vim
-    ZZ               # Speichere diese Datei und schließe vim
-    :q!              # Schließe vim ohne die Datei zu speichern
-                     # ! *zwingt* die Ausführung von :q,
-                     # daher wird die Datei nicht gespeichert.
-    ZQ               # Beende vim ohne die Datei zu speichern
-    :x               # Speichere die Datei und beende vim
-                     # Dies ist eine kürzere Version von :wq
-
-    u                # Änderung rückgängig machen
-    CTRL+R           # Änderung wiederherstellen
-
-    h                # Den Cursor um ein Zeichen nach links bewegen
-    j                # Den Cursor eine Zeile nach unten bewegen
-    k                # Den Cursor eine Zeile nach oben bewegen
-    l                # Den Cursor um ein Zeichen nach rechts bewegen
-
-    Ctrl+B 	         # Gehe eine Bildschirmanzeige zurück
-    Ctrl+F 	         # Gehe eine Bildschirmanzeige vorwärts
-    Ctrl+D 	         # Gehe eine halbe Bildschirmanzeige vorwärts
-    Ctrl+U           # Gehe eine halbe Bildschirmanzeige zurück
-
-    # Navigieren innerhalb einer Zeile
-
-    0                # Navigiere zum Anfang der Zeile
-    $                # Navigiere zum Ende der Zeile
-    ^                # Navigiere zum ersten Zeichen, welches kein Leerzeichen ist
-
-    # Im Text suchen
-
-    /word            # Hebt alle Ergebnisse nach dem Cursor hervor
-    ?word            # Hebt alle Ergebnisse vor dem Cursor hervor
-    n                # Bewegt den Cursor zum nächsten Ergebnis nach der Suche
-    N                # Bewegt den Cursor zum vorherigen Ergebnis der Suche
-
-    :%s/foo/bar/g    # Ersetze "foo" durch "bar" in allen Zeilen
-    :s/foo/bar/g     # Ersetze "foo" durch "bar" in der aktuellen Zeile
-    :%s/\n/\r/g      # Ersetze das newline-Zeichen bei allen Zeilen durch
-                     # ein carriage return
-
-    # Zu einzelnen Zeichen springen
-
-    f<character>     # Springe vorwärts und auf dem Zeichen  <character>
-    t<character>     # Springe vorwärts und lande vor dem Zeichen <character>
-
-    # Zum Beispiel,
-    f<               # Springe vorwärts und lande auf <
-    t<               # Springe vorwärts und lande vor <
-
-    # Wortweise navigieren
-
-    w                # Springe um ein Wort vorwärts
-    b                # Gehe ein Wort zurück
-    e                # Springe zum Ende des aktuellen Wortes
-
-    # Weitere Befehle, um zu navigieren
-
-    gg               # Gehe an den Start der Datei
-    G                # Gehe an das Ende der Datei
-    :NUM             # Springe zur Zeile NUM (NUM kann eine beliebige Zahl sein)
-    H                # Navigiere zum Start der aktuellen Bildschirmanzeige
-    M                # Navigiere in die Mitte der aktuellen Bildschirmanzeige
-    L                # Navigiere an das Ende der aktuellen Bildschirmanzeige
+vim <filename>   # Öffne <filename> in Vim
+:help <topic>    # Öffne die eingebaute Hilfe zum Thema  <topic>, wenn
+# es existiert
+:q               # Schließe vim
+:w               # Speichere diese Datei
+:wq              # Speichere diese Datei und schließe vim
+ZZ               # Speichere diese Datei und schließe vim
+:q!              # Schließe vim ohne die Datei zu speichern
+# ! *zwingt* die Ausführung von :q,
+# daher wird die Datei nicht gespeichert.
+ZQ               # Beende vim ohne die Datei zu speichern
+:x               # Speichere die Datei und beende vim
+# Dies ist eine kürzere Version von :wq
+
+u                # Änderung rückgängig machen
+CTRL+R           # Änderung wiederherstellen
+
+h                # Den Cursor um ein Zeichen nach links bewegen
+j                # Den Cursor eine Zeile nach unten bewegen
+k                # Den Cursor eine Zeile nach oben bewegen
+l                # Den Cursor um ein Zeichen nach rechts bewegen
+
+Ctrl+B 	         # Gehe eine Bildschirmanzeige zurück
+Ctrl+F 	         # Gehe eine Bildschirmanzeige vorwärts
+Ctrl+D 	         # Gehe eine halbe Bildschirmanzeige vorwärts
+Ctrl+U           # Gehe eine halbe Bildschirmanzeige zurück
+
+# Navigieren innerhalb einer Zeile
+
+0                # Navigiere zum Anfang der Zeile
+$                # Navigiere zum Ende der Zeile
+^                # Navigiere zum ersten Zeichen, welches kein Leerzeichen ist
+
+# Im Text suchen
+
+/word            # Hebt alle Ergebnisse nach dem Cursor hervor
+?word            # Hebt alle Ergebnisse vor dem Cursor hervor
+n                # Bewegt den Cursor zum nächsten Ergebnis nach der Suche
+N                # Bewegt den Cursor zum vorherigen Ergebnis der Suche
+
+:%s/foo/bar/g    # Ersetze "foo" durch "bar" in allen Zeilen
+:s/foo/bar/g     # Ersetze "foo" durch "bar" in der aktuellen Zeile
+:%s/\n/\r/g      # Ersetze das newline-Zeichen bei allen Zeilen durch
+# ein carriage return
+
+# Zu einzelnen Zeichen springen
+
+f<character>     # Springe vorwärts und auf dem Zeichen  <character>
+t<character>     # Springe vorwärts und lande vor dem Zeichen <character>
+
+# Zum Beispiel,
+f<               # Springe vorwärts und lande auf <
+t<               # Springe vorwärts und lande vor <
+
+# Wortweise navigieren
+
+w                # Springe um ein Wort vorwärts
+b                # Gehe ein Wort zurück
+e                # Springe zum Ende des aktuellen Wortes
+
+# Weitere Befehle, um zu navigieren
+
+gg               # Gehe an den Start der Datei
+G                # Gehe an das Ende der Datei
+:NUM             # Springe zur Zeile NUM (NUM kann eine beliebige Zahl sein)
+H                # Navigiere zum Start der aktuellen Bildschirmanzeige
+M                # Navigiere in die Mitte der aktuellen Bildschirmanzeige
+L                # Navigiere an das Ende der aktuellen Bildschirmanzeige
 ```
 
 ## Hilfsdokumente:
@@ -110,22 +110,22 @@ Vim basiert auf dem Konzept von **modes**.
 - Ex Mode      - Wird verwendet, um im ':'-Prompt Befehle einzugeben
 
 ```
-    i                # Führt vim in den Insert Mode, vor der Cursorposition
-    a                # Führt vim in den Insert Mode, nach der Cursorposition
-    v                # Führt vim in den Visual Mode
-    :                # Führt vim in den Ex Mode
-    <esc>            # Führt zurück in den Command Mode, egal in welchem Mode
-                     # man sich gerade befindet.
-
-    # Kopieren und einfügen von Text
-
-    y                # Kopiere alles, was im Moment ausgewählt ist
-    yy               # Kopiert die aktuelle Zeile
-    d                # Löscht alles, was im Moment ausgewählt ist
-    dd               # Löscht die aktuelle Zeile
-    p                # Fügt den kopierten Text nach dem Cursor ein
-    P                # Fügt den kopierten Text vor dem Cursor ein
-    x                # Löscht das Zeichen unter dem Cursor
+i                # Führt vim in den Insert Mode, vor der Cursorposition
+a                # Führt vim in den Insert Mode, nach der Cursorposition
+v                # Führt vim in den Visual Mode
+:                # Führt vim in den Ex Mode
+<esc>            # Führt zurück in den Command Mode, egal in welchem Mode
+# man sich gerade befindet.
+
+# Kopieren und einfügen von Text
+
+y                # Kopiere alles, was im Moment ausgewählt ist
+yy               # Kopiert die aktuelle Zeile
+d                # Löscht alles, was im Moment ausgewählt ist
+dd               # Löscht die aktuelle Zeile
+p                # Fügt den kopierten Text nach dem Cursor ein
+P                # Fügt den kopierten Text vor dem Cursor ein
+x                # Löscht das Zeichen unter dem Cursor
 ```
 
 ## Die 'Grammatik' von Vim
@@ -140,68 +140,68 @@ Vim kann als Satz von Kommandos angesehen werden, welche im Format
 Einige wichtige Beispiele von 'Verb', 'Modifier' und 'Nouns':
 
 ```
-    # 'Verb'
-
-    d                # löschen
-    c                # ändern
-    y                # kopieren
-    v                # visuelles auswählen
-
-    # 'Modifiers'
-
-    i                # innerhalb
-    a                # außerhalb
-    NUM              # Nummer (NUM kann irgendeine Zahl sein)
-    f                # Sucht nach etwas und landet darauf
-    t                # Sucht nach etwas und stoppt davor
-    /                # Suche eine Zeichenfolge ab dem Cursor
-    ?                # Suche eine Zeichenfolge vor dem Cursor
-
-    # 'Nouns'
-
-    w                # Wort
-    s                # Satz
-    p                # Abschnitt
-    b                # Block
-
-    # Beispielsätze resp. Kommandos
-
-    d2w              # lösche zwei Wörter
-    cis              # Ändere innerhalb des Satzes.
-    yip              # Kopiere innerhalb des Abschnitts (kopiere den Abschnitt,
-                     # in welchem du bist)
-    ct<              # Ändere bis zur spitzen Klammer
-                     # Ändere den Text von deiner aktuellen Cursorposition bis
-                     # zur nächsten spitzen Klammer
-    d$               # Lösche bis zum Ende der Zeile
+# 'Verb'
+
+d                # löschen
+c                # ändern
+y                # kopieren
+v                # visuelles auswählen
+
+# 'Modifiers'
+
+i                # innerhalb
+a                # außerhalb
+NUM              # Nummer (NUM kann irgendeine Zahl sein)
+f                # Sucht nach etwas und landet darauf
+t                # Sucht nach etwas und stoppt davor
+/                # Suche eine Zeichenfolge ab dem Cursor
+?                # Suche eine Zeichenfolge vor dem Cursor
+
+# 'Nouns'
+
+w                # Wort
+s                # Satz
+p                # Abschnitt
+b                # Block
+
+# Beispielsätze resp. Kommandos
+
+d2w              # lösche zwei Wörter
+cis              # Ändere innerhalb des Satzes.
+yip              # Kopiere innerhalb des Abschnitts (kopiere den Abschnitt,
+# in welchem du bist)
+ct<              # Ändere bis zur spitzen Klammer
+# Ändere den Text von deiner aktuellen Cursorposition bis
+# zur nächsten spitzen Klammer
+d$               # Lösche bis zum Ende der Zeile
 ```
 
 ## Einige Shortcuts und Tricks
 
 ```
-    >                # Rücke die Auswahl um einen Block ein
-    <                # Lösche eine Einrückung der Auswahl
-    :earlier 15m     # Stellt das Dokument so wieder her, wie es vor 15
-                     # Minuten war
-    :later 15m       # den oberen Befehl rückgängig machen
-    ddp              # Vertauschen zweier aufeinanderfolgenden Zeilen
-                     # Zuerst dd, dann p
-    .                # Wiederhole die vorherige Aktion
-    :w !sudo tee %   # Speichere die Datei als Root
-    :set syntax=c    # Stelle das Syntax-Highlighting für 'C' ein
-    :sort            # Alle Zeilen sortieren
-    :sort!           # Alle Zeilen rückwärts sortieren
-    :sort u          # Alle Zeilen sortieren und Duplikate entfernen
-    ~                # Umschalten der Groß-/Kleinschreibung des ausgewählten Textes
-    u                # Ausgewählten Text zu Kleinschreibung ändern
-    U                # Ausgewählten Text zu Großschreibung ändern
-
-    # Text-Folding (Textfaltung)
-    zf               # Erstelle eine Faltung des ausgewählten Textes
-    zo               # Öffne die aktuelle Faltung
-    zc               # Schließe die aktuelle Faltung
-    zR               # Öffne alle Faltungen
-    zM               # Schließe alle Faltungen
+>                # Rücke die Auswahl um einen Block ein
+<                # Lösche eine Einrückung der Auswahl
+:earlier 15m     # Stellt das Dokument so wieder her, wie es vor 15
+# Minuten war
+:later 15m       # den oberen Befehl rückgängig machen
+ddp              # Vertauschen zweier aufeinanderfolgenden Zeilen
+# Zuerst dd, dann p
+.                # Wiederhole die vorherige Aktion
+:w !sudo tee %   # Speichere die Datei als Root
+:set syntax=c    # Stelle das Syntax-Highlighting für 'C' ein
+:sort            # Alle Zeilen sortieren
+:sort!           # Alle Zeilen rückwärts sortieren
+:sort u          # Alle Zeilen sortieren und Duplikate entfernen
+~                # Umschalten der Groß-/Kleinschreibung des ausgewählten Textes
+u                # Ausgewählten Text zu Kleinschreibung ändern
+U                # Ausgewählten Text zu Großschreibung ändern
+
+# Text-Folding (Textfaltung)
+zf               # Erstelle eine Faltung des ausgewählten Textes
+zo               # Öffne die aktuelle Faltung
+zc               # Schließe die aktuelle Faltung
+zR               # Öffne alle Faltungen
+zM               # Schließe alle Faltungen
 ```
 
 ## Makros
@@ -212,9 +212,9 @@ Kommandos, welche du braucht, aufgenommen bis die Aufnahme gestoppt wird.
 Wenn du ein Makro ausführst, werden exakt die gleichen Schritte gemacht.
 
 ```
-    qa               # Starte das Aufnehmen des Makros 'a'
-    q                # Beende das Aufnehmen
-    @a               # Führe das Makro 'a' aus
+qa               # Starte das Aufnehmen des Makros 'a'
+q                # Beende das Aufnehmen
+@a               # Führe das Makro 'a' aus
 ```
 
 ### Konfigurieren mit ~/.vimrc
-- 
cgit v1.2.3


From 07ec65627438412c973209d8c489ef21ef16fb4a Mon Sep 17 00:00:00 2001
From: Norwid Behrnd <nbehrnd@yahoo.com>
Date: Mon, 14 Nov 2022 12:24:52 +0100
Subject: correct/reinstall indentations

There were a few 'false positives' applying sed's rule to remove
leading spaces.  This commit corrects this.
---
 de-de/vim-de.html.markdown | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/de-de/vim-de.html.markdown b/de-de/vim-de.html.markdown
index 707bae5b..70082feb 100644
--- a/de-de/vim-de.html.markdown
+++ b/de-de/vim-de.html.markdown
@@ -13,26 +13,25 @@ filename: LearnVim-de.txt
 [Vim](http://www.vim.org)
 (Vi IMproved) ist ein Klon von vi, dem bekannten Editor für Unix. Es ist ein
 Texteditor, welcher mit Fokus auf Geschwindigkeit und Prouktivität entwickelt
-wurde.
-Vim hat viele Keybindings für ein schnelles navigieren und schnelles bearbeiten
-einer Datei.
+wurde. Vim hat viele Keybindings für ein schnelles navigieren und schnelles
+bearbeiten einer Datei.
 
 ## Grundlagen, um in Vim zu navigieren
 
 ```
 vim <filename>   # Öffne <filename> in Vim
 :help <topic>    # Öffne die eingebaute Hilfe zum Thema  <topic>, wenn
-# es existiert
+                 # es existiert
 :q               # Schließe vim
 :w               # Speichere diese Datei
 :wq              # Speichere diese Datei und schließe vim
 ZZ               # Speichere diese Datei und schließe vim
 :q!              # Schließe vim ohne die Datei zu speichern
-# ! *zwingt* die Ausführung von :q,
-# daher wird die Datei nicht gespeichert.
+                 # ! *zwingt* die Ausführung von :q,
+                 # daher wird die Datei nicht gespeichert.
 ZQ               # Beende vim ohne die Datei zu speichern
 :x               # Speichere die Datei und beende vim
-# Dies ist eine kürzere Version von :wq
+                 # Dies ist eine kürzere Version von :wq
 
 u                # Änderung rückgängig machen
 CTRL+R           # Änderung wiederherstellen
@@ -63,7 +62,7 @@ N                # Bewegt den Cursor zum vorherigen Ergebnis der Suche
 :%s/foo/bar/g    # Ersetze "foo" durch "bar" in allen Zeilen
 :s/foo/bar/g     # Ersetze "foo" durch "bar" in der aktuellen Zeile
 :%s/\n/\r/g      # Ersetze das newline-Zeichen bei allen Zeilen durch
-# ein carriage return
+                 # ein carriage return
 
 # Zu einzelnen Zeichen springen
 
@@ -115,7 +114,7 @@ a                # Führt vim in den Insert Mode, nach der Cursorposition
 v                # Führt vim in den Visual Mode
 :                # Führt vim in den Ex Mode
 <esc>            # Führt zurück in den Command Mode, egal in welchem Mode
-# man sich gerade befindet.
+                 # man sich gerade befindet.
 
 # Kopieren und einfügen von Text
 
@@ -169,10 +168,10 @@ b                # Block
 d2w              # lösche zwei Wörter
 cis              # Ändere innerhalb des Satzes.
 yip              # Kopiere innerhalb des Abschnitts (kopiere den Abschnitt,
-# in welchem du bist)
+                 # in welchem du bist)
 ct<              # Ändere bis zur spitzen Klammer
-# Ändere den Text von deiner aktuellen Cursorposition bis
-# zur nächsten spitzen Klammer
+                 # Ändere den Text von deiner aktuellen Cursorposition bis
+                 # zur nächsten spitzen Klammer
 d$               # Lösche bis zum Ende der Zeile
 ```
 
@@ -181,11 +180,10 @@ d$               # Lösche bis zum Ende der Zeile
 ```
 >                # Rücke die Auswahl um einen Block ein
 <                # Lösche eine Einrückung der Auswahl
-:earlier 15m     # Stellt das Dokument so wieder her, wie es vor 15
-# Minuten war
+:earlier 15m     # Stellt das Dokument so wieder her, wie es vor 15 Minuten war
 :later 15m       # den oberen Befehl rückgängig machen
 ddp              # Vertauschen zweier aufeinanderfolgenden Zeilen
-# Zuerst dd, dann p
+                 # Zuerst dd, dann p
 .                # Wiederhole die vorherige Aktion
 :w !sudo tee %   # Speichere die Datei als Root
 :set syntax=c    # Stelle das Syntax-Highlighting für 'C' ein
-- 
cgit v1.2.3


From df4dacd110bc69aec68ad5d4487981c0c4c233a4 Mon Sep 17 00:00:00 2001
From: Norwid Behrnd <nbehrnd@yahoo.com>
Date: Mon, 14 Nov 2022 12:28:17 +0100
Subject: A spellcheck

---
 de-de/vim-de.html.markdown | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/de-de/vim-de.html.markdown b/de-de/vim-de.html.markdown
index 70082feb..8aeddeb4 100644
--- a/de-de/vim-de.html.markdown
+++ b/de-de/vim-de.html.markdown
@@ -12,7 +12,7 @@ filename: LearnVim-de.txt
 
 [Vim](http://www.vim.org)
 (Vi IMproved) ist ein Klon von vi, dem bekannten Editor für Unix. Es ist ein
-Texteditor, welcher mit Fokus auf Geschwindigkeit und Prouktivität entwickelt
+Texteditor, welcher mit Fokus auf Geschwindigkeit und Produktivität entwickelt
 wurde. Vim hat viele Keybindings für ein schnelles navigieren und schnelles
 bearbeiten einer Datei.
 
@@ -97,7 +97,6 @@ Zum Beispiel öffnet `:help navigation` die Dokumentation über das Navigieren
 
 `:help` kann auch ohne ein Argument verwendet werden. Dies zeigt den Standard-
 Hilfsdialog an, welcher den Start mit vim einfacher macht.
-that aims to make getting started with vim more approachable!
 
 ## Modi:
 
-- 
cgit v1.2.3


From 437ebf772b4e3688f4cb98b3f29cc472e6fdf35b Mon Sep 17 00:00:00 2001
From: Norwid Behrnd <nbehrnd@yahoo.com>
Date: Mon, 14 Nov 2022 12:33:52 +0100
Subject: use markdownlint for additional improvements

Accounts for a selection of issues identified by markdownlint.[1]

[1] https://github.com/markdownlint/markdownlint, version 0.12.0.
---
 de-de/vim-de.html.markdown | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/de-de/vim-de.html.markdown b/de-de/vim-de.html.markdown
index 8aeddeb4..f3dd12e5 100644
--- a/de-de/vim-de.html.markdown
+++ b/de-de/vim-de.html.markdown
@@ -9,7 +9,6 @@ translators:
 filename: LearnVim-de.txt
 ---
 
-
 [Vim](http://www.vim.org)
 (Vi IMproved) ist ein Klon von vi, dem bekannten Editor für Unix. Es ist ein
 Texteditor, welcher mit Fokus auf Geschwindigkeit und Produktivität entwickelt
@@ -41,9 +40,9 @@ j                # Den Cursor eine Zeile nach unten bewegen
 k                # Den Cursor eine Zeile nach oben bewegen
 l                # Den Cursor um ein Zeichen nach rechts bewegen
 
-Ctrl+B 	         # Gehe eine Bildschirmanzeige zurück
-Ctrl+F 	         # Gehe eine Bildschirmanzeige vorwärts
-Ctrl+D 	         # Gehe eine halbe Bildschirmanzeige vorwärts
+Ctrl+B           # Gehe eine Bildschirmanzeige zurück
+Ctrl+F           # Gehe eine Bildschirmanzeige vorwärts
+Ctrl+D           # Gehe eine halbe Bildschirmanzeige vorwärts
 Ctrl+U           # Gehe eine halbe Bildschirmanzeige zurück
 
 # Navigieren innerhalb einer Zeile
@@ -89,7 +88,7 @@ M                # Navigiere in die Mitte der aktuellen Bildschirmanzeige
 L                # Navigiere an das Ende der aktuellen Bildschirmanzeige
 ```
 
-## Hilfsdokumente:
+## Hilfsdokumente
 
 Vim hat eine eingebaute Dokumentation, welche mit `:help <topic>` aufgerufen
 werden kann.
@@ -98,13 +97,13 @@ Zum Beispiel öffnet `:help navigation` die Dokumentation über das Navigieren
 `:help` kann auch ohne ein Argument verwendet werden. Dies zeigt den Standard-
 Hilfsdialog an, welcher den Start mit vim einfacher macht.
 
-## Modi:
+## Modi
 
 Vim basiert auf dem Konzept von **modes**.
 
-- Command Mode - Vim startet in diesem Modus, hier kann man navigieren und Befehle eingeben
+- Command Mode - Vim erster Modus, hier kann man navigieren und Befehle eingeben
 - Insert Mode  - Wird verwendet, um Änderungen in der Datei zu machen.
-- Visual Mode  - Wird verwendet, um Text zu markieren und Operationen durchzuführen
+- Visual Mode  - Wird verwendet, um Text zu markieren und diesen zu verändern
 - Ex Mode      - Wird verwendet, um im ':'-Prompt Befehle einzugeben
 
 ```
-- 
cgit v1.2.3


From 0cdb0f0c065d961ff612171a60daddbfbcf5d23f Mon Sep 17 00:00:00 2001
From: nbehrnd <nbehrnd@users.noreply.github.com>
Date: Mon, 14 Nov 2022 12:54:14 +0100
Subject: Update vim-de.html.markdown

---
 de-de/vim-de.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/de-de/vim-de.html.markdown b/de-de/vim-de.html.markdown
index f3dd12e5..d0b4eb9d 100644
--- a/de-de/vim-de.html.markdown
+++ b/de-de/vim-de.html.markdown
@@ -101,7 +101,7 @@ Hilfsdialog an, welcher den Start mit vim einfacher macht.
 
 Vim basiert auf dem Konzept von **modes**.
 
-- Command Mode - Vim erster Modus, hier kann man navigieren und Befehle eingeben
+- Command Mode - Vims erster Modus, hier kann man navigieren und Befehle eingeben
 - Insert Mode  - Wird verwendet, um Änderungen in der Datei zu machen.
 - Visual Mode  - Wird verwendet, um Text zu markieren und diesen zu verändern
 - Ex Mode      - Wird verwendet, um im ':'-Prompt Befehle einzugeben
-- 
cgit v1.2.3


From 847f5c22590cf6ec6401caf31c2b1744cb67ae1a Mon Sep 17 00:00:00 2001
From: Alexander Hecke <26191361+heckelson@users.noreply.github.com>
Date: Tue, 15 Nov 2022 10:29:45 +0100
Subject: Remove dead link

---
 hy.html.markdown | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/hy.html.markdown b/hy.html.markdown
index 1287095f..f6bdead0 100644
--- a/hy.html.markdown
+++ b/hy.html.markdown
@@ -13,8 +13,7 @@ hy to call native python code or python to call native hy code as well
 This tutorial works for hy ≥ 0.9.12, with some corrections for hy 0.11.
 
 ```clojure
-;; this gives an gentle introduction to hy for a quick trial head to
-;; http://try-hy.appspot.com
+;; this gives an gentle introduction to hy
 ;;
 ; Semicolon comments, like other LISPS
 
-- 
cgit v1.2.3


From 155ed84239fd5064dc7238fa054c8688dedd5c73 Mon Sep 17 00:00:00 2001
From: Kemel Zaidan <kemelzaidan@gmail.com>
Date: Wed, 16 Nov 2022 11:38:26 -0300
Subject: Update processing-pt.html.markdown

Fixing a typo to capital letter since it refers to the language name
---
 pt-br/processing-pt.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pt-br/processing-pt.html.markdown b/pt-br/processing-pt.html.markdown
index 229aec07..b9b5b4ea 100644
--- a/pt-br/processing-pt.html.markdown
+++ b/pt-br/processing-pt.html.markdown
@@ -171,7 +171,7 @@ float sr = sqrt(25); // sr = 5.0
 // aqui. (https://processing.org/reference/PVector.html)
 
 // Trigonometria
-// O processamento também suporta operações trigonométricas fornecendo um 
+// O Processamento também suporta operações trigonométricas fornecendo um 
 // conjunto de funções. sin(), cos(), tan(), asin(), acos(), atan() e também 
 // degrees() e radians() para conversão conveniente.
 // No entanto, essas funções usam o ângulo em radianos como parâmetro, então é 
@@ -476,4 +476,4 @@ e até mesmo suas próprias aulas. (Confie em mim! O processamento de projetos p
 ## Alguns recursos úteis
 
   - [Site do Processing](http://processing.org)
-  - [Sketches em Processing](http://openprocessing.org)
\ No newline at end of file
+  - [Sketches em Processing](http://openprocessing.org)
-- 
cgit v1.2.3


From f1c573417500e13c9aab7590e1e3873b7262b8d4 Mon Sep 17 00:00:00 2001
From: Kemel Zaidan <kemelzaidan@gmail.com>
Date: Wed, 16 Nov 2022 11:46:14 -0300
Subject: Update processing-pt.html.markdown

Fixing some translation errors
---
 pt-br/processing-pt.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pt-br/processing-pt.html.markdown b/pt-br/processing-pt.html.markdown
index b9b5b4ea..880e1377 100644
--- a/pt-br/processing-pt.html.markdown
+++ b/pt-br/processing-pt.html.markdown
@@ -171,7 +171,7 @@ float sr = sqrt(25); // sr = 5.0
 // aqui. (https://processing.org/reference/PVector.html)
 
 // Trigonometria
-// O Processamento também suporta operações trigonométricas fornecendo um 
+// O Processing também suporta operações trigonométricas fornecendo um 
 // conjunto de funções. sin(), cos(), tan(), asin(), acos(), atan() e também 
 // degrees() e radians() para conversão conveniente.
 // No entanto, essas funções usam o ângulo em radianos como parâmetro, então é 
@@ -293,7 +293,7 @@ arc(x, y, largura, altura, inicio, fim, [modo]);
 // CHORD porém sem contorno
 
 // Curvas
-// O processamento fornece duas implementações de curvas; usando curve() e 
+// O Processing fornece duas implementações de curvas; usando curve() e 
 // bezier(). Como pretendo manter isso simples, não vou discutir mais detalhes.
 // No entanto, se você quiser implementá-lo em seu sketch, aqui estão as 
 // referências: (https://processing.org/reference/curve_.html)
-- 
cgit v1.2.3


From a4a507bef1249840b3ed44aca018ff2234f2457c Mon Sep 17 00:00:00 2001
From: Kemel Zaidan <kemelzaidan@gmail.com>
Date: Wed, 16 Nov 2022 11:52:34 -0300
Subject: Update processing-pt.html.markdown

Last typo changes left
---
 pt-br/processing-pt.html.markdown | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/pt-br/processing-pt.html.markdown b/pt-br/processing-pt.html.markdown
index 880e1377..5ed2950a 100644
--- a/pt-br/processing-pt.html.markdown
+++ b/pt-br/processing-pt.html.markdown
@@ -5,7 +5,7 @@ contributors:
     - ["Phone Thant Ko", "http://github.com/phonethantko"]
     - ["Divay Prakash", "https://github.com/divayprakash"]
 translators:
-	- ["Kemel Zaidan", "https://github.com/kemelzaidan"]
+    - ["Kemel Zaidan", "https://github.com/kemelzaidan"]
 lang: pt-br
 ---
 
@@ -19,7 +19,8 @@ Embora a linguagem seja baseada na linguagem Java, sua sintaxe foi amplamente
 influenciado por ambas as sintaxes Java e Javascript.
 [Veja mais aqui](https://processing.org/reference/)
 
-A linguagem é tipada estaticamente e também vem com a sua IDE oficial para
+A linguagem é tipada estaticamente e também vem com o seu Ambiente de Desenvolvimento
+Integrado (do inglês Integrated Development Environment - IDE) oficial para
 compilar e executar os scripts.
 
 ```
@@ -47,7 +48,7 @@ compilar e executar os scripts.
 // Observação! A sintaxe é muito semelhante à do C++.
 void setup() {
   // Isso imprime a saída clássica "Hello World!" no console quando executado.
-  println("Olá Mundo!"); // Outra linguagem cilada para ponto e vírgula, não é?
+  println("Olá Mundo!"); // Mais uma linguagem com esse maldito ponto e vírgula, não é?
 }
 
 // Normalmente, colocamos todos os códigos estáticos dentro do método setup() 
@@ -244,7 +245,7 @@ exit(); // Isso para o programa. É útil para programas com draw()
 ## Desenho com Processing
 
 Como você já deve ter entendido o básico da linguagem, vamos agora
-veja a melhor parte do Processing - DESENHAR.
+ver a melhor parte do Processing - DESENHAR.
 
 ```
 /* ------
@@ -378,9 +379,9 @@ stroke(255, 255, 0, 200); // cor do traço definida para amarelo com transparên
 // definido para um valor menor.
 
 // Imagens
-// O processamento pode renderizar imagens e usá-las de várias maneiras. 
+// O Processing pode renderizar imagens e usá-las de várias maneiras. 
 // Principalmente armazenado como Tipo de dados PImage.
-filter(sombreador); // O processamento suporta várias funções de filtro para manipulação de imagens.
+filter(sombreador); // O Processing suporta várias funções de filtro para manipulação de imagens.
 texture(imagem); // PImage pode ser passado em argumentos para mapeamento de textura das formas.
 ```
 
@@ -466,12 +467,12 @@ void branch(float len) {
 }
 ```
 
-O processamento é fácil de aprender e é particularmente útil para criar
+A linguagem Processing é fácil de aprender e é particularmente útil para criar
 conteúdo (mesmo em 3D) sem ter que digitar muitos códigos. É tão simples
 que você pode ler o código e ter uma ideia aproximada do fluxo do programa.
 
 No entanto, isso não se aplica quando você introduz bibliotecas externas, pacotes
-e até mesmo suas próprias aulas. (Confie em mim! O processamento de projetos pode ficar realmente monstruoso...)
+e até mesmo suas próprias aulas. (Confie em mim! Projetos em processing podem ficar realmente monstruosos...)
 
 ## Alguns recursos úteis
 
-- 
cgit v1.2.3


From 32aad6aaf2a808d0efcb4b2b787db84c31762bda Mon Sep 17 00:00:00 2001
From: precondition <57645186+precondition@users.noreply.github.com>
Date: Wed, 16 Nov 2022 23:30:30 +0100
Subject: =?UTF-8?q?Fix=20typo:=20sting=20=E2=86=92=20string?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 cobol.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cobol.html.markdown b/cobol.html.markdown
index 1c858396..1350c66f 100644
--- a/cobol.html.markdown
+++ b/cobol.html.markdown
@@ -132,7 +132,7 @@ organizations.
       
       *Now it is time to learn about two related COBOL verbs: string and unstring.
 
-      *The string verb is used to concatenate, or put together, two or more stings.
+      *The string verb is used to concatenate, or put together, two or more strings.
       *Unstring is used, not surprisingly, to separate a         
       *string into two or more smaller strings. 
       *It is important that you remember to use ‘delimited by’ when you
-- 
cgit v1.2.3


From 2a56a9cc5ecd7a4daf6c8b90c2f4ad51d1e75ce2 Mon Sep 17 00:00:00 2001
From: Norwid Behrnd <nbehrnd@yahoo.com>
Date: Wed, 23 Nov 2022 20:48:05 +0100
Subject: run `sed -i "s/ *$//" awk.html.markdown`

Remove of trailing spaces.
---
 awk.html.markdown | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/awk.html.markdown b/awk.html.markdown
index 34013251..55b8e5da 100644
--- a/awk.html.markdown
+++ b/awk.html.markdown
@@ -118,11 +118,11 @@ BEGIN {
     # Arrays
     arr[0] = "foo";
     arr[1] = "bar";
-    
+
     # You can also initialize an array with the built-in function split()
-    
+
     n = split("foo:bar:baz", arr, ":");
-   
+
     # You also have associative arrays (actually, they're all associative arrays)
     assoc["foo"] = "bar";
     assoc["bar"] = "baz";
@@ -240,7 +240,7 @@ function io_functions(    localvar) {
     # for this can be treated as a file handle, for purposes of I/O. This makes
     # it feel sort of like shell scripting, but to get the same output, the string
     # must match exactly, so use a variable:
-    
+
     outfile = "/tmp/foobar.txt";
 
     print "foobar" > outfile;
@@ -261,7 +261,7 @@ function io_functions(    localvar) {
 
     # Reads a line from a file and stores in localvar
     infile = "/tmp/foobar.txt";
-    getline localvar < infile; 
+    getline localvar < infile;
     close(infile);
 }
 
@@ -273,10 +273,10 @@ function io_functions(    localvar) {
 # When you pass arguments to AWK, they are treated as file names to process.
 # It will process them all, in order. Think of it like an implicit for loop,
 # iterating over the lines in these files. these patterns and actions are like
-# switch statements inside the loop. 
+# switch statements inside the loop.
 
 /^fo+bar$/ {
-    
+
     # This action will execute for every line that matches the regular
     # expression, /^fo+bar$/, and will be skipped for any line that fails to
     # match it. Let's just print the line:
@@ -382,5 +382,5 @@ Further Reading:
 * [Awk man page](https://linux.die.net/man/1/awk)
 * [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU Awk is found on most Linux systems.
 * [AWK one-liner collection](http://tuxgraphics.org/~guido/scripts/awk-one-liner.html)
-* [Awk alpinelinux wiki](https://wiki.alpinelinux.org/wiki/Awk) a technical summary and list of "gotchas" (places where different implementations may behave in different or unexpected ways). 
+* [Awk alpinelinux wiki](https://wiki.alpinelinux.org/wiki/Awk) a technical summary and list of "gotchas" (places where different implementations may behave in different or unexpected ways).
 * [basic libraries for awk](https://github.com/dubiousjim/awkenough)
-- 
cgit v1.2.3


From 15c75c28b94d1700d75baba4346e70beb43d8137 Mon Sep 17 00:00:00 2001
From: Norwid Behrnd <nbehrnd@yahoo.com>
Date: Wed, 23 Nov 2022 20:53:39 +0100
Subject: rm overly long lines, consider markdownlint

Lines longer than 80 characters are edited.  Within reason, issues
identified by markdownlint[1] are equally curated.

[1] https://github.com/markdownlint/markdownlint, version 0.12.0
---
 awk.html.markdown | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/awk.html.markdown b/awk.html.markdown
index 55b8e5da..dc22a2bd 100644
--- a/awk.html.markdown
+++ b/awk.html.markdown
@@ -123,7 +123,7 @@ BEGIN {
 
     n = split("foo:bar:baz", arr, ":");
 
-    # You also have associative arrays (actually, they're all associative arrays)
+    # You also have associative arrays (indeed, they're all associative arrays)
     assoc["foo"] = "bar";
     assoc["bar"] = "baz";
 
@@ -216,7 +216,8 @@ function string_functions(    localvar, arr) {
     match(localvar, "t"); # => 4, since the 't' is the fourth character
 
     # Split on a delimiter
-    n = split("foo-bar-baz", arr, "-"); # a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3
+    n = split("foo-bar-baz", arr, "-");
+    # result: a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3
 
     # Other useful stuff
     sprintf("%s %d %d %d", "Testing", 1, 2, 3); # => "Testing 1 2 3"
@@ -238,8 +239,8 @@ function io_functions(    localvar) {
     # AWK doesn't have file handles, per se. It will automatically open a file
     # handle for you when you use something that needs one. The string you used
     # for this can be treated as a file handle, for purposes of I/O. This makes
-    # it feel sort of like shell scripting, but to get the same output, the string
-    # must match exactly, so use a variable:
+    # it feel sort of like shell scripting, but to get the same output, the
+    # string must match exactly, so use a variable:
 
     outfile = "/tmp/foobar.txt";
 
@@ -376,11 +377,15 @@ END {
 }
 
 ```
+
 Further Reading:
 
 * [Awk tutorial](http://www.grymoire.com/Unix/Awk.html)
 * [Awk man page](https://linux.die.net/man/1/awk)
-* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU Awk is found on most Linux systems.
+* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html)
+  GNU Awk is found on most Linux systems.
 * [AWK one-liner collection](http://tuxgraphics.org/~guido/scripts/awk-one-liner.html)
-* [Awk alpinelinux wiki](https://wiki.alpinelinux.org/wiki/Awk) a technical summary and list of "gotchas" (places where different implementations may behave in different or unexpected ways).
+* [Awk alpinelinux wiki](https://wiki.alpinelinux.org/wiki/Awk) a technical
+  summary and list of "gotchas" (places where different implementations may
+  behave in different or unexpected ways).
 * [basic libraries for awk](https://github.com/dubiousjim/awkenough)
-- 
cgit v1.2.3


From 033f3e65b930fbb6b48eb1a931717fed3666ed95 Mon Sep 17 00:00:00 2001
From: Norwid Behrnd <nbehrnd@yahoo.com>
Date: Wed, 23 Nov 2022 21:01:38 +0100
Subject: run `sed -i "s/ *$//" awk-es.html.markdown`

Remove of trailing spaces.
---
 es-es/awk-es.html.markdown | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/es-es/awk-es.html.markdown b/es-es/awk-es.html.markdown
index 2f771320..c5fec19e 100644
--- a/es-es/awk-es.html.markdown
+++ b/es-es/awk-es.html.markdown
@@ -11,8 +11,8 @@ lang: es-es
 
 AWK es una herramienta estándar en cada sistema UNIX compatible con POSIX.
 Es como un Perl restringido, perfecto para tareas de procesamiento de texto y
-otras necesidades de scripting. Tiene una sintaxis similar a C, pero sin 
-puntos y comas, manejo manual de memoria y tipado estático. Puedes llamarlo 
+otras necesidades de scripting. Tiene una sintaxis similar a C, pero sin
+puntos y comas, manejo manual de memoria y tipado estático. Puedes llamarlo
 desde un script de shell o usarlo como un lenguaje stand-alone para scripting.
 
 ¿Por qué elegir AWK sobre Perl? Principalmente, porque AWK es parte de UNIX.
@@ -74,7 +74,7 @@ BEGIN {
 
     # Bloques formados por múltiples líneas usan llaves
     while (a < 10) {
-        print "La concatenación de strings se hace " " con series " 
+        print "La concatenación de strings se hace " " con series "
 	print " de" " strings separados por espacios"
         print a
 
@@ -153,12 +153,12 @@ function arithmetic_functions(a, b, c,     localvar) {
     # Todo es global. No es problema en scripts pequeños, pero sí para
     # scripts más grandes.
 
-    # Hay un work-around (mmm... hack). Los argumentos de las funciones son 
+    # Hay un work-around (mmm... hack). Los argumentos de las funciones son
     # locales para la función, y AWK permite definir más argumentos de función
-    # de los que necesita, por lo que define las variables locales en la 
+    # de los que necesita, por lo que define las variables locales en la
     # declaración como en la función de arriba. Como convención, agrega
-    # espacios en blanco para distinguir los parámetros de la función de las 
-    # variables locales. En este ejemplo, a, b y c son parámetros y localvar es una 
+    # espacios en blanco para distinguir los parámetros de la función de las
+    # variables locales. En este ejemplo, a, b y c son parámetros y localvar es una
     # variable local.
 
     # Ahora, a demostrar las funciones aritméticas
@@ -222,8 +222,8 @@ function io_functions(    localvar) {
     # También hay printf
     printf("%s %d %d %d\n", "Testing", 1, 2, 3)
 
-    # AWK no tiene handles de archivos en sí mismo. Automáticamente abrirá un 
-    # handle de archivo cuando use algo que necesite uno. El string que usaste 
+    # AWK no tiene handles de archivos en sí mismo. Automáticamente abrirá un
+    # handle de archivo cuando use algo que necesite uno. El string que usaste
     # para esto puede ser tratada como un handle de archivo para propósitos de I/O.
     # Esto lo hace similar al scripting de shell:
 
@@ -247,17 +247,17 @@ function io_functions(    localvar) {
     close("/tmp/foobar.txt")
 }
 
-# Como dije al inicio, los programas en AWK son una colección de patrones y 
+# Como dije al inicio, los programas en AWK son una colección de patrones y
 # acciones. Ya conociste el patrón BEGIN. otros patrones sólo se usan si estás
 # procesando líneas desde archivos o stdin.
 
-# Cuando pasas argumentos a AWK, son tratados como nombres de archivos a 
-# procesar. Los va a procesar todos, en orden. Imagínalos como un ciclo for 
+# Cuando pasas argumentos a AWK, son tratados como nombres de archivos a
+# procesar. Los va a procesar todos, en orden. Imagínalos como un ciclo for
 # implícito, iterando sobre las líneas de estos archivos. Estos patrones y
 # acciones son como instrucciones switch dentro del ciclo.
 
 /^fo+bar$/ {
-    
+
     # Esta acción se ejecutará por cada línea que haga match con la expresión
     # regular /^fo+bar$/, y será saltada por cualquier línea que no haga match.
     # Vamos a sólo mostrar la línea:
@@ -268,7 +268,7 @@ function io_functions(    localvar) {
     # $0 es el nombre de la línea actual que se está procesando.
     # Se crea automáticamente para ti.
 
-    # Probablemente puedas adivinar que hay otras variables $. Cada línea es 
+    # Probablemente puedas adivinar que hay otras variables $. Cada línea es
     # separada implícitamente antes de que se llame cada acción, justo como lo
     # hace shell. Y, como shell, cada campo puede ser accesado con $.
 
@@ -301,7 +301,7 @@ a > 0 {
 # Y ya te das una idea. Procesar archivos de texto, leyendo una línea a la vez,
 # y haciendo algo con ella, particularmente separando en un deliminator, es tan
 # común en UNIX que AWK es un lenguaje de scripting que hace todo eso por ti
-# sin que tengas que pedirlo. Basta con escribir los patrones y acciones 
+# sin que tengas que pedirlo. Basta con escribir los patrones y acciones
 # basados en lo que esperas de la entrada y lo quieras quieras hacer con ella.
 
 # Aquí está un ejemplo de un script simple, para lo que AWK es perfecto.
@@ -343,7 +343,7 @@ $1 == name {
     nlines++
 }
 
-# Otro patrón especial es END. Va a ejecutarse después de procesar todos los 
+# Otro patrón especial es END. Va a ejecutarse después de procesar todos los
 # archivos de texto. A diferencia de BEGIN, sólo se ejecuta si le das dado una
 # entrada a procesar. Se ejecutará después de que todos los archivos hayan sido
 # leídos y procesados según las reglas y acciones que programaste. El propósito
-- 
cgit v1.2.3


From 5260db7077d839da6bb94e9bb5c1857a3498d7b6 Mon Sep 17 00:00:00 2001
From: Norwid Behrnd <nbehrnd@yahoo.com>
Date: Wed, 23 Nov 2022 21:04:56 +0100
Subject: substitute a tab space by explicit spaces

---
 es-es/awk-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/es-es/awk-es.html.markdown b/es-es/awk-es.html.markdown
index c5fec19e..25c40ca4 100644
--- a/es-es/awk-es.html.markdown
+++ b/es-es/awk-es.html.markdown
@@ -75,7 +75,7 @@ BEGIN {
     # Bloques formados por múltiples líneas usan llaves
     while (a < 10) {
         print "La concatenación de strings se hace " " con series "
-	print " de" " strings separados por espacios"
+        print " de" " strings separados por espacios"
         print a
 
         a++
-- 
cgit v1.2.3


From 2ad6b09fa9cbc693bceb6b4abe14599b425f1998 Mon Sep 17 00:00:00 2001
From: Norwid Behrnd <nbehrnd@yahoo.com>
Date: Wed, 23 Nov 2022 21:08:20 +0100
Subject: edit overly long lines, consider markdownlint

Lines longer than 80 characters are edited.  Withn reason, suggests
by markdownlint[1] are equally considered, too.

[1] https://github.com/markdownlint/markdownlint, version 0.12.0.
---
 es-es/awk-es.html.markdown | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/es-es/awk-es.html.markdown b/es-es/awk-es.html.markdown
index 25c40ca4..725dae1d 100644
--- a/es-es/awk-es.html.markdown
+++ b/es-es/awk-es.html.markdown
@@ -158,8 +158,8 @@ function arithmetic_functions(a, b, c,     localvar) {
     # de los que necesita, por lo que define las variables locales en la
     # declaración como en la función de arriba. Como convención, agrega
     # espacios en blanco para distinguir los parámetros de la función de las
-    # variables locales. En este ejemplo, a, b y c son parámetros y localvar es una
-    # variable local.
+    # variables locales. En este ejemplo, a, b y c son parámetros y localvar es
+    # una variable local.
 
     # Ahora, a demostrar las funciones aritméticas
 
@@ -224,8 +224,8 @@ function io_functions(    localvar) {
 
     # AWK no tiene handles de archivos en sí mismo. Automáticamente abrirá un
     # handle de archivo cuando use algo que necesite uno. El string que usaste
-    # para esto puede ser tratada como un handle de archivo para propósitos de I/O.
-    # Esto lo hace similar al scripting de shell:
+    # para esto puede ser tratada como un handle de archivo para propósitos
+    # de I/O. Esto lo hace similar al scripting de shell:
 
     print "foobar" >"/tmp/foobar.txt"
 
@@ -356,8 +356,10 @@ END {
 }
 
 ```
+
 Más información:
 
 * [Tutorial de AWK](http://www.grymoire.com/Unix/Awk.html)
 * [Página man de AWK](https://linux.die.net/man/1/awk)
-* [La guía del usuario de GNU Awk](https://www.gnu.org/software/gawk/manual/gawk.html): GNU Awk se encuentra en la mayoría de los sistemas Linux.
+* [La guía del usuario de GNU Awk](https://www.gnu.org/software/gawk/manual/gawk.html):
+  GNU Awk se encuentra en la mayoría de los sistemas Linux.
-- 
cgit v1.2.3


From 38abd4298cd25bd1a2ed9efd09df51766c97ae27 Mon Sep 17 00:00:00 2001
From: Norwid Behrnd <nbehrnd@yahoo.com>
Date: Wed, 23 Nov 2022 21:17:18 +0100
Subject: run `sed -i 's/ *$//' awk-fr.html.markdown`

Remove of trailing spaces.
---
 fr-fr/awk-fr.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fr-fr/awk-fr.html.markdown b/fr-fr/awk-fr.html.markdown
index 9e45a89b..fa4c36cc 100644
--- a/fr-fr/awk-fr.html.markdown
+++ b/fr-fr/awk-fr.html.markdown
@@ -53,7 +53,7 @@ BEGIN {
     # Les variables sont globales. Pas besoin de les déclarer.
     count = 0;
 
-    # les opérateurs sont identiques au langage C et aux langages similaires 
+    # les opérateurs sont identiques au langage C et aux langages similaires
     # (tels que C#, C++, etc.)
     a = count + 1; # addition
     b = count - 1; # soustraction
-- 
cgit v1.2.3


From 27f052e68d1132796b7fcf3deed61dfe937193ee Mon Sep 17 00:00:00 2001
From: Norwid Behrnd <nbehrnd@yahoo.com>
Date: Wed, 23 Nov 2022 21:26:20 +0100
Subject: break overly long lines

Critical threshold for a line are 80 characters maximum.
---
 fr-fr/awk-fr.html.markdown | 54 ++++++++++++++++++++++++++--------------------
 1 file changed, 31 insertions(+), 23 deletions(-)

diff --git a/fr-fr/awk-fr.html.markdown b/fr-fr/awk-fr.html.markdown
index fa4c36cc..172a3ba4 100644
--- a/fr-fr/awk-fr.html.markdown
+++ b/fr-fr/awk-fr.html.markdown
@@ -73,7 +73,8 @@ BEGIN {
     a++;
     b--;
 
-    # En tant qu'opérateur préfixé, c'est la valeur incrémentée qui est retournée
+    # En tant qu'opérateur préfixé, c'est la valeur incrémentée qui
+    # est retournée
     ++a;
     --b;
 
@@ -155,7 +156,8 @@ BEGIN {
 
     delete ARGV[1];
 
-    # Le nombre d'arguments de la ligne de commande est assigné à la variable ARGC
+    # Le nombre d'arguments de la ligne de commande est assigné à
+    # la variable ARGC
     print ARGC;
 
     # AWK inclue trois catégories de fonction.
@@ -175,11 +177,11 @@ function arithmetic_functions(a, b, c,     d) {
 
     # Il y a cependant une solution de contournement (enfin ... une bidouille).
     # Les arguments d'une fonction sont locaux à cette fonction.
-    # Et AWK vous permet de définir plus d'arguments à la fonction que nécessaire.
-    # Il suffit donc de mettre une variable locale dans la déclaration de fonction,
-    # comme ci-dessus. La convention veut que vous mettiez quelques espaces
-    # supplémentaires pour faire la distinction entre les paramètres réels et
-    # les variables locales.
+    # Et AWK vous permet de définir plus d'arguments à la fonction que
+    # nécessaire. Il suffit donc de mettre une variable locale dans la
+    # déclaration de fonction, comme ci-dessus. La convention veut que vous
+    # mettiez quelques espaces supplémentaires pour faire la distinction entre
+    # les paramètres réels et les variables locales.
     # Dans cet exemple, a, b et c sont des paramètres réels,
     # alors que d est simplement une variable locale.
 
@@ -225,12 +227,14 @@ function string_functions(    localvar, arr) {
     sub("fo+", "Meet me at the ", localvar); # localvar => "Meet me at the bar"
     gsub("e", ".", localvar); # localvar => "m..t m. at th. bar"
 
-    # Rechercher une chaîne de caractères qui correspond à une expression régulière
-    # index() fait la même chose, mais n'autorise pas les expressions régulières
+    # Rechercher une chaîne de caractères qui correspond à une expression
+    # régulière index() fait la même chose, mais n'autorise pas les expressions
+    # régulières
     match(localvar, "t"); # => 4, puisque 't' est le quatrième caractère
 
     # Séparer par un délimiteur
-    n = split("foo-bar-baz", arr, "-"); # a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3
+    n = split("foo-bar-baz", arr, "-");
+    # résultat : a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3
 
     # Autre astuces utiles
     sprintf("%s %d %d %d", "Testing", 1, 2, 3); # => "Testing 1 2 3"
@@ -259,15 +263,15 @@ function io_functions(    localvar) {
 
     print "foobar" > outfile;
 
-    # Maintenant, la chaîne de caractères "outfile" est un descripteur de fichier.
-    # Vous pouvez le fermer
+    # Maintenant, la chaîne de caractères "outfile" est un descripteur de
+    # fichier. Vous pouvez le fermer
     close(outfile);
 
     # Voici comment exécuter quelque chose dans le shell
     system("echo foobar"); # => affiche foobar
 
-    # Lire quelque chose depuis l'entrée standard et la stocker dans une variable
-    # locale
+    # Lire quelque chose depuis l'entrée standard et la stocker dans une
+    # variable locale
     getline localvar;
 
     # Lire quelque chose à partir d'un pipe (encore une fois, utilisez une
@@ -299,12 +303,13 @@ function io_functions(    localvar) {
     print;
 
     # Pas d'argument ! C'est parce que print a un défaut : $0.
-    # $0 est le nom de la ligne en cours de traitement. Il est créé automatiquement.
+    # $0 est le nom de la ligne en cours de traitement. Il est créé
+    # automatiquement.
 
     # Vous devinez probablement qu'il existe d'autres variables $.
-    # Chaque ligne est divisée implicitement avant que chaque action soit exécutée,
-    # comme le fait le shell. Et, comme le shell, chaque champ est accessible
-    # avec un signe dollar
+    # Chaque ligne est divisée implicitement avant que chaque action soit
+    # exécutée, comme le fait le shell. Et, comme le shell, chaque champ est
+    # accessible avec un signe dollar.
 
      # Ceci affichera les deuxième et quatrième champs de la ligne.
     print $2, $4;
@@ -364,22 +369,24 @@ BEGIN {
     # Premièrement, on demande à l'utilisateur le prénom voulu
     print "Pour quel prénom voudriez vous savoir l'age moyen ?";
 
-    # On récupère la ligne à partir de l'entrée standard, pas de la ligne de commande
+    # On récupère la ligne à partir de l'entrée standard, pas de la ligne
+    # de commande :
     getline name < "/dev/stdin";
 }
 
 # Maintenant, pour chaque ligne dont le premier champ est le prénom donné
 $1 == name {
 
-    # Ici, nous avons accès à un certain nombre de variables utiles déjà préchargées :
+    # Ici, nous avons accès à un certain nombre de variables utiles déjà
+    # préchargées :
     # $0 est la ligne entière
     # $3 est le troisième champ. Ici il correspond à l'age qui nous intéresse
     # NF est le nombre de champs et vaut 3
     # NR est le nombre d'enregistrements (lignes) vus jusqu'à présent
     # FILENAME est le nom du fichier en cours de traitement
     # FS est séparateur de champs, ici c'est " " (un espace)
-    # ...etc. Et beaucoup d'autre que vous pouvez connaître dans le manuel de man.
-    # Pour cela exécutez "man awk" dans votre terminal
+    # ...etc. Et beaucoup d'autre que vous pouvez connaître dans le manuel de
+    # man. Pour cela exécutez "man awk" dans votre terminal.
 
     # Garder une trace du total accumulé et du nombre de lignes correspondant.
     sum += $3;
@@ -405,5 +412,6 @@ Pour plus d'informations :
 
 * [Awk tutorial](http://www.grymoire.com/Unix/Awk.html)
 * [Awk man page](https://linux.die.net/man/1/awk)
-* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU Awk est dans la majorité des systèmes Linux.
+* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html)
+  GNU Awk est dans la majorité des systèmes Linux.
 * [AWK one-liner collection](http://tuxgraphics.org/~guido/scripts/awk-one-liner.html)
-- 
cgit v1.2.3


From 7a2f6ddacd5b5895bfc57baef19d17d24716061c Mon Sep 17 00:00:00 2001
From: Norwid Behrnd <nbehrnd@yahoo.com>
Date: Wed, 23 Nov 2022 22:01:08 +0100
Subject: keep introducing comments close to their object

In previous commits, some introducing comments ended just in the
line ahead of their example; others did not.  For consistency,
comments are now back to back with their example.
---
 fr-fr/awk-fr.html.markdown | 56 +++++++++++++++++-----------------------------
 1 file changed, 21 insertions(+), 35 deletions(-)

diff --git a/fr-fr/awk-fr.html.markdown b/fr-fr/awk-fr.html.markdown
index 172a3ba4..a5db24b2 100644
--- a/fr-fr/awk-fr.html.markdown
+++ b/fr-fr/awk-fr.html.markdown
@@ -24,14 +24,12 @@ ce qui concerne le traitement de texte simple. Notamment le traitement de ceux
 qui nécessitent de lire des fichiers ligne par ligne ; chaque ligne comportant
 des champs séparés par des délimiteur.
 
-
 ```awk
 #!/usr/bin/awk -f
 
 # Les commentaires commencent par un #
 
-
-# les programmes AWK consistent en une collection de règles et d'actions
+# Les programmes AWK consistent en une collection de règles et d'actions.
 règle1 { action; }
 règle2 { action; }
 
@@ -46,14 +44,14 @@ règle2 { action; }
 # texte. Si vous ne disposez pas de fichiers texte, considérez BEGIN comme le
 # point d’entrée principal du script.
 # À l'opposé de BEGIN, il existe la règle END. Cette règle est présente après
-#chaque fin de fichier (EOF : End Of File).
+# chaque fin de fichier (EOF : End Of File).
 
 BEGIN {
 
     # Les variables sont globales. Pas besoin de les déclarer.
     count = 0;
 
-    # les opérateurs sont identiques au langage C et aux langages similaires
+    # Les opérateurs sont identiques au langage C et aux langages similaires
     # (tels que C#, C++, etc.)
     a = count + 1; # addition
     b = count - 1; # soustraction
@@ -122,7 +120,6 @@ BEGIN {
     arr[1] = "bar";
 
     # Vous pouvez aussi initialiser un tableau avec la fonction split()
-
     n = split("foo:bar:baz", arr, ":");
 
     # Il y a aussi les tableaux associatifs
@@ -131,7 +128,6 @@ BEGIN {
 
     # et les tableaux multi-dimensions, avec certaines limitations que l'on ne
     # mentionnera pas ici
-
     multidim[0,0] = "foo";
     multidim[0,1] = "bar";
     multidim[1,0] = "baz";
@@ -150,19 +146,16 @@ BEGIN {
     for (argnum in ARGV)
         print ARGV[argnum];
 
-    # Vous pouvez supprimer des éléments d'un tableau
+    # Vous pouvez supprimer des éléments d'un tableau.
     # C'est utile pour empêcher AWK de supposer que certains arguments soient
     # des fichiers à traiter.
-
     delete ARGV[1];
 
     # Le nombre d'arguments de la ligne de commande est assigné à
     # la variable ARGC
     print ARGC;
 
-    # AWK inclue trois catégories de fonction.
-    # On les examinera plus tard
-
+    # AWK inclue trois catégories de fonction. On les examinera plus tard.
     return_value = arithmetic_functions(a, b, c);
     string_functions();
     io_functions();
@@ -182,8 +175,8 @@ function arithmetic_functions(a, b, c,     d) {
     # déclaration de fonction, comme ci-dessus. La convention veut que vous
     # mettiez quelques espaces supplémentaires pour faire la distinction entre
     # les paramètres réels et les variables locales.
-    # Dans cet exemple, a, b et c sont des paramètres réels,
-    # alors que d est simplement une variable locale.
+    # Dans cet exemple, a, b et c sont des paramètres réels, alors que d est
+    # simplement une variable locale.
 
     # Maintenant, les fonctions arithmétiques
 
@@ -219,17 +212,16 @@ function string_functions(    localvar, arr) {
     # AWK a plusieurs fonctions pour le traitement des chaînes de caractères,
     # dont beaucoup reposent sur des expressions régulières.
 
-    # Chercher et remplacer, la première occurrence (sub) ou toutes les
-    # occurrences (gsub)
+    # Chercher et remplacer, la première occurrence (sub), ou toutes les
+    # occurrences (gsub).
     # Les deux renvoient le nombre de correspondances remplacées
-
     localvar = "fooooobar";
     sub("fo+", "Meet me at the ", localvar); # localvar => "Meet me at the bar"
     gsub("e", ".", localvar); # localvar => "m..t m. at th. bar"
 
     # Rechercher une chaîne de caractères qui correspond à une expression
     # régulière index() fait la même chose, mais n'autorise pas les expressions
-    # régulières
+    # régulières.
     match(localvar, "t"); # => 4, puisque 't' est le quatrième caractère
 
     # Séparer par un délimiteur
@@ -255,16 +247,13 @@ function io_functions(    localvar) {
 
     # AWK n'a pas de descripteur de fichier en soi. Il ouvrira automatiquement
     # un descripteur de fichier lorsque vous utilisez quelque chose qui en a
-    # besoin.
-    # La chaîne de caractères que vous avez utilisée pour cela peut être traitée
-    # comme un descripteur de fichier à des fins d'entrée / sortie.
-
+    # besoin. La chaîne de caractères que vous avez utilisée pour cela peut être
+    # traitée comme un descripteur de fichier à des fins d'entrée / sortie.
     outfile = "/tmp/foobar.txt";
-
     print "foobar" > outfile;
 
     # Maintenant, la chaîne de caractères "outfile" est un descripteur de
-    # fichier. Vous pouvez le fermer
+    # fichier. Vous pouvez le fermer.
     close(outfile);
 
     # Voici comment exécuter quelque chose dans le shell
@@ -298,7 +287,7 @@ function io_functions(    localvar) {
 
     # Cette action sera exécutée pour chaque ligne qui correspond à l'expression
     # régulière, /^fo+bar$/, et sera ignorée pour toute ligne qui n'y correspond
-    # pas. Imprimons simplement la ligne:
+    # pas. Imprimons simplement la ligne :
 
     print;
 
@@ -311,11 +300,11 @@ function io_functions(    localvar) {
     # exécutée, comme le fait le shell. Et, comme le shell, chaque champ est
     # accessible avec un signe dollar.
 
-     # Ceci affichera les deuxième et quatrième champs de la ligne.
+    # Ceci affichera les deuxième et quatrième champs de la ligne.
     print $2, $4;
 
     # AWK défini automatiquement beaucoup d'autres variables qui peuvent vous
-    # aider à inspecter et traiter chaque ligne. La plus importante est NF
+    # aider à inspecter et traiter chaque ligne. La plus importante est NF.
 
     # Affiche le nombre de champs de la ligne
     print NF;
@@ -325,7 +314,6 @@ function io_functions(    localvar) {
 }
 
 # Chaque règle est en réalité un test conditionnel.
-
 a > 0 {
     # Ceci s’exécutera une fois pour chaque ligne, tant que le test est positif
 }
@@ -333,19 +321,16 @@ a > 0 {
 # Les expressions régulières sont également des tests conditionnels.
 # Si le test de l'expression régulières n'est pas vrais alors le bloc
 # n'est pas exécuté.
-
 $0 /^fobar/ {
    print "la ligne commence par foobar"
 }
 
 # Dans le cas où vous voulez tester votre chaîne de caractères sur la ligne
 # en cours de traitement $0 est optionnelle.
-
 /^[a-zA-Z0-9]$/ {
     print "La ligne courante ne contient que des caractères alphanumériques.";
 }
 
-
 # AWK peut parcourir un fichier texte ligne par ligne et exécuter des actions en
 # fonction de règles établies. Cela est si courant sous UNIX qu'AWK est un
 # langage de script.
@@ -354,7 +339,7 @@ $0 /^fobar/ {
 # parfait. Le script lit un nom à partir de l'entrée standard, puis affiche
 # l'âge moyen de toutes les personnes portant ce prénom.
 # Supposons que vous fournissiez comme argument le nom d'un fichier comportant
-# ces données:
+# ces données :
 #
 # Bob Jones 32
 # Jane Doe 22
@@ -397,9 +382,9 @@ $1 == name {
 # les fichiers texte. Contrairement à BEGIN, il ne fonctionne que si vous lui
 # donnez une entrée à traiter. Il sera exécuté une fois que tous les fichiers
 # auront été lus et traités conformément aux règles et aux actions que vous
-# avez fournies. Le but est généralement de produire un rapport final
-# ou de faire quelque chose avec l'ensemble des données que vous avez
-# accumulées au cours du script.
+# avez fournies. Le but est généralement de produire un rapport final, ou de
+# faire quelque chose avec l'ensemble des données que vous avez accumulées
+# au cours du script.
 
 
 END {
@@ -408,6 +393,7 @@ END {
 }
 
 ```
+
 Pour plus d'informations :
 
 * [Awk tutorial](http://www.grymoire.com/Unix/Awk.html)
-- 
cgit v1.2.3


From 11dbb27e750a0bf9f085226ae4520a9be03e1e1d Mon Sep 17 00:00:00 2001
From: Norwid Behrnd <nbehrnd@yahoo.com>
Date: Wed, 23 Nov 2022 22:08:19 +0100
Subject: account for markdownlint

Account for two smaller suggestions put forward by markdownlint[1].
---
 pt-br/awk-pt.html.markdown | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown
index 366ae886..597b0e7a 100644
--- a/pt-br/awk-pt.html.markdown
+++ b/pt-br/awk-pt.html.markdown
@@ -370,8 +370,10 @@ END {
 }
 
 ```
+
 Leituras adicionais (em inglês):
 
 * [Awk tutorial](http://www.grymoire.com/Unix/Awk.html)
 * [Awk man page](https://linux.die.net/man/1/awk)
-* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU AWK é encontrado na maioria dos sistemas GNU/Linux.
+* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html)
+  GNU AWK é encontrado na maioria dos sistemas GNU/Linux.
-- 
cgit v1.2.3