Merge pull request #134 from bogdanbacosca/sync-29216730

Updated sections to match

Author: bogdanbacosca

1-js/02-first-steps/14-switch/article.md

@@ -47,18 +47,14 @@ switch (a) {
     break;
 */!*
   case 5:
-<<<<<<< HEAD:1-js/02-first-steps/13-switch/article.md
     alert( 'Prea mare' );
-=======
-    alert( 'Too big' );
->>>>>>> 29216730a877be28d0a75a459676db6e7f5c4834:1-js/02-first-steps/14-switch/article.md
     break;
   default:
     alert( "Nu știu astfel de valori" );
 }
 ```
 
-Aici, `switch` începe să compare `a` cu valoarea din primul `case`, adică `3`. Egalitatea nu este îndeplinită.
+Aici `switch` începe să compare `a` cu valoarea din primul `case`, adică `3`. Egalitatea nu este îndeplinită.
 
 Urmează `4`. Acesta se potrivește, deci execuția începe de la `case 4` până la cel mai apropiat `break`.
 
@@ -129,11 +125,7 @@ switch (a) {
     break;
 
 *!*
-<<<<<<< HEAD
-  case 3:                    // (*) două cazuri grupate
-=======
-  case 3: // (*) grouped two cases
->>>>>>> 852ee189170d9022f67ab6d387aeae76810b5923
+  case 3: // (*) două cazuri grupate
   case 5:
     alert('Greșit!');
     alert("De ce nu urmezi un curs de matematică?");

1-js/03-code-quality/03-comments/article.md

@@ -4,15 +4,11 @@ După cum știm din capitolul <info:structure>, comentariile pot fi pe o singur
 
 Noi le folosim în mod obișnuit pentru a descrie cum și de ce funcționează codul. 
 
-<<<<<<< HEAD
-La prima vedere, scrierea comentariilor pare a fi evidentă, dar adeseori începătorii în programare fac greșeli. 
-=======
-At first sight, commenting might be obvious, but novices in programming often use them wrongly.
->>>>>>> 852ee189170d9022f67ab6d387aeae76810b5923
+La prima vedere, scrierea comentariilor pare a fi evidentă, dar deseori începătorii în programare fac greșeli.
 
-## Comentarii rele
+## Comentarii greșite
 
-Începătorii tind să utilizeze comentariile pentru a explica "ce se întâmplă în cod". Ceva de genul ăsta: 
+Începătorii tind să utilizeze comentariile pentru a explica "ce se întâmplă în cod". Cam așa:
 
 ```js
 // Acest cod va face asta (...) și asta (...)
