diff options
| -rw-r--r-- | c++.html.markdown | 4 | ||||
| -rw-r--r-- | factor.html.markdown | 2 | ||||
| -rw-r--r-- | it-it/pcre-it.html.markdown | 80 | ||||
| -rw-r--r-- | julia.html.markdown | 76 | ||||
| -rw-r--r-- | pcre.html.markdown | 22 | ||||
| -rw-r--r-- | pt-br/factor-pt.html.markdown | 184 | ||||
| -rw-r--r-- | tcl.html.markdown | 8 |
7 files changed, 316 insertions, 60 deletions
diff --git a/c++.html.markdown b/c++.html.markdown index 225472cb..4113d5f4 100644 --- a/c++.html.markdown +++ b/c++.html.markdown @@ -1057,7 +1057,7 @@ cout << ST.size(); // will print the size of set ST // Output: 0 // NOTE: for duplicate elements we can use multiset -// NOTE: For hash sets, use unordered_set. They are more effecient but +// NOTE: For hash sets, use unordered_set. They are more efficient but // do not preserve order. unordered_set is available since C++11 // Map @@ -1086,7 +1086,7 @@ cout << it->second; // Output: 26 -// NOTE: For hash maps, use unordered_map. They are more effecient but do +// NOTE: For hash maps, use unordered_map. They are more efficient but do // not preserve order. unordered_map is available since C++11. /////////////////////////////////// diff --git a/factor.html.markdown b/factor.html.markdown index 79596d83..53c692df 100644 --- a/factor.html.markdown +++ b/factor.html.markdown @@ -9,7 +9,7 @@ Factor is a modern stack-based language, based on Forth, created by Slava Pestov Code in this file can be typed into Factor, but not directly imported because the vocabulary and import header would make the beginning thoroughly confusing. -``` +```factor ! This is a comment ! Like Forth, all programming is done by manipulating the stack. diff --git a/it-it/pcre-it.html.markdown b/it-it/pcre-it.html.markdown new file mode 100644 index 00000000..68233858 --- /dev/null +++ b/it-it/pcre-it.html.markdown @@ -0,0 +1,80 @@ +--- +language: PCRE +filename: pcre-it.txt +contributors: + - ["Sachin Divekar", "http://github.com/ssd532"] +translators: + - ["Christian Grasso", "https://grasso.io"] +lang: it-it +--- + +Un'espressione regolare (regex o regexp in breve) è una speciale stringa +utilizzata per definire un pattern, ad esempio per cercare una sequenza di +caratteri; ad esempio, `/^[a-z]+:/` può essere usato per estrarre `http:` +dall'URL `http://github.com/`. + +PCRE (Perl Compatible Regular Expressions) è una libreria per i regex in C. +La sintassi utilizzata per le espressioni è molto simile a quella di Perl, da +cui il nome. Si tratta di una delle sintassi più diffuse per la scrittura di +regex. + +Esistono due tipi di metacaratteri (caratteri con una funzione speciale): +* Caratteri riconosciuti ovunque tranne che nelle parentesi quadre +``` + \ carattere di escape + ^ cerca all'inizio della stringa (o della riga, in modalità multiline) + $ cerca alla fine della stringa (o della riga, in modalità multiline) + . qualsiasi carattere eccetto le newline + [ inizio classe di caratteri + | separatore condizioni alternative + ( inizio subpattern + ) fine subpattern + ? quantificatore "0 o 1" + * quantificatore "0 o più" + + quantificatore "1 o più" + { inizio quantificatore numerico +``` + +* Caratteri riconosciuti nelle parentesi quadre +``` + \ carattere di escape + ^ nega la classe se è il primo carattere + - indica una serie di caratteri + [ classe caratteri POSIX (se seguita dalla sintassi POSIX) + ] termina la classe caratteri + +``` + +PCRE fornisce inoltre delle classi di caratteri predefinite: +``` + \d cifra decimale + \D NON cifra decimale + \h spazio vuoto orizzontale + \H NON spazio vuoto orizzontale + \s spazio + \S NON spazio + \v spazio vuoto verticale + \V NON spazio vuoto verticale + \w parola + \W "NON parola" +``` + +## Esempi + +Utilizzeremo la seguente stringa per i nostri test: +``` +66.249.64.13 - - [18/Sep/2004:11:07:48 +1000] "GET /robots.txt HTTP/1.0" 200 468 "-" "Googlebot/2.1" +``` +Si tratta di una riga di log del web server Apache. + +| Regex | Risultato | Commento | +| :---- | :-------------- | :------ | +| `GET` | GET | Cerca esattamente la stringa "GET" (case sensitive) | +| `\d+.\d+.\d+.\d+` | 66.249.64.13 | `\d+` identifica uno o più (quantificatore `+`) numeri [0-9], `\.` identifica il carattere `.` | +| `(\d+\.){3}\d+` | 66.249.64.13 | `(\d+\.){3}` cerca il gruppo (`\d+\.`) esattamente 3 volte. | +| `\[.+\]` | [18/Sep/2004:11:07:48 +1000] | `.+` identifica qualsiasi carattere, eccetto le newline; `.` indica un carattere qualsiasi | +| `^\S+` | 66.249.64.13 | `^` cerca all'inizio della stringa, `\S+` identifica la prima stringa di caratteri diversi dallo spazio | +| `\+[0-9]+` | +1000 | `\+` identifica il carattere `+`. `[0-9]` indica una cifra da 0 a 9. L'espressione è equivalente a `\+\d+` | + +## Altre risorse +[Regex101](https://regex101.com/) - tester per le espressioni regolari diff --git a/julia.html.markdown b/julia.html.markdown index 15c09da4..2fe05c49 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -114,12 +114,12 @@ println("I'm Julia. Nice to meet you!") # => I'm Julia. Nice to meet you! #################################################### # You don't declare variables before assigning to them. -some_var = 5 # => 5 -some_var # => 5 +someVar = 5 # => 5 +someVar # => 5 # Accessing a previously unassigned variable is an error try - some_other_var # => ERROR: UndefVarError: some_other_var not defined + someOtherVar # => ERROR: UndefVarError: someOtherVar not defined catch e println(e) end @@ -286,62 +286,62 @@ d # => 5 e # => 4 # Dictionaries store mappings -empty_dict = Dict() # => Dict{Any,Any} with 0 entries +emptyDict = Dict() # => Dict{Any,Any} with 0 entries # You can create a dictionary using a literal -filled_dict = Dict("one" => 1, "two" => 2, "three" => 3) +filledDict = Dict("one" => 1, "two" => 2, "three" => 3) # => Dict{String,Int64} with 3 entries: # => "two" => 2, "one" => 1, "three" => 3 # Look up values with [] -filled_dict["one"] # => 1 +filledDict["one"] # => 1 # Get all keys -keys(filled_dict) +keys(filledDict) # => Base.KeySet for a Dict{String,Int64} with 3 entries. Keys: # => "two", "one", "three" # Note - dictionary keys are not sorted or in the order you inserted them. # Get all values -values(filled_dict) +values(filledDict) # => Base.ValueIterator for a Dict{String,Int64} with 3 entries. Values: # => 2, 1, 3 # Note - Same as above regarding key ordering. # Check for existence of keys in a dictionary with in, haskey -in(("one" => 1), filled_dict) # => true -in(("two" => 3), filled_dict) # => false -haskey(filled_dict, "one") # => true -haskey(filled_dict, 1) # => false +in(("one" => 1), filledDict) # => true +in(("two" => 3), filledDict) # => false +haskey(filledDict, "one") # => true +haskey(filledDict, 1) # => false # Trying to look up a non-existent key will raise an error try - filled_dict["four"] # => ERROR: KeyError: key "four" not found + filledDict["four"] # => ERROR: KeyError: key "four" not found catch e println(e) end # Use the get method to avoid that error by providing a default value -# get(dictionary, key, default_value) -get(filled_dict, "one", 4) # => 1 -get(filled_dict, "four", 4) # => 4 +# get(dictionary, key, defaultValue) +get(filledDict, "one", 4) # => 1 +get(filledDict, "four", 4) # => 4 # Use Sets to represent collections of unordered, unique values -empty_set = Set() # => Set(Any[]) +emptySet = Set() # => Set(Any[]) # Initialize a set with values -filled_set = Set([1, 2, 2, 3, 4]) # => Set([4, 2, 3, 1]) +filledSet = Set([1, 2, 2, 3, 4]) # => Set([4, 2, 3, 1]) # Add more values to a set -push!(filled_set, 5) # => Set([4, 2, 3, 5, 1]) +push!(filledSet, 5) # => Set([4, 2, 3, 5, 1]) # Check if the values are in the set -in(2, filled_set) # => true -in(10, filled_set) # => false +in(2, filledSet) # => true +in(10, filledSet) # => false # There are functions for set intersection, union, and difference. -other_set = Set([3, 4, 5, 6]) # => Set([4, 3, 5, 6]) -intersect(filled_set, other_set) # => Set([4, 3, 5]) -union(filled_set, other_set) # => Set([4, 2, 3, 5, 6, 1]) +otherSet = Set([3, 4, 5, 6]) # => Set([4, 3, 5, 6]) +intersect(filledSet, otherSet) # => Set([4, 3, 5]) +union(filledSet, otherSet) # => Set([4, 2, 3, 5, 6, 1]) setdiff(Set([1,2,3,4]), Set([2,3,5])) # => Set([4, 1]) #################################################### @@ -349,15 +349,15 @@ setdiff(Set([1,2,3,4]), Set([2,3,5])) # => Set([4, 1]) #################################################### # Let's make a variable -some_var = 5 +someVar = 5 # Here is an if statement. Indentation is not meaningful in Julia. -if some_var > 10 - println("some_var is totally bigger than 10.") -elseif some_var < 10 # This elseif clause is optional. - println("some_var is smaller than 10.") +if someVar > 10 + println("someVar is totally bigger than 10.") +elseif someVar < 10 # This elseif clause is optional. + println("someVar is smaller than 10.") else # The else clause is optional too. - println("some_var is indeed 10.") + println("someVar is indeed 10.") end # => prints "some var is smaller than 10" @@ -488,14 +488,14 @@ keyword_args(k1="mine") # => ["name2"=>"hello", "k1"=>"mine"] keyword_args() # => ["name2"=>"hello", "k1"=>4] # You can combine all kinds of arguments in the same function -function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo") - println("normal arg: $normal_arg") - println("optional arg: $optional_positional_arg") - println("keyword arg: $keyword_arg") +function all_the_args(normalArg, optionalPositionalArg=2; keywordArg="foo") + println("normal arg: $normalArg") + println("optional arg: $optionalPositionalArg") + println("keyword arg: $keywordArg") end # => all_the_args (generic function with 2 methods) -all_the_args(1, 3, keyword_arg=4) +all_the_args(1, 3, keywordArg=4) # => normal arg: 1 # => optional arg: 3 # => keyword arg: 4 @@ -616,7 +616,7 @@ supertype(SubString) # => AbstractString # <: is the subtyping operator struct Lion <: Cat # Lion is a subtype of Cat - mane_color + maneColor roar::AbstractString end @@ -627,7 +627,7 @@ Lion(roar::AbstractString) = Lion("green", roar) # This is an outer constructor because it's outside the type definition struct Panther <: Cat # Panther is also a subtype of Cat - eye_color + eyeColor Panther() = new("green") # Panthers will only have this constructor, and no default constructor. end @@ -695,7 +695,7 @@ fight(tigger, Panther()) # => The orange tiger wins! fight(tigger, Lion("ROAR")) # => The orange tiger wins! # Let's change the behavior when the Cat is specifically a Lion -fight(t::Tiger, l::Lion) = println("The $(l.mane_color)-maned lion wins!") +fight(t::Tiger, l::Lion) = println("The $(l.maneColor)-maned lion wins!") # => fight (generic function with 2 methods) fight(tigger, Panther()) # => The orange tiger wins! diff --git a/pcre.html.markdown b/pcre.html.markdown index 0b61653d..3e877a35 100644 --- a/pcre.html.markdown +++ b/pcre.html.markdown @@ -63,20 +63,12 @@ We will test our examples on following string `66.249.64.13 - - [18/Sep/2004:11: | Regex | Result | Comment | | :---- | :-------------- | :------ | -| GET | GET | GET matches the characters GET literally (case sensitive) | -| \d+.\d+.\d+.\d+ | 66.249.64.13 | `\d+` match a digit [0-9] one or more times defined by `+` quantifier, `\.` matches `.` literally | -| (\d+\.){3}\d+ | 66.249.64.13 | `(\d+\.){3}` is trying to match group (`\d+\.`) exactly three times. | -| \[.+\] | [18/Sep/2004:11:07:48 +1000] | `.+` matches any character (except newline), `.` is any character | -| ^\S+ | 66.249.64.13 | `^` means start of the line, `\S+` matches any number of non-space characters | -| \+[0-9]+ | +1000 | `\+` matches the character `+` literally. `[0-9]` character class means single number. Same can be achieved using `\+\d+` | - -All these examples can be tried at https://regex101.com/ - -1. Copy the example string in `TEST STRING` section -2. Copy regex code in `Regular Expression` section -3. The web application will show the matching result - +| `GET` | GET | GET matches the characters GET literally (case sensitive) | +| `\d+.\d+.\d+.\d+` | 66.249.64.13 | `\d+` match a digit [0-9] one or more times defined by `+` quantifier, `\.` matches `.` literally | +| `(\d+\.){3}\d+` | 66.249.64.13 | `(\d+\.){3}` is trying to match group (`\d+\.`) exactly three times. | +| `\[.+\]` | [18/Sep/2004:11:07:48 +1000] | `.+` matches any character (except newline), `.` is any character | +| `^\S+` | 66.249.64.13 | `^` means start of the line, `\S+` matches any number of non-space characters | +| `\+[0-9]+` | +1000 | `\+` matches the character `+` literally. `[0-9]` character class means single number. Same can be achieved using `\+\d+` | ## Further Reading - - +[Regex101](https://regex101.com/) - Regular Expression tester and debugger diff --git a/pt-br/factor-pt.html.markdown b/pt-br/factor-pt.html.markdown new file mode 100644 index 00000000..e3c8f4a9 --- /dev/null +++ b/pt-br/factor-pt.html.markdown @@ -0,0 +1,184 @@ +--- +language: factor +contributors: + - ["hyphz", "http://github.com/hyphz/"] +filename: learnfactor.factor + +lang: pt-br +--- + +Factor é uma linguagem moderna baseada em pilha, baseado em Forth, criada por Slava Pestov. + +Código neste arquivo pode ser digitado em Fator, mas não importado diretamente porque o cabeçalho de vocabulário e importação faria o início completamente confuso. + +```factor +! Este é um comentário + +! Como Forth, toda a programação é feita manipulando a pilha. +! A indicação de um valor literal o coloca na pilha. +5 2 3 56 76 23 65 ! Nenhuma saída, mas a pilha é impressa no modo interativo + +! Esses números são adicionados à pilha, da esquerda para a direita. +! .s imprime a pilha de forma não destrutiva. +.s ! 5 2 3 56 76 23 65 + +! A aritmética funciona manipulando dados na pilha. +5 4 + ! Sem saída + +! `.` mostra o resultado superior da pilha e o imprime. +. ! 9 + +! Mais exemplos de aritmética: +6 7 * . ! 42 +1360 23 - . ! 1337 +12 12 / . ! 1 +13 2 mod . ! 1 + +99 neg . ! -99 +-99 abs . ! 99 +52 23 max . ! 52 +52 23 min . ! 23 + +! Várias palavras são fornecidas para manipular a pilha, coletivamente conhecidas como palavras embaralhadas. + +3 dup - ! duplica o primeiro item (1st agora igual a 2nd): 3 - 3 +2 5 swap / ! troca o primeiro com o segundo elemento: 5 / 2 +4 0 drop 2 / ! remove o primeiro item (não imprima na tela): 4 / 2 +1 2 3 nip .s ! remove o segundo item (semelhante a drop): 1 3 +1 2 clear .s ! acaba com toda a pilha +1 2 3 4 over .s ! duplica o segundo item para o topo: 1 2 3 4 3 +1 2 3 4 2 pick .s ! duplica o terceiro item para o topo: 1 2 3 4 2 3 + +! Criando Palavras +! O `:` conjuntos de palavras do Factor no modo de compilação até que ela veja a palavra `;`. +: square ( n -- n ) dup * ; ! Sem saída +5 square . ! 25 + +! Podemos ver o que as palavra fazem também. +! \ suprime a avaliação de uma palavra e coloca seu identificador na pilha. +\ square see ! : square ( n -- n ) dup * ; + +! Após o nome da palavra para criar, a declaração entre parênteses dá o efeito da pilha. +! Podemos usar os nomes que quisermos dentro da declaração: +: weirdsquare ( camel -- llama ) dup * ; + +! Contanto que sua contagem corresponda ao efeito da pilha da palavra: +: doubledup ( a -- b ) dup dup ; ! Error: Stack effect declaration is wrong +: doubledup ( a -- a a a ) dup dup ; ! Ok +: weirddoubledup ( i -- am a fish ) dup dup ; ! Além disso Ok + +! Onde Factor difere do Forth é no uso de citações. +! Uma citação é um bloco de código que é colocado na pilha como um valor. +! [ inicia o modo de citação; ] termina. +[ 2 + ] ! A citação que adiciona 2 é deixada na pilha +4 swap call . ! 6 + +! E assim, palavras de ordem mais alta. TONS de palavras de ordem superior. +2 3 [ 2 + ] dip .s ! Retira valor do topo da pilha, execute citação, empurre de volta: 4 3 +3 4 [ + ] keep .s ! Copie o valor do topo da pilha, execute a citação, envie a cópia: 7 4 +1 [ 2 + ] [ 3 + ] bi .s ! Executar cada citação no valor do topo, empurrar os dois resultados: 3 4 +4 3 1 [ + ] [ + ] bi .s ! As citações em um bi podem extrair valores mais profundos da pilha: 4 5 ( 1+3 1+4 ) +1 2 [ 2 + ] bi@ .s ! Executar a citação no primeiro e segundo valores +2 [ + ] curry ! Injeta o valor fornecido no início da citação: [ 2 + ] é deixado na pilha + +! Condicionais +! Qualquer valor é verdadeiro, exceto o valor interno f. +! m valor interno não existe, mas seu uso não é essencial. +! Condicionais são palavras de maior ordem, como com os combinadores acima. + +5 [ "Five is true" . ] when ! Cinco é verdadeiro +0 [ "Zero is true" . ] when ! Zero é verdadeiro +f [ "F is true" . ] when ! Sem saída +f [ "F is false" . ] unless ! F é falso +2 [ "Two is true" . ] [ "Two is false" . ] if ! Two é verdadeiro + +! Por padrão, as condicionais consomem o valor em teste, mas variantes com asterisco +! deixe sozinho se é verdadeiro: + +5 [ . ] when* ! 5 +f [ . ] when* ! Nenhuma saída, pilha vazia, f é consumida porque é falsa + + +! Laços +! Você adivinhou .. estas são palavras de ordem mais elevada também. + +5 [ . ] each-integer ! 0 1 2 3 4 +4 3 2 1 0 5 [ + . ] each-integer ! 0 2 4 6 8 +5 [ "Hello" . ] times ! Hello Hello Hello Hello Hello + +! Here's a list: +{ 2 4 6 8 } ! Goes on the stack as one item + +! Aqui está uma lista: +{ 2 4 6 8 } [ 1 + . ] each ! Exibe 3 5 7 9 +{ 2 4 6 8 } [ 1 + ] map ! Sai { 3 5 7 9 } na pilha + +! Reduzir laços ou criar listas: +{ 1 2 3 4 5 } [ 2 mod 0 = ] filter ! Mantém apenas membros da lista para os quais a citação é verdadeira: { 2 4 } +{ 2 4 6 8 } 0 [ + ] reduce . ! Como "fold" em linguagens funcionais: exibe 20 (0+2+4+6+8) +{ 2 4 6 8 } 0 [ + ] accumulate . . ! Como reduzir, mas mantém os valores intermediários em uma lista: exibe { 0 2 6 12 } então 20 +1 5 [ 2 * dup ] replicate . ! Repete a citação 5 vezes e coleta os resultados em uma lista: { 2 4 8 16 32 } +1 [ dup 100 < ] [ 2 * dup ] produce ! Repete a segunda citação até que a primeira retorne como falsa e colete os resultados: { 2 4 8 16 32 64 128 } + +! Se tudo mais falhar, uma finalidade geral, enquanto repete: +1 [ dup 10 < ] [ "Hello" . 1 + ] while ! Exibe "Hello" 10 vezes + ! Sim, é difícil de ler + ! Isso é o que todos esses loops variantes são para + +! Variáveis +! Normalmente, espera-se que os programas Factor mantenham todos os dados na pilha. +! Usar variáveis nomeadas torna a refatoração mais difícil (e é chamada de Factor por um motivo) +! Variáveis globais, se você precisar: + +SYMBOL: name ! Cria o nome como uma palavra identificadora +"Bob" name set-global ! Sem saída +name get-global . ! "Bob" + +! Variáveis locais nomeadas são consideradas uma extensão, mas estão disponíveis +! Em uma citação .. +[| m n ! A citação captura os dois principais valores da pilha em m e n + | m n + ] ! Leia-os + +! Ou em uma palavra.. +:: lword ( -- ) ! Note os dois pontos duplos para invocar a extensão da variável lexica + 2 :> c ! Declara a variável imutável c para manter 2 + c . ; ! Imprima isso + +! Em uma palavra declarada dessa maneira, o lado de entrada da declaração de pilha +! torna-se significativo e fornece os valores das variáveis em que os valores da pilha são capturados +:: double ( a -- result ) a 2 * ; + +! Variáveis são declaradas mutáveis ao terminar seu nome com um ponto de exclamação +:: mword2 ( a! -- x y ) ! Capture o topo da pilha na variável mutável a + a ! Empurrar a + a 2 * a! ! Multiplique por 2 e armazene o resultado em a + a ; ! Empurre novo valor de a +5 mword2 ! Pilha: 5 10 + +! Listas e Sequências +! Vimos acima como empurrar uma lista para a pilha + +0 { 1 2 3 4 } nth ! Acessar um membro específico de uma lista: 1 +10 { 1 2 3 4 } nth ! Error: índice de sequência fora dos limites +1 { 1 2 3 4 } ?nth ! O mesmo que nth se o índice estiver dentro dos limites: 2 +10 { 1 2 3 4 } ?nth ! Nenhum erro se estiver fora dos limites: f + +{ "at" "the" "beginning" } "Append" prefix ! { "Append" "at" "the" "beginning" } +{ "Append" "at" "the" } "end" suffix ! { "Append" "at" "the" "end" } +"in" 1 { "Insert" "the" "middle" } insert-nth ! { "Insert" "in" "the" "middle" } +"Concat" "enate" append ! "Concatenate" - strings are sequences too +"Concatenate" "Reverse " prepend ! "Reverse Concatenate" +{ "Concatenate " "seq " "of " "seqs" } concat ! "Concatenate seq of seqs" +{ "Connect" "subseqs" "with" "separators" } " " join ! "Connect subseqs with separators" + +! E se você quiser obter meta, as citações são seqüências e podem ser desmontadas.. +0 [ 2 + ] nth ! 2 +1 [ 2 + ] nth ! + +[ 2 + ] \ - suffix ! Quotation [ 2 + - ] + + +``` + +##Pronto para mais? + +* [Documentação do Factor](http://docs.factorcode.org/content/article-help.home.html) diff --git a/tcl.html.markdown b/tcl.html.markdown index f48d5271..3d23870b 100644 --- a/tcl.html.markdown +++ b/tcl.html.markdown @@ -5,7 +5,7 @@ contributors: filename: learntcl.tcl --- -Tcl was created by [John Ousterhout](https://wiki.tcl.tk/John%20Ousterout) as a +Tcl was created by [John Ousterhout](https://wiki.tcl-lang.org/page/John+Ousterhout) as a reusable scripting language for circuit design tools that he authored. In 1997 he was awarded the [ACM Software System Award](https://en.wikipedia.org/wiki/ACM_Software_System_Award) for Tcl. Tcl @@ -283,7 +283,7 @@ set c [expr {$a + $b}] # Since "expr" performs variable substitution on its own, brace the expression # to prevent Tcl from performing variable substitution first. See -# "http://wiki.tcl.tk/Brace%20your%20#%20expr-essions" for details. +# "https://wiki.tcl-lang.org/page/Brace+your+expr-essions" for details. # "expr" understands variable and script substitution: @@ -581,8 +581,8 @@ a ## Reference -[Official Tcl Documentation](http://www.tcl.tk/man/tcl/) +[Official Tcl Documentation](https://www.tcl-lang.org) -[Tcl Wiki](http://wiki.tcl.tk) +[Tcl Wiki](https://wiki.tcl-lang.org) [Tcl Subreddit](http://www.reddit.com/r/Tcl) |