diff --git a/asymptotic-notation.html.markdown b/asymptotic-notation.html.markdown
index a516737e..a23ef1c8 100644
--- a/asymptotic-notation.html.markdown
+++ b/asymptotic-notation.html.markdown
@@ -3,41 +3,52 @@ category: Algorithms & Data Structures
name: Asymptotic Notation
contributors:
- ["Jake Prather", "http://github.com/JakeHP"]
+ - ["Divay Prakash", "http://github.com/divayprakash"]
---
# Asymptotic Notations
## What are they?
-Asymptotic Notations are languages that allow us to analyze an algorithm's running time by
-identifying its behavior as the input size for the algorithm increases. This is also known as
-an algorithm's growth rate. Does the algorithm suddenly become incredibly slow when the input
-size grows? Does it mostly maintain its quick run time as the input size increases?
-Asymptotic Notation gives us the ability to answer these questions.
+Asymptotic Notations are languages that allow us to analyze an algorithm's
+running time by identifying its behavior as the input size for the algorithm
+increases. This is also known as an algorithm's growth rate. Does the
+algorithm suddenly become incredibly slow when the input size grows? Does it
+mostly maintain its quick run time as the input size increases? Asymptotic
+Notation gives us the ability to answer these questions.
## Are there alternatives to answering these questions?
-One way would be to count the number of primitive operations at different input sizes.
-Though this is a valid solution, the amount of work this takes for even simple algorithms
-does not justify its use.
+One way would be to count the number of primitive operations at different
+input sizes. Though this is a valid solution, the amount of work this takes
+for even simple algorithms does not justify its use.
-Another way is to physically measure the amount of time an algorithm takes to complete
-given different input sizes. However, the accuracy and relativity (times obtained would
-only be relative to the machine they were computed on) of this method is bound to
-environmental variables such as computer hardware specifications, processing power, etc.
+Another way is to physically measure the amount of time an algorithm takes to
+complete given different input sizes. However, the accuracy and relativity
+(times obtained would only be relative to the machine they were computed on)
+of this method is bound to environmental variables such as computer hardware
+specifications, processing power, etc.
## Types of Asymptotic Notation
-In the first section of this doc we described how an Asymptotic Notation identifies the
-behavior of an algorithm as the input size changes. Let us imagine an algorithm as a function
-f, n as the input size, and f(n) being the running time. So for a given algorithm f, with input
-size n you get some resultant run time f(n). This results in a graph where the Y axis is the
-runtime, X axis is the input size, and plot points are the resultants of the amount of time
-for a given input size.
+In the first section of this doc we described how an Asymptotic Notation
+identifies the behavior of an algorithm as the input size changes. Let us
+imagine an algorithm as a function f, n as the input size, and f(n) being
+the running time. So for a given algorithm f, with input size n you get
+some resultant run time f(n). This results in a graph where the Y axis is the
+runtime, X axis is the input size, and plot points are the resultants of the
+amount of time for a given input size.
-You can label a function, or algorithm, with an Asymptotic Notation in many different ways.
-Some examples are, you can describe an algorithm by its best case, worse case, or equivalent case.
-The most common is to analyze an algorithm by its worst case. You typically don't evaluate by best case because those conditions aren't what you're planning for. A very good example of this is sorting algorithms; specifically, adding elements to a tree structure. Best case for most algorithms could be as low as a single operation. However, in most cases, the element you're adding will need to be sorted appropriately through the tree, which could mean examining an entire branch. This is the worst case, and this is what we plan for.
+You can label a function, or algorithm, with an Asymptotic Notation in many
+different ways. Some examples are, you can describe an algorithm by its best
+case, worse case, or equivalent case. The most common is to analyze an
+algorithm by its worst case. You typically don't evaluate by best case because
+those conditions aren't what you're planning for. A very good example of this
+is sorting algorithms; specifically, adding elements to a tree structure. Best
+case for most algorithms could be as low as a single operation. However, in
+most cases, the element you're adding will need to be sorted appropriately
+through the tree, which could mean examining an entire branch. This is the
+worst case, and this is what we plan for.
### Types of functions, limits, and simplification
@@ -45,16 +56,25 @@ The most common is to analyze an algorithm by its worst case. You typically don'
Logarithmic Function - log n
Linear Function - an + b
Quadratic Function - an^2 + bn + c
-Polynomial Function - an^z + . . . + an^2 + a*n^1 + a*n^0, where z is some constant
+Polynomial Function - an^z + . . . + an^2 + a*n^1 + a*n^0, where z is some
+constant
Exponential Function - a^n, where a is some constant
```
-These are some basic function growth classifications used in various notations. The list starts at the slowest growing function (logarithmic, fastest execution time) and goes on to the fastest growing (exponential, slowest execution time). Notice that as 'n', or the input, increases in each of those functions, the result clearly increases much quicker in quadratic, polynomial, and exponential, compared to logarithmic and linear.
+These are some basic function growth classifications used in various
+notations. The list starts at the slowest growing function (logarithmic,
+fastest execution time) and goes on to the fastest growing (exponential,
+slowest execution time). Notice that as 'n', or the input, increases in each
+of those functions, the result clearly increases much quicker in quadratic,
+polynomial, and exponential, compared to logarithmic and linear.
-One extremely important note is that for the notations about to be discussed you should do your best to use simplest terms. This means to disregard constants, and lower order terms, because as the input size (or n in our f(n)
-example) increases to infinity (mathematical limits), the lower order terms and constants are of little
-to no importance. That being said, if you have constants that are 2^9001, or some other ridiculous,
-unimaginable amount, realize that simplifying will skew your notation accuracy.
+One extremely important note is that for the notations about to be discussed
+you should do your best to use simplest terms. This means to disregard
+constants, and lower order terms, because as the input size (or n in our f(n)
+example) increases to infinity (mathematical limits), the lower order terms
+and constants are of little to no importance. That being said, if you have
+constants that are 2^9001, or some other ridiculous, unimaginable amount,
+realize that simplifying will skew your notation accuracy.
Since we want simplest form, lets modify our table a bit...
@@ -67,10 +87,13 @@ Exponential - a^n, where a is some constant
```
### Big-O
-Big-O, commonly written as O, is an Asymptotic Notation for the worst case, or ceiling of growth
-for a given function. Say `f(n)` is your algorithm runtime, and `g(n)` is an arbitrary time complexity
-you are trying to relate to your algorithm. `f(n)` is O(g(n)), if for any real constant c (c > 0),
-`f(n)` <= `c g(n)` for every input size n (n > 0).
+Big-O, commonly written as **O**, is an Asymptotic Notation for the worst
+case, or ceiling of growth for a given function. It provides us with an
+_**asymptotic upper bound**_ for the growth rate of runtime of an algorithm.
+Say `f(n)` is your algorithm runtime, and `g(n)` is an arbitrary time
+complexity you are trying to relate to your algorithm. `f(n)` is O(g(n)), if
+for some real constant c (c > 0), `f(n)` <= `c g(n)` for every input size
+n (n > 0).
*Example 1*
@@ -114,19 +137,62 @@ Is there some constant c that satisfies this for all n?
No, there isn't. `f(n)` is NOT O(g(n)).
### Big-Omega
-Big-Omega, commonly written as Ω, is an Asymptotic Notation for the best case, or a floor growth rate
-for a given function.
+Big-Omega, commonly written as **Ω**, is an Asymptotic Notation for the best
+case, or a floor growth rate for a given function. It provides us with an
+_**asymptotic lower bound**_ for the growth rate of runtime of an algorithm.
-`f(n)` is Ω(g(n)), if for any real constant c (c > 0), `f(n)` is >= `c g(n)` for every input size n (n > 0).
+`f(n)` is Ω(g(n)), if for some real constant c (c > 0), `f(n)` is >= `c g(n)`
+for every input size n (n > 0).
-Feel free to head over to additional resources for examples on this. Big-O is the primary notation used
-for general algorithm time complexity.
+### Note
+
+The asymptotic growth rates provided by big-O and big-omega notation may or
+may not be asymptotically tight. Thus we use small-o and small-omega notation
+to denote bounds that are not asymptotically tight.
+
+### Small-o
+Small-o, commonly written as **o**, is an Asymptotic Notation to denote the
+upper bound (that is not asymptotically tight) on the growth rate of runtime
+of an algorithm.
+
+`f(n)` is o(g(n)), if for any real constant c (c > 0), `f(n)` is < `c g(n)`
+for every input size n (n > 0).
+
+The definitions of O-notation and o-notation are similar. The main difference
+is that in f(n) = O(g(n)), the bound f(n) <= g(n) holds for _**some**_
+constant c > 0, but in f(n) = o(g(n)), the bound f(n) < c g(n) holds for
+_**all**_ constants c > 0.
+
+### Small-omega
+Small-omega, commonly written as **ω**, is an Asymptotic Notation to denote
+the lower bound (that is not asymptotically tight) on the growth rate of
+runtime of an algorithm.
+
+`f(n)` is ω(g(n)), if for any real constant c (c > 0), `f(n)` is > `c g(n)`
+for every input size n (n > 0).
+
+The definitions of Ω-notation and ω-notation are similar. The main difference
+is that in f(n) = Ω(g(n)), the bound f(n) >= g(n) holds for _**some**_
+constant c > 0, but in f(n) = ω(g(n)), the bound f(n) > c g(n) holds for
+_**all**_ constants c > 0.
+
+### Theta
+Theta, commonly written as **Θ**, is an Asymptotic Notation to denote the
+_**asymptotically tight bound**_ on the growth rate of runtime of an algorithm.
+
+`f(n)` is Θ(g(n)), if for some real constants c1, c2 (c1 > 0, c2 > 0),
+`c1 g(n)` is < `f(n)` is < `c2 g(n)` for every input size n (n > 0).
+
+∴ `f(n)` is Θ(g(n)) implies `f(n)` is O(g(n)) as well as `f(n)` is Ω(g(n)).
+
+Feel free to head over to additional resources for examples on this. Big-O
+is the primary notation use for general algorithm time complexity.
### Ending Notes
-It's hard to keep this kind of topic short, and you should definitely go through the books and online
-resources listed. They go into much greater depth with definitions and examples.
-More where x='Algorithms & Data Structures' is on its way; we'll have a doc up on analyzing actual
-code examples soon.
+It's hard to keep this kind of topic short, and you should definitely go
+through the books and online resources listed. They go into much greater depth
+with definitions and examples. More where x='Algorithms & Data Structures' is
+on its way; we'll have a doc up on analyzing actual code examples soon.
## Books
@@ -137,3 +203,4 @@ code examples soon.
* [MIT](http://web.mit.edu/16.070/www/lecture/big_o.pdf)
* [KhanAcademy](https://www.khanacademy.org/computing/computer-science/algorithms/asymptotic-notation/a/asymptotic-notation)
+* [Big-O Cheatsheet](http://bigocheatsheet.com/) - common structures, operations, and algorithms, ranked by complexity.
diff --git a/bash.html.markdown b/bash.html.markdown
index bd2d5984..f3c9cccc 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -130,6 +130,15 @@ ls -l # Lists every file and directory on a separate line
# .txt files in the current directory:
ls -l | grep "\.txt"
+# Since bash works in the context of a current directory, you might want to
+# run your command in some other directory. We have cd for changing location:
+cd ~ # change to home directory
+cd .. # go up one directory
+ # (^^say, from /home/username/Downloads to /home/username)
+cd /home/username/Documents # change to specified directory
+cd ~/Documents/.. # still in home directory..isn't it??
+
+
# You can redirect command input and output (stdin, stdout, and stderr).
# Read from stdin until ^EOF$ and overwrite hello.py with the lines
# between "EOF":
diff --git a/c.html.markdown b/c.html.markdown
index d4ff529d..7c9dd590 100644
--- a/c.html.markdown
+++ b/c.html.markdown
@@ -36,7 +36,6 @@ Multi-line comments don't nest /* Be careful */ // comment ends on this line...
enum days {SUN = 1, MON, TUE, WED, THU, FRI, SAT};
// MON gets 2 automatically, TUE gets 3, etc.
-
// Import headers with #include
#include
#include
@@ -114,7 +113,6 @@ int main (int argc, char** argv)
// sizeof(obj) yields the size of the expression (variable, literal, etc.).
printf("%zu\n", sizeof(int)); // => 4 (on most machines with 4-byte words)
-
// If the argument of the `sizeof` operator is an expression, then its argument
// is not evaluated (except VLAs (see below)).
// The value it yields in this case is a compile-time constant.
@@ -130,7 +128,6 @@ int main (int argc, char** argv)
int my_int_array[20]; // This array occupies 4 * 20 = 80 bytes
// (assuming 4-byte words)
-
// You can initialize an array to 0 thusly:
char my_array[20] = {0};
@@ -347,7 +344,6 @@ int main (int argc, char** argv)
this will print out "Error occured at i = 52 & j = 99."
*/
-
///////////////////////////////////////
// Typecasting
///////////////////////////////////////
@@ -386,7 +382,6 @@ int main (int argc, char** argv)
// (%p formats an object pointer of type void *)
// => Prints some address in memory;
-
// Pointers start with * in their declaration
int *px, not_a_pointer; // px is a pointer to an int
px = &x; // Stores the address of x in px
@@ -432,7 +427,6 @@ int main (int argc, char** argv)
printf("%zu, %zu\n", sizeof arraythethird, sizeof ptr);
// probably prints "40, 4" or "40, 8"
-
// Pointers are incremented and decremented based on their type
// (this is called pointer arithmetic)
printf("%d\n", *(x_ptr + 1)); // => Prints 19
@@ -578,8 +572,6 @@ void testFunc2() {
}
//**You may also declare functions as static to make them private**
-
-
///////////////////////////////////////
// User-defined types and structs
///////////////////////////////////////
@@ -696,6 +688,7 @@ typedef void (*my_fnp_type)(char *);
"%o"; // octal
"%%"; // prints %
*/
+
///////////////////////////////////////
// Order of Evaluation
///////////////////////////////////////
@@ -786,4 +779,4 @@ Readable code is better than clever code and fast code. For a good, sane coding
Other than that, Google is your friend.
-[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member
+[1] http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member
\ No newline at end of file
diff --git a/chapel.html.markdown b/chapel.html.markdown
index 866e92d2..9c1daf40 100644
--- a/chapel.html.markdown
+++ b/chapel.html.markdown
@@ -1066,7 +1066,7 @@ The more information you give the Chapel development team about issues you encou
Feel free to email the team and other developers through the [sourceforge email lists](https://sourceforge.net/p/chapel/mailman).
If you're really interested in the development of the compiler or contributing to the project,
-[check out the master Github repository](https://github.com/chapel-lang/chapel).
+[check out the master GitHub repository](https://github.com/chapel-lang/chapel).
It is under the [Apache 2.0 License](http://www.apache.org/licenses/LICENSE-2.0).
Installing the Compiler
diff --git a/cs-cz/brainfuck.html.markdown b/cs-cz/brainfuck.html.markdown
new file mode 100644
index 00000000..29abc21f
--- /dev/null
+++ b/cs-cz/brainfuck.html.markdown
@@ -0,0 +1,87 @@
+---
+language: brainfuck
+contributors:
+ - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+ - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+ - ["Vojta Svoboda", "https://github.com/vojtasvoboda/"]
+filename: learnbrainfuck-cz.bf
+lang: cs-cz
+---
+
+Brainfuck (psaný bez kapitálek s vyjímkou začátku věty) je extrémně minimální
+Turingovsky kompletní (ekvivalentní) programovací jazyk a má pouze 8 příkazů.
+
+Můžete si ho vyzkoušet přímo v prohlížeči s [brainfuck-visualizer](http://fatiherikli.github.io/brainfuck-visualizer/).
+
+```
+Jakýkoliv znak mimo "><+-.,[]" (bez uvozovek) je ignorován.
+
+Brainfuck je reprezentován jako pole, které má 30.000 buněk s počátkem v nule
+a datovým ukazatelem na aktuální buňce.
+
+Můžeme využít těchto osm příkazů:
++ : Přičte k aktuální buňce jedničku.
+- : Odečte od aktuální buňky jedničku.
+> : Posune datový ukazatel na další buňku, která je napravo.
+< : Posune datový ukazatel na předchozí buňku, která je nalevo.
+. : Vytiskne ASCII hodnotu aktuální buňky (například 65 = 'A').
+, : Načte jeden znak do aktuální buňky.
+[ : Pokud je hodnota aktuální buňky nulová, přeskočí na buňku odpovídající ] .
+ Jinak skočí na další instrukci.
+] : Pokud je hodnota aktuální buňky nulova, přeskočí na další instrukci.
+ Jinak skočí zpět na instrukci odpovídající [ .
+
+[ a ] tak tvoří 'while' smyčku a tyto symboly musí tak být v páru.
+
+Pojďme se mrknout na některé brainfuck programy.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Tento program vypíše písmeno 'A' (v ASCII je to číslo 65). Nejdříve navýší
+buňku #1 na hodnotu 6. Buňka #1 bude použita pro smyčku. Potom program vstoupí
+do smyčky ([) a sníží hodnotu buňky #1 o jedničku. Ve smyčce zvýší hodnotu
+buňky #2 desetkrát, vrátí ze zpět na buňku #1 a sníží její hodnotu o jedničku.
+Toto se stane šestkrát (je potřeba šestkrát snížit hodnotu buňky #1, aby byla
+nulová a program přeskočil na konec cyklu označený znakem ].
+
+Na konci smyčky, kdy jsme na buňce #1 (která má hodnotu 0), tak má buňka #2
+hodnotu 60. Přesuneme se na buňku #2 a pětkrát zvýšíme její hodnotu o jedničku
+na hodnotu 65. Na konci vypíšeme hodnotu buňky #2 - 65, což je v ASCII znak 'A'
+na terminálu.
+
+
+, [ > + < - ] > .
+
+Tento program přečte znak z uživatelského vstupu a zkopíruje ho do buňky #1.
+Poté začne smyčka - přesun na buňku #2, zvýšení hodnoty buňky #2 o jedničku,
+přesun zpět na buňku #1 a snížení její hodnoty o jedničku. Takto smyčka pokračuje
+do té doby, než je buňka #1 nulová a buňka #2 nabyde původní hodnotu buňky #1.
+Protože jsme na buňce #1, přesuneme se na buňku #2 a vytiskneme její hodnotu
+v ASCII.
+
+Je dobré vědět, že mezery jsou v programu uvedené pouze z důvodu čitelnosti.
+Program je možné klidně zapsat i takto:
+
+,[>+<-]>.
+
+
+Nyní se podívejte na tento program a zkuste zjistit co dělá:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Tento program vezme dvě čísla ze vstupu a vynásobí je.
+
+Program nejdříve načte dvě vstupní hodnoty. Poté začíná smyčka řízená hodnotou
+v buňce #1 - přesun na buňku #2 a start druhé vnořené smyčky, která je řízená
+hodnotou v buňce #2 a zvyšuje hodnotu v buňce #3. Nicméně je zde problém
+kdy na konci vnitřní smyčky je v buňce #2 nula a smyčka by tak znovu
+napokračovala. Vyřešíme to tak, že zvyšujeme o jedničku i buňku #4 a její
+hodnotu poté překopírujeme do buňky #2. Na konci programu je v buňce #3
+výsledek.
+```
+
+A to je brainbuck. Zase tak složitý není, co? Zkuste si nyní napsat nějaký
+vlastní brainfuck program a nebo interpretr v jiném jazyce, což není zase
+tak složité, ale pokud jste opravdový masochista, zkuste si naprogramovat
+interpretr jazyka brainfuck v jazyce... brainfuck :)
diff --git a/cs-cz/json.html.markdown b/cs-cz/json.html.markdown
new file mode 100644
index 00000000..5972da5e
--- /dev/null
+++ b/cs-cz/json.html.markdown
@@ -0,0 +1,62 @@
+---
+language: json
+contributors:
+ - ["Anna Harren", "https://github.com/iirelu"]
+ - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+ - ["Vojta Svoboda", "https://github.com/vojtasvoboda/"]
+filename: learnjson-cz.json
+lang: cs-cz
+---
+
+JSON je exterémně jednoduchý datově nezávislý formát a bude asi jeden z
+nejjednodušších 'Learn X in Y Minutes' ze všech.
+
+JSON nemá ve své nejzákladnější podobě žádné komentáře, ale většina parserů
+umí pracovat s komentáři ve stylu jazyka C (`//`, `/* */`). Pro tyto účely
+však budeme používat 100% validní JSON bez komentářů. Pojďme se podívat na
+syntaxi formátu JSON:
+
+```json
+{
+ "klic": "value",
+
+ "hodnoty": "Musí být vždy uvozený v dvojitých uvozovkách",
+ "cisla": 0,
+ "retezce": "Hellø, wørld. Všechny unicode znaky jsou povolené, společně s \"escapováním\".",
+ "pravdivostni_hodnota": true,
+ "prazdna_hodnota": null,
+
+ "velke_cislo": 1.2e+100,
+
+ "objekt": {
+ "komentar": "Most of your structure will come from objects.",
+
+ "pole": [0, 1, 2, 3, "Pole nemusí být pouze homogenní.", 5],
+
+ "jiny_objekt": {
+ "comment": "Je povolené jakkoli hluboké zanoření."
+ }
+ },
+
+ "cokoli": [
+ {
+ "zdroje_drasliku": ["banány"]
+ },
+ [
+ [1, 0, 0, 0],
+ [0, 1, 0, 0],
+ [0, 0, 1, "neo"],
+ [0, 0, 0, 1]
+ ]
+ ],
+
+ "alternativni_styl_zapisu": {
+ "komentar": "Mrkni se na toto!"
+ , "pozice_carky": "Na pozici čárky nezáleží - pokud je před hodnotou, ať už je kdekoli, tak je validní."
+ , "dalsi_komentar": "To je skvělé."
+ },
+
+ "to_bylo_rychle": "A tím jsme hotový. Nyní již víte vše, co může formát JSON nabídnout!"
+}
+```
diff --git a/cs-cz/markdown.html.markdown b/cs-cz/markdown.html.markdown
index 0d44bc12..568e4343 100644
--- a/cs-cz/markdown.html.markdown
+++ b/cs-cz/markdown.html.markdown
@@ -53,7 +53,7 @@ __Stejně jako tento.__
**_Jako tento!_**
*__A tento!__*
-
+
~~Tento text je prošktrnutý.~~
@@ -152,7 +152,7 @@ Tento box bude zašktrnutý
Jan nevědel, jak se dělá `go_to()` funkce!
-
+
\`\`\`ruby
def neco
@@ -160,7 +160,7 @@ def neco
end
\`\`\`
-
@@ -232,13 +232,13 @@ Dejte text, který chcete zobrazit, do [] následovaný url v závorkách () a j
Chci napsat *tento text obklopený hvězdičkami*, ale nechci aby to bylo kurzívou, tak udělám: \*tento text obklopený hvězdičkami\*.
-
+
Váš počítač přestal pracovat? Zkuste
Ctrl+Alt+Del
-
| Sloupec1 | Sloupec2 | Sloupec3 |
diff --git a/csharp.html.markdown b/csharp.html.markdown
index 7d7f4340..197f43e7 100644
--- a/csharp.html.markdown
+++ b/csharp.html.markdown
@@ -24,10 +24,12 @@ Multi-line comments look like this
/// This is an XML documentation comment which can be used to generate external
/// documentation or provide context help within an IDE
///
-//public void MethodOrClassOrOtherWithParsableHelp() {}
+/// This is some parameter documentation for firstParam
+/// Information on the returned value of a function
+//public void MethodOrClassOrOtherWithParsableHelp(string firstParam) {}
// Specify the namespaces this source code will be using
-// The namespaces below are all part of the standard .NET Framework Class Libary
+// The namespaces below are all part of the standard .NET Framework Class Library
using System;
using System.Collections.Generic;
using System.Dynamic;
@@ -421,7 +423,7 @@ on a new line! ""Wow!"", the masses cried";
// Item is an int
Console.WriteLine(item.ToString());
}
-
+
// YIELD
// Usage of the "yield" keyword indicates that the method it appears in is an Iterator
// (this means you can use it in a foreach loop)
@@ -437,7 +439,7 @@ on a new line! ""Wow!"", the masses cried";
foreach (var counter in YieldCounter())
Console.WriteLine(counter);
}
-
+
// you can use more than one "yield return" in a method
public static IEnumerable ManyYieldCounter()
{
@@ -446,7 +448,7 @@ on a new line! ""Wow!"", the masses cried";
yield return 2;
yield return 3;
}
-
+
// you can also use "yield break" to stop the Iterator
// this method would only return half of the values from 0 to limit.
public static IEnumerable YieldCounterWithBreak(int limit = 10)
@@ -482,7 +484,7 @@ on a new line! ""Wow!"", the masses cried";
// ?? is syntactic sugar for specifying default value (coalesce)
// in case variable is null
int notNullable = nullable ?? 0; // 0
-
+
// ?. is an operator for null-propagation - a shorthand way of checking for null
nullable?.Print(); // Use the Print() extension method if nullable isn't null
@@ -913,17 +915,17 @@ on a new line! ""Wow!"", the masses cried";
public DbSet Bikes { get; set; }
}
-
+
// Classes can be split across multiple .cs files
// A1.cs
- public partial class A
+ public partial class A
{
public static void A1()
{
Console.WriteLine("Method A1 in class A");
}
}
-
+
// A2.cs
public partial class A
{
@@ -932,9 +934,9 @@ on a new line! ""Wow!"", the masses cried";
Console.WriteLine("Method A2 in class A");
}
}
-
+
// Program using the partial class "A"
- public class Program
+ public class Program
{
static void Main()
{
diff --git a/css.html.markdown b/css.html.markdown
index 8ee4f4b9..4ec95f8b 100644
--- a/css.html.markdown
+++ b/css.html.markdown
@@ -7,6 +7,7 @@ contributors:
- ["Connor Shea", "https://github.com/connorshea"]
- ["Deepanshu Utkarsh", "https://github.com/duci9y"]
- ["Tyler Mumford", "https://tylermumford.com"]
+
filename: learncss.css
---
@@ -195,7 +196,7 @@ Save a CSS stylesheet with the extension `.css`.
## Precedence or Cascade
-An element may be targeted by multiple selectors and may have a property set on it in more than once. In these cases, one of the rules takes precedence over others. Rules with a more specific selector take precedence over a less specific one, and a rule occuring later in the stylesheet overwrites a previous one.
+An element may be targeted by multiple selectors and may have a property set on it in more than once. In these cases, one of the rules takes precedence over others. Rules with a more specific selector take precedence over a less specific one, and a rule occuring later in the stylesheet overwrites a previous one (which also means that if two different linked stylesheets contain rules for an element and if the rules are of the same specificity, then order of linking would take precedence and the sheet linked latest would govern styling) .
This process is called cascading, hence the name Cascading Style Sheets.
diff --git a/de-de/bash-de.html.markdown b/de-de/bash-de.html.markdown
index 541d28bb..654fcdd4 100644
--- a/de-de/bash-de.html.markdown
+++ b/de-de/bash-de.html.markdown
@@ -92,12 +92,12 @@ echo "immer ausgeführt" || echo "Nur ausgeführt wenn der erste Befehl fehlschl
echo "immer ausgeführt" && echo "Nur ausgeführt wenn der erste Befehl Erfolg hat"
# Um && und || mit if statements zu verwenden, braucht man mehrfache Paare eckiger Klammern:
-if [ $NAME == "Steve" ] && [ $Alter -eq 15 ]
+if [ "$NAME" == "Steve" ] && [ "$Alter" -eq 15 ]
then
echo "Wird ausgeführt wenn $NAME gleich 'Steve' UND $Alter gleich 15."
fi
-if [ $Name == "Daniya" ] || [ $Name == "Zach" ]
+if [ "$Name" == "Daniya" ] || [ "$Name" == "Zach" ]
then
echo "Wird ausgeführt wenn $NAME gleich 'Daniya' ODER $NAME gleich 'Zach'."
fi
diff --git a/de-de/git-de.html.markdown b/de-de/git-de.html.markdown
index dea329d5..61f7bb67 100644
--- a/de-de/git-de.html.markdown
+++ b/de-de/git-de.html.markdown
@@ -33,6 +33,7 @@ Eine Versionsverwaltung erfasst die Änderungen einer Datei oder eines Verzeichn
* Ist offline einsetzbar.
* Einfache Kollaboration!
* Branching ist einfach!
+* Branching ist schnell!
* Merging ist einfach!
* Git ist schnell.
* Git ist flexibel.
@@ -53,11 +54,11 @@ Das .git-Verzeichnis enthält alle Einstellung, Logs, Branches, den HEAD und meh
### Arbeitsverzeichnis (Teil des Repositorys)
-Dies sind die Verzeichnisse und Dateien in deinem Repository.
+Dies sind die Verzeichnisse und Dateien in deinem Repository, also z.B. dein Programmcode.
### Index (Teil des .git-Verzeichnisses)
-Der Index ist die die Staging-Area von Git. Es ist im Grunde eine Ebene, die Arbeitsverzeichnis vom Repository trennt. Sie gibt Entwicklern mehr Einfluss darüber, was ins Git-Repository eingeht.
+Der Index ist die Staging-Area von Git. Es ist im Grunde eine Ebene, die Arbeitsverzeichnis vom Repository trennt. Sie gibt Entwicklern mehr Einfluss darüber, was ins Git-Repository eingeht.
### Commit
@@ -84,7 +85,7 @@ Ein *head* ist ein Pointer, der auf einen beliebigen Commit zeigt. Ein Reposito
### init
-Erstelle ein leeres Git-Repository. Die Einstellungen, gespeicherte Informationen und mehr zu diesem Git-Repository werden in einem Verzeichnis namens *.git* angelegt.
+Erstelle ein leeres Git-Repository im aktuellen Verzeichnis. Die Einstellungen, gespeicherte Informationen und mehr zu diesem Git-Repository werden in einem Verzeichnis namens *.git* angelegt.
```bash
$ git init
@@ -180,6 +181,8 @@ Bringt alle Dateien im Arbeitsverzeichnis auf den Stand des Index oder des angeg
```bash
# Ein Repo auschecken - wenn nicht anders angegeben ist das der master
$ git checkout
+# Eine Datei auschecken - sie befindet sich dann auf dem aktuellen Stand im Repository
+$ git checkout /path/to/file
# Einen bestimmten Branch auschecken
$ git checkout branchName
# Erstelle einen neuen Branch und wechsle zu ihm. Wie: "git branch ; git checkout "
@@ -217,6 +220,9 @@ $ git diff --cached
# Unterschiede zwischen deinem Arbeitsverzeichnis und dem aktuellsten Commit anzeigen
$ git diff HEAD
+
+# Unterschiede zwischen dem Index und dem aktuellsten Commit (betrifft nur Dateien im Index)
+$ git diff --staged
```
### grep
@@ -374,3 +380,5 @@ $ git rm /pather/to/the/file/HelloWorld.c
* [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
* [GitGuys](http://www.gitguys.com/)
+
+* [gitflow - Ein Modell um mit Branches zu arbeiten](http://nvie.com/posts/a-successful-git-branching-model/)
diff --git a/de-de/go-de.html.markdown b/de-de/go-de.html.markdown
index 94f48e65..dca88f01 100644
--- a/de-de/go-de.html.markdown
+++ b/de-de/go-de.html.markdown
@@ -4,6 +4,7 @@ filename: learngo-de.go
contributors:
- ["Joseph Adams", "https://github.com/jcla1"]
- ["Dennis Keller", "https://github.com/denniskeller"]
+translators:
- ["Jerome Meinke", "https://github.com/jmeinke"]
lang: de-de
---
diff --git a/de-de/hack-de.html.markdown b/de-de/hack-de.html.markdown
new file mode 100644
index 00000000..42428130
--- /dev/null
+++ b/de-de/hack-de.html.markdown
@@ -0,0 +1,322 @@
+---
+language: Hack
+lang: de-de
+contributors:
+ - ["Stephen Holdaway", "https://github.com/stecman"]
+ - ["David Lima", "https://github.com/davelima"]
+translators:
+ - ["Jerome Meinke", "https://github.com/jmeinke"]
+filename: learnhack-de.hh
+---
+
+Hack ist eine von Facebook neu entwickelte Programmiersprache auf Basis von PHP.
+Sie wird von der HipHop Virtual Machine (HHVM) ausgeführt. Die HHVM kann
+aufgrund der Ähnlichkeit der Programmiersprachen nicht nur Hack, sondern auch
+PHP-Code ausführen. Der wesentliche Unterschied zu PHP besteht in der statischen
+Typisierung der Sprache, die eine wesentlich höhere Performance erlaubt.
+
+
+Hier werden nur Hack-spezifische Eigenschaften beschrieben. Details über PHP's
+Syntax findet man im [PHP Artikel](http://learnxinyminutes.com/docs/php/) dieser
+Seite.
+
+```php
+id = $id;
+ }
+}
+
+
+// Kurzgefasste anonyme Funktionen (lambdas)
+$multiplier = 5;
+array_map($y ==> $y * $multiplier, [1, 2, 3]);
+
+
+// Weitere, spezielle Felder (Generics)
+// Diese kann man sich als ein zugreifbares Interface vorstellen
+class Box
+{
+ protected T $data;
+
+ public function __construct(T $data) {
+ $this->data = $data;
+ }
+
+ public function getData(): T {
+ return $this->data;
+ }
+}
+
+function openBox(Box $box) : int
+{
+ return $box->getData();
+}
+
+
+// Formen
+//
+// Hack fügt das Konzept von Formen hinzu, wie struct-ähnliche arrays
+// mit einer typ-geprüften Menge von Schlüsseln
+type Point2D = shape('x' => int, 'y' => int);
+
+function distance(Point2D $a, Point2D $b) : float
+{
+ return sqrt(pow($b['x'] - $a['x'], 2) + pow($b['y'] - $a['y'], 2));
+}
+
+distance(
+ shape('x' => -1, 'y' => 5),
+ shape('x' => 2, 'y' => 50)
+);
+
+
+// Typen-Definition bzw. Aliasing
+//
+// Hack erlaubt es Typen zu definieren und sorgt somit für bessere Lesbarkeit
+newtype VectorArray = array>;
+
+// Ein Tupel mit zwei Integern
+newtype Point = (int, int);
+
+function addPoints(Point $p1, Point $p2) : Point
+{
+ return tuple($p1[0] + $p2[0], $p1[1] + $p2[1]);
+}
+
+addPoints(
+ tuple(1, 2),
+ tuple(5, 6)
+);
+
+
+// Erstklassige Aufzählungen (enums)
+enum RoadType : int
+{
+ Road = 0;
+ Street = 1;
+ Avenue = 2;
+ Boulevard = 3;
+}
+
+function getRoadType() : RoadType
+{
+ return RoadType::Avenue;
+}
+
+
+// Automatische Erstellung von Klassen-Eigenschaften durch Konstruktor-Argumente
+//
+// Wiederkehrende Definitionen von Klassen-Eigenschaften können durch die Hack-
+// Syntax vermieden werden. Hack erlaubt es die Klassen-Eigenschaften über
+// Argumente des Konstruktors zu definieren.
+class ArgumentPromotion
+{
+ public function __construct(public string $name,
+ protected int $age,
+ private bool $isAwesome) {}
+}
+
+class WithoutArgumentPromotion
+{
+ public string $name;
+
+ protected int $age;
+
+ private bool $isAwesome;
+
+ public function __construct(string $name, int $age, bool $isAwesome)
+ {
+ $this->name = $name;
+ $this->age = $age;
+ $this->isAwesome = $isAwesome;
+ }
+}
+
+
+// Kooperatives Multitasking
+//
+// Die Schlüsselworte "async" and "await" führen Multitasking ein.
+// Achtung, hier werden keine Threads benutzt, sondern nur Aktivität getauscht.
+async function cooperativePrint(int $start, int $end) : Awaitable
+{
+ for ($i = $start; $i <= $end; $i++) {
+ echo "$i ";
+
+ // Geben anderen Tasks die Möglichkeit aktiv zu werden
+ await RescheduleWaitHandle::create(RescheduleWaitHandle::QUEUE_DEFAULT, 0);
+ }
+}
+
+// Die Ausgabe von folgendem Code ist "1 4 7 2 5 8 3 6 9"
+AwaitAllWaitHandle::fromArray([
+ cooperativePrint(1, 3),
+ cooperativePrint(4, 6),
+ cooperativePrint(7, 9)
+])->getWaitHandle()->join();
+
+
+// Attribute
+//
+// Attribute repräsentieren eine Form von Metadaten für Funktionen.
+// Hack bietet Spezial-Attribute, die nützliche Eigenschaften mit sich bringen.
+
+// Das __Memoize Attribut erlaubt es die Ausgabe einer Funktion zu cachen.
+<<__Memoize>>
+function doExpensiveTask() : ?string
+{
+ return file_get_contents('http://example.com');
+}
+
+// Der Funktionsrumpf wird im Folgenden nur ein einziges mal ausgeführt:
+doExpensiveTask();
+doExpensiveTask();
+
+
+// Das __ConsistentConstruct Attribut signalisiert dem type-checker, dass
+// die Funktionsdeklaration von __construct für alle Unterklassen dieselbe ist.
+<<__ConsistentConstruct>>
+class ConsistentFoo
+{
+ public function __construct(int $x, float $y)
+ {
+ // ...
+ }
+
+ public function someMethod()
+ {
+ // ...
+ }
+}
+
+class ConsistentBar extends ConsistentFoo
+{
+ public function __construct(int $x, float $y)
+ {
+ // Der Type-checker erzwingt den Aufruf des Eltern-Klassen-Konstruktors
+ parent::__construct($x, $y);
+
+ // ...
+ }
+
+ // Das __Override Attribut ist ein optionales Signal an den Type-Checker,
+ // das erzwingt, dass die annotierte Methode die Methode der Eltern-Klasse
+ // oder des Traits verändert.
+ <<__Override>>
+ public function someMethod()
+ {
+ // ...
+ }
+}
+
+class InvalidFooSubclass extends ConsistentFoo
+{
+ // Wenn der Konstruktor der Eltern-Klasse nicht übernommen wird,
+ // wird der Type-Checker einen Fehler ausgeben:
+ //
+ // "This object is of type ConsistentBaz. It is incompatible with this object
+ // of type ConsistentFoo because some of their methods are incompatible"
+ //
+ public function __construct(float $x)
+ {
+ // ...
+ }
+
+ // Auch bei der Benutzung des __Override Attributs für eine nicht veränderte
+ // Methode wird vom Type-Checker eine Fehler ausgegeben:
+ //
+ // "InvalidFooSubclass::otherMethod() is marked as override; no non-private
+ // parent definition found or overridden parent is defined in non->
+ public function otherMethod()
+ {
+ // ...
+ }
+}
+
+// Ein Trait ist ein Begriff aus der objektorientierten Programmierung und
+// beschreibt eine wiederverwendbare Sammlung von Methoden und Attributen,
+// ähnlich einer Klasse.
+
+// Anders als in PHP können Traits auch als Schnittstellen (Interfaces)
+// implementiert werden und selbst Schnittstellen implementieren.
+interface KittenInterface
+{
+ public function play() : void;
+}
+
+trait CatTrait implements KittenInterface
+{
+ public function play() : void
+ {
+ // ...
+ }
+}
+
+class Samuel
+{
+ use CatTrait;
+}
+
+
+$cat = new Samuel();
+$cat instanceof KittenInterface === true; // True
+
+```
+
+## Weitere Informationen
+
+Die Hack [Programmiersprachen-Referenz](http://docs.hhvm.com/manual/de/hacklangref.php)
+erklärt die neuen Eigenschaften der Sprache detailliert auf Englisch. Für
+allgemeine Informationen kann man auch die offizielle Webseite [hacklang.org](http://hacklang.org/)
+besuchen.
+
+Die offizielle Webseite [hhvm.com](http://hhvm.com/) bietet Infos zum Download
+und zur Installation der HHVM.
+
+Hack's [nicht-untersützte PHP Syntax-Elemente](http://docs.hhvm.com/manual/en/hack.unsupported.php)
+werden im offiziellen Handbuch beschrieben.
diff --git a/de-de/haml-de.html.markdown b/de-de/haml-de.html.markdown
new file mode 100644
index 00000000..7272b365
--- /dev/null
+++ b/de-de/haml-de.html.markdown
@@ -0,0 +1,156 @@
+---
+language: haml
+filename: learnhaml-de.haml
+contributors:
+ - ["Simon Neveu", "https://github.com/sneveu"]
+ - ["Sol Bekic", "https://github.com/S0lll0s"]
+lang: de-de
+---
+
+Haml ist eine Markup- und Templatingsprache, aufgesetzt auf Ruby, mit der HTML Dokumente einfach beschrieben werden können.
+
+Haml vermindert Wiederholung und Fehleranfälligkeit, indem es Tags basierend auf der Markup-Struktur schließt und schachtelt.
+Dadurch ergibt sich kurzes, präzises und logisches Markup.
+
+Haml kann außerhalb eines Ruby-projekts verwendet werden. Mit dem installierten Haml gem kann man das Terminal benutzen um Haml zu HTML umzuwandeln:
+
+$ haml input_file.haml output_file.html
+
+
+```haml
+/ -------------------------------------------
+/ Einrückung
+/ -------------------------------------------
+
+/
+ Einrückung ist ein wichtiges Element des Haml Syntax, deswegen ist es
+ wichtig ein konsequentes Schema zu verwenden. Meistens werden zwei spaces
+ verwendet, solange die Einrückungen das gleiche Schema verfolgen können
+ aber auch andere Breiten und Tabs verwendet werden
+
+
+/ -------------------------------------------
+/ Kommentare
+/ -------------------------------------------
+
+/ Kommentare beginnen mit einem Slash
+
+/
+ Mehrzeilige Kommentare werden eingerückt und mit einem Slash
+ eingeführt
+
+-# Diese Zeile ist ein "stummes" Kommentar, es wird nicht mitgerendert
+
+
+/ -------------------------------------------
+/ HTML Elemente
+/ -------------------------------------------
+
+/ Tags werden durch ein Prozentzeichen und den Tagnamen erzeugt
+%body
+ %header
+ %nav
+
+/ Die Zeilen oben würden folgendes ergeben:
+
+
+
+
+/ Text kann direkt nach dem Tagnamen eingefügt werden:
+%h1 Headline copy
+
+/ Mehrzeilige Inhalte müssen stattdessen eingerückt werden:
+%p
+ This is a lot of content that we could probably split onto two
+ separate lines.
+
+/
+ HTML kann mit &= escaped werden. So werden HTML-sensitive Zeichen
+ enkodiert. Zum Beispiel:
+
+%p
+ &= "Ja & Nein"
+
+/ würde 'Ja & Nein' ergeben
+
+/ HTML kann mit != dekodiert werden:
+%p
+ != "so schreibt man ein Paragraph-Tag: "
+
+/ ...was 'This is how you write a paragraph tag ' ergeben würde
+
+/ CSS Klassen können mit '.classname' an Tags angehängt werden:
+%div.foo.bar
+
+/ oder über einen Ruby Hash:
+%div{:class => 'foo bar'}
+
+/ Das div Tag wird standardmäßig verwendet, divs können also verkürzt werden:
+.foo
+
+/ andere Attribute können über den Hash angegeben werden:
+%a{:href => '#', :class => 'bar', :title => 'Bar'}
+
+/ Booleesche Attribute können mit 'true' gesetzt werden:
+%input{:selected => true}
+
+/ data-Attribute können in einem eigenen Hash im :data key angegeben werden:
+%div{:data => {:attribute => 'foo'}}
+
+
+/ -------------------------------------------
+/ Verwendung von Ruby
+/ -------------------------------------------
+
+/ Mit dem = Zeichen können Ruby-werte evaluiert und als Tag-text verwendet werden:
+
+%h1= book.name
+
+%p
+ = book.author
+ = book.publisher
+
+
+/ Code nach einem Bindestrich wird ausgeführt aber nicht gerendert:
+- books = ['book 1', 'book 2', 'book 3']
+
+/ So können zum Beispiel auch Blöcke verwendet werden:
+- books.shuffle.each_with_index do |book, index|
+ %h1= book
+
+ if book do
+ %p This is a book
+
+/
+ Auch hier werden wieder keine End-Tags benötigt!
+ Diese ergeben sich aus der Einrückung.
+
+
+/ -------------------------------------------
+/ Inline Ruby / Ruby Interpolation
+/ -------------------------------------------
+
+/ Ruby variablen können mit #{} in Text interpoliert werden:
+%p dein bestes Spiel ist #{best_game}
+
+
+/ -------------------------------------------
+/ Filter
+/ -------------------------------------------
+
+/
+ Mit dem Doppelpinkt können Haml Filter benutzt werden.
+ Zum Beispiel gibt es den :javascript Filter, mit dem inline JS
+ geschrieben werden kann:
+
+:javascript
+ console.log('Dies ist ein
+