From 29002c1a6fe62c996363f91320288bd762fe8e9e Mon Sep 17 00:00:00 2001
From: Ovidiu Ciule <ovidiu.ciule@gmail.com>
Date: Wed, 4 Sep 2013 13:50:59 +0200
Subject: Add romanian python translation. Expect spelling corrections.

---
 ro-ro/python-ro.html.markdown | 490 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 490 insertions(+)
 create mode 100644 ro-ro/python-ro.html.markdown

(limited to 'ro-ro')

diff --git a/ro-ro/python-ro.html.markdown b/ro-ro/python-ro.html.markdown
new file mode 100644
index 00000000..677f4356
--- /dev/null
+++ b/ro-ro/python-ro.html.markdown
@@ -0,0 +1,490 @@
+---
+language: python
+contributors:
+    - ["Louie Dinh", "http://ldinh.ca"]
+translators:
+    - ["Ovidiu Ciule", "https://github.com/ociule"] lang: ro-ro filename: python-ro.html.markdown
+filename: learnpython.py
+---
+
+Python a fost creat de Guido Van Rossum la începutul anilor '90. Python a devenit astăzi unul din
+cele mai populare limbaje de programare. M-am indrăgostit de Python pentru claritatea sa sintactică.
+Python este aproape pseudocod executabil.
+
+Opinia dumneavoastră este binevenită! Puteţi sa imi scrieţi la [@ociule](http://twitter.com/ociule) sau ociule [at] [google's email service]
+Feedback would be highly appreciated! You can reach me at [@louiedinh](http://twitter.com/louiedinh) or louiedinh [at] [google's email service]
+
+Notă: Acest articol descrie Python 2.7, dar este util şi pentru Python 2.x. O versiune Python 3 va apărea
+în curând, în limba engleză mai întâi.
+
+```python
+# Comentariile pe o singură linie încep cu un caracter diez.
+""" Şirurile de caractere pe mai multe linii pot fi încadrate folosind trei caractere ", şi sunt des
+    folosite ca şi comentarii pe mai multe linii.
+"""
+
+####################################################
+## 1. Operatori şi tipuri de date primare 
+####################################################
+
+# Avem numere
+3 #=> 3
+
+# Matematica se comportă cum ne-am aştepta
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+
+# Împărţirea este un pic surprinzătoare. Este de fapt împărţire pe numere întregi şi rotunjeşte
+# automat spre valoarea mai mică
+5 / 2 #=> 2
+
+# Pentru a folosi împărţirea fără rest avem nevoie de numere reale 
+2.0     # Acesta e un număr real
+11.0 / 4.0 #=> 2.75 ahhh ... cum ne aşteptam 
+
+# Ordinea operaţiilor se poate forţa cu paranteze
+(1 + 3) * 2 #=> 8
+
+# Valoriile boolene sunt şi ele valori primare
+True
+False
+
+# Pot fi negate cu operatorul not
+not True #=> False
+not False #=> True
+
+# Egalitatea este ==
+1 == 1 #=> True
+2 == 1 #=> False
+
+# Inegalitate este !=
+1 != 1 #=> False
+2 != 1 #=> True
+
+# Comparaţii
+1 < 10 #=> True
+1 > 10 #=> False
+2 <= 2 #=> True
+2 >= 2 #=> True
+
+# Comparaţiile pot fi inlănţuite! 
+1 < 2 < 3 #=> True
+2 < 3 < 2 #=> False
+
+# Şirurile de caractere pot fi încadrate cu " sau '
+"Acesta e un şir de caractere."
+'Şi acesta este un şir de caractere.'
+
+# Şirurile de caractere pot fi adăugate!
+"Hello " + "world!" #=> "Hello world!"
+
+# Un şir de caractere poate fi folosit ca o listă 
+"Acesta e un şir de caractere"[0] #=> 'A'
+
+# Caracterul % (procent) poate fi folosit pentru a formata şiruri de caractere :
+"%s pot fi %s" % ("şirurile", "interpolate")
+
+# O metodă mai nouă de a formata şiruri este metoda "format"
+# Este metoda recomandată
+"{0} pot fi {1}".format("şirurile", "formatate")
+# Puteţi folosi cuvinte cheie dacă nu doriţi sa număraţi 
+"{nume} vrea să mănânce {fel}".format(nume="Bob", fel="lasagna")
+
+# "None", care reprezintă valoarea nedefinită, e un obiect
+None #=> None
+
+# Nu folosiţi operatorul == pentru a compara un obiect cu None
+# Folosiţi operatorul "is"
+"etc" is None #=> False
+None is None  #=> True
+
+# Operatorul "is" testeaza dacă obiectele sunt identice.
+# Acastă operaţie nu e foarte folositoare cu tipuri primare,
+# dar e foarte folositoare cu obiecte.
+
+# None, 0, şi şiruri de caractere goale sunt evaluate ca si fals, False. 
+# Toate celelalte valori sunt adevărate, True.
+0 == False  #=> True
+"" == False #=> True
+
+
+####################################################
+## 2. Variabile şi colecţii
+####################################################
+
+# Printarea este uşoară 
+print "Eu sunt Python. Încântat de cunoştinţă!" 
+
+
+# Nu este nevoie sa declari variabilele înainte de a le folosi 
+o_variabila = 5    # Convenţia este de a folosi caractere_minuscule_cu_underscore 
+o_variabila #=> 5
+
+# Dacă accesăm o variabilă nefolosită declanşăm o excepţie.
+# Vezi secţiunea Control de Execuţie pentru mai multe detalii despre excepţii.
+alta_variabila # Declanşează o eroare de nume 
+
+# "If" poate fi folosit într-o expresie.
+"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
+
+# Listele sunt folosite pentru colecţii
+li = []
+# O listă poate avea valori de la început 
+alta_li = [4, 5, 6]
+
+# Se adaugă valori la sfârşitul lister cu append 
+li.append(1)    #li e acum [1]
+li.append(2)    #li e acum [1, 2]
+li.append(4)    #li e acum [1, 2, 4]
+li.append(3)    #li este acum [1, 2, 4, 3]
+# Se şterg de la sfarşit cu pop 
+li.pop()        #=> 3 şi li e acum [1, 2, 4]
+# Să o adaugăm înapoi valoarea
+li.append(3)    # li e din nou [1, 2, 4, 3]
+
+# Putem accesa valorile individuale dintr-o listă cu operatorul index 
+li[0] #=> 1
+# Valoarea speciala -1 pentru index accesează ultima valoare
+li[-1] #=> 3
+
+# Dacă depaşim limitele listei declanşăm o eroare IndexError
+li[4] # Declanşează IndexError
+
+# Putem să ne uităm la intervale folosind sintaxa de "felii" 
+# În Python, intervalele sunt închise la început si deschise la sfârşit. 
+li[1:3] #=> [2, 4]
+# Fără început
+li[2:] #=> [4, 3]
+# Fără sfarşit
+li[:3] #=> [1, 2, 4]
+
+# Putem şterge elemente arbitrare din lista cu operatorul "del" care primeşte indexul lor
+del li[2] # li e acum [1, 2, 3]
+
+# Listele pot fi adăugate
+li + alta_li #=> [1, 2, 3, 4, 5, 6] - Notă: li si alta_li nu sunt modificate! 
+
+# Concatenăm liste cu "extend()"
+li.extend(alta_li) # Acum li este [1, 2, 3, 4, 5, 6]
+
+# Se verifică existenţa valorilor in lista cu "in" 
+1 in li #=> True
+
+# Şi lungimea cu "len()"
+len(li) #=> 6
+
+
+# Tuplele sunt ca şi listele dar imutabile 
+tup = (1, 2, 3)
+tup[0] #=> 1
+tup[0] = 3  # Declanşează TypeError
+
+# Pot fi folosite ca şi liste 
+len(tup) #=> 3
+tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
+tup[:2] #=> (1, 2)
+2 in tup #=> True
+
+# Tuplele pot fi despachetate 
+a, b, c = (1, 2, 3)     # a este acum 1, b este acum 2 şi c este acum 3
+# Tuplele pot fi folosite şi fără paranteze 
+d, e, f = 4, 5, 6
+# Putem inversa valori foarte uşor! 
+e, d = d, e     # d este acum 5 şi e este acum 4
+
+
+# Dicţionarele stochează chei şi o valoare pentru fiecare cheie
+dict_gol = {}
+# Şi un dicţionar cu valori 
+dict_cu_valori = {"unu": 1, "doi": 2, "trei": 3}
+
+# Căutaţi valori cu []
+dict_cu_valori["unu"] #=> 1
+
+# Obţinem lista cheilor cu "keys()"
+dict_cu_valori.keys() #=> ["trei", "doi", "unu"]
+# Notă - ordinea cheilor obţinute cu keys() nu este garantată. 
+# Puteţi obţine rezultate diferite de exemplul de aici. 
+
+# Obţinem valorile cu values() 
+dict_cu_valori.values() #=> [3, 2, 1]
+# Notă - aceeaşi ca mai sus, aplicată asupra valorilor.
+
+# Verificăm existenţa unei valori cu "in" 
+"unu" in dict_cu_valori #=> True
+1 in dict_cu_valori #=> False
+
+# Accesarea unei chei care nu exista declanşează o KeyError
+dict_cu_valori["four"] # KeyError
+
+# Putem folosi metoda "get()" pentru a evita KeyError
+dict_cu_valori.get("one") #=> 1
+dict_cu_valori.get("four") #=> None
+# Metoda get poate primi ca al doilea argument o valoare care va fi returnată
+# când cheia nu este prezentă. 
+dict_cu_valori.get("one", 4) #=> 1
+dict_cu_valori.get("four", 4) #=> 4
+
+# "setdefault()" este o metodă pentru a adăuga chei-valori fără a le modifica, dacă cheia există deja
+dict_cu_valori.setdefault("five", 5) #dict_cu_valori["five"] este acum 5
+dict_cu_valori.setdefault("five", 6) #dict_cu_valori["five"] exista deja, nu este modificată, tot 5
+
+
+# Set este colecţia mulţime
+set_gol = set()
+# Putem crea un set cu valori
+un_set = set([1,2,2,3,4]) # un_set este acum set([1, 2, 3, 4]), amintiţi-vă ca mulţimile garantează unicatul!
+
+# În Python 2.7, {} poate fi folosit pentru un set 
+set_cu_valori = {1, 2, 2, 3, 4} # => {1 2 3 4}
+
+# Putem adăuga valori cu add 
+set_cu_valori.add(5) # set_cu_valori este acum {1, 2, 3, 4, 5}
+
+# Putem intersecta seturi 
+alt_set = {3, 4, 5, 6}
+set_cu_valori & alt_set #=> {3, 4, 5}
+
+# Putem calcula uniunea cu |
+set_cu_valori | alt_set #=> {1, 2, 3, 4, 5, 6}
+
+# Diferenţa între seturi se face cu -
+{1,2,3,4} - {2,3,5} #=> {1, 4}
+
+# Verificăm existenţa cu "in" 
+2 in set_cu_valori #=> True
+10 in set_cu_valori #=> False
+
+
+####################################################
+## 3. Controlul Execuţiei
+####################################################
+
+# O variabilă 
+o_variabila = 5
+
+# Acesta este un "if". Indentarea este importanta în python!
+# Printează "o_variabila este mai mică ca 10"
+if o_variabila > 10:
+    print "o_variabila e mai mare ca 10."
+elif o_variabila < 10:    # Clauza elif e opţională. 
+    print "o_variabila este mai mică ca 10."
+else:           # Şi else e opţional.
+    print "o_variabila este exact 10."
+
+
+"""
+Buclele "for" pot fi folosite pentru a parcurge liste
+Vom afişa:
+    câinele este un mamifer 
+    pisica este un mamifer
+    şoarecele este un mamifer
+"""
+for animal in ["câinele", "pisica", "şoarecele"]:
+    # Folosim % pentru a compune mesajul 
+    print "%s este un mamifer" % animal
+    
+"""
+"range(număr)" crează o lista de numere 
+de la zero la numărul dat
+afişează:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print i
+
+"""
+While repetă pana când condiţia dată nu mai este adevărată. 
+afişează:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print x
+    x += 1  # Prescurtare pentru x = x + 1
+
+# Recepţionăm excepţii cu blocuri try/except 
+
+# Acest cod e valid in Python > 2.6:
+try:
+    # Folosim "raise" pentru a declanşa o eroare 
+    raise IndexError("Asta este o IndexError")
+except IndexError as e:
+    pass    # Pass nu face nimic. În mod normal aici ne-am ocupa de eroare. 
+
+
+####################################################
+## 4. Funcţii
+####################################################
+
+# Folosim "def" pentru a defini funcţii 
+def add(x, y):
+    print "x este %s şi y este %s" % (x, y)
+    return x + y    # Funcţia poate returna valori cu "return" 
+
+# Apelăm funcţia "add" cu parametrii 
+add(5, 6) #=> Va afişa "x este 5 şi y este 6" şi va returna 11 
+
+# Altă cale de a apela funcţii: cu parametrii numiţi 
+add(y=6, x=5)   # Ordinea parametrilor numiţi nu contează 
+
+# Putem defini funcţii care primesc un număr variabil de parametrii nenumiţi
+# Aceşti parametrii nenumiţi se cheamă si poziţinali
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3) #=> (1,2,3)
+
+
+# Şi putem defini funcţii care primesc un număr variabil de parametrii numiţi
+def keyword_args(**kwargs):
+    return kwargs
+
+# Hai să vedem cum merge 
+keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
+
+# Se pot combina 
+def all_the_args(*args, **kwargs):
+    print args
+    print kwargs
+"""
+all_the_args(1, 2, a=3, b=4) va afişa:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# Când apelăm funcţii, putem face inversul args/kwargs!
+# Folosim * pentru a expanda tuple şi ** pentru a expanda kwargs.
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args) # echivalent cu foo(1, 2, 3, 4)
+all_the_args(**kwargs) # echivalent cu foo(a=3, b=4)
+all_the_args(*args, **kwargs) # echivalent cu foo(1, 2, 3, 4, a=3, b=4)
+
+# În Python, funcţiile sunt obiecte primare
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3) #=> 13
+
+# Funcţiile pot fi anonime 
+(lambda x: x > 2)(3) #=> True
+
+# Există funcţii de ordin superior (care operează pe alte funcţii) predefinite 
+map(add_10, [1,2,3]) #=> [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
+
+# Putem folosi scurtături de liste pentru a simplifica munca cu map si filter 
+[add_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
+
+####################################################
+## 5. Clase
+####################################################
+
+# Moştenim object pentru a crea o nouă clasă 
+class Om(object):
+
+    # Acesta este un atribut al clasei. Va fi moştenit de toate instanţele. 
+    species = "H. sapiens"
+
+    # Constructor (mai degrabă, configurator de bază) 
+    def __init__(self, nume):
+        # Valoarea parametrului este stocată in atributul instanţei 
+        self.nume = nume
+
+    # Aceasta este o metoda a instanţei.
+    # Toate metodele primesc "self" ca si primul argument.
+    def spune(self, mesaj):
+       return "%s: %s" % (self.nume, mesaj)
+
+    # O metodă a clasei. Este partajată de toate instanţele.
+    # Va primi ca si primul argument clasa căreia îi aparţine. 
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # O metoda statica nu primeste un argument automat. 
+    @staticmethod
+    def exclama():
+        return "*Aaaaaah*"
+
+
+# Instanţiem o clasă 
+i = Om(nume="Ion")
+print i.spune("salut")  # afişează: "Ion: salut"
+
+j = Om("George")
+print j.spune("ciau")   # afişează George: ciau"
+
+# Apelăm metoda clasei 
+i.get_species() #=> "H. sapiens"
+
+# Modificăm atributul partajat 
+Om.species = "H. neanderthalensis"
+i.get_species() #=> "H. neanderthalensis"
+j.get_species() #=> "H. neanderthalensis"
+
+# Apelăm metoda statică 
+Om.exclama() #=> "*Aaaaaah*"
+
+
+####################################################
+## 6. Module
+####################################################
+
+# Pentru a folosi un modul, trebuie importat 
+import math
+print math.sqrt(16) #=> 4
+
+# Putem importa doar anumite funcţii dintr-un modul 
+from math import ceil, floor
+print ceil(3.7)  #=> 4.0
+print floor(3.7) #=> 3.0
+
+# Putem importa toate funcţiile dintr-un modul, dar nu este o idee bună
+# Nu faceţi asta!
+from math import *
+
+# Numele modulelor pot fi modificate la import, de exemplu pentru a le scurta 
+import math as m
+math.sqrt(16) == m.sqrt(16) #=> True
+
+# Modulele python sunt pur şi simplu fişiere cu cod python. 
+# Puteţi sa creaţi modulele voastre, şi sa le importaţi.
+# Numele modulului este acelasi cu numele fişierului.
+
+# Cu "dir" inspectăm ce funcţii conţine un modul
+import math
+dir(math)
+
+
+```
+
+## Doriţi mai mult?
+
+### Gratis online, in limba engleză
+
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [The Official Docs](http://docs.python.org/2.6/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Module of the Week](http://pymotw.com/2/)
+
+### Cărţi
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
+
-- 
cgit v1.2.3


From 8df74f0aceacd983a10c224d6cdf4c6f6c19743a Mon Sep 17 00:00:00 2001
From: Ovidiu Ciule <ovidiu.ciule@gmail.com>
Date: Wed, 4 Sep 2013 13:57:36 +0200
Subject: Corrections.

---
 ro-ro/python-ro.html.markdown | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'ro-ro')

diff --git a/ro-ro/python-ro.html.markdown b/ro-ro/python-ro.html.markdown
index 677f4356..0654fc8f 100644
--- a/ro-ro/python-ro.html.markdown
+++ b/ro-ro/python-ro.html.markdown
@@ -12,7 +12,6 @@ cele mai populare limbaje de programare. M-am indrăgostit de Python pentru clar
 Python este aproape pseudocod executabil.
 
 Opinia dumneavoastră este binevenită! Puteţi sa imi scrieţi la [@ociule](http://twitter.com/ociule) sau ociule [at] [google's email service]
-Feedback would be highly appreciated! You can reach me at [@louiedinh](http://twitter.com/louiedinh) or louiedinh [at] [google's email service]
 
 Notă: Acest articol descrie Python 2.7, dar este util şi pentru Python 2.x. O versiune Python 3 va apărea
 în curând, în limba engleză mai întâi.
@@ -474,7 +473,7 @@ dir(math)
 
 ## Doriţi mai mult?
 
-### Gratis online, in limba engleză
+### Gratis online, în limba engleză
 
 * [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
 * [Dive Into Python](http://www.diveintopython.net/)
@@ -482,7 +481,7 @@ dir(math)
 * [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
 * [Python Module of the Week](http://pymotw.com/2/)
 
-### Cărţi
+### Cărţi, în limba engleză
 
 * [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
 * [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
-- 
cgit v1.2.3


From ee8bed8c98df81e63b430ab5e61096f8140f09b5 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Wed, 4 Sep 2013 09:36:51 -0700
Subject: Fixed up potential conflicts

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

(limited to 'ro-ro')

diff --git a/ro-ro/python-ro.html.markdown b/ro-ro/python-ro.html.markdown
index 0654fc8f..36ea78ec 100644
--- a/ro-ro/python-ro.html.markdown
+++ b/ro-ro/python-ro.html.markdown
@@ -4,7 +4,7 @@ contributors:
     - ["Louie Dinh", "http://ldinh.ca"]
 translators:
     - ["Ovidiu Ciule", "https://github.com/ociule"] lang: ro-ro filename: python-ro.html.markdown
-filename: learnpython.py
+filename: learnpython-ro.py
 ---
 
 Python a fost creat de Guido Van Rossum la începutul anilor '90. Python a devenit astăzi unul din
-- 
cgit v1.2.3


From b28900b889c27f8500a44d9f9bcad5244f1f79bd Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Sun, 8 Sep 2013 22:52:09 -0700
Subject: Fixed up so it builds

---
 ro-ro/python-ro.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'ro-ro')

diff --git a/ro-ro/python-ro.html.markdown b/ro-ro/python-ro.html.markdown
index 36ea78ec..125ba2f4 100644
--- a/ro-ro/python-ro.html.markdown
+++ b/ro-ro/python-ro.html.markdown
@@ -3,8 +3,9 @@ language: python
 contributors:
     - ["Louie Dinh", "http://ldinh.ca"]
 translators:
-    - ["Ovidiu Ciule", "https://github.com/ociule"] lang: ro-ro filename: python-ro.html.markdown
+    - ["Ovidiu Ciule", "https://github.com/ociule"]
 filename: learnpython-ro.py
+lang: ro-ro
 ---
 
 Python a fost creat de Guido Van Rossum la începutul anilor '90. Python a devenit astăzi unul din
-- 
cgit v1.2.3


From 35acb53ee3b99f52d1b4f588200c724ce338be3a Mon Sep 17 00:00:00 2001
From: Adrian Bordinc <adrian.bordinc@gmail.com>
Date: Fri, 7 Mar 2014 19:09:56 +0100
Subject: Added ruby/ro-ro translation

---
 ro-ro/ruby-ro.html.markdown | 479 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 479 insertions(+)
 create mode 100644 ro-ro/ruby-ro.html.markdown

(limited to 'ro-ro')

diff --git a/ro-ro/ruby-ro.html.markdown b/ro-ro/ruby-ro.html.markdown
new file mode 100644
index 00000000..27c6c462
--- /dev/null
+++ b/ro-ro/ruby-ro.html.markdown
@@ -0,0 +1,479 @@
+---
+language: ruby
+contributors:
+  - ["David Underwood", "http://theflyingdeveloper.com"]
+  - ["Joel Walden", "http://joelwalden.net"]
+  - ["Luke Holder", "http://twitter.com/lukeholder"]
+  - ["Tristan Hume", "http://thume.ca/"]
+  - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+  - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
+translators:
+  - ["Adrian Bordinc", "https://github.com/ellimist"]
+filename: learnruby-ro.rb
+lang: ro-ro
+---
+
+```ruby
+# Acesta este un comentariu
+
+=begin
+Acesta este un comentariu pe mai multe linii
+Nimeni nu le foloseste
+Si nici tu nu ar trebui sa o faci
+=end
+
+# In primul rand: totul este un obiect
+
+# Numerele sunt obiecte
+
+3.class #=> Fixnum
+
+3.to_s #=> "3"
+
+
+# Aritmetica de baza
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+
+# Aritmetica este doar "zahar sintactic"
+# pentru a putea chema metode pe un obiect
+1.+(3) #=> 4
+10.* 5 #=> 50
+
+# Valorile speciale sunt obiecte
+nil # Nimic
+true # true
+false # false
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Egalitate
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Inegalitate
+1 != 1 #=> false
+2 != 1 #=> true
+!true  #=> false
+!false #=> true
+
+# Excluzand "false", "nil" este singura valoare "falsa"
+
+!nil   #=> true
+!false #=> true
+!0     #=> false
+
+# Mai multe comparatii
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Sirurule de caractere sunt obiecte
+
+'Sunt un sir de caractere'.class #=> String
+"Si eu sunt un sir de caractere".class #=> String
+
+fi_inlocuit = "inlocui o valoare in string"
+"Pot #{fi_inlocuit} atunci cand folosesc dublu apostrof"
+#=> "Pot inlocui o valoare intr-un sir de caractere atunci cand folosesc dublu apostrof"
+
+
+# Printeaza 
+puts "Afisez rezultate!"
+
+# Variabile
+x = 25 #=> 25
+x #=> 25
+
+# Retineti faptul ca atribuire unei valori, o si returneaza pe aceasta
+# Asta inseamna ca poti sa faci atribuire multipla:
+
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# Prin conventie se foloseste "snake_case" in denumirea variabilelor
+snake_case = true
+
+# Folositi nume descriptive pentru variablie
+adresa_radacina_proiect = '/nume/bun/'
+adresa = '/nume/nu atat de bun/'
+
+# Simbolurile (sunt obiecte)
+# Simbolurile sunt constante imutabile, reutilizabile, reprezentate intern 
+# de o valoare numerica. Sunt deseori folosite in locul sirurilor de caractere pentru a da un nume reprezentativ unei valori
+
+:exemplu_simbol.class #=> Symbol
+
+status = :exemplu_simbol
+
+status == :exemplu_simbol #=> adevarat
+
+status == 'exemplu_simbol' #=> fals
+
+status == :aprobat #=> fals
+
+# Vectori
+
+# Acesta este un vector
+vector = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Vectorii pot contine diferite tipuri de date
+
+[1, "salut", false] #=> [1, "salut", false]
+
+# Vectorii pot fi indexati
+# de la inceput
+vector[0] #=> 1
+vector[12] #=> nil
+
+# Ca si aritmetica, accessul [valoare]
+# este doar "zahar sintactic"
+# pentru a chema metoda [] a unui obiect
+vector.[] 0 #=> 1
+vector.[] 12 #=> nil
+
+# De la sfarsit
+vector[-1] #=> 5
+
+# Cu un index de inceput si o lungime
+vector[2, 3] #=> [3, 4, 5]
+
+# Sau cu un interval
+vector[1..3] #=> [2, 3, 4]
+
+# Adauga elemente intr-un vector in felul urmator:
+vector << 6 #=> [1, 2, 3, 4, 5, 6]
+
+# Hash-urile sunt dictionarele din Ruby cu perechi cheie/valoare.
+# Hash-urile sunt notate cu acolade
+hash = {'culoare' => 'verde', 'numar' => 5}
+
+hash.keys #=> ['culoare', 'numar']
+
+# Poti lua valoare unui element dintr-un hash foarte rapid folosind cheia
+hash['culoare'] #=> 'verde'
+hash['numar'] #=> 5
+
+# Incercand sa accesezi un element dintr-un hash printr-o cheie care nu exista va returna "nil".
+hash['nimic_aici'] #=> nil
+
+# Incepand cu Ruby 1.9, este o sintaxa speciala pentru atunci cand se folosesc simboluri drept chei:
+
+hash_nou = { defcon: 3, actiune: true}
+
+hash_now.keys #=> [:defcon, :actiune]
+
+# Pont: Atat vectorii (Array) si hash-urile (Hash) sunt enumerabile (Enumerable)
+# Ele impart o multime de metode utile precum each, map, count si altele
+
+
+# Structuri de control
+
+if true
+  "instructiune if"
+elsif false
+  "else if, optional"
+else
+  "else, de asemenea optional"
+end
+
+for numar in 1..5
+  puts "iteratia #{numar}"
+end
+#=> iteratia 1
+#=> iteratia 2
+#=> iteratia 3
+#=> iteratia 4
+#=> iteratia 5
+
+# TOTUSI, Nici una nu foloseste instructiunea for
+# In locul acesteia ar trebui sa folosesti metoda "each" si sa ii trimiti un block
+# Un bloc este o bucata de cod pe care o poti trimite unei metode precum "each".
+# Este analog pentru "lambda", functii anonime, sau closures in alte limbaje de programare.
+#
+# The "each" method of a range runs the block once for each element of the range.
+# Metoda "each" a unui interval, ruleaza block-ul o data pentru fiecare element din interval.
+# Block-ul primeste ca si parametru un index
+# Invocand metoda "each" cu un block, arata in urmatorul fel:
+
+(1..5).each do |index|
+  puts "iteratia #{index}"
+end
+#=> iteratia 1
+#=> iteratia 2
+#=> iteratia 3
+#=> iteratia 4
+#=> iteratia 5
+
+# Poti de asemenea sa pui block-ul intre acolade
+(1..5).each {|index| puts "iteratia #{index}"}
+
+# Continutul unei structuri de date poate fi parcurs folosind "each".
+array.each do |element|
+  puts "#{element} parte din vector"
+end
+hash.each do |cheie, valoare|
+  puts "#{cheie} este #{valoare}"
+end
+
+index = 1
+while index <= 5 do
+  puts "iteratia #{index}"
+  index += 1
+end
+#=> iteratia 1
+#=> iteratia 2
+#=> iteratia 3
+#=> iteratia 4
+#=> iteratia 5
+
+nota = 'B'
+
+case nota
+when 'A'
+  puts "Bravo pustiule!"
+when 'B'
+  puts "Mai mult noroc data viitoare"
+when 'C'
+  puts "Poti mai mult"
+when 'D'
+  puts "Incet, incet..."
+when 'F'
+  puts "Ai esuat!"
+else
+  puts "Sistem de notare alternativ?!"
+end
+
+# Functii
+
+def dublu(x)
+  x * 2
+end
+
+# Functille (si toate block-urile) returneaza implicit valoarea ultimei instructiuni
+dublu(2) #=> 4
+
+# Parantezele sunt optionale cand rezultatul nu este ambiguu
+dublu 3 #=> 6
+
+dublu dublu 3 #=> 12
+
+def suma(x,y)
+  x + y
+end
+
+# Argumentele metodei sunt separate printr-o virgula
+suma 3, 4 #=> 7
+
+suma suma(3,4), 5 #=> 12
+
+# yield
+# Toate metodele au un parametru block, implicit si optional
+# care poate fi invocat folosit cuvantul cheie 'yield'
+
+def incercuieste
+  puts "{"
+  yield
+  puts "}"
+end
+
+incercuieste { puts 'Salut Mihai!' }
+
+# {
+# Salut Mihai!
+# }
+
+
+# Poti trimite un block unei functii.
+# "&" marcheaza o referinta trimisa unui block
+def vizitatori(&block)
+ block.call "un_parametru" 
+end
+ 
+# Poti trimite o lista de argumente, care va fi convertita intr-un vector (array).
+# Pentru asta se foloseste ("*")
+def vizitatori(*vector)
+ vector.each { |vizitator| puts "#{vizitator}" }
+end
+
+# Defineste o clasa folosind cuvantul cheie "class"
+class Om
+
+  # O variabila apartinand clasei. Este folosita in toate instantele clasei
+  @@specie = "H. sapiens"
+
+  # Constructor
+  def initialize(nume, varsta=0)
+    # Atribuie argumentul, variabilei "nume", care apartine doar unei instante
+    @nume = nume
+    # Daca varsta nu este data, o sa ii atribuim valoarea implicita din lista de argumente (0, in cazul nostru)
+    @varsta = varsta
+  end
+
+  # Metoda pentru a seta valoarea unei variabile
+  def nume=(nume)
+    @nume = nume
+  end
+
+  # Metoda pentru a lua valoarea unei variabile
+  def nume
+    @nume
+  end
+
+  # Functionalitatea de mai sus poate fi obtinuta folosing metoda "attr_accessor" dupa cum urmeaza:
+  attr_accessor :nume
+
+  # Metodele pentru a lua si a seta valoarea unei variabile pot fi de asemenea obtinute individial:
+  attr_reader :nume
+  attr_writer :nume
+
+  # O metoda apartinand unei clase foloseste "self" pentru a se diferentia de metodele unei instante ale clasei respective
+  # Poate fi invocata doar pe clasa, si nu pe o instanta a acesteia
+  def self.spune(msg)
+    puts "#{msg}"
+  end
+
+  def specie
+    @@specie
+  end
+
+end
+
+
+# Creaza o instanta a unei clase
+ion = Om.new("Ionut Popescu")
+
+eugen = Om.new("Eugen Ionescu")
+
+# Sa invocam niste metode
+ion.specie #=> "H. sapiens"
+ion.nume #=> "Ionut Popescu"
+ion.nume = "Ionut Popescu JR." #=> "Ionut Popescu JR."
+ion.nume #=> "Ionut Popescu JR."
+eugen.specie #=> "H. sapiens"
+eugen.nume #=> "Eugen Ionescu"
+
+# Invoca o metoda a unei clase
+Om.spune("Salut") #=> "Salut"
+
+
+# Scopul unei variabile este definit de modul in care le numim
+# Variabilele care incep cu $ au scop global
+$var = "Sunt o variabila globala"
+defined? $var #=> "global-variable"
+
+# Variabilele care incep cu @ apartin unei instante
+@var = "Sunt o variabila a unei instante"
+defined? @var #=> "instance-variable"
+
+# Variabilele care incep cu @@ apartin unei clase
+@@var = "Sunt variabila unei clase"
+defined? @@var #=> "class variable"
+
+# Variabilele care incep cu litera mare sunt constante
+Var = "Sunt o constanta"
+defined? Var #=> "constant"
+
+# Clasele sunt de asemenea obiecte in ruby. Astfel incat clasele pot avea variabile care apartin unei instante
+# O variabila care apartine unei clase poate fi accesata de toate instantele acesteia si de clasele care o extind
+
+# clasa parinte
+class Om
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(valoare)
+    @@foo = valoare
+  end
+end
+
+#  clasa copil
+class Muncitor < Om
+end
+
+Om.foo # 0
+Muncitor.foo # 0
+
+Om.foo = 2 # 2
+Muncitor.foo # 2
+
+# Variabilele care apartin unei instante ale unei clase, nu sunt impartite de (copii acesteia) clasele care o extind
+class Om
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(valoare)
+    @bar = valoare
+  end
+end
+
+class Doctor < Om
+end
+
+Om.bar # 0
+Doctor.bar # nil
+
+module ExempluModul
+  def foo
+    'foo'
+  end
+end
+
+# Incluzand modulul instantei unui obiect
+# Extinzand modulul unei instante ale unei clase
+
+class Persoana
+  include ExempluModul
+end
+
+class Carte
+  extend ExempluModul
+end
+
+Persoana.foo     # => NoMethodError: undefined method `foo' for Persoana:Class
+Persoana.new.foo # => 'foo'
+Carte.foo       # => 'foo'
+Carte.new.foo   # => NoMethodError: undefined method `foo'
+
+# Callbacks atunci cand includerea si extinderea unui modul sunt executate
+
+module ModulExempluCallBack
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+  end
+
+  module ClassMethods
+    def bar
+      'bar'
+    end
+  end
+
+  module InstanceMethods
+    def qux
+      'qux'
+    end
+  end
+end
+
+class CevaRelevant
+  include ModulExempluCallBack
+end
+
+CevaRelevant.bar     # => 'bar'
+CevaRelevant.qux     # => NoMethodError: undefined method `qux'
+CevaRelevant.new.bar # => NoMethodError: undefined method `bar'
+CevaRelevant.new.qux # => 'qux'
+```
-- 
cgit v1.2.3


From 0e0ae337d43d7c418f2fc59f62abede8de0323a4 Mon Sep 17 00:00:00 2001
From: Adrian Bordinc <adrian.bordinc@gmail.com>
Date: Fri, 7 Mar 2014 20:01:32 +0100
Subject: Added bash/ro-ro translation

---
 ro-ro/bash-ro.html.markdown | 171 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 171 insertions(+)
 create mode 100644 ro-ro/bash-ro.html.markdown

(limited to 'ro-ro')

diff --git a/ro-ro/bash-ro.html.markdown b/ro-ro/bash-ro.html.markdown
new file mode 100644
index 00000000..fa91cca4
--- /dev/null
+++ b/ro-ro/bash-ro.html.markdown
@@ -0,0 +1,171 @@
+---
+category: tool
+tool: bash
+contributors:
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Darren Lin", "https://github.com/CogBear"]
+    - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
+    - ["Denis Arh", "https://github.com/darh"]
+translators:
+    - ["Adrian Bordinc", "https://github.com/ellimist"]
+lang: ro-ro
+filename: LearnBash-ro.sh
+---
+
+Bash este numele shell-ului unix, care a fost de asemenea distribuit drept shell pentru pentru sistemul de operare GNU si ca shell implicit pentru Linux si Mac OS X.
+Aproape toate exemplele de mai jos pot fi parte dintr-un script sau pot fi executate direct in linia de comanda.
+
+[Citeste mai multe:](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/bash
+# Prima linie din script se numeste "shebang" care spune systemului cum sa execute scriptul
+# http://en.wikipedia.org/wiki/Shebang_(Unix)
+# Dupa cum te-ai prins deja, comentariile incep cu #. Shebang este de asemenea un comentariu.
+
+# Exemplu simplu de hello world:
+echo Hello world!
+
+# Fiecare comanda incepe pe o linie noua, sau dupa punct si virgula ;
+echo 'Prima linie'; echo 'A doua linie'
+
+# Declararea unei variabile se face astfel:
+VARIABLE="Niste text"
+
+# DAR nu asa:
+VARIABLE = "Niste text"
+# Bash va crede ca VARIABLE este o comanda care trebuie executata si va
+# returna o eroare pentru ca nu va putea fi gasita.
+
+# Folosind variabila:
+echo $VARIABLE
+echo "$VARIABLE"
+echo '$VARIABLE'
+# Atunci cand folosesti variabila, o atribui, o exporti sau altfel, numele ei se scrie fara $.
+# Daca vrei sa folosesti valoarea variabilei, atunci trebuie sa folosesti $.
+# Atentie la faptul ca ' (apostrof) nu va inlocui variabla cu valoarea ei.
+
+# Inlocuirea de caractere in variabile
+echo ${VARIABLE/Some/A}
+# Asta va inlocui prima aparitie a "Some" cu "A" in variabila de mai sus.
+
+# Substring dintr-o variabila
+echo ${VARIABLE:0:7}
+# Asta va returna numai primele 7 caractere din variabila.
+
+# Valoarea implicita a unei variabile:
+echo ${FOO:-"ValoareaImplicitaDacaFOOLipsesteSauEGoala"}
+# Asta functioneaza pentru null (FOO=), sir de caractere gol (FOO=""), zero (FOO=0) returneaza 0
+
+# Variabile pre-existente
+echo "Ulima valoare returnata de ultimul program rulat: $?"
+echo "ID-ul procesului (PID) care ruleaza scriptul: $$"
+echo "Numarul de argumente: $#"
+echo "Argumentele scriptului: $@"
+echo "Argumentele scriptului separate in variabile: $1 $2..."
+
+# Citind o valoare din consola
+echo "Care e numele tau?"
+read NAME # Observa faptul ca nu a trebuit sa declaram o variabila noua
+echo Salut, $NAME!
+
+# Avem obisnuita instructiune "if"
+# Foloseste "man test" pentru mai multe informatii despre instructinea conditionala
+if [ $NAME -ne $USER ]
+then
+    echo "Numele tau este username-ul tau"
+else
+    echo "Numele tau nu este username-ul tau"
+fi
+
+# Este de asemenea si executarea conditionala de comenzi
+echo "Intotdeauna executat" || echo "Executat numai daca prima instructiune esueaza"
+echo "Intotdeauna executat" && echo "Executat numai daca prima instructiune NU esueaza"
+
+# Expresiile apar in urmatorul format
+echo $(( 10 + 5 ))
+
+# Spre deosebire de alte limbaje de programare bash este un shell - asa ca 
+# functioneaza in contextul directorului curent. Poti vedea fisiere si directoare
+# din directorul curent folosind comanda "ls":
+ls
+
+# Aceste comenzi au optiuni care la controleaza executia
+ls -l # Listeaza fiecare fisier si director pe o linie separata
+
+# Rezultatele comenzii precedente poate fi trimis urmatoarei comenzi drept argument
+# Comanda grep filtreaza argumentele trimise cu sabloane. Astfel putem vedea fiserele
+# .txt din directorul curent.
+ls -l | grep "\.txt"
+
+# De asemenea poti redirectiona o comanda, input si error output
+python2 hello.py < "input.in"
+python2 hello.py > "output.out"
+python2 hello.py 2> "error.err"
+# Output-ul va suprascrie fisierul daca acesta exista.
+# Daca vrei sa fie concatenate poti folosi ">>" 
+
+# Comenzile pot fi inlocuite in interiorul altor comenzi folosind $( ):
+# Urmatoarea comanda afiseaza numarul de fisiere si directoare din directorul curent
+echo "Sunt $(ls | wc -l) fisiere aici."
+
+# The same can be done using backticks `` but they can't be nested - the preferred way
+# is to use $( ).
+# Acelasi lucru se poate obtine folosind apostrf-ul inversat ``, dar nu pot fi folosite
+# unele in interiorul celorlalte asa ca modalitatea preferata este de a folosi $( )
+echo "Sunt `ls | wc -l` fisiere aici."
+
+# Bash foloseste o instructiune 'case' care functioneaza in mod similar cu instructiunea
+# switch din Java si C++
+case "$VARIABLE" in 
+    0) echo "Este un zero.";;
+    1) echo "Este un unu.";;
+    *) echo "Nu este null";;
+esac
+
+# Instructiunea for parcurge toate elementele trimise:
+# Continutul variabilei $VARIABLE este printat de 3 ori
+for VARIABLE in {1..3}
+do
+    echo "$VARIABLE"
+done
+
+# while loop:
+while [true]
+do
+    echo "in interiorul iteratiei aici..."
+    break
+done
+
+# De asemenea poti defini functii
+# Definitie:
+function foo ()
+{
+    echo "Argumentele functioneaza ca si argumentele scriptului: $@"
+    echo "Si: $1 $2..."
+    echo "Asta este o functie"
+    return 0
+}
+
+# sau mai simplu
+bar ()
+{
+    echo "Alta metoda de a declara o functie"
+    return 0
+}
+
+# Invocarea unei functii
+foo "Numele meu este: " $NAME
+
+# Sunt o multime de comenzi utile pe care ar trebui sa le inveti:
+tail -n 10 file.txt
+# printeaza ultimele 10 linii din fisierul file.txt
+head -n 10 file.txt
+# printeaza primele 10 linii din fisierul file.txt
+sort file.txt
+# sorteaza liniile din file.txt
+uniq -d file.txt
+# raporteaza sau omite liniile care se repeta, cu -d le raporteaza
+cut -d ',' -f 1 file.txt
+# printeaza doar prima coloana inainte de caracterul ","
+```
-- 
cgit v1.2.3


From e8264c3fa95dd8bf457c7f4ebe0c1b20db0506b8 Mon Sep 17 00:00:00 2001
From: Adrian Bordinc <adrian.bordinc@gmail.com>
Date: Wed, 7 May 2014 18:53:23 +0200
Subject: fixed typos, a little bit of formatting

---
 ro-ro/bash-ro.html.markdown | 42 ++++++++++++++++++++++++------------------
 ro-ro/ruby-ro.html.markdown | 44 ++++++++++++++++++++++++++++----------------
 2 files changed, 52 insertions(+), 34 deletions(-)

(limited to 'ro-ro')

diff --git a/ro-ro/bash-ro.html.markdown b/ro-ro/bash-ro.html.markdown
index fa91cca4..debeb67a 100644
--- a/ro-ro/bash-ro.html.markdown
+++ b/ro-ro/bash-ro.html.markdown
@@ -12,16 +12,18 @@ lang: ro-ro
 filename: LearnBash-ro.sh
 ---
 
-Bash este numele shell-ului unix, care a fost de asemenea distribuit drept shell pentru pentru sistemul de operare GNU si ca shell implicit pentru Linux si Mac OS X.
+Bash este numele shell-ului unix, care a fost de asemenea distribuit drept shell pentru sistemul de operare GNU si ca shell implicit pentru Linux si Mac OS X.
 Aproape toate exemplele de mai jos pot fi parte dintr-un script sau pot fi executate direct in linia de comanda.
 
 [Citeste mai multe:](http://www.gnu.org/software/bash/manual/bashref.html)
 
 ```bash
 #!/bin/bash
-# Prima linie din script se numeste "shebang" care spune systemului cum sa execute scriptul
+# Prima linie din script se numeste "shebang" 
+# care spune systemului cum sa execute scriptul
 # http://en.wikipedia.org/wiki/Shebang_(Unix)
-# Dupa cum te-ai prins deja, comentariile incep cu #. Shebang este de asemenea un comentariu.
+# Dupa cum te-ai prins deja, comentariile incep cu #. 
+# Shebang este de asemenea un comentariu.
 
 # Exemplu simplu de hello world:
 echo Hello world!
@@ -41,7 +43,8 @@ VARIABLE = "Niste text"
 echo $VARIABLE
 echo "$VARIABLE"
 echo '$VARIABLE'
-# Atunci cand folosesti variabila, o atribui, o exporti sau altfel, numele ei se scrie fara $.
+# Atunci cand folosesti variabila, o atribui, o exporti sau altfel, 
+# numele ei se scrie fara $.
 # Daca vrei sa folosesti valoarea variabilei, atunci trebuie sa folosesti $.
 # Atentie la faptul ca ' (apostrof) nu va inlocui variabla cu valoarea ei.
 
@@ -55,7 +58,8 @@ echo ${VARIABLE:0:7}
 
 # Valoarea implicita a unei variabile:
 echo ${FOO:-"ValoareaImplicitaDacaFOOLipsesteSauEGoala"}
-# Asta functioneaza pentru null (FOO=), sir de caractere gol (FOO=""), zero (FOO=0) returneaza 0
+# Asta functioneaza pentru null (FOO=),
+# sir de caractere gol (FOO=""), zero (FOO=0) returneaza 0
 
 # Variabile pre-existente
 echo "Ulima valoare returnata de ultimul program rulat: $?"
@@ -70,7 +74,8 @@ read NAME # Observa faptul ca nu a trebuit sa declaram o variabila noua
 echo Salut, $NAME!
 
 # Avem obisnuita instructiune "if"
-# Foloseste "man test" pentru mai multe informatii despre instructinea conditionala
+# Foloseste "man test" pentru mai multe informatii 
+# despre instructinea conditionala
 if [ $NAME -ne $USER ]
 then
     echo "Numele tau este username-ul tau"
@@ -79,8 +84,8 @@ else
 fi
 
 # Este de asemenea si executarea conditionala de comenzi
-echo "Intotdeauna executat" || echo "Executat numai daca prima instructiune esueaza"
-echo "Intotdeauna executat" && echo "Executat numai daca prima instructiune NU esueaza"
+echo "Intotdeauna executat" || echo "Executat daca prima instructiune esueaza"
+echo "Intotdeauna executat" && echo "Executat daca prima instructiune NU esueaza"
 
 # Expresiile apar in urmatorul format
 echo $(( 10 + 5 ))
@@ -93,9 +98,10 @@ ls
 # Aceste comenzi au optiuni care la controleaza executia
 ls -l # Listeaza fiecare fisier si director pe o linie separata
 
-# Rezultatele comenzii precedente poate fi trimis urmatoarei comenzi drept argument
-# Comanda grep filtreaza argumentele trimise cu sabloane. Astfel putem vedea fiserele
-# .txt din directorul curent.
+# Rezultatele comenzii anterioare pot fi 
+# trimise urmatoarei comenzi drept argument
+# Comanda grep filtreaza argumentele trimise cu sabloane. 
+# Astfel putem vedea fiserele .txt din directorul curent.
 ls -l | grep "\.txt"
 
 # De asemenea poti redirectiona o comanda, input si error output
@@ -106,17 +112,17 @@ python2 hello.py 2> "error.err"
 # Daca vrei sa fie concatenate poti folosi ">>" 
 
 # Comenzile pot fi inlocuite in interiorul altor comenzi folosind $( ):
-# Urmatoarea comanda afiseaza numarul de fisiere si directoare din directorul curent
+# Urmatoarea comanda afiseaza numarul de fisiere 
+# si directoare din directorul curent
 echo "Sunt $(ls | wc -l) fisiere aici."
 
-# The same can be done using backticks `` but they can't be nested - the preferred way
-# is to use $( ).
-# Acelasi lucru se poate obtine folosind apostrf-ul inversat ``, dar nu pot fi folosite
-# unele in interiorul celorlalte asa ca modalitatea preferata este de a folosi $( )
+# Acelasi lucru se poate obtine folosind apostrf-ul inversat ``,
+# dar nu pot fi folosite unele in interiorul celorlalte asa ca modalitatea 
+# preferata este de a folosi $( )
 echo "Sunt `ls | wc -l` fisiere aici."
 
-# Bash foloseste o instructiune 'case' care functioneaza in mod similar cu instructiunea
-# switch din Java si C++
+# Bash foloseste o instructiune 'case' care functioneaza 
+# in mod similar cu instructiunea switch din Java si C++
 case "$VARIABLE" in 
     0) echo "Este un zero.";;
     1) echo "Este un unu.";;
diff --git a/ro-ro/ruby-ro.html.markdown b/ro-ro/ruby-ro.html.markdown
index 27c6c462..12672b68 100644
--- a/ro-ro/ruby-ro.html.markdown
+++ b/ro-ro/ruby-ro.html.markdown
@@ -78,9 +78,9 @@ false.class #=> FalseClass
 'Sunt un sir de caractere'.class #=> String
 "Si eu sunt un sir de caractere".class #=> String
 
-fi_inlocuit = "inlocui o valoare in string"
+fi_inlocuit = "fi inlocuit"
 "Pot #{fi_inlocuit} atunci cand folosesc dublu apostrof"
-#=> "Pot inlocui o valoare intr-un sir de caractere atunci cand folosesc dublu apostrof"
+#=> "Pot fi inlocuit atunci cand folosesc dublu apostrof"
 
 
 # Printeaza 
@@ -106,7 +106,8 @@ adresa = '/nume/nu atat de bun/'
 
 # Simbolurile (sunt obiecte)
 # Simbolurile sunt constante imutabile, reutilizabile, reprezentate intern 
-# de o valoare numerica. Sunt deseori folosite in locul sirurilor de caractere pentru a da un nume reprezentativ unei valori
+# de o valoare numerica. Sunt deseori folosite in locul sirurilor de caractere 
+# pentru a da un nume reprezentativ unei valori
 
 :exemplu_simbol.class #=> Symbol
 
@@ -160,10 +161,12 @@ hash.keys #=> ['culoare', 'numar']
 hash['culoare'] #=> 'verde'
 hash['numar'] #=> 5
 
-# Incercand sa accesezi un element dintr-un hash printr-o cheie care nu exista va returna "nil".
+# Incercand sa accesezi un element dintr-un hash 
+# printr-o cheie care nu exista va returna "nil".
 hash['nimic_aici'] #=> nil
 
-# Incepand cu Ruby 1.9, este o sintaxa speciala pentru atunci cand se folosesc simboluri drept chei:
+# Incepand cu Ruby 1.9, este o sintaxa speciala 
+# pentru atunci cand se folosesc simboluri drept chei:
 
 hash_nou = { defcon: 3, actiune: true}
 
@@ -195,10 +198,11 @@ end
 # TOTUSI, Nici una nu foloseste instructiunea for
 # In locul acesteia ar trebui sa folosesti metoda "each" si sa ii trimiti un block
 # Un bloc este o bucata de cod pe care o poti trimite unei metode precum "each".
-# Este analog pentru "lambda", functii anonime, sau closures in alte limbaje de programare.
+# Este analog pentru "lambda", functii anonime,
+# sau closures in alte limbaje de programare.
 #
-# The "each" method of a range runs the block once for each element of the range.
-# Metoda "each" a unui interval, ruleaza block-ul o data pentru fiecare element din interval.
+# Metoda "each" a unui interval, ruleaza block-ul o data
+# pentru fiecare element din interval.
 # Block-ul primeste ca si parametru un index
 # Invocand metoda "each" cu un block, arata in urmatorul fel:
 
@@ -256,7 +260,8 @@ def dublu(x)
   x * 2
 end
 
-# Functille (si toate block-urile) returneaza implicit valoarea ultimei instructiuni
+# Functille (si toate block-urile) 
+# returneaza implicit valoarea ultimei instructiuni
 dublu(2) #=> 4
 
 # Parantezele sunt optionale cand rezultatul nu este ambiguu
@@ -312,7 +317,8 @@ class Om
   def initialize(nume, varsta=0)
     # Atribuie argumentul, variabilei "nume", care apartine doar unei instante
     @nume = nume
-    # Daca varsta nu este data, o sa ii atribuim valoarea implicita din lista de argumente (0, in cazul nostru)
+    # Daca varsta nu este data, o sa ii atribuim valoarea implicita
+    # din lista de argumente (0, in cazul nostru)
     @varsta = varsta
   end
 
@@ -326,14 +332,17 @@ class Om
     @nume
   end
 
-  # Functionalitatea de mai sus poate fi obtinuta folosing metoda "attr_accessor" dupa cum urmeaza:
+  # Functionalitatea de mai sus poate fi obtinuta 
+  # folosing metoda "attr_accessor" dupa cum urmeaza:
   attr_accessor :nume
 
-  # Metodele pentru a lua si a seta valoarea unei variabile pot fi de asemenea obtinute individial:
+  # Metodele pentru a lua si a seta valoarea unei variabile 
+  # pot fi de asemenea obtinute individial:
   attr_reader :nume
   attr_writer :nume
 
-  # O metoda apartinand unei clase foloseste "self" pentru a se diferentia de metodele unei instante ale clasei respective
+  # O metoda apartinand unei clase foloseste "self" pentru a se diferentia 
+  # de metodele unei instante ale clasei respective
   # Poate fi invocata doar pe clasa, si nu pe o instanta a acesteia
   def self.spune(msg)
     puts "#{msg}"
@@ -380,8 +389,10 @@ defined? @@var #=> "class variable"
 Var = "Sunt o constanta"
 defined? Var #=> "constant"
 
-# Clasele sunt de asemenea obiecte in ruby. Astfel incat clasele pot avea variabile care apartin unei instante
-# O variabila care apartine unei clase poate fi accesata de toate instantele acesteia si de clasele care o extind
+# Clasele sunt de asemenea obiecte in ruby. Astfel incat clasele 
+# pot avea variabile care apartin unei instante
+# O variabila care apartine unei clase poate fi accesata de toate 
+# instantele acesteia si de clasele care o extind
 
 # clasa parinte
 class Om
@@ -406,7 +417,8 @@ Muncitor.foo # 0
 Om.foo = 2 # 2
 Muncitor.foo # 2
 
-# Variabilele care apartin unei instante ale unei clase, nu sunt impartite de (copii acesteia) clasele care o extind
+# Variabilele care apartin unei instante ale unei clase, 
+# nu sunt impartite de (copii acesteia) clasele care o extind
 class Om
   @bar = 0
 
-- 
cgit v1.2.3


From ab81738386a6fd5e5facfa14357e089744af979d Mon Sep 17 00:00:00 2001
From: Bogdan Paun <bgdnpn@gmail.com>
Date: Fri, 7 Aug 2015 12:45:47 +0300
Subject: Added Romanian Clojure translation

---
 ro-ro/clojure-ro.html.markdown | 385 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 385 insertions(+)
 create mode 100644 ro-ro/clojure-ro.html.markdown

(limited to 'ro-ro')

diff --git a/ro-ro/clojure-ro.html.markdown b/ro-ro/clojure-ro.html.markdown
new file mode 100644
index 00000000..7dd51615
--- /dev/null
+++ b/ro-ro/clojure-ro.html.markdown
@@ -0,0 +1,385 @@
+---
+language: clojure
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+translators:
+    - ["Bogdan Paun", "http://twitter.com/bgdnpn"]
+filename: learnclojure-ro.clj
+lang: ro-ro
+---
+
+Clojure este un limbaj din familia Lisp dezvoltat pentru Masina Virtuala Java
+(Java Virtual Machine - JVM). Pune un accent mult mai puternic pe [programarea funcionala](https://en.wikipedia.org/wiki/Functional_programming) pura decat Common Lisp, dar include
+utilitare [STM](https://en.wikipedia.org/wiki/Software_transactional_memory) pentru 
+a gestiona starea, atunci cand aceasta apare.
+
+Combinatia aceasta ii permite sa gestioneze procese concurente foarte usor,
+de multe ori in mod automat.
+
+(Aveti nevoie deo versiune Clojure 1.2 sau mai noua)
+
+
+```clojure
+; Comentariile incep cu punct si virgula.
+
+; Clojure se scrie in "forme", care nu sunt decat
+; liste de lucruri in interiorul unor paranteze, separate prin spatii.
+;
+; Reader-ul Clojure presupune ca primul lucru este o
+; functie sau un macro de apelat, iar restul sunt argumente.
+
+; Prima apelare intr-un fisier ar trebui sa fie ns, pentru a configura namespace-ul
+(ns learnclojure)
+
+; Mai multe exemple de baza:
+
+; str va crea un string folosint toate argumentele sale
+(str "Hello" " " "World") ; => "Hello World"
+
+; Matematica este simpla
+(+ 1 1) ; => 2
+(- 2 1) ; => 1
+(* 1 2) ; => 2
+(/ 2 1) ; => 2
+
+; Egalitatea este =
+(= 1 1) ; => true
+(= 2 1) ; => false
+
+; Folosim si not pentru logica
+(not true) ; => false
+
+; Formele imbricate functioneaza asa
+(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2
+
+; Tipuri
+;;;;;;;;;;;;;
+
+; Clojure foloseste sistemul de obiecte Java pentru boolean, string si numere.
+; Folositi `class` pentru a le inspecta.
+(class 1) ; Numere intregi sunt jaba.lang.Long, in mod normal
+(class 1.); Numelere reale sunt java.lang.Double
+(class ""); Sirurile de caractere sunt mere intre apostrofuri duble, si sunt java.lang.String
+(class false) ; Booleanele sunt java.lang.Boolean
+(class nil); Valoarea "null" este numita nil
+
+; Daca doriti sa creati o lista de date literale, folositi ' pentru a preveni
+; evaluarea ei
+'(+ 1 2) ; => (+ 1 2)
+; (prescurtare pentru (quote (+ 1 2)))
+
+; Puteti evalua o lista cu apostrof
+(eval '(+ 1 2)) ; => 3
+
+; Colectii & Secvente
+;;;;;;;;;;;;;;;;;;;
+
+; Listele sunt structuri de date lista-inlantuita, spre deosebire de Vectori
+; Vectorii si Listele sunt si ele clase Java!
+(class [1 2 3]); => clojure.lang.PersistentVector
+(class '(1 2 3)); => clojure.lang.PersistentList
+
+; O liste ar putea fi scrisa direct ca (1 2 3), dar trebuie sa folosim apostrof
+; pentru a preveni reader-ul din a crede ca e o functie.
+; De asemenea, (list 1 2 3) este acelasi lucru cu '(1 2 3)
+
+; "Colectiile" sunt grupuri de date
+; Atat listele cat si vectorii sunt colectii:
+(coll? '(1 2 3)) ; => true
+(coll? [1 2 3]) ; => true
+
+; "Sequences" (seqs) are abstract descriptions of lists of data.
+; Only lists are seqs.
+(seq? '(1 2 3)) ; => true
+(seq? [1 2 3]) ; => false
+
+; O secventa necesita un punct de intrare doar cand este accesata.
+; Deci, secventele, care pot fi "lazy" -- pot defini serii infinite:
+(range 4) ; => (0 1 2 3)
+(range) ; => (0 1 2 3 4 ...) (o serie infinita)
+(take 4 (range)) ;  (0 1 2 3)
+
+; Folositi cons pentru a adauga un element la inceputul unei liste sau unui vector
+(cons 4 [1 2 3]) ; => (4 1 2 3)
+(cons 4 '(1 2 3)) ; => (4 1 2 3)
+
+; Conj va adauga un element unei colectii in modul cel mai eficient.
+; Pentru liste, aceastea sunt inserate la inceput. Pentru vectori, sunt inserate la final.
+(conj [1 2 3] 4) ; => [1 2 3 4]
+(conj '(1 2 3) 4) ; => (4 1 2 3)
+
+; Folositi concat pentru a uni liste sau vectori
+(concat [1 2] '(3 4)) ; => (1 2 3 4)
+
+; Folositi filter, map pentru a interactiona cu colectiile
+(map inc [1 2 3]) ; => (2 3 4)
+(filter even? [1 2 3]) ; => (2)
+
+; Folositi reduce pentru a le reduce
+(reduce + [1 2 3 4])
+; = (+ (+ (+ 1 2) 3) 4)
+; => 10
+
+; Reduce poate lua un argument valoare-initiala
+(reduce conj [] '(3 2 1))
+; = (conj (conj (conj [] 3) 2) 1)
+; => [3 2 1]
+
+; Functii
+;;;;;;;;;;;;;;;;;;;;;
+
+; Folositi fn pentru a crea functii noi. O functie returneaza intotdeauna
+; ultima sa instructiune.
+(fn [] "Hello World") ; => fn
+
+; (Necesita paranteze suplimentare pentru a fi apelata)
+((fn [] "Hello World")) ; => "Hello World"
+
+; Puteti crea o variabila folosind def
+(def x 1)
+x ; => 1
+
+; Atribuiti o functie unei variabile
+(def hello-world (fn [] "Hello World"))
+(hello-world) ; => "Hello World"
+
+; Puteti scurta acest proces folosind defn
+(defn hello-world [] "Hello World")
+
+; Elementul [] este lista de argumente a functiei.
+(defn hello [name]
+  (str "Hello " name))
+(hello "Steve") ; => "Hello Steve"
+
+; Puteti, de asemenea, folosi aceasta prescurtare pentru a crea functii:
+(def hello2 #(str "Hello " %1))
+(hello2 "Fanny") ; => "Hello Fanny"
+
+; Puteti avea si functii cu mai multe variabile
+(defn hello3
+  ([] "Hello World")
+  ([name] (str "Hello " name)))
+(hello3 "Jake") ; => "Hello Jake"
+(hello3) ; => "Hello World"
+
+; Functiile pot primi mai mult argumente dintr-o secventa
+(defn count-args [& args]
+  (str "Ati specificat " (count args) " argumente: " args))
+(count-args 1 2 3) ; => "Ati specificat 3 argumente: (1 2 3)"
+
+; Puteti interschimba argumente normale si argumente-secventa
+(defn hello-count [name & args]
+  (str "Salut " name ", ati specificat " (count args) " argumente extra"))
+(hello-count "Finn" 1 2 3)
+; => "Salut Finn, ai specificat 3 argumente extra"
+
+
+; Maps (Dictionare)
+;;;;;;;;;;
+
+; Hash maps si Array maps impart o interfata. Hash maps au cautari mai rapide
+; dar nu retin ordinea cheilor.
+(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap
+(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap
+
+; Arraymaps de vin automat hashmaps prin majoritatea operatiilor
+; daca sunt suficient de mari, asa ca nu trebuie sa va preocupe acest aspect.
+
+; Dictionarele pot folosi orice tip hashable ca si cheie, dar cuvintele cheie
+; (keywords) sunt, de obicei, cele mai indicate. Cuvintele cheie sunt ca niste
+; siruri de caractere cu un plus de eficienta
+(class :a) ; => clojure.lang.Keyword
+
+(def stringmap {"a" 1, "b" 2, "c" 3})
+stringmap  ; => {"a" 1, "b" 2, "c" 3}
+
+(def keymap {:a 1, :b 2, :c 3})
+keymap ; => {:a 1, :c 3, :b 2}
+
+; Apropo, virgulele sunt intotdeauna considerate echivalente cu spatiile.
+
+; Apelati un dictionar (map) ca pe o functie pentru a primi o valoare anume
+(stringmap "a") ; => 1
+(keymap :a) ; => 1
+
+; Cuvintele cheie pot fi folosite si ele pentru a "cere" dictionarului valorile lor!
+(:b keymap) ; => 2
+
+; Nu incercati asta cu siruri de caractere.
+;("a" stringmap)
+; => Exception: java.lang.String cannot be cast to clojure.lang.IFn
+
+; Recuperarea unei chei inexistente returneaza nil
+(stringmap "d") ; => nil
+
+; Folositi assoc pentru a adauga nou chei unui ductionar
+(def newkeymap (assoc keymap :d 4))
+newkeymap ; => {:a 1, :b 2, :c 3, :d 4}
+
+; Dar retineti ca tipurile sunt imuabile in clojure
+keymap ; => {:a 1, :b 2, :c 3}
+
+; Folositi dissoc pentru a elimina chei
+(dissoc keymap :a :b) ; => {:c 3}
+
+; Seturi (multimi)
+;;;;;;
+
+(class #{1 2 3}) ; => clojure.lang.PersistentHashSet
+(set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3}
+
+; Adaugati un membru cu conj
+(conj #{1 2 3} 4) ; => #{1 2 3 4}
+
+; Eliminati unul cu disj
+(disj #{1 2 3} 1) ; => #{2 3}
+
+; Testati existenta unuia folosing setul ca o functie:
+(#{1 2 3} 1) ; => 1
+(#{1 2 3} 4) ; => nil
+
+; Exista mai multe functii in namespace-ul clojure.sets.
+
+; Forme utile
+;;;;;;;;;;;;;;;;;
+
+; In Clojure constructiile logice sunt macro-uri, si arata ca
+; oricare alta forma
+(if false "a" "b") ; => "b"
+(if false "a") ; => nil
+
+; Folositi let pentru a crea atribuiri temporare
+(let [a 1 b 2]
+  (> a b)) ; => false
+
+; Grupati instructiuni impreuna folosind do
+(do
+  (print "Hello")
+  "World") ; => "World" (prints "Hello")
+
+; Functiile contin un do implicit
+(defn print-and-say-hello [name]
+  (print "Saying hello to " name)
+  (str "Hello " name))
+(print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff")
+
+; Asemanator pentru let
+(let [name "Urkel"]
+  (print "Saying hello to " name)
+  (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
+
+; Module
+;;;;;;;;;;;;;;;
+
+; Folositi "use" pentru a recupera toate functiile dintr-un modul
+(use 'clojure.set)
+
+; Acum putem folosi operatiuni pe seturi
+(intersection #{1 2 3} #{2 3 4}) ; => #{2 3}
+(difference #{1 2 3} #{2 3 4}) ; => #{1}
+
+; Puteri de asemenea alege un subset al functiilor de importat
+(use '[clojure.set :only [intersection]])
+
+; Folositi require pentru a importa un modul
+(require 'clojure.string)
+
+; Folositi / pentru a apela functii dintr-un modul
+; In acest caz, modulul este clojure.string, iar functia este blank?
+(clojure.string/blank? "") ; => true
+
+; Puteti atribui un nume mai scurt unui modul in momentul importului
+(require '[clojure.string :as str])
+(str/replace "Acesta este un test." #"[a-o]" str/upper-case) ; => "ACEstA EstE un tEst."
+; (#"" denota o expresie regulata)
+
+; Puteti folsi require (sau use, contraindicat) dintr-un namespace folosind :require.
+; Nu trebuie sa folositi apostrof pentru module daca procedati astfel.
+(ns test
+  (:require
+    [clojure.string :as str]
+    [clojure.set :as set]))
+
+; Java
+;;;;;;;;;;;;;;;;;
+
+; Java are o biblioteca standard imensa si folositoare, deci
+; ar fi util sa stiti cum sa o folositi.
+
+; Folositi import pentru a incarca un modul Java
+(import java.util.Date)
+
+; Puteti importa si dintr-un namesopace.
+(ns test
+  (:import java.util.Date
+           java.util.Calendar))
+
+; Folositi numele clasei cu "." la final pentru a crea o noua instanta
+(Date.) ; <a date object>
+
+; Folositi . pentru a apela metode. Pe scurt, folositi ".method"
+(. (Date.) getTime) ; <a timestamp>
+(.getTime (Date.)) ; exact acelasi lucru.
+
+; Folositi / pentru a apela metode statice
+(System/currentTimeMillis) ; <a timestamp> (System este prezent intotdeauna)
+
+; Folositi doto pentru a gestiona clase (mutable) mai usor
+(import java.util.Calendar)
+(doto (Calendar/getInstance)
+  (.set 2000 1 1 0 0 0)
+  .getTime) ; => A Date. set to 2000-01-01 00:00:00
+
+; STM
+;;;;;;;;;;;;;;;;;
+
+; Software Transactional Memory este un mecanism folost de Clojure pentru
+; a gestiona stari persistente. Sunt putine instante in care este folosit.
+
+; Un atom este cel mai simplu exemplu. Dati-i o valoare initiala
+(def my-atom (atom {}))
+
+; Modificati-l cu swap!.
+; swap! primeste o functie si o apeleaza cu valoarea actuala a atomului
+; ca prim argument si orice argumente suplimentare ca al doilea
+(swap! my-atom assoc :a 1) ; Atomul ia valoarea rezultata din (assoc {} :a 1)
+(swap! my-atom assoc :b 2) ; Atomul ia valoarea rezultata din (assoc {:a 1} :b 2)
+
+; Folositi '@' pentru a dereferentia atomul si a-i recupera valoarea
+my-atom  ;=> Atom<#...> (Returmeaza obiectul Atom)
+@my-atom ; => {:a 1 :b 2}
+
+; Aici avem un contor simplu care foloseste un atom
+(def counter (atom 0))
+(defn inc-counter []
+  (swap! counter inc))
+
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+
+@counter ; => 5
+
+; Alte utilizari ale STM sunt referintele (refs) si agentii (agents).
+; Refs: http://clojure.org/refs
+; Agents: http://clojure.org/agents
+```
+
+### Lectura suplimentara
+
+Lista nu este in niciun caz exhaustiva, dar speram ca este suficienta pentru
+a va oferi un inceput bun in Clojure.
+
+Clojure.org contine multe articole:
+[http://clojure.org/](http://clojure.org/)
+
+Clojuredocs.org contine documentatie cu exemple pentru majoritatea functiilor de baza:
+[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
+
+4Clojure este o metoda excelenta pentru a exersa Clojure/FP (Programarea Functionala):
+[http://www.4clojure.com/](http://www.4clojure.com/)
+
+Clojure-doc.org are un numar de article pentru incepatori:
+[http://clojure-doc.org/](http://clojure-doc.org/)
-- 
cgit v1.2.3


From 7cb4534b6e088744f9b79cc6eeaf47ab90ed413b Mon Sep 17 00:00:00 2001
From: Bogdan Paun <bgdnpn@gmail.com>
Date: Fri, 7 Aug 2015 12:47:36 +0300
Subject: fixed some spacing issues

---
 ro-ro/clojure-ro.html.markdown | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'ro-ro')

diff --git a/ro-ro/clojure-ro.html.markdown b/ro-ro/clojure-ro.html.markdown
index 7dd51615..8b1327d8 100644
--- a/ro-ro/clojure-ro.html.markdown
+++ b/ro-ro/clojure-ro.html.markdown
@@ -9,8 +9,10 @@ lang: ro-ro
 ---
 
 Clojure este un limbaj din familia Lisp dezvoltat pentru Masina Virtuala Java
-(Java Virtual Machine - JVM). Pune un accent mult mai puternic pe [programarea funcionala](https://en.wikipedia.org/wiki/Functional_programming) pura decat Common Lisp, dar include
-utilitare [STM](https://en.wikipedia.org/wiki/Software_transactional_memory) pentru 
+(Java Virtual Machine - JVM). Pune un accent mult mai puternic pe
+[programarea funcionala](https://en.wikipedia.org/wiki/Functional_programming)
+pura decat Common Lisp, dar include
+utilitare [STM](https://en.wikipedia.org/wiki/Software_transactional_memory) pentru
 a gestiona starea, atunci cand aceasta apare.
 
 Combinatia aceasta ii permite sa gestioneze procese concurente foarte usor,
-- 
cgit v1.2.3


From c0a6e8fdf9508348645f895840ff93bcfcb9fa02 Mon Sep 17 00:00:00 2001
From: Bogdan Paun <bgdnpn@gmail.com>
Date: Fri, 7 Aug 2015 12:50:36 +0300
Subject: line length tweaking..

---
 ro-ro/clojure-ro.html.markdown | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'ro-ro')

diff --git a/ro-ro/clojure-ro.html.markdown b/ro-ro/clojure-ro.html.markdown
index 8b1327d8..32ba9620 100644
--- a/ro-ro/clojure-ro.html.markdown
+++ b/ro-ro/clojure-ro.html.markdown
@@ -11,9 +11,8 @@ lang: ro-ro
 Clojure este un limbaj din familia Lisp dezvoltat pentru Masina Virtuala Java
 (Java Virtual Machine - JVM). Pune un accent mult mai puternic pe
 [programarea funcionala](https://en.wikipedia.org/wiki/Functional_programming)
-pura decat Common Lisp, dar include
-utilitare [STM](https://en.wikipedia.org/wiki/Software_transactional_memory) pentru
-a gestiona starea, atunci cand aceasta apare.
+pura decat Common Lisp, dar include utilitare [STM](https://en.wikipedia.org/wiki/Software_transactional_memory)
+pentru a gestiona starea, atunci cand aceasta apare.
 
 Combinatia aceasta ii permite sa gestioneze procese concurente foarte usor,
 de multe ori in mod automat.
-- 
cgit v1.2.3