5 files changed, 431 insertions, 2 deletions
diff --git a/hu-hu/coffeescript-hu.html.markdown b/hu-hu/coffeescript-hu.html.markdown
new file mode 100644
index 00000000..b5ae2107
--- /dev/null
+++ b/hu-hu/coffeescript-hu.html.markdown
@@ -0,0 +1,107 @@
+---
+language: coffeescript
+contributors:
+  - ["Tenor Biel", "http://github.com/L8D"]
+  - ["Xavier Yao", "http://github.com/xavieryao"]
+translators:
+  - ["Tamás Diószegi", "http://github.com/ditam"]
+lang: hu-hu
+filename: coffeescript-hu.coffee
+---
+
+A CoffeeScript egy apró nyelv ami egy-az-egyben egyenértékű Javascript kódra fordul, és így futásidőben már nem szükséges interpretálni.
+Mint a JavaScript egyik követője, a CoffeeScript mindent megtesz azért, hogy olvasható, jól formázott és jól futó JavaScript kódot állítson elő, ami minden JavaScript futtatókörnyezetben jól működik.
+
+Rézletekért lásd még a [CoffeeScript weboldalát](http://coffeescript.org/), ahol egy teljes CoffeScript tutorial is található.
+
+```coffeescript
+# A CoffeeScript egy hipszter nyelv.
+# Követi több modern nyelv trendjeit.
+# Így a kommentek, mint Ruby-ban és Python-ban, a szám szimbólummal kezdődnek.
+
+###
+A komment blokkok ilyenek, és közvetlenül '/ *' és '* /' jelekre fordítódnak
+az eredményül kapott JavaScript kódban.
+
+Mielőtt tovább olvasol, jobb, ha a JavaScript alapvető szemantikájával
+tisztában vagy.
+
+(A kód példák alatt kommentként látható a fordítás után kapott JavaScript kód.)
+###
+
+# Értékadás:
+number   = 42 #=> var number = 42;
+opposite = true #=> var opposite = true;
+
+# Feltételes utasítások:
+number = -42 if opposite #=> if(opposite) { number = -42; }
+
+# Függvények:
+square = (x) -> x * x #=> var square = function(x) { return x * x; }
+
+fill = (container, liquid = "coffee") ->
+  "Filling the #{container} with #{liquid}..."
+#=>var fill;
+#
+#fill = function(container, liquid) {
+#  if (liquid == null) {
+#    liquid = "coffee";
+#  }
+#  return "Filling the " + container + " with " + liquid + "...";
+#};
+
+# Szám tartományok:
+list = [1..5] #=> var list = [1, 2, 3, 4, 5];
+
+# Objektumok:
+math =
+  root:   Math.sqrt
+  square: square
+  cube:   (x) -> x * square x
+#=> var math = {
+#    "root": Math.sqrt,
+#    "square": square,
+#    "cube": function(x) { return x * square(x); }
+#   };
+
+# "Splat" jellegű függvény-paraméterek:
+race = (winner, runners...) ->
+  print winner, runners
+#=>race = function() {
+#    var runners, winner;
+#    winner = arguments[0], runners = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+#    return print(winner, runners);
+#  };
+
+# Létezés-vizsgálat:
+alert "I knew it!" if elvis?
+#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); }
+
+# Tömb értelmezések: (array comprehensions)
+cubes = (math.cube num for num in list)
+#=>cubes = (function() {
+#	  var _i, _len, _results;
+#	  _results = [];
+# 	for (_i = 0, _len = list.length; _i < _len; _i++) {
+#		  num = list[_i];
+#		  _results.push(math.cube(num));
+#	  }
+#	  return _results;
+# })();
+
+foods = ['broccoli', 'spinach', 'chocolate']
+eat food for food in foods when food isnt 'chocolate'
+#=>foods = ['broccoli', 'spinach', 'chocolate'];
+#
+#for (_k = 0, _len2 = foods.length; _k < _len2; _k++) {
+#  food = foods[_k];
+#  if (food !== 'chocolate') {
+#    eat(food);
+#  }
+#}
+```
+
+## További források
+
+- [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/)
+- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read)
diff --git a/hu-hu/go.html.markdown b/hu-hu/go-hu.html.markdown
index 638c9489..638c9489 100644
--- a/hu-hu/go.html.markdown
+++ b/hu-hu/go-hu.html.markdown
diff --git a/hu-hu/ruby.html.markdown b/hu-hu/ruby-hu.html.markdown
index 169f2b8e..f2fe4e5d 100644
--- a/hu-hu/ruby.html.markdown
+++ b/hu-hu/ruby-hu.html.markdown
@@ -1,7 +1,7 @@
 ---
 language: ruby
 lang: hu-hu