@@ -48,6 +44,7 @@ function showPrimes(n) {
 
 Varianta mai bună, cu o funcție separată `isPrime`
 
+
 ```js
 function showPrimes(n) {
 
@@ -120,68 +117,33 @@ function addJuice(container) {
 
 Deci, comentarii explicative sunt de obicei rele. Ce comentarii sunt bune?
 
-<<<<<<< HEAD
 Descrierea arhitecturii
-: Oferă o vedere de ansamblu asupra componentelor, cum interacționează, care este ordinea de control în diverse situații... Pe scurt -- ochiul de vultur al codului. Există un limbaj-diagramă special [UML](https://ro.wikipedia.org/wiki/Unified_Modeling_Language) pentru diagrame de nivel înalt. Cu siguranță merită studiate.
+: Oferă o vedere de ansamblu asupra componentelor, cum interacționează, care este ordinea de control flow în diverse situații... Pe scurt -- privirea de ansamblu a codului. Există un limbaj special [UML](https://ro.wikipedia.org/wiki/Unified_Modeling_Language) pentru a construi diagrame de arhitectură high-level. Cu siguranță merită studiate.
 
 Documentarea utilizării unei funcții
-: Există o sintaxă specială [JSDoc](http://en.wikipedia.org/wiki/JSDoc) pentru pentru a documenta funcțiile: utilizare, parametri, valoare returnată.
-=======
-Describe the architecture
-: Provide a high-level overview of components, how they interact, what's the control flow in various situations... In short -- the bird's eye view of the code. There's a special language [UML](http://wikipedia.org/wiki/Unified_Modeling_Language) to build high-level architecture diagrams explaining the code. Definitely worth studying.
-
-Document function parameters and usage
-: There's a special syntax [JSDoc](http://en.wikipedia.org/wiki/JSDoc) to document a function: usage, parameters, returned value.
->>>>>>> 852ee189170d9022f67ab6d387aeae76810b5923
-
-<<<<<<< HEAD
-    De exemplu:
-    ```js
-    /**
-     * Returnează x la puterea n.
-     *
-     * @param {number} x Numărul ridicat la putere.
-     * @param {number} n Puterea, trebuie să fie un număr natural.
-     * @return {number} x ridicat la puterea n.
-     */
-    function pow(x, n) {
-      ...
-    }
-    ```
-    Comentariile de acest tip ne permit să înțelegem scopul funcției și să o folosim în modul corect fără a ne uita în codul ei.
+: Există o sintaxă specială [JSDoc](http://en.wikipedia.org/wiki/JSDoc) pentru pentru a documenta o funcție: utilizare, parametri, valoare returnată.
 
-    
-    Apropo, multe editoare precum [WebStorm](https://www.jetbrains.com/webstorm/) le pot înțelege la fel de bine și să le folosească pentru a asigura autocompletare și verificări automate ale codului.
-    
-    De asemenea, sunt și unelte precum [JSDoc 3](https://github.com/jsdoc3/jsdoc) care pot genera documentație HTML din comentarii. Poți citi mai multe informații despre JSDoc la <http://usejsdoc.org/>
-=======
-For instance:
+Spre exemplu:
 ```js
 /**
- * Returns x raised to the n-th power.
- *
- * @param {number} x The number to raise.
- * @param {number} n The power, must be a natural number.
- * @return {number} x raised to the n-th power.
- */
+* Returnează x la puterea n.
+*
+* @param {number} x Numărul de ridicat la putere.
+* @param {number} n Puterea, trebuie să fie un număr natural.
+* @return {number} x ridicat la puterea n.
+*/
 function pow(x, n) {
-  ...
+...
 }
 ```
 
-Such comments allow us to understand the purpose of the function and use it the right way without looking in its code.
-
-By the way, many editors like [WebStorm](https://www.jetbrains.com/webstorm/) can understand them as well and use them to provide autocomplete and some automatic code-checking.
-
-Also, there are tools like [JSDoc 3](https://github.com/jsdoc3/jsdoc) that can generate HTML-documentation from the comments. You can read more information about JSDoc at <http://usejsdoc.org/>.
-
-Why is the task solved this way?
-: What's written is important. But what's *not* written may be even more important to understand what's going on. Why is the task solved exactly this way? The code gives no answer.
-
-    If there are many ways to solve the task, why this one? Especially when it's not the most obvious one.
->>>>>>> 29216730a877be28d0a75a459676db6e7f5c4834
+Comentariile de acest tip ne permit să înțelegem scopul funcției și să o folosim în modul corect fără a ne uita în codul ei.
+    
+Apropo, multe editoare precum [WebStorm](https://www.jetbrains.com/webstorm/) le pot înțelege la fel de bine și să le folosească pentru a furniza autocomplete și câteva verificări automate ale codului.
+    
+De asemenea, sunt și unelte precum [JSDoc 3](https://github.com/jsdoc3/jsdoc) care pot genera documentație HTML din comentarii. Poți citi mai multe informații despre JSDoc la <https://jsdoc.app>.
 
-De ce este rezolvată sarcina în modul acesta?
+De ce este rezolvată sarcina în acest mod?
 : Ce este scris este important. Dar ce *nu* este scris s-ar putea să fie mult mai important pentru a înțelege ce se îmtâmplă. De ce este sarcina rezolvată în felul acesta? Codul nu oferă nici un răspuns.
 
     Dacă sunt multe moduri de a rezolva sarcina, de ce tocmai acesta? În special când nu este chiar cel mai evident. 
@@ -202,20 +164,16 @@ Un semn important al unui dezvoltator bun sunt comentariile: prezența lor și c
 
 Comentariile bune ne permit să păstrăm codul organizat, să ne întoarcem la el după un timp și să îl folosim mult mai eficient.
 
-**Folosește comentariile pentru:**
+**Comentează următoarele:**
 
 - Arhitectura per total, o vedere de ansamblu a acesteia.
 - Utilizarea funcțiilor.
 - Soluții importante, în special când nu sunt imediat evidente.
 
 **Evită comentariile pentru:**
 
-<<<<<<< HEAD
-- Pentru a descrie "cum funcționează codul" și "ce face".
-- Folosește-le doar dacă este imposibil să faci codul atât de simplu și autodescriptiv încât comentariile să nu mai fie necesare.
-=======
-- That tell "how code works" and "what it does".
-- Put them in only if it's impossible to make the code so simple and self-descriptive that it doesn't require them.
->>>>>>> 29216730a877be28d0a75a459676db6e7f5c4834
+- Pentru a spune "cum funcționează codul" și "ce face".
+- Punele înăuntru doar dacă este imposibil să faci codul atât de simplu și autodescriptiv încat nu este nevoie de ele.
+
 
-Comentariile sunt de asemenea folosite pentru unelte de autodocumentare precum JSDoc3: acestea le citesc și generează documentații HTML (sau documentații în alt format).
+Comentariile sunt de asemeni folosite pentru unelte de autodocumentare precum JSDoc3: acestea le citesc și generează documentații HTML (sau documentații în alt format).