-filenev: learnruby.rb
+filename: learnruby-hu.rb
 contributors:
   - ["David Underwood", "http://theflyingdeveloper.com"]
   - ["Joel Walden", "http://joelwalden.net"]
@@ -13,7 +13,7 @@ contributors:
   - ["Dzianis Dashkevich", "https://github.com/dskecse"]
   - ["Levi Bostian", "https://github.com/levibostian"]
   - ["Rahil Momin", "https://github.com/iamrahil"]
-  translators:
+translators:
   - ["Zsolt Prontvai", "https://github.com/prozsolt"]
 ---
 
diff --git a/hu-hu/typescript-hu.html.markdown b/hu-hu/typescript-hu.html.markdown
new file mode 100644
index 00000000..aedd5a64
--- /dev/null
+++ b/hu-hu/typescript-hu.html.markdown
@@ -0,0 +1,175 @@
+---
+language: TypeScript
+contributors:
+    - ["Philippe Vlérick", "https://github.com/pvlerick"]
+translators:
+    - ["Tamás Diószegi", "https://github.com/ditam"]
+filename: learntypescript-hu.ts
+lang: hu-hu
+---
+
+A TypeScript nyelv a JavaScript nyelven írt nagy méretű alkalmazások fejlesztését kívánja megkönnyíteni.
+A TypeScript olyan, más nyelvekből ismert gyakori fogalmakat ad hozzá a JavaScripthez, mint például osztályok, interfészek, generikusság, és (opcionális) statikus típusosság.
+A JavaScript egy befoglaló halmazát képzi: minden JavaScript kód érvényes TypeScript kód, így könnyen hozzáadható meglévő projektekhez. A TypeScript fordító kimenetként JavaScript kódot állít elő.
+
+Ez a dokumentum a TypeScript által hozzáadott új szintaxissal foglalkozik, nem pedig a [Javascripttel](../javascript/).
+
+Hogy kipróbáld a TypeScript fordítót, látogass el a [Játszótérre avagy Playground-ra](http://www.typescriptlang.org/Playground) ahol kódot írhatsz automatikus kódkiegészítéssel, és közvetlenül láthatod az előállított JavaScript kódot.
+
+```js
+// 3 alapvető típus létezik TypeScriptben
+var isDone: boolean = false;
+var lines: number = 42;
+var name: string = "Anders";
+
+// Amikor nem lehet a típust előre tudni, használható az "Any" típus
+var notSure: any = 4;
+notSure = "talán mégis sztring lesz";
+notSure = false; // tévedtem, mégis boolean
+
+// Kollekciókból létezik típusos és generikus tömb
+var list: number[] = [1, 2, 3];
+// ugyanez a generikus típus használatával
+var list: Array<number> = [1, 2, 3];
+
+// Enumerált típusok:
+enum Color {Red, Green, Blue};
+var c: Color = Color.Green;
+
+// Végül, "void" használható a visszatérési értékkel nem bíró függvényeknél
+function bigHorribleAlert(): void {
+  alert("Kis idegesítő doboz vagyok!");
+}
+
+// A függvények elsőrangú (first-class) típusok, használható a vastag nyilas
+// lambda szintaxis,
+// a compiler pedig kikövetkezteti a típusokat (inferred types)
+
+// A következők egyenértékűek, ugyanaz a szignatúra kerül kikövetkeztetésre, és
+// így ugyanaz a JavaScript kód lesz előállítva
+var f1 = function(i: number): number { return i * i; }
+// Következtetett visszatérési értékkel
+var f2 = function(i: number) { return i * i; }
+var f3 = (i: number): number => { return i * i; }
+// Következtetett visszatérési értékkel
+var f4 = (i: number) => { return i * i; }
+// Következtetett visszatérési értékkel, 
+// ebben az egysoros formában nem szükséges a return kulcsszó
+var f5 = (i: number) =>  i * i;
+
+// Az interfészek szerkezeti alapon működnek, vagyis minden objektum, ahol 
+// jelen vannak a megfelelő mezők kompatibilis az interfésszel
+interface Person {
+  name: string;
+  // Az opcionális tagokat "?" jelöli
+  age?: number;
+  // És persze függvények is:
+  move(): void;
+}
+
+// Egy objektum, ami megvalósítja a "Person" interfészt
+// Tekinthető Personnek, hiszen van name és move mezője
+var p: Person = { name: "Bobby", move: () => {} };
+// Egy objektum, ahol az opcionális mező is jelen van:
+var validPerson: Person = { name: "Bobby", age: 42, move: () => {} };
+// Ez viszont nem Person, mert az age mező típusa nem szám!
+var invalidPerson: Person = { name: "Bobby", age: true };
+
+// Az interfészekkel függvény típusok is leírhatóak:
+interface SearchFunc {
+  (source: string, subString: string): boolean;
+}
+// Csak a paraméterek típusai számítanak, a neveik nem.
+var mySearch: SearchFunc;
+mySearch = function(src: string, sub: string) {
+  return src.search(sub) != -1;
+}
+
+// Osztályok - a mezők alapértelmezésben publikusak
+class Point {
+    // Mezők
+    x: number;
+
+    // Konstruktor - a public/private kulcsszavak ebben a kontextusban
+    // legenerálják a mezőkhöz szükséges kódot a konstruktorban.
+    // Ebben a példában az "y" ugyanúgy definiálva lesz, mint az "x", csak 
+    // kevesebb kóddal.
+    // Alapértelmezett (default) értékek is megadhatóak.
+
+    constructor(x: number, public y: number = 0) {
+        this.x = x;
+    }
+
+    // Metódusok
+    dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+    // Statikus mezők
+    static origin = new Point(0, 0);
+}
+
+var p1 = new Point(10 ,20);
+var p2 = new Point(25); //y itt 0 lesz
+
+// Öröklés
+class Point3D extends Point {
+    constructor(x: number, y: number, public z: number = 0) {
+        super(x, y); // Szükséges az ősosztály konstruktorának explicit hívása
+    }
+
+    // Felülírás
+    dist() {
+        var d = super.dist();
+        return Math.sqrt(d * d + this.z * this.z);
+    }
+}
+
+// Modulok
+// ("." használható az almodulok számára)
+module Geometry {
+  export class Square {
+    constructor(public sideLength: number = 0) {
+    }
+    area() {
+      return Math.pow(this.sideLength, 2);
+    }
+  }
+}
+
+var s1 = new Geometry.Square(5);
+
+// Új lokális név definiálása a module számára
+import G = Geometry;
+
+var s2 = new G.Square(10);
+
+// Generikus típusok
+// Osztályok
+class Tuple<T1, T2> {
+    constructor(public item1: T1, public item2: T2) {
+    }
+}
+
+// Interfészek
+interface Pair<T> {
+    item1: T;
+    item2: T;
+}
+
+// és függvények
+var pairToTuple = function<T>(p: Pair<T>) {
+    return new Tuple(p.item1, p.item2);
+};
+
+var tuple = pairToTuple({ item1:"hello", item2:"world"});
+
+// definíciós fájl hivatkozása:
+/// <reference path="jquery.d.ts" />
+
+```
+
+## További források
+ * [TypeScript hivatalos weboldala] (http://www.typescriptlang.org/)
+ * [TypeScript nyelv specifikációja (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [Anders Hejlsberg - Introducing TypeScript on Channel 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [Forráskód GitHubon] (https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed - típusdefiníciók gyűjteménye] (http://definitelytyped.org/)
diff --git a/hu-hu/yaml-hu.html.markdown b/hu-hu/yaml-hu.html.markdown
new file mode 100644
index 00000000..37ce4cb2
--- /dev/null
+++ b/hu-hu/yaml-hu.html.markdown
@@ -0,0 +1,147 @@
+---
+language: yaml
+filename: learnyaml-hu.yaml
+contributors:
+  - ["Adam Brenecki", "https://github.com/adambrenecki"]
+translators:
+  - ["Tamás Diószegi", "https://github.com/ditam"]
+lang: hu-hu
+---
+
+A YAML egy adat sorosító nyelv, amit úgy terveztek, hogy közvetlenül is 
+olvasható és írható legyen emberi szemmel.
+
+A JSON formátum egy szigorú befoglaló halmazát alkotja, kiegészítve azt
+szintaktikai jelentéssel bíró sortörésekkel és indentációval,
+a Pythonhoz hasonlóan. A Pythonnal ellentétben azonban a YAML nem engedélyezi
+a közvetlen tab karakterek jelenlétét.
+
+Megjegyzés: UTF-8 ékezetes betűk használhatóak, ha a fájl kódlása megfelelő,
+a kódolást a tartalomban explicit nem kell (és nem is lehet) feltüntetni.
+
+```yaml
+# A kommentek YAML-ban így néznek ki.
+
+##################
+# Skalár típusok #
+##################
+
+# A gyökér objektumunk (az egész dokumentumra értve) egy map,
+# ami a más nyelvekből ismert dictionary, hash vagy object típusokkal egyenértékű.
+kulcs: érték
+masik_kulcs: Másik érték jön ide.
+egy_szam: 100
+tudomanyos_jelolessel: 1e+12
+boolean: true
+null_value: null
+kulcs benne szóközökkel: érték
+# Látható, hogy a sztringeket nem szükséges idézőjelek közé zárni, bár szabad.
+Továbbá: "Idézőjelekkel megadott sztring."
+"A kulcs is lehet idézőjeles.": "Hasznos lehet, ha ':'-ot akarsz a kulcsban."
+
+# Többsoros sztringek írhatóak 'literal block'-ként ('|' jelet használva)
+# vagy 'folded block'-ként is ('>' jelet használva).
+literal_block: |
+    Ez az egész szöveg-blokk lesz az értéke a literal_block kulcsnak,
+    a sortöréseket megtartva.
+
+    Az ilyen sztringet az indentáció visszahúzása zárja le, a behúzás pedig
+    eltávolításra kerül.
+
+        A 'még jobban' behúzott részek megtartják a behúzásukat - 
+        ezeknek a soroknak 4 szóköz behúzása lesz.
+folded_style: >
+    Az az egész szöveg-blokk lesz az értéke a 'folded_style' kulcsnak, de
+    ezúttal minden sortörés egy szóközre lesz cserélve.
+
+    Az üres sorok, mint a fenti, új sor karakterre cserélődnek.
+
+        A 'még jobban' behúzott sorok megtartják a sortöréseiket, -
+        ez a szöveg két sorban jelenik meg.
+
+######################
+# Gyűjtemény típusok #
+######################
+
+# Egymásba ágyazás a behúzás változtatásával érhető el.
+beagyazott_map:
+    key: value
+    another_key: Another Value
+    masik_beagyazott_map:
+        hello: hello
+
+# A mapeknek nem csak sztring kulcsaik lehetnek.
+0.25: lebegőpontos kulcs
+
+# A kulcsok lehetnek többsoros objektumok is, ? jellel jelezve a kulcs kezdetét
+? |
+    Ez itt egy
+    többsoros kulcs
+: és ez az értéke
+
+# Szintén engedélyezett a kollekció típusok használata kulcsként, de egyéb
+# nyelvekben ez gyakran problémákat fog okozni.
+
+# Szekvenciák (listákkal vagy tömbökkel egyenértékűek) így néznek ki:
+egy_szekvencia:
+    - Item 1
+    - Item 2
+    - 0.5 # Többféle típust is tartalmazhat
+    - Item 4
+    - key: value
+      another_key: another_value
+    -
+        - Ez egy szekvencia
+        - egy másik szekvenciába ágyazva
+
+# Mivel a YAML a JSON befoglaló halmazát alkotja, JSON szintaxisú
+# mapek és szekvenciák is használhatóak:
+json_map: {"key": "value"}
+json_seq: [3, 2, 1, "takeoff"]
+
+#########################
+# EXTRA YAML KÉPESSÉGEK #
+#########################
+
+# A YAML-ben ún. 'anchor'-ök segítségével könnyen lehet duplikálni
+# tartalmakat a dokumentumon belül. A következő kulcsok azonos értékkel bírnak:
+anchored_tartalom: &anchor_neve Ez a sztring két kulcs értéke is lesz.
+másik_anchor: *anchor_neve
+
+# Vannak a YAML-ben tagek is, amivel explicit lehet típusokat jelölni.
+explicit_string: !!str 0.5
+# Bizonyos implementációk nyelv-specifikus tageket tartalmaznak, mint
+# például ez a Python komplex szám típusának jelölésére:
+python_complex_number: !!python/complex 1+2j
+
+######################
+# EXTRA YAML TÍPUSOK #
+######################
+
+# Nem a sztringek és a számok az egyedüli skalár típusok YAML-ben.
+# ISO-formátumú dátumok és dátumot jelölő literal kifejezések is értelmezettek.
+datetime: 2001-12-15T02:59:43.1Z
+datetime_with_spaces: 2001-12-14 21:59:43.10 -5
+date: 2002-12-14
+
+# A !!binary tag jelöli, hogy egy sztring valójában base64-kódolású
+# reprezentációja egy bináris blob-nak
+gif_file: !!binary |
+    R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
+    OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
+    +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
+    AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
+
+# Létezik a YAML-ban egy halmaz típus (set) is, ami így néz ki:
+set:
+    ? elem1
+    ? elem2
+    ? elem3
+
+# Mint Pythonban, a halmazok null értékekkel feltöltött mapek, vagyis a fenti
+# halmaz egyenértékű a következővel:
+set2:
+    elem1: null
+    elem2: null
+    elem3: null
+```
+\ No newline at end of file