Merge pull request #1 from adambard/master

Merging from master.

306 files changed, 47732 insertions, 5484 deletions

diff --git a/CONTRIBUTING.markdown b/CONTRIBUTING.markdown
index 455c3256..18a5a5d7 100644
--- a/CONTRIBUTING.markdown
+++ b/CONTRIBUTING.markdown
@@ -52,6 +52,8 @@ languages:
 
 Other fields:
 
+- **category**: The category of the article. So far, can be one of *language*,
+  *tool* or *Algorithms & Data Structures*. Defaults to *language* if omitted.
 - **filename**: The filename for this article's code. It will be fetched, mashed
   together, and made downloadable.
     + For non-English articles, *filename* should   have a language-specific 
@@ -78,3 +80,26 @@ If you want to add yourself to contributors, keep in mind that contributors get
 equal billing, and the first contributor usually wrote the whole article. Please
 use your judgement when deciding if your contribution constitutes a substantial
 addition or not.
+
+## Building the site locally
+
+You can buid the site locally to test your changes. Follow the steps below.
+
+* Install Ruby language runtime and RubyGems. See [here](https://middlemanapp.com/basics/install/) for more details.
+* Clone or zip download the [learnxinyminutes-site](https://github.com/adambard/learnxinyminutes-site) repo.
+	* `git clone https://github.com/adambard/learnxinyminutes-site`
+* Install Middleman and other required dependencies using Bundler.
+	* `cd learnxinyminutes-site/`
+	* `bundle install`
+* Get the source in place
+	* Copy the contents of your clone of the fork of learnxinyminutes-docs repo
+	into the `source/docs` folder. There shouldn't be a `learnxinyminutes-docs`
+	folder inside the `docs` folder, it should just contain all the repo
+	contents.
+	* Checkout your fork of the learnxinyminutes-docs repo as `source/docs`.
+		* `cd source/docs/`
+		* `git clone https://github.com/YOUR-USERNAME/learnxinyminutes-docs ./source/docs/`
+* Build the site or run a development server to test your changes (NOTE: run
+these commands at `learnxinyminutes-site/`).
+	* Build - `bundle exec middleman build`
+	* Dev server - `bundle exec middleman --force-polling --verbose`
diff --git a/ansible.html.markdown b/ansible.html.markdown
new file mode 100644
index 00000000..41a8c9b5
--- /dev/null
+++ b/ansible.html.markdown
@@ -0,0 +1,755 @@
+---
+category: tool
+tool: ansible
+contributors:
+    - ["Jakub Muszynski" , "http://github.com/sirkubax"]
+    - ["Pat Myron" , "https://github.com/patmyron"]
+    - ["Divay Prakash", "https://github.com/divayprakash"]
+filename: LearnAnsible.txt
+---
+
+## Introduction
+
+```yaml
+---
+"{{ Ansible }}" is an orchestration tool written in Python.
+...
+```
+
+Ansible is (one of many) orchestration tools. It allows you to control your
+environment (infrastructure and code) and automate the manual tasks.
+
+Ansible has great integration with multiple operating systems (even Windows)
+and some hardware (switches, Firewalls, etc). It has multiple tools that
+integrate with the cloud providers. Almost every noteworthy cloud provider is
+present in the ecosystem (AWS, Azure, Google, DigitalOcean, OVH, etc...).
+
+But ansible is way more! It provides execution plans, an API, library, and callbacks.
+
+### Main pros and cons
+
+#### Pros
+
+* It is an agent-less tools In most scenarios, it use ssh as a transport layer.
+In some way you can use it as 'bash on steroids'.
+* It is very easy to start. If you are familiar with ssh concept - you already
+know Ansible (ALMOST).
+* It executes 'as is' - other tools (salt, puppet, chef - might execute in
+different scenario than you would expect)
+* Documentation is at the world-class standard!
+* Writing your own modules and extensions is fairly easy.
+* Ansible AWX is the open source version of Ansible Tower we have been waiting
+for, which provides an excellent UI.
+
+#### Cons
+
+* It is an agent-less tool - every agent consumes up to 16MB ram - in some
+environments, it may be noticable amount.
+* It is agent-less - you have to verify your environment consistency
+'on-demand' - there is no built-in mechanism that would warn you about some
+change automatically (this can be achieved with reasonable effort)
+* Official GUI - Ansible Tower - is great but expensive.
+* There is no 'small enterprise' payment plan, however Ansible AWX is the free
+open source version we were all waiting for.
+
+#### Neutral
+
+Migration - Ansible <-> Salt is fairly easy - so if you would need an
+event-driven agent environment - it would be a good choice to start quick with
+Ansible, and convert to Salt when needed.
+
+#### Some concepts
+
+Ansible uses ssh or paramiko as a transport layer. In a way you can imagine
+that you are using a ssh with API to perform your action. The simplest way is
+to execute remote command in more controlled way (still using ssh).
+On the other hand - in advanced scope - you can wrap Ansible (use python Ansible
+code as a library) with your own Python scripts! It would act a
+bit like Fabric then.
+
+## Example
+
+An example playbook to install apache and configure log level
+
+```yaml
+---
+- hosts: apache
+
+  vars:
+      apache2_log_level: "warn"
+
+  handlers:
+  - name: restart apache
+    service:
+      name: apache2
+      state: restarted
+      enabled: True
+    notify:
+      - Wait for instances to listen on port 80
+    become: True
+
+  - name: reload apache
+    service:
+      name: apache2
+      state: reloaded
+    notify:
+      - Wait for instances to listen on port 80
+    become: True
+
+  - name: Wait for instances to listen on port 80
+    wait_for:
+      state: started
+      host: localhost
+      port: 80
+      timeout: 15
+      delay: 5
+
+  tasks:
+  - name: Update cache
+    apt:
+      update_cache: yes
+      cache_valid_time: 7200
+    become: True
+
+  - name: Install packages
+    apt:
+      name={{ item }}
+    with_items:
+      - apache2
+      - logrotate
+    notify:
+      - restart apache
+    become: True
+
+  - name: Configure apache2 log level
+    lineinfile:
+      dest: /etc/apache2/apache2.conf
+      line: "LogLevel {{ apache2_log_level }}"
+      regexp: "^LogLevel"
+    notify:
+      - reload apache
+    become: True
+...
+```
+
+## Installation
+
+```bash
+# Universal way
+$ pip install ansible
+
+# Debian, Ubuntu
+$ apt-get install ansible
+```
+
+* [Appendix A - How do I install ansible](#infrastructure-as-a-code)
+* [Additional Reading.](http://docs.ansible.com/ansible/latest/intro_installation.html)
+
+### Your first ansible command (shell execution)
+
+```bash
+# Command pings localhost (defined in default inventory: /etc/ansible/hosts)
+$ ansible -m ping localhost
+# You should see this output
+localhost | SUCCESS => {
+    "changed": false,
+    "ping": "pong"
+}
+```
+
+### Shell Commands
+
+There are few commands you should know about
+
+* `ansible` (to run modules in CLI)
+* `ansible-playbook` (to run playbooks)
+* `ansible-vault` (to manage secrets)
+* `ansible-galaxy` (to install roles from github/galaxy)
+
+### Module
+
+A program (usually python) that executes, does some work and returns proper
+JSON output. This program performs specialized task/action (like manage
+instances in the cloud, execute shell command). The simplest module is called
+`ping` - it just returns a JSON with `pong` message.
+
+Example of modules:
+
+* Module: `ping` - the simplest module that is useful to verify host connectivity
+* Module: `shell` - a module that executes shell command on a specified host(s).
+
+
+```bash
+$ ansible -m ping all
+$ ansible -m shell -a 'date; whoami' localhost #hostname_or_a_group_name
+```
+
+* Module: `command` - executes a single command that will not be processed
+through the shell, so variables like `$HOME` or operands like ``|` `;`` will not
+work. The command module is more secure, because it will not be affected by the
+user’s environment. For more complex commands - use shell module.
+
+```bash
+$ ansible -m command -a 'date; whoami' # FAILURE
+$ ansible -m command -a 'date' all
+$ ansible -m command -a 'whoami' all
+```
+
+* Module: `file` - performs file operations (stat, link, dir, ...)
+* Module: `raw` - executes a low-down and dirty SSH command, not going through
+the module subsystem (useful to install python2.7)
+
+### Task
+
+Execution of a single Ansible **module** is called a **task**. The simplest
+module is called `ping` as you could see above.
+
+Another example of the module that allow you to execute command remotly on
+multiple resources is called `shell`. See above how you were using them already.
+
+### Playbook
+
+**Execution plan** written in a form of script file(s) is called **playbook**.
+Playbook consist of multiple elements -
+* a list (or group) of hosts that 'the play' is executed against
+* `task(s)` or `role(s)` that are going to be executed
+* multiple optional settings (like default variables, and way more)
+
+Playbook script language is YAML. You can think that playbook is very advanced
+CLI script that you are executing.
+
+#### Example of the playbook
+
+This example-playbook would execute (on all hosts defined in inventory) two tasks:
+* `ping` that would return message *pong*
+* `shell` that execute three commands and return the output to our terminal
+
+```yaml
+- hosts: all
+
+  tasks:
+    - name: "ping all"
+      ping:
+
+    - name: "execute a shell command"
+      shell: "date; whoami; df -h;"
+```
+
+Run the playbook with the command:
+
+```bash
+$ ansible-playbook path/name_of_the_playbook.yml
+```
+
+Note: Example playbook is explained in the next chapter: 'Roles'
+
+### More on ansible concept
+
+### Inventory
+
+Inventory is a set of objects or hosts, against which we are executing our
+playbooks or single tasks via shell commands. For these few minutes, let's
+assume that we are using the default ansible inventory (which in Debian based
+system is placed in `/etc/ansible/hosts`).
+
+```
+localhost
+
+[some_group]
+hostA.mydomain.com
+hostB.localdomain
+1.2.3.4
+
+[a_group_of_a_groups:children]
+some_group
+some_other_group
+```
+
+* [Additional Reading.](http://docs.ansible.com/ansible/latest/intro_inventory.html)
+
+### ansible-roles (a 'template-playbooks' with right structure)
+
+You already know that the tasks (modules) can be run via CLI. You also know the
+playbooks - the execution plans of multiple tasks (with variables and logic).
+
+A concept called `role` was introduced for parts of the code (playbooks) that
+should be reusable.
+
+**Role** is a structured way to manage your set of tasks, variables, handlers,
+default settings, and way more (meta, files, templates). Roles allow reusing
+the same parts of code in multiple playbooks (you can parametrize the role
+'further' during its execution). Its a great way to introduce `object oriented`
+management for your applications.
+
+Role can be included in your playbook (executed via your playbook).
+
+
+```yaml
+- hosts: all
+
+  tasks:
+      - name: "ping all"
+        ping:
+      - name: "execute a shell command"
+        shell: "date; whoami; df -h;"
+
+  roles:
+      - some_role
+      - { role: another_role, some_variable: 'learnxiny', tags: ['my_tag'] }
+
+  pre_tasks:
+      - name: some pre-task
+        shell: echo 'this task is the last, but would be executed before roles, and before tasks'
+```
+
+#### For remaining examples we would use additional repository
+This example install ansible in `virtualenv` so it is independend from a system.
+You need to initialize it into your shell-context with `source environment.sh`
+command.
+
+We are going to use this repository with examples: [https://github.com/sirkubax/ansible-for-learnXinYminutes]()
+
+```bash
+$ # The following example contains a shell-prompt to indicate the venv and relative path
+$ git clone git@github.com:sirkubax/ansible-for-learnXinYminutes.git
+user@host:~/$ cd ansible-for-learnXinYminutes
+user@host:~/ansible-for-learnXinYminutes$ source environment.sh
+$
+$ # First lets execute the simple_playbook.yml
+(venv) user@host:~/ansible-for-learnXinYminutes$ ansible-playbook playbooks/simple_playbook.yml
+```
+
+Run the playbook with roles example
+
+```bash
+$ source environment.sh
+$ # Now we would run the above playbook with roles
+(venv) user@host:~/ansible-for-learnXinYminutes$ ansible-playbook playbooks/simple_role.yml
+```
+
+#### Role directory structure
+
+```
+roles/
+   some_role/
+     defaults/      # contains default variables
+     files/         # for static files
+     templates/     # for jinja templates
+     tasks/         # tasks
+     handlers/      # handlers
+     vars/          # more variables (higher priority)
+     meta/          # meta - package (role) info
+```
+
+#### Role Handlers
+Handlers are tasks that can be triggered (notified) during execution of a
+playbook, but they execute at the very end of a playbook. It is the best way to
+restart a service, check if the application port is active (successful
+deployment criteria), etc.
+
+Get familiar with how you can use roles in the simple_apache_role example
+
+```
+playbooks/roles/simple_apache_role/
+├── tasks
+│   └── main.yml
+└── templates
+    └── main.yml
+```
+
+### ansible - variables
+
+Ansible is flexible - it has 21 levels of variable precedence.
+[read more](http://docs.ansible.com/ansible/latest/playbooks_variables.html#variable-precedence-where-should-i-put-a-variable)
+For now you should know that CLI variables have the top priority.
+You should also know, that a nice way to pool some data is a **lookup**
+
+### Lookups
+Awesome tool to query data from various sources!!! Awesome!
+query from:
+* pipe  (load shell command output into variable!)
+* file
+* stream
+* etcd
+* password management tools
+* url
+
+```bash
+# read playbooks/lookup.yml
+# then run
+(venv) user@host:~/ansible-for-learnXinYminutes$ ansible-playbook playbooks/lookup.yml
+```
+
+You can use them in CLI too
+
+```yaml
+ansible -m shell -a 'echo "{{ my_variable }}"' -e 'my_variable="{{ lookup("pipe", "date") }}"' localhost
+ansible -m shell -a 'echo "{{ my_variable }}"' -e 'my_variable="{{ lookup("pipe", "hostname") }}"' all
+
+# Or use in playbook
+
+(venv) user@host:~/ansible-for-learnXinYminutes$ ansible-playbook playbooks/lookup.yml
+```
+
+### Register and Conditional
+
+#### Register
+
+Another way to dynamically generate the variable content is the `register` command.
+`Register` is also useful to store an output of a task and use its value
+for executing further tasks.
+
+```
+(venv) user@host:~/ansible-for-learnXinYminutes$ ansible-playbook playbooks/register_and_when.yml
+```
+
+```yaml
+---
+- hosts: localhost
+  tasks:
+   - name: check the system capacity
+     shell: df -h /
+     register: root_size
+
+   - name: debug root_size
+     debug:
+        msg: "{{ root_size }}"
+
+   - name: debug root_size return code
+     debug:
+       msg:  "{{ root_size.rc }}"
+
+# when: example
+
+   - name: Print this message when return code of 'check the system capacity' was ok
+     debug:
+       msg:  "{{ root_size.rc }}"
+     when: root_size.rc == 0
+...
+```
+
+#### Conditionals - when:
+
+You can define complex logic with Ansible and Jinja functions. Most common is
+usage of `when:`, with some variable (often dynamically generated in previous
+playbook steps with `register` or `lookup`)
+
+```yaml
+---
+- hosts: localhost
+  tasks:
+   - name: check the system capacity
+     shell: df -h /
+     when: some_variable in 'a string'
+  roles:
+   - { role: mid_nagios_probe, when: allow_nagios_probes }
+...
+```
+
+### ansible - tags, limit
+
+You should know about a way to increase efficiency by this simple functionality
+
+#### TAGS
+
+You can tag a task, role (and its tasks), include, etc, and then run only the
+tagged resources
+
+```
+ansible-playbook playbooks/simple_playbook.yml --tags=tagA,tag_other
+ansible-playbook playbooks/simple_playbook.yml -t tagA,tag_other
+
+There are special tags:
+    always
+
+--skip-tags can be used to exclude a block of code
+--list-tags to list available tags
+```
+
+[Read more](http://docs.ansible.com/ansible/latest/playbooks_tags.html)
+
+#### LIMIT
+
+You can limit an execution of your tasks to defined hosts
+
+```
+ansible-playbook playbooks/simple_playbook.yml --limit localhost
+
+--limit my_hostname
+--limit groupname
+--limit some_prefix*
+--limit hostname:group #JM
+```
+
+### Templates
+
+Templates are a powerful way to deliver some (partially) dynamic content.
+Ansible uses **Jinja2** language to describe the template.
+
+```
+Some static content
+
+{{ a_variable }}
+
+{% for item in loop_items %}
+    this line item is {{ item }}
+{% endfor %}
+```
+
+Jinja may have some limitations, but it is a powerful tool that you might like.
+
+Please examine this simple example that installs apache2 and generates
+index.html from the template
+"playbooks/roles/simple_apache_role/templates/index.html"
+
+```bash
+$ source environment.sh
+$ # Now we would run the above playbook with roles
+(venv) user@host:~/ansible-for-learnXinYminutes$ ansible-playbook playbooks/simple_role.yml --tags apache2
+```
+
+#### Jinja2 CLI
+
+You can use the jinja in the CLI too
+
+```bash
+ansible -m shell -a 'echo {{ my_variable }}` -e 'my_variable=something, playbook_parameter=twentytwo" localhost
+```
+
+In fact - jinja is used to template parts of the playbooks too
+
+```yaml
+# check part of this playbook: playbooks/roles/sys_debug/tasks/debug_time.yml
+- local_action: shell date +'%F %T'
+  register: ts
+  become: False
+  changed_when: False
+
+- name: Timestamp
+  debug: msg="{{ ts.stdout }}"
+  when: ts is defined and ts.stdout is defined
+  become: False
+```
+
+#### Jinja2 filters
+
+Jinja is powerful. It has many built-in useful functions.
+
+```
+# get first item of the list
+{{ some_list | first() }}
+# if variable is undefined - use default value
+{{ some_variable | default('default_value') }}
+```
+
+[Read More](http://docs.ansible.com/ansible/latest/playbooks_filters.html)
+
+### ansible-vault
+
+To maintain **infrastructure as code** you need to store secrets. Ansible
+provides a way to encrypt confidential files so you can store them in the
+repository, yet the files are decrypted on-the-fly during ansible execution.
+
+The best way to use it is to store the secret in some secure location, and
+configure ansible to use during runtime.
+
+```bash
+# Try (this would fail)
+$ ansible-playbook playbooks/vault_example.yml
+
+$ echo some_very_very_long_secret > ~/.ssh/secure_located_file
+
+# in ansible.cfg set the path to your secret file
+$ vi ansible.cfg
+  ansible_vault_password_file = ~/.ssh/secure_located_file
+
+#or use env
+$ export ANSIBLE_VAULT_PASSWORD_FILE=~/.ssh/secure_located_file
+
+$ ansible-playbook playbooks/vault_example.yml
+
+  # encrypt the file
+$ ansible-vault encrypt path/somefile
+
+  # view the file
+$ ansible-vault view path/somefile
+
+  # check the file content:
+$ cat path/somefile
+
+  # decrypt the file
+$ ansible-vault decrypt path/somefile
+```
+
+### dynamic inventory
+
+You might like to know, that you can build your inventory dynamically.
+(For Ansible) inventory is just JSON with proper structure - if you can
+deliver that to ansible - anything is possible.
+
+You do not need to reinvent the wheel - there are plenty of ready to use
+inventory scripts for most popular Cloud providers and a lot of in-house
+popular usecases.
+
+[AWS example](http://docs.ansible.com/ansible/latest/intro_dynamic_inventory.html#example-aws-ec2-external-inventory-script)
+
+```bash
+$ etc/inv/ec2.py --refresh
+$ ansible -m ping all -i etc/inv/ec2.py
+```
+
+[Read more](http://docs.ansible.com/ansible/latest/intro_dynamic_inventory.html)
+
+### ansible profiling - callback
+
+Playbook execution takes some time. It is OK. First make it run, then you may
+like to speed things up. Since ansible 2.x there is built-in callback for task
+execution profiling.
+
+```
+vi ansible.cfg
+# set this to:
+callback_whitelist = profile_tasks
+```
+
+### facts-cache and ansible-cmdb
+
+You can pull some information about your environment from another hosts.
+If the information does not change - you may consider using a facts_cache
+to speed things up.
+
+```
+vi ansible.cfg
+
+# if set to a persistent type (not 'memory', for example 'redis') fact values
+# from previous runs in Ansible will be stored.  This may be useful when
+# wanting to use, for example, IP information from one group of servers
+# without having to talk to them in the same playbook run to get their
+# current IP information.
+fact_caching = jsonfile
+fact_caching_connection = ~/facts_cache
+fact_caching_timeout = 86400
+```
+
+I like to use `jsonfile` as my backend. It allows to use another project
+`ansible-cmdb` [(project on github)](https://github.com/fboender/ansible-cmdb) that generates a HTML page of your inventory
+resources. A nice 'free' addition!
+
+### Debugging ansible [chapter in progress]
+
+When your job fails - it is good to be effective with debugging.
+
+1. Increase verbosity by using multiple -v **[ -vvvvv]**
+2. If variable is undefined -
+`grep -R path_of_your_inventory -e missing_variable`
+3. If variable (dictionary or a list) is undefined -
+`grep -R path_of_your_inventory -e missing_variable`
+4. Jinja template debug
+5. Strange behaviour - try to run the code 'at the destination'
+
+### Infrastructure as code
+
+You already know, that ansible-vault allows you to store your confidential data
+along with your code. You can go further - and define your
+ansible installation and configuration as code.
+See `environment.sh` to learn how to install the ansible itself inside a
+`virtualenv` that is not attached to your operating system (can be changed by
+non-privileged user), and as additional benefit - upgrading version of ansible
+is as easy as installing new version in new virtualenv. What is more, you can
+have multiple versions of Ansible present at the same time.
+
+```bash
+# recreate ansible 2.x venv
+$ rm -rf venv2
+$ source environment2.sh
+
+# execute playbook
+(venv2)$ ansible-playbook playbooks/ansible1.9_playbook.yml # would fail - deprecated syntax
+
+# now lets install ansible 1.9.x next to ansible 2.x
+(venv2)$ deactivate
+$ source environment.1.9.sh
+
+# execute playbook
+(venv1.9)$ ansible-playbook playbooks/ansible1.9_playbook.yml # works!
+
+# please note that you have both venv1.9 and venv2 present - you need to (de)activate one - that is all
+```
+
+#### become-user, become
+
+In Ansible - to become `sudo` - use the `become` parameter. Use `become_user`
+to specify the username.
+
+```
+- name: Ensure the httpd service is running
+  service:
+    name: httpd
+    state: started
+  become: true
+```
+
+Note: You may like to execute Ansible with `--ask-sudo-pass` or add the user to
+sudoers file in order to allow non-supervised execution if you require 'admin'
+privilages.
+
+[Read more](http://docs.ansible.com/ansible/latest/become.html)
+
+## Tips and tricks
+
+#### --check -C
+
+Always make sure that your playbook can execute in 'dry run' mode (--check),
+and its execution is not declaring 'Changed' objects.
+
+#### --diff -D
+
+Diff is useful to see nice detail of the files changed.
+It compare 'in memory' the files like `diff -BbruN fileA fileB`.
+
+
+#### Execute hosts with 'regex'
+
+```bash
+ansible -m ping web*
+```
+
+#### Host groups can be joined, negated, etc
+
+```bash
+ansible -m ping web*:!backend:monitoring:&allow_change
+```
+
+#### Tagging
+
+You should tag some (not all) objects - a task in a playbook, all tasks
+included form a role, etc. It allows you to execute the chosen parts of the
+playbook.
+
+#### no_logs: True
+
+You may see, that some roles print a lot of output in verbose mode. There is
+also a debug module. This is the place where credentials may leak. Use `no_log`
+to hide the output.
+
+#### Debug module
+
+allows to print a value to the screen - use it!
+
+#### Register the output of a task
+
+You can register the output (stdout), rc (return code), stderr of a task with
+the `register` command.
+
+#### Conditionals: when:
+
+#### Loop: with, with\_items, with\_dict, with\_together
+
+[Read more](http://docs.ansible.com/ansible/latest/playbooks_conditionals.html)
+
+## Additional Resources
+
+* [Servers For Hackers: An Ansible Tutorial](https://serversforhackers.com/c/an-ansible-tutorial)
+* [A system administrator's guide to getting started with Ansible - FAST!](https://www.redhat.com/en/blog/system-administrators-guide-getting-started-ansible-fast)
+* [Ansible Tower](https://www.ansible.com/products/tower) - Ansible Tower provides a web UI, dashboard and rest interface to ansible.
+* [Ansible AWX](https://github.com/ansible/awx) - The Open Source version of Ansible Tower.
diff --git a/ar-ar/python3-ar.html.markdown b/ar-ar/python3-ar.html.markdown
new file mode 100644
index 00000000..e1a12690
--- /dev/null
+++ b/ar-ar/python3-ar.html.markdown
@@ -0,0 +1,1019 @@
+---
+language: python3
+contributors:
+    - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
+    - ["evuez", "http://github.com/evuez"]
+    - ["Rommel Martinez", "https://ebzzry.io"]
+    - ["Roberto Fernandez Diaz", "https://github.com/robertofd1995"]
+translators:
+    - ["Ahmad Hegazy", "https://github.com/ahegazy"]
+lang: ar-ar
+filename: learnpython3-ar.py
+---
+
+لقد أُنشئت لغة البايثون بواسطة جايدو ڤان روسم في بداية التسعينات. هي الأن أحد أشهر اللغات الموجودة. 
+لقد أحببت لغة البايثون بسبب وضوحها. هي في الأساس عبارة عن سودوكود قابل للتنفيذ.
+
+ردود أفعالكم عن المقال مُقدرة بشدة. يمكنكم التواصل مع الكاتب الاساسي من خلال [@louiedinh](http://twitter.com/louiedinh) أو louiedinh [at] [google's email service]
+
+ملحوظة: هذا المقال يُطبق على بايثون 3 فقط. راجع المقال [هنا](http://learnxinyminutes.com/docs/python/) إذا أردت تعلم لغة البايثون نسخة 2.7 الأقدم
+
+```python
+
+# تعليق من سطر واحد يبدأ برمز الرقم.
+
+""" يمكن كتابة تعليق يتكون من أكثر من سطر
+    باستخدام ثلاثة علامات "
+    ، وعادة يُستخدم في كتابة التوثيقات.
+"""
+
+####################################################
+## 1. أنواع البيانات البدائية والعمليات
+####################################################
+
+# لديك أرقام
+3  # => 3
+
+# العمليات الحسابية هي ما تتوقعه
+1 + 1   # => 2
+8 - 1   # => 7
+10 * 2  # => 20
+35 / 5  # => 7.0
+
+# نتائج قسمة الأرقام الصحيحية تُقرب للأصغر سواءًا كانت الأرقام موجبة أو سالبة.
+5 // 3       # => 1
+5.0 // 3.0   # => 1.0 # يعمل في حالة الكسور أيضا
+-5 // 3      # => -2
+-5.0 // 3.0  # => -2.0
+
+# ناتج القسمة هو دائما كسر
+10.0 / 3  # => 3.3333333333333335
+
+# عملية باقي القسمة
+7 % 3  # => 1
+
+# الأُس  (س ** ص، رفع س لقوى ص)
+2**3  # => 8
+
+# أفرض ترتيب العمليات الحسابية بالأقواس
+(1 + 3) * 2  # => 8
+
+# القيم الثنائية هي المعروفة عموما (ﻻحظ: تكبير أول حرف)
+True
+False
+
+# أنفي بـ (not)
+not True   # => False
+not False  # => True
+
+# العمليات على القيم الثنائية
+# ﻻحظ ﻻيهم حالة الحرف (كبير أو صغير) في "and" و "or"
+True and False  # => False
+False or True   # => True
+
+# True و False هما في الواقع 1 و 0 لكن بمسميات مختلفة
+True + True # => 2
+True * 8    # => 8
+False - 5   # => -5
+
+# عمليات المقارنة تنظر الي القيمة الرقمية لل True وال False
+0 == False  # => True
+1 == True   # => True
+2 == True   # => False
+-5 != False # => True
+
+# عند استخدام المنطق الثنائي على القيم الصحيحة يتم تحويلهم الي قيم ثنائية لإجرات العمليات عليهم، لكن قيمهم الأصلية تعود
+# ﻻ تخلط بين bool(قيمة صحيحة) و العمليات المنطقية الثناية and/or (&,|)
+bool(0)     # => False
+bool(4)     # => True
+bool(-6)    # => True
+0 and 2     # => 0
+-5 or 0     # => -5
+
+# مقارنة التساوي ب ==
+1 == 1  # => True
+2 == 1  # => False
+
+# مقارنة الاختلاف ب !=
+1 != 1  # => False
+2 != 1  # => True
+
+# مقارنات أخرى
+1 < 10  # => True
+1 > 10  # => False
+2 <= 2  # => True
+2 >= 2  # => True
+
+# لمعرفة هل القيمة في نطاق معين 
+1 < 2 and 2 < 3  # => True
+2 < 3 and 3 < 2  # => False
+
+# التسلسل يجعلها تبدو أجمل
+1 < 2 < 3  # => True
+2 < 3 < 2  # => False
+
+# (is مقابل ==) is تتحق من أن المتغيرين يشيران إلي نفس العنصر,
+# لكن == تتحقق من أن العنصرين المُشار اليهما بالمتغيرين لهما نفس القيمة.
+a = [1, 2, 3, 4]  # اجعل a تشير إلي قائمة جديدة, [1, 2, 3, 4]
+b = a             # اجعل a تُشير الي ما تُشير إليه b
+b is a            # => True, a و b يُشيران إلي نفس العنصر
+b == a            # => True, قيمة عنصر a و b متساوية
+b = [1, 2, 3, 4]  # اجعل b تشير الي قائمة جديدة , [1, 2, 3, 4]
+b is a            # => False, a و b do ﻻ يشيران إلي نفس العنصر
+b == a            # => True,  قيمة عنصر a و b متساوية
+
+# يمكنك إنشاء الكلمات (تسلسلات الحروف) عن طريق " أو '
+"This is a string."
+'This is also a string.'
+
+# يمكنك جمع هذا النوع أيضا! لكن حاول ألا تفعل هذا.
+"Hello " + "world!"  # => "Hello world!"
+# يمكنك الربط بين الكلمات بدون استخدام '+' (لكن ليس المتغيرات)
+"Hello " "world!"    # => "Hello world!"
+
+# يمكنك معاملة الكلمات كقائمة من الحروف
+"This is a string"[0]  # => 'T'
+
+# يمكنك معرفة طول الكلمة
+len("This is a string")  # => 16
+
+# .format يمكنك استخدامها لبناء الجمل بشكل معين, مثل هذا:
+"{} can be {}".format("Strings", "interpolated")  # => "Strings can be interpolated"
+
+# يمكنك تكرار معاملات بناء الجملة لتقليل الكتابة.
+"{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick")
+# => "Jack be nimble, Jack be quick, Jack jump over the candle stick"
+
+# يمكنك استخدام الكلمات المفتاحية إذا لم تُرد العد.
+"{name} wants to eat {food}".format(name="Bob", food="lasagna")  # => "Bob wants to eat lasagna"
+
+# إذا كان كود بايثون 3 الخاص بك يحتاج لبايثون 2.5 أو نسخة أقدم
+# يمكنك استخدام أسلوب بناء الجمل القديم:
+"%s can be %s the %s way" % ("Strings", "interpolated", "old")  # => "Strings can be interpolated the old way"
+
+# يمكنك أبضا بناء الجمل باستخدام f-strings أو حروف بناء الجمل (في بايثون 3.6 فما فوق)
+name = "Reiko"
+f"She said her name is {name}." # => "She said her name is Reiko"
+# يمكنك ببساطة وضع أي كود بايثون داخل أقواس وستقوم بإخراج الجملة.
+f"{name} is {len(name)} characters long."
+
+
+# None عبارة عن كائن
+None  # => None
+
+# ﻻ تستخدم رمز المساواة "==" لمقارنة العناصر ب None
+# استخدم is بدلا منه. يقوم بالتحقق من مساواة هوية العنصر
+"etc" is None  # => False
+None is None   # => True
+
+# None, 0, قوائم/جمل/قواميس/صفوف فارغة كلها تُترجم إلي False.
+# كل القيم الأخرى True.
+bool(0)   # => False
+bool("")  # => False
+bool([])  # => False
+bool({})  # => False
+bool(())  # => False
+
+####################################################
+## 2. المتغيرات والمجموعات
+####################################################
+
+# بايثون لديها دالة عرض "print"
+print("I'm Python. Nice to meet you!")  # => I'm Python. Nice to meet you!
+
+# الافتراضي دالة print تطبع سطر جديد في النهاية.
+# استخدم المعامل end لتغيير أخر الجملة المعروضة.
+print("Hello, World", end="!")  # => Hello, World!
+
+# طريقة بسيطة لطلب مدخل من الطرفية
+input_string_var = input("Enter some data: ") # يقوم بإعادة البيانات ك "string"
+# لاحظ: في النسخ القديمة من بايثون، دالة input() كان اسمها raw_input()
+
+# ﻻ يوجد تعريفات للمتغيرات، يتم تعيين قيمة المتغير مباشرة.
+# العٌرف تسمية المتغيرات حروف_صغيرة_مع_خطوط_سُفلية
+some_var = 5
+some_var  # => 5
+
+# محاولة استخدام متغير غير مُعين يعتبر خطأ
+# إقرأ جزء 3.مسار التحكم لمعرفة المزيد عن التحكم في الأخطاء
+some_unknown_var  # يعرض خطأ NameError
+
+# يمكن استخدام if كتعبير واحد
+# مساوِ للتعبير الأتي في لغة السي '?:' عملية ثلاثية
+"yahoo!" if 3 > 2 else 2  # => "yahoo!"
+
+# القوائم تحفظ المتسلسلات
+li = []
+# يمكنك البدأ بقائمة مليئة
+other_li = [4, 5, 6]
+
+# إضافة بيانات لأخر القائمة عن طريق append
+li.append(1)    # li is now [1]
+li.append(2)    # li is now [1, 2]
+li.append(4)    # li is now [1, 2, 4]
+li.append(3)    # li is now [1, 2, 4, 3]
+# حذف أخر عنصر في القائمة عن طريق pop
+li.pop()        # => 3 and li is now [1, 2, 4]
+# هيا نعيده ثانية
+li.append(3)    # li is now [1, 2, 4, 3] again.
+
+# يمكنك الوصول لعناصر القائمة كما تفعل في ال array
+# Access a list like you would any array
+li[0]   # => 1
+# للوصول لأخر عنصر
+li[-1]  # => 3
+
+# محاولة الوصول لعنصر خارج نطاق القائمة يعتبر خطأ: IndexError
+li[4]  # يعرض خطأ IndexError
+
+# يمكنك النظر للنطاقات باستخدام تركيب التقطيع
+# مؤشر/رقم/فهرس البداية مُضمن، مؤشر النهاية ﻻ
+# (لمحبي الرياضيات هو نطاق مفتوح/مغلق)
+li[1:3]   # => [2, 4]
+# إحذف أول عنصر ثم إعرض القائمة
+li[2:]    # => [4, 3]
+# إحذف أخر عنصر ثم إعرض القائمة
+li[:3]    # => [1, 2, 4]
+# حدد عنصر ثم إحذف الذي يليه ثم حدد عنصر وهكذا
+li[::2]   # =>[1, 4]
+# اعرض نسخة معكوسة من القائمة
+li[::-1]  # => [3, 4, 2, 1]
+# إستخدم أي تجميعة من الطرق المذكورة لعمل تقطيعات متقدمة
+# li[start:end:step]
+
+# عمل نسخة من طبقة واحدة باستخدم التقطيع
+li2 = li[:]  # => li2 = [1, 2, 4, 3] لكن عند عمل(li2 is li) سينتج False.
+
+# إمسح أي عنصر من القائمة باستخدام "del"
+del li[2]  # li is now [1, 2, 3]
+
+# إمسح أول ظهور لقيمة.
+li.remove(2)  # li is now [1, 3]
+li.remove(2)  # يعرض خطأ ValueError لأن 2 غير موجود في القائمة
+
+# أضف عنصر في خانة معينة
+li.insert(1, 2)  # li is now [1, 2, 3] مرة أخرى
+
+# أحصل على مؤشر/رقم لأول ظهور للقيمة
+li.index(2)  # => 1
+li.index(4)  # يعرض خطأ ValueError لأن 4 غير موجودة في القائمة
+
+# يمكنك جمع قوائم
+# لاحظ: لا يتم تعديل قيمة li و other_li
+li + other_li  # => [1, 2, 3, 4, 5, 6]
+
+# إستخدم دالة "extend()" لربط القوائم
+li.extend(other_li)  # Now li is [1, 2, 3, 4, 5, 6]
+
+# راجع وجود قيمة في القائمة باستخدام "in"
+1 in li  # => True
+
+# إحصل على طول القائمة باستخدام دالة "len()"
+len(li)  # => 6
+
+
+# الصفوف تشبه القوائم لكنها غير قابلة للتغيير.
+tup = (1, 2, 3)
+tup[0]      # => 1
+tup[0] = 3  # يعرض خطأ TypeError
+
+# لاحظ أن صف طوله عنصر واحد يحتاج لإضافة فاصلة "," بعد أخر عنصر
+# لكن الصفوف من أي طول أخر، حتى صفر لا تحتاج.
+type((1))   # => <class 'int'>
+type((1,))  # => <class 'tuple'>
+type(())    # => <class 'tuple'>
+
+# يمكنك عمل معظم عمليات القوائم على الصفوف.
+len(tup)         # => 3
+tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
+tup[:2]          # => (1, 2)
+2 in tup         # => True
+
+# يمكنك تفريغ الصفوف (أو القوائم) في متغيرات
+a, b, c = (1, 2, 3)  # a is now 1, b is now 2 and c is now 3
+# يمكنك أيضا عمل تفريغ واسع
+a, *b, c = (1, 2, 3, 4)  # a is now 1, b is now [2, 3] and c is now 4
+# الصفوف تُنشأ تلقائيا إذا تركت الأقواس
+d, e, f = 4, 5, 6  # تم توسعة الصف 4, 5 ,6 في المتغيرات d, e, f
+# بالترتيب حيث d = 4, e = 5 و f = 6
+# الأن إنظر إلي مدى سهولة التبديل بين قيم متغيرين
+e, d = d, e  # d is now 5 and e is now 4
+
+
+# القواميس تُخزن خرائط من المفتاح للقيمة
+empty_dict = {}
+# هذا قاموس مملوء
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# لاحظ أن القواميس يجب أن تكون أنواع غير قابلة للتغيير.
+# هذا للتأكد من أن المفتاح يمكن تحويله لقيمة ثابتة للوصول السريع.
+# الأنواع الغير قابلة للتغير تتضمن: الأرقام الصحيحة، الكسور، الكلمات، الصفوف.
+invalid_dict = {[1,2,3]: "123"}  # =>يعرض خطأ TypeError: unhashable type: 'list'
+valid_dict = {(1,2,3):[1,2,3]}   # القيم يمكن أن تكون من أي نوع.
+
+# يمكنك البحث عن قيمة باستخدام []
+filled_dict["one"]  # => 1
+
+# يمكنك الحصول على كل المفاتيح باستخدام "keys()".
+# نحتاج لإرسالها لدالة list() لتحويلها لقائمة. سنتعلم هذا لاحقًا
+# لاحظ - لنسخ بايثون قبل 3.7، ترتيب مفاتيح القاموس غير مضمون. نتائجك
+# يمكن ألا تساوي المثال بالأسفل. مع ذلك، من أول بايثون 3.7،
+# عناصر القاموس تحتفظ بالترتيب الذي تم إضافة المفاتيح به في القاموس.
+list(filled_dict.keys())  # => ["three", "two", "one"] in Python <3.7
+list(filled_dict.keys())  # => ["one", "two", "three"] in Python 3.7+
+
+# يمكنك الحصول على كل القيم باستخدام "values()".
+# مرة أخرى نستخدم list() للحصول عليها كقائمة.
+# نفس الكلام السابق بخصوص ترتيب المفاتيح
+list(filled_dict.values())  # => [3, 2, 1]  in Python <3.7
+list(filled_dict.values())  # => [1, 2, 3] in Python 3.7+
+
+# إفحص للتأكد من وجود مغتاح في القاموس باستخدام "in"
+"one" in filled_dict  # => True
+1 in filled_dict      # => False
+
+# البحث عن مفتاح غير موجود يعرض خطأ KeyError
+filled_dict["four"]  # KeyError
+
+# استخدم "get()" لتجنب الخطأ KeyError
+filled_dict.get("one")      # => 1
+filled_dict.get("four")     # => None
+# دالة get تدعم إدخال قيمة افتراضية عند عدم وجود البحث
+filled_dict.get("one", 4)   # => 1
+filled_dict.get("four", 4)  # => 4
+
+# "setdefault()" تقوم بإدخال قيمة جديدة في القاموس في حالة عدم وجود المفتاح فقط.
+filled_dict.setdefault("five", 5)  # filled_dict["five"] is set to 5
+filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5
+
+# إضافة عنصر للقاموس
+filled_dict.update({"four":4})  # => {"one": 1, "two": 2, "three": 3, "four": 4}
+filled_dict["four"] = 4         # طريقة أخرى للإضافة
+
+# مسح المفاتيح من القاموس باستخدام del
+del filled_dict["one"]  # Removes the key "one" from filled dict
+
+# من بايثون 3.5 فما فوق يمكنك أيضا استخدام خيارات تفريغ إضافية
+{'a': 1, **{'b': 2}}  # => {'a': 1, 'b': 2}
+{'a': 1, **{'a': 2}}  # => {'a': 2}
+
+
+# المجموعات تُخزن .. مجموعات
+empty_set = set()
+# .تهيئة مجموعة بمجموعة قيم. نعم، تشبه قليلا تهيئة القاموس. أسف
+some_set = {1, 1, 2, 2, 3, 4}  # some_set is now {1, 2, 3, 4}
+
+# مثل مفتاح القاموس، عناصر المجموعة يجب أن تكون غير قابلة للتغيير.
+invalid_set = {[1], 1}  # => يعرض خطأ TypeError: unhashable type: 'list'
+valid_set = {(1,), 1}
+
+# إضافة عنصر أخر للمجموعة
+filled_set = some_set
+filled_set.add(5)  # filled_set is now {1, 2, 3, 4, 5}
+# المجموعات لا يمكن أن تحتوي على عناصر مكررة
+filled_set.add(5)  # it remains as before {1, 2, 3, 4, 5}
+
+# تقاطع مجموعتين باستخدام &
+other_set = {3, 4, 5, 6}
+filled_set & other_set  # => {3, 4, 5}
+
+# اتحاد مجموعتين باستخدام | 
+filled_set | other_set  # => {1, 2, 3, 4, 5, 6}
+
+# الفرق بين مجموعتين باستخدام -
+{1, 2, 3, 4} - {2, 3, 5}  # => {1, 4}
+
+# الفروق بين مجموعتين باستخدام ^
+{1, 2, 3, 4} ^ {2, 3, 5}  # => {1, 4, 5}
+
+# لفحص هل المجموعة على اليسار مجموعة عُليا للمجموعة على اليمين (تحتوي على كل عناصرها)
+{1, 2} >= {1, 2, 3} # => False
+
+# لفحص هل المجموعة على اليسار مجموعة فرعية من المجموعة على اليمين
+{1, 2} <= {1, 2, 3} # => True
+
+# للتأكد من وجود عن في مجموعة استخدم in 
+2 in filled_set   # => True
+10 in filled_set  # => False
+
+
+
+####################################################
+## 3. مسار التحكم والعمليات التكرارية #Control Flow and Iterables
+####################################################
+
+# هيا ننشيء متغير
+some_var = 5
+
+# الأن الأمر if. الفجوات (المسافات قبل الأوامر) مهمة في البايثون!
+# العُرف استخدام أربع مسافات. ليس تبويب.
+# هذا السطر البرمجي يطبع "some_var is smaller than 10"
+if some_var > 10:
+    print("some_var is totally bigger than 10.")
+elif some_var < 10:    # This elif clause is optional.
+    print("some_var is smaller than 10.")
+else:                  # This is optional too.
+    print("some_var is indeed 10.")
+
+
+"""
+For عبارة عن حلقات تدور حول عناصر قوائم 
+:ثم تطبع
+    dog is a mammal
+    cat is a mammal
+    mouse is a mammal
+"""
+for animal in ["dog", "cat", "mouse"]:
+    # يمكنك استخدام format() لترجمة كلمات بشكل معين.
+    print("{} is a mammal".format(animal))
+
+"""
+"range(number)" يقوم بإعادة مجموعة من الأرقام يمكن الدوران حولها
+من الصفر إلي رقم معين 
+ثم يطبع: 
+    0
+    1
+    2
+    3
+"""
+
+for i in range(4):
+    print(i)
+
+"""
+"range(lower, upper)" يقوم بإعادة مجموعة من الأرقام يمكن الدوران حولها من القيمة السُفلى
+lower حتى القيمة العُليا upper
+ثم يطبع:
+    4
+    5
+    6
+    7
+"""
+for i in range(4, 8):
+    print(i)
+
+"""
+"range(lower, upper, step)" يقوم بإعادة مجموعة من الأرقام يمكن الدوران حولها من القيمة السُفلى
+lower حتى القيمة العُليا upper، ثم يقوم بالزيادة قيمة الstep.
+إذا لم تُحدد ال step, القيمة الأفتراضية 1.
+ثم يطبع:
+    4
+    6
+"""
+for i in range(4, 8, 2):
+    print(i)
+
+"""
+While هي عبارة عن حلقات تدور حتى عدم تحقق شرط معين.
+وتطبع: 
+    0
+    1
+    2
+    3
+"""
+x = 0 for
+while x < 4:
+    print(x)
+    x += 1  # اختصار ل x = x + 1
+
+# يمكنك التحكم في الأخطاء والاستثناءات باستخدام مجموعة try/except 
+try:
+    # استخدم "raise" لرفع خطأ.
+    raise IndexError("This is an index error")
+except IndexError as e:
+    pass                 # Pass: هو مجرد أمر ﻻ تفعل شيء. عادة تقوم بتصحيح الخطأ هنا.
+except (TypeError, NameError):
+    pass                 # يمكنك التحكم في أكثر من خطأ في نفس الوقت، إذا أقتضت الضرورة
+else:                    # فقرة اختيارية في مجموعة try/except. يجب أن يتبع جميع مجموعات معارضة الأخطاء
+    print("All good!")   # تُنفذ في حالة أن السطور البرمجية داخل ال try لم ترفع أي خطأ
+finally:                 #  تُنفذ في كل الحالات
+    print("We can clean up resources here")
+
+# بدلا من مجموعة try/finally لتنظيف الموارد يمكنك استخدام سطر with 
+with open("myfile.txt") as f:
+    for line in f:
+        print(line)
+
+# يتيح البايثون تجريد أساسي يسمى المُكرَر.
+# المُكرٍَر عبارة عن متغير يمكن التعامل معه كسلسلة.
+# الكائن الذي يعود من دالة نطاق، يسمى المُكرَر.
+
+filled_dict = {"one": 1, "two": 2, "three": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable)  # => dict_keys(['one', 'two', 'three'])
+# هذا عبارة عن متغير يعرض عناصر مفاتيح المُكرَر.
+
+# يمكننا الدوران حوله.
+for i in our_iterable:
+    print(i)  # Prints one, two, three
+
+# مع ذلك ﻻ يمكننا الوصول للعناصر بالمؤشر.
+our_iterable[1]  # يرفع خطأ TypeError
+
+# المُكرَر هو عبارة عن عنصر يعلم كيفية إنشاء مُكرِر
+our_iterator = iter(our_iterable)
+
+# المُكرِر هو عبارة عن عنصر يمكنه تذكر الحالة أثناء مرورنا بعناصره.
+# يمكننا الحصول على العنصر التالي عن طريق "next()"
+next(our_iterator)  # => "one"
+
+# يحفظ الحالة أثناء الدوران.
+next(our_iterator)  # => "two"
+next(our_iterator)  # => "three"
+
+# بعد عرض المُكرِر كل عناصره، يرفع استثناء StopIteration
+next(our_iterator)  # يرفع StopIteration
+
+# يمكنك الحصول على كل عناصر المُكرر بمناداة دالة list() عليه.
+list(filled_dict.keys())  # => Returns ["one", "two", "three"]
+
+
+####################################################
+## 4. الدوال
+####################################################
+
+# إستخدم "def" لإنشاء دوال جديدة.
+def add(x, y):
+    print("x is {} and y is {}".format(x, y))
+    return x + y  # يمكنك إرجاع قيمة من الدالة بسطر return
+
+# مناداة دوال بمعطيات
+add(5, 6)  # => prints out "x is 5 and y is 6" and returns 11
+
+# طريقة أخرى لمناداة دوال باستخدام كلمات مفتاحية.
+add(y=6, x=5)  # الكلمة المفتاحية يمكن أن تُعطى بأي ترتيب.
+
+# يمكنك تعريف دوال تأخذ عدد متغير من المُعطيات
+
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3)  # => (1, 2, 3)
+
+# يمكنك تعريف دوال تأخذ عدد متغير من الكلمات المفتاحية كمعطيات أيضا.
+def keyword_args(**kwargs):
+    return kwargs
+
+# هيا ننادي على الدالة لنرى ماذا سيحدث 
+keyword_args(big="foot", loch="ness")  # => {"big": "foot", "loch": "ness"}
+
+
+# يمكنك فعل الأثنين معًا في نفس الوقت، إذا أردت
+def all_the_args(*args, **kwargs):
+    print(args)
+    print(kwargs)
+"""
+all_the_args(1, 2, a=3, b=4) prints:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# عندما تنادي على دوال، يمكنك عمل عكس المعطيات/المفاتيح!
+# استخدم * لتوسعة الصفوف، واستخدم ** لتوسعة المفاتيح.
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args)            # مساوٍ ل all_the_args(1, 2, 3, 4)
+all_the_args(**kwargs)         # مساوٍ ل to all_the_args(a=3, b=4)
+all_the_args(*args, **kwargs)  # مساوٍ ل to all_the_args(1, 2, 3, 4, a=3, b=4)
+
+# يقوم بإعادة مجموعة من القيم (بتعيين الصفوف)
+def swap(x, y):
+    return y, x  # يقوم بإعادة مجموعة من القيم على شكل صفوف بدون الأقواس
+                 # (لاحظ: الأقواس حُذفت لكن يمكن إضافتها)
+
+x = 1
+y = 2
+x, y = swap(x, y)     # => x = 2, y = 1
+# (x, y) = swap(x,y)  # مرة أخرى الأقواس حُذفت لكن يمكن إضافتها.
+
+# مجال الدالة
+x = 5
+
+def set_x(num):
+    # المتغير المحلي x ليس هو المتغير العام x
+    x = num    # => 43
+    print(x)   # => 43
+
+def set_global_x(num):
+    global x
+    print(x)   # => 5
+    x = num    #المتغير العام x الأن مساوٍ ل 6
+    print(x)   # => 6
+
+set_x(43)
+set_global_x(6)
+
+
+# بايثون تدعم دوال الفئة أولية [first class functions] (أي أنه يمكن إرسال الدوال كمعطيات لدوال أخرى)
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+add_10 = create_adder(10)
+add_10(3)   # => 13
+
+# يوجد أيضا دوال مجهولة
+(lambda x: x > 2)(3)                  # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
+
+# يوجد دوال مدمجة من درجة أعلى
+list(map(add_10, [1, 2, 3]))          # => [11, 12, 13]
+list(map(max, [1, 2, 3], [4, 2, 1]))  # => [4, 2, 3]
+
+list(filter(lambda x: x > 5, [3, 4, 5, 6, 7]))  # => [6, 7]
+
+# يمكن إشتمال القوائم على خرائط وفلاتر حسنة الشكل
+# هذه القوائم تحفظ المُخرج كقائمة والتي بدورها يمكن أن تكون قائمة مداخلة
+[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]
+
+# يمكنك بناء مجموعات وقواميس على هذا المنوال أيضا
+{x for x in 'abcddeef' if x not in 'abc'}  # => {'d', 'e', 'f'}
+{x: x**2 for x in range(5)}  # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
+
+
+####################################################
+## 5. الوحدات البرمجية (الموديولات)
+####################################################
+
+# يمكنك استدعاء موديولات
+import math
+print(math.sqrt(16))  # => 4.0
+
+# يمكنك استدعاء دالة معينة من موديول
+from math import ceil, floor
+print(ceil(3.7))   # => 4.0
+print(floor(3.7))  # => 3.0
+
+# يمكنك استدعاء كل الدوال من مديول.
+# تحذير: هذا الفعل غير موصى به
+from math import *
+
+# يمكنك تصغير اسم موديول
+import math as m
+math.sqrt(16) == m.sqrt(16)  # => True
+
+# موديولات البايثون عبارة عن ملفات بايثون عادية.
+# يمكنك كتابة الموديولات الخاصة بك, واستدعاها.
+# اسم الموديول يكون نفس اسم الملف.
+
+# يمكنك معرفة أي الدوال والصفات مُعرفة في الموديول.
+import math
+dir(math)
+
+# إذا كان لديك سكربت بايثون يسمى math.py
+# في نفس المجلد الموجود به السكربت الخاص بك، الملف الخاص بك math.py
+# سَيُستدعى بدلا من موديول البايثون بنفس الاسم
+# هذا يحدث لأن المجلدات المحلية لديها أولوية عن مكتبات البايثون المُدمجة
+
+
+####################################################
+## 6. الفئات/القوالب (الكلاسات)
+####################################################
+
+# نستخدم السطر البرمجي "class" لإنشاء قالب
+class Human:
+
+    # صفة القالب. مشتركة بين كل نسخ القالب
+    species = "H. sapiens"
+
+    # مُهيئ إبتدائي، يُنادى عليه عندما يتم استدعاء القالب.
+    # لاحظ أن الشرطة السٌفلية المُكررة مرتين __ قبل وبعد الاسم تُعبر عن الكائنات
+    # أو الصفات المُستخدمة عن طريق  بايثون لكنها تعيش في مساحة تحكم المُستخدم.
+    # العمليات -الدوال- (أو الكائنات أو الصفات) مثل: __init__, __str__,__repr__ ألخ.
+    # تُسمى عمليات خاصة (أو أحيانا تسمى عمليات سحرية أو dunder methods)
+    # يجب عليك ألا تُسمي مثل هذه الاسماء بنفسك.
+    def __init__(self, name):
+        # ساوِ المُعطى بالصفة name الخاصة بهذه النسخة من القالب.
+        self.name = name
+        
+        # هيئ الصفة
+        self._age = 0
+
+    # عملية/دالة خاصة بنسخة القالب. كل العمليات تأخذ "self" كأول مُعطى
+    # An instance method. All methods take "self" as the first argument
+    def say(self, msg):
+        print("{name}: {message}".format(name=self.name, message=msg))
+
+    # عملية أخرى خاصة بنسخة القالب.
+    def sing(self):
+        return 'yo... yo... microphone check... one two... one two...'
+
+    # عمليات القالب مشتركة بين كل أجزاء القالب
+    # يتم مناداتهم عن طريق جعل القالب المُنادي أول معطى
+    # They are called with the calling class as the first argument
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # تُنادى العملية الثابتة بدون قالب أو نسخة قالب
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+    # الخاصية تشبه تماما إمر الطلب
+    # تُحَوِل العملية age() إلي صفة مقروءة فقط بنفس الاسم.
+    # ﻻ حاجة لكتابة أوامر طلب أو تهيئة
+    @property
+    def age(self):
+        return self._age
+
+    # هذا يتيح تهيئة الخاصية 
+    @age.setter
+    def age(self, age):
+        self._age = age
+
+    # هذا يتيح حذف الخاصية
+    @age.deleter
+    def age(self):
+        del self._age
+
+
+# عندما يقرأ مُترجم البايثون ملف مصدري يقوم بتنفيذ كل الكود.
+# فحص ال __name__ يجعل هذا الجزء من الكود يُنَفَذ فقط 
+# في حالة أن هذا الموديول هو البرنامج الرئيسي
+if __name__ == '__main__':
+    # Instantiate a class
+    i = Human(name="Ian")
+    i.say("hi")                     # "Ian: hi"
+    j = Human("Joel")
+    j.say("hello")                  # "Joel: hello"
+    # i و j نُسخ من النوع Human, أول بكلمات أخرى: هما كائنات للقالب Human
+
+    # نادي على عملية القالب
+    i.say(i.get_species())          # "Ian: H. sapiens"
+    # عدل الخاصية المُشتركة
+    Human.species = "H. neanderthalensis"
+    i.say(i.get_species())          # => "Ian: H. neanderthalensis"
+    j.say(j.get_species())          # => "Joel: H. neanderthalensis"
+
+    # نادي على العملية الثابتة
+    print(Human.grunt())            # => "*grunt*"
+    
+    # لا يمكن مناداة العملية الثابتة من نسخة الكائن
+    # لأن i.grunt() سيقوم تلقائيا بوضع "self" (الكائن i) كمُعطى للعملية
+    print(i.grunt())                # => TypeError: grunt() takes 0 positional arguments but 1 was given
+                                    
+    # حدًث الخاصية لهذه النسخة
+    i.age = 42
+    # أحصل على الخاصية
+    i.say(i.age)                    # => "Ian: 42"
+    j.say(j.age)                    # => "Joel: 0"
+    # إحذف الخاصية
+    del i.age
+    # i.age                         # => سوف يرفع استثناء AttributeError
+
+
+####################################################
+## 6.1 الإرث
+####################################################
+
+# الإرث يتيح لقالب ابن أن يُعَرف ويرث بعض عمليات/دوال ومتغيرات القالب الأب.
+
+# باستخدام القالب Human المُعَرف بالأعلى كأساس أو كقالب أب،
+# يمكننا تعريف قالب ابن،Superhero ، يرث متغيرات القالب مثل "species", "name", و "age"، 
+# وأيضا العمليات، مثل "sing", "grunt"
+# من القالب Human، لكنه أيضا لديه خواصه الفريدة
+
+# للاستفادة من التقطيع بالملف يمكنك وضع القوالب بالأعلى في ملفاتهم الخاصة،
+# مثلا، human.py
+
+# لاستيراد دالة من ملف أخر استخدم الطريقة التالية
+# from "اسم الملف بدون مُلحق" import "اسم الدالة أو القالب"
+
+from human import Human
+
+# حدد القالب/ات الأب كمُعطى أثناء تعريف القالب.
+class Superhero(Human):
+
+    # إذا أردت أن يرث القالب الابن كل تعريفات القالب الأب بدون تعديل
+    # يمكنك استخدام الكلمة المفتاحية "pass" (بدون شيء أخر)
+    # لكن في هذه الحالة تم أهمالها لإنشاء قالب ابن فريد:
+    # pass
+
+    # القوالب الابن يمكنها تعديل صفات القوالب الأب
+    species = 'Superhuman'
+
+    # القوالب الابن ترث تلقائيا عمليات الإنشاء الخاصة بالقالب الأب بالإضافة إلي مُعطياتهم
+    # لكن يمكن أيضا تعريف مُعطيات إضافية أو تعريفات
+    # وتعديل العمليات مثل منشيء القالب.
+    # هذا المُنشيء يرث المُعطى "name" من القالب "Human" 
+    # ويضيف المعطيات"superpower" و "movies":
+    def __init__(self, name, movie=False,
+                 superpowers=["super strength", "bulletproofing"]):
+
+        # إضافة صفة جديدة للقالب
+        self.fictional = True
+        self.movie = movie
+        # كن على علم بالقيم الافتراضية المتغيرة، حيث أن القيم الافتراضية تُشارك
+        self.superpowers = superpowers
+
+        # الدالة "super" تتيح لك الوصول لعمليات القالب الأب
+        # التي تم تغييرها عن طريق الابن، في هذه الحالة، العملية __init__<
+        # هذا السطر يُنادي على منشيء القالب الأب.
+        super().__init__(name)
+
+    # تعديل العملية sing
+    def sing(self):
+        return 'Dun, dun, DUN!'
+
+    # إضافة عملية جديدة للنسخة
+    def boast(self):
+        for power in self.superpowers:
+            print("I wield the power of {pow}!".format(pow=power))
+
+
+if __name__ == '__main__':
+    sup = Superhero(name="Tick")
+
+    # فحص نوع النسخة
+    if isinstance(sup, Human):
+        print('I am human')
+    if type(sup) is Superhero:
+        print('I am a superhero')
+
+    # إحصل على ترتيب قرار البحث للعملية (Method Resolution search Order) المُستخدمة بواسطة العمليات getattr() و super()
+    # هذه الصفة ديناميكية ويمكن أن تُحَدًث.
+    print(Superhero.__mro__)    # => (<class '__main__.Superhero'>,
+                                # => <class 'human.Human'>, <class 'object'>)
+
+    # نادي العملية الأب لكن استخدم صفات القالب الخاص بها.
+    print(sup.get_species())    # => Superhuman
+
+    # نادي العملية المُعدلة.
+    print(sup.sing())           # => Dun, dun, DUN!
+
+    # نادي العملية من القالب Human
+    sup.say('Spoon')            # => Tick: Spoon
+
+    # نادي عملية موجودة فقط في Superhero
+    sup.boast()                 # => I wield the power of super strength!
+                                # => I wield the power of bulletproofing!
+
+    # وَرَثَ صفات القالب
+    sup.age = 31
+    print(sup.age)              # => 31
+
+    # صفة موجودة فقط في القالب Superhero
+    print('Am I Oscar eligible? ' + str(sup.movie))
+
+####################################################
+## 6.2 الإرث المُتعدد
+####################################################
+
+# تعريف قالب أخرA
+# bat.py
+class Bat:
+
+    species = 'Baty'
+
+    def __init__(self, can_fly=True):
+        self.fly = can_fly
+
+    # هذا القالب لديه عملية تسمى say
+    def say(self, msg):
+        msg = '... ... ...'
+        return msg
+
+    # ولديه عمليته الخاصة به أيضا
+    def sonar(self):
+        return '))) ... ((('
+
+if __name__ == '__main__':
+    b = Bat()
+    print(b.say('hello'))
+    print(b.fly)
+
+# تعريف قالب أخر يرث من Superhero و Bat
+# superhero.py
+from superhero import Superhero
+from bat import Bat
+
+# عَرٍف Batman كقالب ابن يرث من كلا من Superhero و Bat
+class Batman(Superhero, Bat):
+
+    def __init__(self, *args, **kwargs):
+        # عادة لكي ترث صفة يجد أن تنادي على super:
+        # super(Batman, self).__init__(*args, **kwargs)      
+        # لكننا في هذه الحالة نتعامل مع إرث متعدد هنا، و super()
+        # تعمل فقط مع القالب التالي في قائمة ال MRO.
+        # لذا بدلا من ذلك ننادي على __init__ صراحة لكل الأباء.
+        # استخدام *args و **kwargs يتيح طريقة نظيفة لتمرير المعطيات.
+        # لكل أب "تقشير طبقة من البصل".
+        Superhero.__init__(self, 'anonymous', movie=True, 
+                           superpowers=['Wealthy'], *args, **kwargs)
+        Bat.__init__(self, *args, can_fly=False, **kwargs)
+        # تعديل قيمة الصفة name
+        self.name = 'Sad Affleck'
+
+    def sing(self):
+        return 'nan nan nan nan nan batman!'
+
+
+if __name__ == '__main__':
+    sup = Batman()
+
+    # إحصل على ترتيب قرار البحث للعملية (Method Resolution search Order) المُستخدمة بواسطة العمليات getattr() و super()
+    # هذه الصفة ديناميكية ويمكن أن تُحَدًث.
+    print(Batman.__mro__)       # => (<class '__main__.Batman'>, 
+                                # => <class 'superhero.Superhero'>, 
+                                # => <class 'human.Human'>, 
+                                # => <class 'bat.Bat'>, <class 'object'>)
+
+    # نادي على العملية الخاصة بالأب لكن استخدم الصفات الخاصة بالقالب الابن
+    print(sup.get_species())    # => Superhuman
+
+    # نادي على العملية المُعدلة
+    print(sup.sing())           # => nan nan nan nan nan batman!
+
+    # نادي على العملية من القالب Human, لأن الترتيب في الأرث مهم.
+    sup.say('I agree')          # => Sad Affleck: I agree
+
+    # نادي على العملية الموجودة فقط في القالب الأب الثاني
+    print(sup.sonar())          # => ))) ... (((
+
+    # الصفة الموروثة من القالب الأب
+    sup.age = 100
+    print(sup.age)              # => 100
+
+    # الصفة الموروثة من القالب الأب الثاني، الذي تم تعديل قيمته الافتراضية
+    print('Can I fly? ' + str(sup.fly)) # => Can I fly? False
+
+
+
+####################################################
+## 7. مُتَقدم
+####################################################
+
+# المولدات تُساعدك على كتابة كود كسول.
+def double_numbers(iterable):
+    for i in iterable:
+        yield i + i
+
+# المولدات فعالة من حيث الذاكرة، لأنها تُحمٍل الذاكرة بالبيانات التي تحتاج
+# لإجراء العملية عليها في الخطوة التالية في المُكَرِر.
+# هذا يتيح إجراء عمليات على قيم كبيرة ممنوعة في حالات أخرى.
+# ﻻحظ: `range` بديل ل `xrange` في بايثون 3.
+for i in double_numbers(range(1, 900000000)):  # `range` is a generator.
+    print(i)
+    if i >= 30:
+        break
+
+# كما يمكنك إنشاء قوائم اشتمال، يمكنك إنشاء مولدات اشتمال أيضا
+values = (-x for x in [1,2,3,4,5])
+for x in values:
+    print(x)  # prints -1 -2 -3 -4 -5 to console/terminal
+
+# يمكنك أيضا تغيير نوع مولد الاشتمال مباشرة إلي قائمة
+values = (-x for x in [1,2,3,4,5])
+gen_to_list = list(values)
+print(gen_to_list)  # => [-1, -2, -3, -4, -5]
+
+
+# المُحسنات
+# في هذا المثال الدالة`beg` تُغلف الدالة `say`. 
+# إذا كانت say_please تساوي True 
+# إذا ستُغير الرسالة الراجعة من الدالة
+from functools import wraps
+
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, "Please! I am poor :(")
+        return msg
+
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Can you buy me a beer?"
+    return msg, say_please
+
+
+print(say())                 # Can you buy me a beer?
+print(say(say_please=True))  # Can you buy me a beer? Please! I am poor :(
+```
+
+## جاهز للمزيد?
+
+### مجانا عبر الانترنت
+
+* [أتمتتة المهمات المُملة عبر بايثون](https://automatetheboringstuff.com)
+* [أفكار لمشروعات بلغة البايثون](http://pythonpracticeprojects.com)
+* [التوثيقات الرسمية](http://docs.python.org/3/)
+* [دليل المُسافر لبايثون](http://docs.python-guide.org/en/latest/)
+* [دورة بايثون](http://www.python-course.eu/index.php)
+* [أولى الخطوات مع بايثون](https://realpython.com/learn/python-first-steps/)
+* [قائمة مُختارة من إطارات عمل بايثون الرائعة, المكتبات والبرمجيات](https://github.com/vinta/awesome-python)
+* [ثلاثون خاصية وخدعة للغة البايثون ربما لم تعرف بها](http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)
+* [الدليل الرسمي لنمط البايثون](https://www.python.org/dev/peps/pep-0008/)
+* [بايثون 3 دوائر علوم الحاسب](http://cscircles.cemc.uwaterloo.ca/)
+* [غُص في بايثون 3](http://www.diveintopython3.net/index.html)
+* [دورة سريعة في البايثون للعلماء](http://nbviewer.jupyter.org/gist/anonymous/5924718)
diff --git a/asymptotic-notation.html.markdown b/asymptotic-notation.html.markdown
index 6a6df968..7a7989d3 100644
--- a/asymptotic-notation.html.markdown
+++ b/asymptotic-notation.html.markdown
@@ -110,7 +110,7 @@ Let's look to the definition of Big-O.
 3log n + 100 <= c * log n
 ```
 
-Is there some pair of constants c, n<sub>0</sub> that satisfies this for all n > <sub>0</sub>?
+Is there some pair of constants c, n<sub>0</sub> that satisfies this for all n > n<sub>0</sub>?
 
 ```
 3log n + 100 <= 150 * log n, n > 2 (undefined at n = 1)
@@ -155,7 +155,7 @@ 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 some real constants c (c > 0) and n<sub>0</sub> (n<sub>0</sub> > 0), `f(n)` is < `c g(n)` 
+`f(n)` is o(g(n)), if for all real constants c (c > 0) and n<sub>0</sub> (n<sub>0</sub> > 0), `f(n)` is < `c g(n)` 
 for every input size n (n > n<sub>0</sub>).
 
 The definitions of O-notation and o-notation are similar. The main difference 
@@ -168,7 +168,7 @@ 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 some real constants c (c > 0) and n<sub>0</sub> (n<sub>0</sub> > 0), `f(n)` is > `c g(n)` 
+`f(n)` is ω(g(n)), if for all real constants c (c > 0) and n<sub>0</sub> (n<sub>0</sub> > 0), `f(n)` is > `c g(n)` 
 for every input size n (n > n<sub>0</sub>).
 
 The definitions of Ω-notation and ω-notation are similar. The main difference 
diff --git a/awk.html.markdown b/awk.html.markdown
index e3ea6318..3ff3f937 100644
--- a/awk.html.markdown
+++ b/awk.html.markdown
@@ -1,19 +1,21 @@
 ---
-language: awk
+category: tool
+tool: awk
 filename: learnawk.awk
 contributors:
      - ["Marshall Mason", "http://github.com/marshallmason"]
 
 ---
 
-AWK is a standard tool on every POSIX-compliant UNIX system. It's like a
-stripped-down Perl, perfect for text-processing tasks and other scripting
-needs. It has a C-like syntax, but without semicolons, manual memory
-management, or static typing. It excels at text processing. You can call to it
-from a shell script, or you can use it as a stand-alone scripting language.
+AWK is a standard tool on every POSIX-compliant UNIX system. It's like
+flex/lex, from the command-line, perfect for text-processing tasks and
+other scripting needs. It has a C-like syntax, but without mandatory
+semicolons (although, you should use them anyway, because they are required
+when you're writing one-liners, something AWK excels at), manual memory
+management, or static typing. It excels at text processing. You can call to
+it from a shell script, or you can use it as a stand-alone scripting language.
 
-Why use AWK instead of Perl? Mostly because AWK is part of UNIX. You can always
-count on it, whereas Perl's future is in question. AWK is also easier to read
+Why use AWK instead of Perl? Readability. AWK is easier to read
 than Perl. For simple text-processing scripts, particularly ones that read
 files line by line and split on delimiters, AWK is probably the right tool for
 the job.
@@ -23,8 +25,23 @@ the job.
 
 # Comments are like this
 
-# AWK programs consist of a collection of patterns and actions. The most
-# important pattern is called BEGIN. Actions go into brace blocks.
+
+# AWK programs consist of a collection of patterns and actions.
+pattern1 { action; } # just like lex
+pattern2 { action; }
+
+# There is an implied loop and AWK automatically reads and parses each
+# record of each file supplied. Each record is split by the FS delimiter,
+# which defaults to white-space (multiple spaces,tabs count as one)
+# You can assign FS either on the command line (-F C) or in your BEGIN
+# pattern
+
+# One of the special patterns is BEGIN. The BEGIN pattern is true
+# BEFORE any of the files are read. The END pattern is true after
+# an End-of-file from the last file (or standard-in if no files specified)
+# There is also an output field separator (OFS) that you can assign, which
+# defaults to a single space
+
 BEGIN {
 
     # BEGIN will run at the beginning of the program. It's where you put all
@@ -32,114 +49,116 @@ BEGIN {
     # have no text files, then think of BEGIN as the main entry point.
 
     # Variables are global. Just set them or use them, no need to declare..
-    count = 0
+    count = 0;
 
     # Operators just like in C and friends
-    a = count + 1
-    b = count - 1
-    c = count * 1
-    d = count / 1 # integer division
-    e = count % 1 # modulus
-    f = count ^ 1 # exponentiation
-
-    a += 1
-    b -= 1
-    c *= 1
-    d /= 1
-    e %= 1
-    f ^= 1
+    a = count + 1;
+    b = count - 1;
+    c = count * 1;
+    d = count / 1; # integer division
+    e = count % 1; # modulus
+    f = count ^ 1; # exponentiation
+
+    a += 1;
+    b -= 1;
+    c *= 1;
+    d /= 1;
+    e %= 1;
+    f ^= 1;
 
     # Incrementing and decrementing by one
-    a++
-    b--
+    a++;
+    b--;
 
     # As a prefix operator, it returns the incremented value
-    ++a
-    --b
+    ++a;
+    --b;
 
     # Notice, also, no punctuation such as semicolons to terminate statements
 
     # Control statements
     if (count == 0)
-        print "Starting with count of 0"
+        print "Starting with count of 0";
     else
-        print "Huh?"
+        print "Huh?";
 
     # Or you could use the ternary operator
-    print (count == 0) ? "Starting with count of 0" : "Huh?"
+    print (count == 0) ? "Starting with count of 0" : "Huh?";
 
     # Blocks consisting of multiple lines use braces
     while (a < 10) {
         print "String concatenation is done" " with a series" " of"
-            " space-separated strings"
-        print a
+            " space-separated strings";
+        print a;
 
-        a++
+        a++;
     }
 
     for (i = 0; i < 10; i++)
-        print "Good ol' for loop"
+        print "Good ol' for loop";
 
     # As for comparisons, they're the standards:
-    a < b   # Less than
-    a <= b  # Less than or equal
-    a != b  # Not equal
-    a == b  # Equal
-    a > b   # Greater than
-    a >= b  # Greater than or equal
+    # a < b   # Less than
+    # a <= b  # Less than or equal
+    # a != b  # Not equal
+    # a == b  # Equal
+    # a > b   # Greater than
+    # a >= b  # Greater than or equal
 
     # Logical operators as well
-    a && b  # AND
-    a || b  # OR
+    # a && b  # AND
+    # a || b  # OR
 
     # In addition, there's the super useful regular expression match
     if ("foo" ~ "^fo+$")
-        print "Fooey!"
+        print "Fooey!";
     if ("boo" !~ "^fo+$")
-        print "Boo!"
+        print "Boo!";
 
     # Arrays
-    arr[0] = "foo"
-    arr[1] = "bar"
-    # Unfortunately, there is no other way to initialize an array. Ya just
-    # gotta chug through every value line by line like that.
-
-    # You also have associative arrays
-    assoc["foo"] = "bar"
-    assoc["bar"] = "baz"
+    arr[0] = "foo";
+    arr[1] = "bar";
+    
+    # You can also initialize an array with the built-in function split()
+    
+    n = split("foo:bar:baz", arr, ":");
+   
+    # You also have associative arrays (actually, they're all associative arrays)
+    assoc["foo"] = "bar";
+    assoc["bar"] = "baz";
 
     # And multi-dimensional arrays, with some limitations I won't mention here
-    multidim[0,0] = "foo"
-    multidim[0,1] = "bar"
-    multidim[1,0] = "baz"
-    multidim[1,1] = "boo"
+    multidim[0,0] = "foo";
+    multidim[0,1] = "bar";
+    multidim[1,0] = "baz";
+    multidim[1,1] = "boo";
 
     # You can test for array membership
     if ("foo" in assoc)
-        print "Fooey!"
+        print "Fooey!";
 
     # You can also use the 'in' operator to traverse the keys of an array
     for (key in assoc)
-        print assoc[key]
+        print assoc[key];
 
     # The command line is in a special array called ARGV
     for (argnum in ARGV)
-        print ARGV[argnum]
+        print ARGV[argnum];
 
     # You can remove elements of an array
     # This is particularly useful to prevent AWK from assuming the arguments
     # are files for it to process
-    delete ARGV[1]
+    delete ARGV[1];
 
     # The number of command line arguments is in a variable called ARGC
-    print ARGC
+    print ARGC;
 
     # AWK has several built-in functions. They fall into three categories. I'll
     # demonstrate each of them in their own functions, defined later.
 
-    return_value = arithmetic_functions(a, b, c)
-    string_functions()
-    io_functions()
+    return_value = arithmetic_functions(a, b, c);
+    string_functions();
+    io_functions();
 }
 
 # Here's how you define a function
@@ -159,26 +178,26 @@ function arithmetic_functions(a, b, c,     d) {
     # Now, to demonstrate the arithmetic functions
 
     # Most AWK implementations have some standard trig functions
-    localvar = sin(a)
-    localvar = cos(a)
-    localvar = atan2(a, b) # arc tangent of b / a
+    localvar = sin(a);
+    localvar = cos(a);
+    localvar = atan2(b, a); # arc tangent of b / a
 
     # And logarithmic stuff
-    localvar = exp(a)
-    localvar = log(a)
+    localvar = exp(a);
+    localvar = log(a);
 
     # Square root
-    localvar = sqrt(a)
+    localvar = sqrt(a);
 
     # Truncate floating point to integer
-    localvar = int(5.34) # localvar => 5
+    localvar = int(5.34); # localvar => 5
 
     # Random numbers
-    srand() # Supply a seed as an argument. By default, it uses the time of day
-    localvar = rand() # Random number between 0 and 1.
+    srand(); # Supply a seed as an argument. By default, it uses the time of day
+    localvar = rand(); # Random number between 0 and 1.
 
     # Here's how to return a value
-    return localvar
+    return localvar;
 }
 
 function string_functions(    localvar, arr) {
@@ -188,61 +207,66 @@ function string_functions(    localvar, arr) {
 
     # Search and replace, first instance (sub) or all instances (gsub)
     # Both return number of matches replaced
-    localvar = "fooooobar"
-    sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar"
-    gsub("e+", ".", localvar) # localvar => "m..t m. at th. bar"
+    localvar = "fooooobar";
+    sub("fo+", "Meet me at the ", localvar); # localvar => "Meet me at the bar"
+    gsub("e+", ".", localvar); # localvar => "m..t m. at th. bar"
 
     # Search for a string that matches a regular expression
     # index() does the same thing, but doesn't allow a regular expression
-    match(localvar, "t") # => 4, since the 't' is the fourth character
+    match(localvar, "t"); # => 4, since the 't' is the fourth character
 
     # Split on a delimiter
-    split("foo-bar-baz", arr, "-") # a => ["foo", "bar", "baz"]
+    n = split("foo-bar-baz", arr, "-"); # a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3
 
     # Other useful stuff
-    sprintf("%s %d %d %d", "Testing", 1, 2, 3) # => "Testing 1 2 3"
-    substr("foobar", 2, 3) # => "oob"
-    substr("foobar", 4) # => "bar"
-    length("foo") # => 3
-    tolower("FOO") # => "foo"
-    toupper("foo") # => "FOO"
+    sprintf("%s %d %d %d", "Testing", 1, 2, 3); # => "Testing 1 2 3"
+    substr("foobar", 2, 3); # => "oob"
+    substr("foobar", 4); # => "bar"
+    length("foo"); # => 3
+    tolower("FOO"); # => "foo"
+    toupper("foo"); # => "FOO"
 }
 
 function io_functions(    localvar) {
 
     # You've already seen print
-    print "Hello world"
+    print "Hello world";
 
     # There's also printf
-    printf("%s %d %d %d\n", "Testing", 1, 2, 3)
+    printf("%s %d %d %d\n", "Testing", 1, 2, 3);
 
     # AWK doesn't have file handles, per se. It will automatically open a file
     # handle for you when you use something that needs one. The string you used
     # for this can be treated as a file handle, for purposes of I/O. This makes
-    # it feel sort of like shell scripting:
+    # it feel sort of like shell scripting, but to get the same output, the string
+    # must match exactly, so use a variable:
+    
+    outfile = "/tmp/foobar.txt";
 
-    print "foobar" >"/tmp/foobar.txt"
+    print "foobar" > outfile;
 
-    # Now the string "/tmp/foobar.txt" is a file handle. You can close it:
-    close("/tmp/foobar.txt")
+    # Now the string outfile is a file handle. You can close it:
+    close(outfile);
 
     # Here's how you run something in the shell
-    system("echo foobar") # => prints foobar
+    system("echo foobar"); # => prints foobar
 
     # Reads a line from standard input and stores in localvar
-    getline localvar
+    getline localvar;
 
-    # Reads a line from a pipe
-    "echo foobar" | getline localvar # localvar => "foobar"
-    close("echo foobar")
+    # Reads a line from a pipe (again, use a string so you close it properly)
+    cmd = "echo foobar";
+    cmd | getline localvar; # localvar => "foobar"
+    close(cmd);
 
     # Reads a line from a file and stores in localvar
-    getline localvar <"/tmp/foobar.txt"
-    close("/tmp/foobar.txt")
+    infile = "/tmp/foobar.txt";
+    getline localvar < infile; 
+    close(infile);
 }
 
 # As I said at the beginning, AWK programs consist of a collection of patterns
-# and actions. You've already seen the all-important BEGIN pattern. Other
+# and actions. You've already seen the BEGIN pattern. Other
 # patterns are used only if you're processing lines from files or standard
 # input.
 #
@@ -257,7 +281,7 @@ function io_functions(    localvar) {
     # expression, /^fo+bar$/, and will be skipped for any line that fails to
     # match it. Let's just print the line:
 
-    print
+    print;
 
     # Whoa, no argument! That's because print has a default argument: $0.
     # $0 is the name of the current line being processed. It is created
@@ -268,16 +292,16 @@ function io_functions(    localvar) {
     # does. And, like the shell, each field can be access with a dollar sign
 
     # This will print the second and fourth fields in the line
-    print $2, $4
+    print $2, $4;
 
     # AWK automatically defines many other variables to help you inspect and
     # process each line. The most important one is NF
 
     # Prints the number of fields on this line
-    print NF
+    print NF;
 
     # Print the last field on this line
-    print $NF
+    print $NF;
 }
 
 # Every pattern is actually a true/false test. The regular expression in the
@@ -286,7 +310,7 @@ function io_functions(    localvar) {
 # currently processing. Thus, the complete version of it is this:
 
 $0 ~ /^fo+bar$/ {
-    print "Equivalent to the last pattern"
+    print "Equivalent to the last pattern";
 }
 
 a > 0 {
@@ -315,10 +339,10 @@ a > 0 {
 BEGIN {
 
     # First, ask the user for the name
-    print "What name would you like the average age for?"
+    print "What name would you like the average age for?";
 
     # Get a line from standard input, not from files on the command line
-    getline name <"/dev/stdin"
+    getline name < "/dev/stdin";
 }
 
 # Now, match every line whose first field is the given name
@@ -335,8 +359,8 @@ $1 == name {
     # ...etc. There are plenty more, documented in the man page.
 
     # Keep track of a running total and how many lines matched
-    sum += $3
-    nlines++
+    sum += $3;
+    nlines++;
 }
 
 # Another special pattern is called END. It will run after processing all the
@@ -348,7 +372,7 @@ $1 == name {
 
 END {
     if (nlines)
-        print "The average age for " name " is " sum / nlines
+        print "The average age for " name " is " sum / nlines;
 }
 
 ```
@@ -357,3 +381,6 @@ Further Reading:
 * [Awk tutorial](http://www.grymoire.com/Unix/Awk.html)
 * [Awk man page](https://linux.die.net/man/1/awk)
 * [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU Awk is found on most Linux systems.
+* [AWK one-liner collection](http://tuxgraphics.org/~guido/scripts/awk-one-liner.html)
+* [Awk alpinelinux wiki](https://wiki.alpinelinux.org/wiki/Awk) a technical summary and list of "gotchas" (places where different implementations may behave in different or unexpected ways). 
+* [basic libraries for awk](https://github.com/dubiousjim/awkenough)
diff --git a/bash.html.markdown b/bash.html.markdown
index 3f3e49eb..856db706 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -11,29 +11,34 @@ contributors:
     - ["Rahil Momin", "https://github.com/iamrahil"]
     - ["Gregrory Kielian", "https://github.com/gskielian"]
     - ["Etan Reisner", "https://github.com/deryni"]
-    - ["Jonathan Wang", "https://github.com/Jonathansw"]   
+    - ["Jonathan Wang", "https://github.com/Jonathansw"]
     - ["Leo Rudberg", "https://github.com/LOZORD"]
     - ["Betsy Lorton", "https://github.com/schbetsy"]
     - ["John Detter", "https://github.com/jdetter"]
     - ["Harry Mumford-Turner", "https://github.com/harrymt"]
+    - ["Martin Nicholson", "https://github.com/mn113"]
 filename: LearnBash.sh
+translators:
+    - ["Dimitri Kokkonis", "https://github.com/kokkonisd"]
 ---
 
-Bash is a name of the unix shell, which was also distributed as the shell for the GNU operating system and as default shell on Linux and Mac OS X.
-Nearly all examples below can be a part of a shell script or executed directly in the shell.
+Bash is a name of the unix shell, which was also distributed as the shell
+for the GNU operating system and as default shell on Linux and Mac OS X.
+Nearly all examples below can be a part of a shell script
+or executed directly in the shell.
 
 [Read more here.](http://www.gnu.org/software/bash/manual/bashref.html)
 
 ```bash
-#!/bin/bash
-# First line of the script is shebang which tells the system how to execute
+#!/usr/bin/env bash
+# First line of the script is the shebang which tells the system how to execute
 # the script: http://en.wikipedia.org/wiki/Shebang_(Unix)
 # As you already figured, comments start with #. Shebang is also a comment.
 
 # Simple hello world example:
 echo Hello world! # => Hello world!
 
-# Each command starts on a new line, or after semicolon:
+# Each command starts on a new line, or after a semicolon:
 echo 'This is the first line'; echo 'This is the second line'
 # => This is the first line
 # => This is the second line
@@ -46,7 +51,7 @@ Variable = "Some string" # => returns error "Variable: command not found"
 # Bash will decide that Variable is a command it must execute and give an error
 # because it can't be found.
 
-# Or like this:
+# Nor like this:
 Variable= 'Some string' # => returns error: "Some string: command not found"
 # Bash will decide that 'Some string' is a command it must execute and give an
 # error because it can't be found. (In this case the 'Variable=' part is seen
@@ -64,8 +69,9 @@ echo '$Variable' # => $Variable
 # Parameter expansion ${ }:
 echo ${Variable} # => Some string
 # This is a simple usage of parameter expansion
-# Parameter Expansion gets a value from a variable.  It "expands" or prints the value
-# During the expansion time the value or parameter are able to be modified
+# Parameter Expansion gets a value from a variable.
+# It "expands" or prints the value
+# During the expansion time the value or parameter can be modified
 # Below are other modifications that add onto this expansion
 
 # String substitution in variables
@@ -76,9 +82,14 @@ echo ${Variable/Some/A} # => A string
 Length=7
 echo ${Variable:0:Length} # => Some st
 # This will return only the first 7 characters of the value
+echo ${Variable: -5} # => tring
+# This will return the last 5 characters (note the space before -5)
+
+# String length
+echo ${#Variable} # => 11
 
 # Default value for variable
-echo ${Foo:-"DefaultValueIfFooIsMissingOrEmpty"} 
+echo ${Foo:-"DefaultValueIfFooIsMissingOrEmpty"}
 # => DefaultValueIfFooIsMissingOrEmpty
 # This works for null (Foo=) and empty string (Foo=""); zero (Foo=0) returns 0.
 # Note that it only returns default value and doesn't change variable value.
@@ -108,8 +119,8 @@ echo {1..10} # => 1 2 3 4 5 6 7 8 9 10
 echo {a..z} # => a b c d e f g h i j k l m n o p q r s t u v w x y z
 # This will output the range from the start value to the end value
 
-# Builtin variables:
-# There are some useful builtin variables, like
+# Built-in variables:
+# There are some useful built-in variables, like
 echo "Last program's return value: $?"
 echo "Script's PID: $$"
 echo "Number of arguments passed to script: $#"
@@ -121,7 +132,7 @@ echo "Script's arguments separated into different variables: $1 $2..."
 
 # Our current directory is available through the command `pwd`.
 # `pwd` stands for "print working directory".
-# We can also use the builtin variable `$PWD`.
+# We can also use the built-in variable `$PWD`.
 # Observe that the following are equivalent:
 echo "I'm in $(pwd)" # execs `pwd` and interpolates output
 echo "I'm in $PWD" # interpolates the variable
@@ -137,7 +148,7 @@ read Name # Note that we didn't need to declare a new variable
 echo Hello, $Name!
 
 # We have the usual if structure:
-# use 'man test' for more info about conditionals
+# use `man test` for more info about conditionals
 if [ $Name != $USER ]
 then
     echo "Your name isn't your username"
@@ -174,9 +185,19 @@ then
     echo "This will run if $Name is Daniya OR Zach."
 fi
 
-# Redefine command 'ping' as alias to send only 5 packets
+# There is also the `=~` operator, which tests a string against a Regex pattern:
+Email=me@example.com
+if [[ "$Email" =~ [a-z]+@[a-z]{2,}\.(com|net|org) ]]
+then
+    echo "Valid email!"
+fi
+# Note that =~ only works within double [[ ]] square brackets,
+# which are subtly different from single [ ].
+# See http://www.gnu.org/software/bash/manual/bashref.html#Conditional-Constructs for more on this.
+
+# Redefine command `ping` as alias to send only 5 packets
 alias ping='ping -c 5'
-# Escape alias and use command with this name instead
+# Escape the alias and use command with this name instead
 \ping 192.168.1.1
 # Print all aliases
 alias -p
@@ -189,14 +210,14 @@ echo $(( 10 + 5 )) # => 15
 # directory with the ls command:
 ls # Lists the files and subdirectories contained in the current directory
 
-# These commands have options that control their execution:
+# This command has options that control its execution:
 ls -l # Lists every file and directory on a separate line
 ls -t # Sorts the directory contents by last-modified date (descending)
 ls -R # Recursively `ls` this directory and all of its subdirectories
 
 # Results of the previous command can be passed to the next command as input.
-# grep command filters the input with provided patterns. That's how we can list
-# .txt files in the current directory:
+# The `grep` command filters the input with provided patterns.
+# That's how we can list .txt files in the current directory:
 ls -l | grep "\.txt"
 
 # Use `cat` to print files to stdout:
@@ -225,13 +246,16 @@ cp -r srcDirectory/ dst/ # recursively copy
 # `mv` is also useful for renaming files!
 mv s0urc3.txt dst.txt # sorry, l33t hackers...
 
-# Since bash works in the context of a current directory, you might want to 
+# 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      # also goes 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??
+cd -    # change to last directory
+# => /home/username/Documents
 
 # Use subshells to work across directories
 (echo "First, I'm here: $PWD") && (cd someDir; echo "Then, I'm here: $PWD")
@@ -256,14 +280,22 @@ print("#stderr", file=sys.stderr)
 for line in sys.stdin:
     print(line, file=sys.stdout)
 EOF
+# Variables will be expanded if the first "EOF" is not quoted
 
-# Run the hello.py Python script with various stdin, stdout, and 
+# Run the hello.py Python script with various stdin, stdout, and
 # stderr redirections:
 python hello.py < "input.in" # pass input.in as input to the script
+
 python hello.py > "output.out" # redirect output from the script to output.out
+
 python hello.py 2> "error.err" # redirect error output to error.err
-python hello.py > "output-and-error.log" 2>&1 # redirect both output and errors to output-and-error.log
-python hello.py > /dev/null 2>&1 # redirect all output and errors to the black hole, /dev/null, i.e., no output
+
+python hello.py > "output-and-error.log" 2>&1
+# redirect both output and errors to output-and-error.log
+
+python hello.py > /dev/null 2>&1
+# redirect all output and errors to the black hole, /dev/null, i.e., no output
+
 # The output error will overwrite the file if it exists,
 # if you want to append instead, use ">>":
 python hello.py >> "output.out" 2>> "error.err"
@@ -292,11 +324,11 @@ rm -r tempDir/ # recursively delete
 # current directory.
 echo "There are $(ls | wc -l) items here."
 
-# The same can be done using backticks `` but they can't be nested - the preferred way
-# is to use $( ).
+# The same can be done using backticks `` but they can't be nested -
+#the preferred way is to use $( ).
 echo "There are `ls | wc -l` items here."
 
-# Bash uses a case statement that works similarly to switch in Java and C++:
+# Bash uses a `case` statement that works similarly to switch in Java and C++:
 case "$Variable" in
     #List patterns for the conditions you want to meet
     0) echo "There is a zero.";;
@@ -304,7 +336,7 @@ case "$Variable" in
     *) echo "It is not null.";;
 esac
 
-# for loops iterate for as many arguments given:
+# `for` loops iterate for as many arguments given:
 # The contents of $Variable is printed three times.
 for Variable in {1..3}
 do
@@ -325,14 +357,14 @@ done
 # => 3
 
 # They can also be used to act on files..
-# This will run the command 'cat' on file1 and file2
+# This will run the command `cat` on file1 and file2
 for Variable in file1 file2
 do
     cat "$Variable"
 done
 
 # ..or the output from a command
-# This will cat the output from ls.
+# This will `cat` the output from `ls`.
 for Output in $(ls)
 do
     cat "$Output"
@@ -412,8 +444,8 @@ grep "^foo.*bar$" file.txt | grep -v "baz"
 # and not the regex, use fgrep (or grep -F)
 fgrep "foobar" file.txt
 
-# The trap command allows you to execute a command whenever your script 
-# receives a signal. Here, trap will execute `rm` if it receives any of the 
+# The `trap` command allows you to execute a command whenever your script
+# receives a signal. Here, `trap` will execute `rm` if it receives any of the
 # three listed signals.
 trap "rm $TEMP_FILE; exit" SIGHUP SIGINT SIGTERM
 
@@ -422,7 +454,7 @@ NAME1=$(whoami)
 NAME2=$(sudo whoami)
 echo "Was $NAME1, then became more powerful $NAME2"
 
-# Read Bash shell builtins documentation with the bash 'help' builtin:
+# Read Bash shell built-ins documentation with the bash `help` built-in:
 help
 help help
 help for
@@ -430,12 +462,12 @@ help return
 help source
 help .
 
-# Read Bash manpage documentation with man
+# Read Bash manpage documentation with `man`
 apropos bash
 man 1 bash
 man bash
 
-# Read info documentation with info (? for help)
+# Read info documentation with `info` (`?` for help)
 apropos info | grep '^info.*('
 man info
 info info
diff --git a/bc.html.markdown b/bc.html.markdown
new file mode 100644
index 00000000..9d63acfb
--- /dev/null
+++ b/bc.html.markdown
@@ -0,0 +1,98 @@
+---
+language: bc
+contributors:
+    - ["Btup"]
+filename: learnbc.bc
+---
+```c
+/*This is a multi-
+line comment.*/
+# This is also a (one-line) comment! (in GNU bc).
+
+    /*1. Variables and control structures*/
+num = 45 /*All variables save only doubles, and you cannot save
+    string constants directly.*/
+num = 45; /*You can choose to add a semicolon after
+    every statement. This is optional.*/
+/*Blocks are denoted using the {} operators(similar to C):*/
+while(num < 50) {
+    num += 1 /*equivalent to num=num+1.
+    a = a op b is equivalent to a op= b.*/
+}
+/*And there are ++(increment) and --(decrement) operators.*/
+/*There are 3 special variables:
+scale: defines the scale of the double numbers.
+ibase: defines the base of input.
+obase: defines the base of output.*/
+/*If clauses:*/
+hour = read() /*Input a number*/
+
+if(hour < 12) { /*Operators are exactly like C.*/
+    print "Good morning\n" /*"print" outputs strings or variables
+	separated by commas.*/
+} else if(hour == 12) {
+    print "Hello\n"
+    /*Escaping sequences start with a \ in a string.
+    In order to make the escaping sequences clearer, here
+	is a simplified list of them that will work in bc:
+    \b: backspace
+    \c: carriage return
+    \n: newline
+    \t: tab
+    \\: backslash*/
+} else {
+    /*Variables are global by default.*/
+    thisIsGlobal = 5
+    /*You can make a variable local. Use the "auto" keyword in a function.*/
+}
+
+/*Every variable is pre-set to 0.*/
+num = blankVariable /*num is set to 0.*/
+
+/*Like C, only 0 is falsy.*/
+if(!num) {print "false\n"}
+
+/*Unlike C, bc does not have the ?: operators. For example,
+ this block of code will cause an error:
+a = (num) ? 1 : 0
+However, you can simulate one:*/
+a = (num) && (1) || (0) /*&& is and, || is or*/
+
+/*For loops*/
+num = 0
+for(i = 1; i <= 100; i++) {/*Similar to the C for loop.*/
+    num += i
+}
+
+    /*2.Functions and Arrays*/
+define fac(n) { /*define a function using define.*/
+    if(n == 1 || n == 0) {
+        return 1 /*return a value*/
+    }
+    return n * fac(n - 1) /*recursion is possible*/
+}
+
+/*Closures and anonymous functions are impossible.*/
+
+num = fac(4) /*24*/
+
+/*This is an example of local variables:*/
+define x(n) {
+    auto x
+    x = 1
+    return n + x
+}
+x(3) /*4*/
+print x /*It turns out that x is not accessible out of the function.*/
+/*Arrays are equivalent to the C array.*/
+for(i = 0; i <= 3; i++) {
+    a[i] = 1
+}
+/*Access it like this:*/
+print a[0], " ", a[1], " ", a[2], " ", a[3], "\n"
+quit /*Add this line of code to make sure
+that your program exits. This line of code is optional.*/
+```
+Enjoy this simple calculator! (Or this programming language, to be exact.)
+
+This whole program is written in GNU bc. To run it, use ```bc learnbc.bc```.
diff --git a/bg-bg/logtalk-bg.html.markdown b/bg-bg/logtalk-bg.html.markdown
new file mode 100644
index 00000000..e788b17d
--- /dev/null
+++ b/bg-bg/logtalk-bg.html.markdown
@@ -0,0 +1,593 @@
+---
+language: Logtalk
+filename: llearnlogtalk-bg.lgt
+contributors:
+    - ["Paulo Moura", "http://github.com/pmoura"]
+translators:
+    - ["vsraptor", "https://github.com/vsraptor"]
+lang: bg-bg
+
+---
+
+Logtalk е обектно-ориентиран (ОО) модерен логически език за програмиране, които разширява Prolog с възможности за капсулиране (еncapsulation) и многократно използване на кода без да компрометира декларативните възможности на езика. Logtalk е имплементиран така че да може да бъде адапртиран към всеки стандартен Prolog като back-end компилатор, тоест е напълно прозрачен за нормална Prolog програма.
+Допълнително, Logtalk също може да интерпретира Prolog модули, като Logtalk обекти.
+
+Основната структурна единица за изграждане на програмни със Logtalk е чрез използване на обекти.
+Logtalk поддържа както стандартния начин за изграждане на иерархий от класове познати ни от езици като Java, същто така и prototype-OOP познат ни от езици като JavaScript.
+Запомнете че всичко стартира с дефинирането и създаването на обект.
+
+
+## Syntax (Синтакс)
+
+
+Logtalk използва стандартен Prolog синтакс, с минимум допълнителни оператори и директиви.
+Важно последствие от това е че кода лесно се капсулира с много малко промени спрямо оригинален код.
+
+Операторите които Logtalk добавя към Prolog са :
+
+    ::/2 - изпраща саобщение до обект (аналогично на метод в стандартните ООП езици)
+    ::/1 - изпраща саобщение до себе си (self) (тоест до обекта който е получил съобщението което обработваме в момента)
+    ^^/1 - super call (изпраща саобщение до наследен или импортиран предикат(predicate))
+
+
+## Entities and roles (Субекти и роли)
+
+
+Logtalk предоставя обекти, портоколи и категории като първокласни-субекти (first-class entities). Връзката между тях описва ролята която субектите изпалняват. 
+Обектите могат да играят различни роли в зависимост от как ги дефинираме тоест какви директиви използваме при дефиницията.
+
+Например когато използваме обект А за да създадем нов обект Б, обект Б играе ролята на "инстанция", а обект А играе ролята на клас.
+Ако използваме "extends"-дефиниция единия от обектите играе ролята на протоип(prototype) за другия.
+
+
+## Defining an object (Дефиниране на обект)
+
+
+Чрез дефинирането на обект ние капсулираме дефиницията на "предикатите".
+Обекти могат да се създадат динамично или дефинират статично във код-файла.
+Ето как дефинираме примерен обект :
+
+```logtalk
+:- object(list).
+
+    :- public(member/2).
+    member(Head, [Head| _]).
+    member(Head, [_| Tail]) :-
+        member(Head, Tail).
+
+:- end_object.
+```
+
+## Compiling source files (Компилиран)
+
+
+Ако предположим че кода е записан във файл с име list.lgt, можем да го компилираме чрез logtalk_load/1 предиката или съкратения вариант {}/1.
+
+
+```logtalk
+?- {list}.
+yes
+```
+
+## Sending a message to an object (Изпращане на събщение до обект) 
+
+
+Както казахме ::/2 infix оператор се използва за изпращане на съобщение до обекта. Както в Prolog, ние можем да backtrack-нем за алтернативни решения, понеже метода е просто стандартен предикат :
+
+```logtalk
+?- list::member(X, [1,2,3]).
+X = 1 ;
+X = 2 ;
+X = 3
+yes
+
+?- write_canonical(list::member(X, [1,2,3])).
+::(list,member(_,[1,2,3]))
+```
+
+Кагато декларирме обект автоматично предикатите са капсулирани (еncapsulation), тоест извън обекта те са невидими за останалата част от програмата. Естествено има опции да променим това поведение чрез public, protected, или private предикати. 
+
+```logtalk
+:- object(scopes).
+
+    :- private(bar/0).
+    bar.
+
+    local.
+
+:- end_object.
+```
+
+Ако кода е записан в scopes.lgt фаил и се опитаме да изпратим саобщтение до частен(private) или локален предикат ще получим грешка:
+
+```logtalk
+?- {scopes}.
+yes
+
+?- catch(scopes::bar, Error, true).
+Error = error(
+    permission_error(access, private_predicate, bar/0),
+    logtalk(scopes::bar, user)
+)
+yes
+
+?- catch(scopes::local, Error, true).
+Error = error(
+    existence_error(predicate_declaration, local/0),
+    logtalk(scopes::local, user)
+)
+yes
+```
+
+Когато предиката е непознат за обекта това също генерира грешка. Например :
+
+```logtalk
+?- catch(scopes::unknown, Error, true).
+Error = error(
+    existence_error(predicate_declaration, unknown/0),
+    logtalk(scopes::unknown, user)
+)
+yes
+```
+
+## Протоколи (Defining and implementing a protocol)
+
+
+За тези от вас свикнали със стандартно ООП, Protocols наподобяват Interfaces в Java.
+Протоколите съдържат предикати които могат да бъдат в последствие имплементирани в обекти и категории :
+
+```logtalk
+:- protocol(listp).
+
+    :- public(member/2).
+
+:- end_protocol.
+
+:- object(list,
+    implements(listp)).
+
+    member(Head, [Head| _]).
+    member(Head, [_| Tail]) :-
+        member(Head, Tail).
+
+:- end_object.
+```
+
+Обхвата(scope) на предикатите в протокола могат да бъде ограничени чрез protected или private клаузи. 
+Например:
+
+```logtalk
+:- object(stack,
+    implements(private::listp)).
+
+:- end_object.
+```
+
+Всички субекти(entity) релации могат да бъдат пре-дефинирани с public, protected или private, подбно на начина показан по горе.
+
+
+## Прототипи (Prototypes)
+
+
+Всеки обект без instantiation или specialization спецификация с друг обект, играе ролята на прототип. 
+Прототип-обект може да предефинира и разщири протоипа-родител.
+
+```logtalk
+% clyde, our prototypical elephant
+:- object(clyde).
+
+    :- public(color/1).
+    color(grey).
+
+    :- public(number_of_legs/1).
+    number_of_legs(4).
+
+:- end_object.
+
+% fred, another elephant, is like clyde, except that he's white
+:- object(fred,
+    extends(clyde)).
+
+    color(white).
+
+:- end_object.
+```
+
+Когато системата отговаря на съобщение изпратено до обект който играе ролята на прототип, тя търси отговор първо в прототипа и ако не намери предикат делегира отговора на прототипа-родител-обект :
+
+```logtalk
+?- fred::number_of_legs(N).
+N = 4
+yes
+
+?- fred::color(C).
+C = white
+yes
+```
+
+Съобщението е валидно но няма да генерира грещка, ако предиката е дефиниран но не е деклариран/имплементиран. Това е така наречения closed-world assumption. 
+Например :
+
+```logtalk
+:- object(foo).
+
+    :- public(bar/0).
+
+:- end_object.
+```
+
+Ако заредим файла и се опитаме да извикаме bar/0, няма да получим отговор, както може да очакваме. Ако обаче предиката не е дори дефиниран, ще получим гращка :
+
+```logtalk
+?- {foo}.
+yes
+
+?- foo::bar.
+no
+
+?- catch(foo::baz, Error, true).
+Error = error(
+    existence_error(predicate_declaration, baz/0),
+    logtalk(foo::baz, user)
+)
+yes
+```
+
+## Класове и инстанции (Classes and instances)
+
+
+За да саздадем обекти които играят ролята на класове и/или инстанции, трябва да използваме поне instantiation или specialization дефиниция с друг обект. Обектите които играят роля на мета-класове могат да се използват ако е нужно още за саздаване на инстанции на класа.
+Следващия пример ще илюстрира как можем динамично да саздадаваме обекти :
+
+```logtalk
+% a simple, generic, metaclass defining a new/2 predicate for its instances
+:- object(metaclass,
+    instantiates(metaclass)).
+
+    :- public(new/2).
+    new(Instance, Clauses) :-
+        self(Class),
+        create_object(Instance, [instantiates(Class)], [], Clauses).
+
+:- end_object.
+
+% a simple class defining age/1 and name/1 predicate for its instances
+:- object(person,
+    instantiates(metaclass)).
+
+    :- public([
+        age/1, name/1
+    ]).
+
+    % a default value for age/1
+    age(42).
+
+:- end_object.
+
+% a static instance of the class person
+:- object(john,
+    instantiates(person)).
+
+    name(john).
+    age(12).
+
+:- end_object.
+```
+
+Когато отговаряме на съобщение изпратено до обект който играе ролята на инстанция, системата валидира съобщението първо в текущия клас, след това класа-родител ако е необходимо. Ако съобщението е валидно тогава проверяваме инстанцията :
+
+```logtalk
+?- person::new(Instance, [name(paulo)]).
+Instance = o1
+yes
+
+?- o1::name(Name).
+Name = paulo
+yes
+
+?- o1::age(Age).
+Age = 42
+yes
+
+?- john::age(Age).
+Age = 12
+yes
+```
+
+## Категории (Categories)
+
+
+Категорията е капсулран код който може да се рециклира (reuse) в различни обекти. Докато Протокола е само дефиниции Категорията е сащо и декларация/имплементация на предикатите които сме дефинирали.
+В следващия пример ще дефинираме категории представящи автомобилни двигатели след което ще ги импортираме в автомобил-обекти :
+   
+
+```logtalk
+% a protocol describing engine characteristics
+:- protocol(carenginep).
+
+    :- public([
+        reference/1,
+        capacity/1,
+        cylinders/1,
+        horsepower_rpm/2,
+        bore_stroke/2,
+        fuel/1
+    ]).
+
+:- end_protocol.
+
+% a typical engine defined as a category
+:- category(classic,
+    implements(carenginep)).
+
+    reference('M180.940').
+    capacity(2195).
+    cylinders(6).
+    horsepower_rpm(94, 4800).
+    bore_stroke(80, 72.8).
+    fuel(gasoline).
+
+:- end_category.
+
+% a souped up version of the previous engine
+:- category(sport,
+    extends(classic)).
+
+    reference('M180.941').
+    horsepower_rpm(HP, RPM) :-
+        ^^horsepower_rpm(ClassicHP, ClassicRPM),    % "super" call
+        HP is truncate(ClassicHP*1.23),
+        RPM is truncate(ClassicRPM*0.762).
+
+:- end_category.
+
+% with engines (and other components), we may start "assembling" some cars
+:- object(sedan,
+    imports(classic)).
+
+:- end_object.
+
+:- object(coupe,
+    imports(sport)).
+
+:- end_object.
+```
+
+Категориите се компилират отделно и разрешават импортираните обекти да бъдат обновени като просто обновим категориите без да е необходимо да прекомпилираме обекта:
+
+```logtalk
+?- sedan::current_predicate(Predicate).
+Predicate = reference/1 ;
+Predicate = capacity/1 ;
+Predicate = cylinders/1 ;
+Predicate = horsepower_rpm/2 ;
+Predicate = bore_stroke/2 ;
+Predicate = fuel/1
+yes
+```
+
+## Hot patching
+
+
+Категориите още могат да се използват за промяна на обекти "в движение", след като вече са били инстанциирани. 
+Например :
+
+```logtalk
+:- object(buggy).
+
+    :- public(p/0).
+    p :- write(foo).
+
+:- end_object.
+```
+
+Да предположим че обекта изпечатва грешното съобщение p/0 :
+
+```logtalk
+?- {buggy}.
+yes
+
+?- buggy::p.
+foo
+yes
+```
+
+Ако кода който описва този обект не е наличен и трябва да коригираме приложението, ние можем просто да създадем категория която да коригира необходимия предикат :
+
+```logtalk
+:- category(patch,
+    complements(buggy)).
+
+    % fixed p/0 def
+    p :- write(bar).
+
+:- end_category.
+```
+
+След компилиране и зареждане на категорията ще получим :
+
+```logtalk
+?- {patch}.
+yes
+
+?- buggy::p.
+bar
+yes
+```
+
+
+## Parametric objects and categories
+
+
+Обектите и категориите могат да се параметризират ако използваме за индентификатор комплексен-термин вместо атом.
+Параметрите са логически променливи достъпни за всички капсулирани предикати. 
+Пример с геометрични кръгове :
+
+```logtalk
+:- object(circle(_Radius, _Color)).
+
+    :- public([
+        area/1, perimeter/1
+    ]).
+
+    area(Area) :-
+        parameter(1, Radius),
+        Area is pi*Radius*Radius.
+
+    perimeter(Perimeter) :-
+        parameter(1, Radius),
+        Perimeter is 2*pi*Radius.
+
+:- end_object.
+```
+
+Параметричните-обекти се използват като всеки друг обект, обикновенно осигуряваики стойности за параметрите когато изпращаме съобщение.
+
+```logtalk
+?- circle(1.23, blue)::area(Area).
+Area = 4.75291
+yes
+```
+
+Параметричните-обекти още осигуряват лесен начин за ассоцииране на различни предикати със нормални Prolog предикати.
+Prolog факти могат да бъдат интерпретирани като посредници (proxies).
+Например следните клаузи на circle/2 предикат :
+
+
+```logtalk
+circle(1.23, blue).
+circle(3.71, yellow).
+circle(0.39, green).
+circle(5.74, black).
+circle(8.32, cyan).
+```
+
+можем лесно да изчислим площа на всички кръгове :
+
+```logtalk
+?- findall(Area, {circle(_, _)}::area(Area), Areas).
+Areas = [4.75291, 43.2412, 0.477836, 103.508, 217.468]
+yes
+```
+
+{Goal}::Message формата доказва(proves) Goal и изпраща съобщение до генерирания термин.
+
+
+## Събития и мониторинг (Events and monitors)
+
+
+Logtalk поддържа event-driven програмиране чрез дефинирането на събития и монитори за тези събития.
+Събитие е просто изпращане на съобщение към обект. При обработването на съобщение системата разпознава before-събитие и after-събитие.
+Мониторите дефинират предикати които ще прихаванат тези събития (before/3 и after/3).
+Нампример следния монитор ще прихаване съобщенията изпратени чрез ::/2  :
+
+```logtalk
+:- object(tracer,
+    implements(monitoring)).    % built-in protocol for event handlers
+
+    :- initialization(define_events(_, _, _, _, tracer)).
+
+    before(Object, Message, Sender) :-
+        write('call: '), writeq(Object), write(' <-- '), writeq(Message),
+        write(' from '), writeq(Sender), nl.
+
+    after(Object, Message, Sender) :-
+        write('exit: '), writeq(Object), write(' <-- '), writeq(Message),
+        write(' from '), writeq(Sender), nl.
+
+:- end_object.
+```
+
+Ето как можем да проследим реакцията на изпращане на съобщение :
+
+```logtalk
+?- list::member(X, [1,2,3]).
+
+call: list <-- member(X, [1,2,3]) from user
+exit: list <-- member(1, [1,2,3]) from user
+X = 1 ;
+exit: list <-- member(2, [1,2,3]) from user
+X = 2 ;
+exit: list <-- member(3, [1,2,3]) from user
+X = 3
+yes
+```
+
+Събития могат да се изтрият динамично чрез define_events/5 и abolish_events/5 предикати.
+
+
+## Lambda expressions
+
+
+Logtalk поддържа lambda expressions. Lambda параметрите се предават чрез списък към (>>)/2 infix оператор свързвайки ги с lambda.
+Ето няколко примера :
+
+```logtalk
+?- {library(metapredicates_loader)}.
+yes
+
+?- meta::map([X,Y]>>(Y is 2*X), [1,2,3], Ys).
+Ys = [2,4,6]
+yes
+```
+
+Currying се поддържа :
+
+```logtalk
+?- meta::map([X]>>([Y]>>(Y is 2*X)), [1,2,3], Ys).
+Ys = [2,4,6]
+yes
+```
+
+Lambda free variables can be expressed using the extended syntax {Free1, ...}/[Parameter1, ...]>>Lambda.
+
+
+## Макроси (Macros)
+
+
+Термини и Цели могат да бъдат пре-интерпретирани (expanded) по време на компилация ако специфицираме hook-обект който дефинира прецедурите на пре-интерпретиране.
+Нека следният обект е записан във фаил source.lgt :
+
+```logtalk
+:- object(source).
+
+    :- public(bar/1).
+    bar(X) :- foo(X).
+
+    foo(a). foo(b). foo(c).
+
+:- end_object.
+```
+
+и следния hooк-обект е записан в my_macros.lgt, който пре-интерпретира foo/1 предиката :
+
+```logtalk
+:- object(my_macros,
+    implements(expanding)).    % built-in protocol for expanding predicates
+
+    term_expansion(foo(Char), baz(Code)) :-
+        char_code(Char, Code). % standard built-in predicate
+
+    goal_expansion(foo(X), baz(X)).
+
+:- end_object.
+```
+
+След зареждането на файла с макроси ние можем да пре-интерпретираме ползайки hook-флаг за компилатора :
+
+```logtalk
+?- logtalk_load(my_macros), logtalk_load(source, [hook(my_macros)]).
+yes
+
+?- source::bar(X).
+X = 97 ;
+X = 98 ;
+X = 99
+true
+```
+
+## Допълнителна информация (Further information)
+
+
+Посетете сайта на [Logtalk website](http://logtalk.org) за повече информация.
+
diff --git a/c++.html.markdown b/c++.html.markdown
index 8d1c7a26..f3dc8e20 100644
--- a/c++.html.markdown
+++ b/c++.html.markdown
@@ -71,10 +71,16 @@ void func(); // function which may accept any number of arguments
 // Use nullptr instead of NULL in C++
 int* ip = nullptr;
 
-// C standard headers are available in C++,
-// but are prefixed with "c" and have no .h suffix.
+// C standard headers are available in C++.
+// C headers end in .h, while
+// C++ headers are prefixed with "c" and have no ".h" suffix.
+
+// The C++ standard version:
 #include <cstdio>
 
+// The C standard version:
+#include <stdio.h>
+
 int main()
 {
     printf("Hello, world!\n");
@@ -251,7 +257,7 @@ fooRef = bar;
 cout << &fooRef << endl; //Still prints the address of foo
 cout << fooRef;  // Prints "I am bar"
 
-//The address of fooRef remains the same, i.e. it is still referring to foo.
+// The address of fooRef remains the same, i.e. it is still referring to foo.
 
 
 const string& barRef = bar; // Create a const reference to bar.
@@ -547,10 +553,14 @@ Point Point::operator+(const Point& rhs) const
     return Point(x + rhs.x, y + rhs.y);
 }
 
+// It's good practice to return a reference to the leftmost variable of
+// an assignment. `(a += b) == c` will work this way.
 Point& Point::operator+=(const Point& rhs)
 {
     x += rhs.x;
     y += rhs.y;
+    
+    // `this` is a pointer to the object, on which a method is called.
     return *this;
 }
 
@@ -651,7 +661,7 @@ printMessage<10>();  // Prints "Learn C++ faster in only 10 minutes!"
 
 // The standard library provides a few exception types
 // (see http://en.cppreference.com/w/cpp/error/exception)
-// but any type can be thrown an as exception
+// but any type can be thrown as an exception
 #include <exception>
 #include <stdexcept>
 
@@ -751,7 +761,7 @@ failure:
 // things are a little cleaner, but still sub-optimal.
 void doSomethingWithAFile(const char* filename)
 {
-    FILE* fh = fopen(filename, "r"); // Open the file in read mode
+    FILE* fh = fopen(filename, "r"); // Open the file in shared_ptrread mode
     if (fh == nullptr)
         throw std::runtime_error("Could not open the file.");
 
@@ -803,7 +813,154 @@ void doSomethingWithAFile(const std::string& filename)
 //   all automatically destroy their contents when they fall out of scope.
 // - Mutexes using lock_guard and unique_lock
 
-// containers with object keys of non-primitive values (custom classes) require
+
+/////////////////////
+// Smart Pointer
+/////////////////////
+
+// Generally a smart pointer is a class which wraps a "raw pointer" (usage of "new"
+// respectively malloc/calloc in C). The goal is to be able to
+// manage the lifetime of the object being pointed to without ever needing to explicitly delete 
+// the object. The term itself simply describes a set of pointers with the
+// mentioned abstraction.
+// Smart pointers should preferred over raw pointers, to prevent
+// risky memory leaks, which happen if you forget to delete an object.
+
+// Usage of a raw pointer:
+Dog* ptr = new Dog();
+ptr->bark();
+delete ptr;
+
+// By using a smart pointer, you don't have to worry about the deletion
+// of the object anymore.
+// A smart pointer describes a policy, to count the references to the
+// pointer. The object gets destroyed when the last
+// reference to the object gets destroyed.
+
+// Usage of "std::shared_ptr":
+void foo()
+{
+// It's no longer necessary to delete the Dog.
+std::shared_ptr<Dog> doggo(new Dog());
+doggo->bark();
+}
+
+// Beware of possible circular references!!!
+// There will be always a reference, so it will be never destroyed!
+std::shared_ptr<Dog> doggo_one(new Dog());
+std::shared_ptr<Dog> doggo_two(new Dog());
+doggo_one = doggo_two; // p1 references p2
+doggo_two = doggo_one; // p2 references p1
+
+// There are several kinds of smart pointers. 
+// The way you have to use them is always the same.
+// This leads us to the question: when should we use each kind of smart pointer?
+// std::unique_ptr - use it when you just want to hold one reference to
+// the object.
+// std::shared_ptr - use it when you want to hold multiple references to the
+// same object and want to make sure that it's deallocated
+// when all references are gone.
+// std::weak_ptr - use it when you want to access
+// the underlying object of a std::shared_ptr without causing that object to stay allocated.
+// Weak pointers are used to prevent circular referencing.
+
+
+/////////////////////
+// Containers
+/////////////////////
+
+// Containers or the Standard Template Library are some predefined templates.
+// They manage the storage space for its elements and provide
+// member functions to access and manipulate them.
+
+// Few containers are as follows:
+
+// Vector (Dynamic array)
+// Allow us to Define the Array or list of objects at run time
+#include <vector>
+string val;
+vector<string> my_vector; // initialize the vector
+cin >> val;
+my_vector.push_back(val); // will push the value of 'val' into vector ("array") my_vector
+my_vector.push_back(val); // will push the value into the vector again (now having two elements)
+
+// To iterate through a vector we have 2 choices:
+// Either classic looping (iterating through the vector from index 0 to its last index):
+for (int i = 0; i < my_vector.size(); i++) {
+	cout << my_vector[i] << endl; // for accessing a vector's element we can use the operator []
+}
+
+// or using an iterator:
+vector<string>::iterator it; // initialize the iterator for vector
+for (it = my_vector.begin(); it != my_vector.end(); ++it) {
+	cout << *it  << endl;
+}
+
+// Set
+// Sets are containers that store unique elements following a specific order.
+// Set is a very useful container to store unique values in sorted order
+// without any other functions or code.
+
+#include<set>
+set<int> ST;    // Will initialize the set of int data type
+ST.insert(30);  // Will insert the value 30 in set ST
+ST.insert(10);  // Will insert the value 10 in set ST
+ST.insert(20);  // Will insert the value 20 in set ST
+ST.insert(30);  // Will insert the value 30 in set ST
+// Now elements of sets are as follows
+//  10 20 30
+
+// To erase an element
+ST.erase(20);  // Will erase element with value 20
+// Set ST: 10 30
+// To iterate through Set we use iterators
+set<int>::iterator it;
+for(it=ST.begin();it<ST.end();it++) {
+	cout << *it << endl;
+}
+// Output:
+// 10
+// 30
+
+// To clear the complete container we use Container_name.clear()
+ST.clear();
+cout << ST.size();  // will print the size of set ST
+// Output: 0
+
+// NOTE: for duplicate elements we can use multiset
+// NOTE: For hash sets, use unordered_set. They are more efficient but
+// do not preserve order. unordered_set is available since C++11
+
+// Map
+// Maps store elements formed by a combination of a key value
+// and a mapped value, following a specific order.
+
+#include<map>
+map<char, int> mymap;  // Will initialize the map with key as char and value as int
+
+mymap.insert(pair<char,int>('A',1));
+// Will insert value 1 for key A
+mymap.insert(pair<char,int>('Z',26));
+// Will insert value 26 for key Z
+
+// To iterate
+map<char,int>::iterator it;
+for (it=mymap.begin(); it!=mymap.end(); ++it)
+    std::cout << it->first << "->" << it->second << '\n';
+// Output:
+// A->1
+// Z->26
+
+// To find the value corresponding to a key
+it = mymap.find('Z');
+cout << it->second;
+
+// Output: 26
+
+// NOTE: For hash maps, use unordered_map. They are more efficient but do
+// not preserve order. unordered_map is available since C++11.
+
+// Containers with object keys of non-primitive values (custom classes) require
 // compare function in the object itself or as a function pointer. Primitives
 // have default comparators, but you can override it.
 class Foo {
@@ -816,12 +973,13 @@ struct compareFunction {
         return a.j < b.j;
     }
 };
-//this isn't allowed (although it can vary depending on compiler)
-//std::map<Foo, int> fooMap;
+// this isn't allowed (although it can vary depending on compiler)
+// std::map<Foo, int> fooMap;
 std::map<Foo, int, compareFunction> fooMap;
 fooMap[Foo(1)]  = 1;
 fooMap.find(Foo(1)); //true
 
+
 ///////////////////////////////////////
 // Lambda Expressions (C++11 and above)
 ///////////////////////////////////////
@@ -988,97 +1146,6 @@ cout << get<3>(concatenated_tuple) << "\n"; // prints: 15
 cout << get<5>(concatenated_tuple) << "\n"; // prints: 'A'
 
 
-/////////////////////
-// Containers
-/////////////////////
-
-// Containers or the Standard Template Library are some predefined templates.
-// They manage the storage space for its elements and provide
-// member functions to access and manipulate them.
-
-// Few containers are as follows:
-
-// Vector (Dynamic array)
-// Allow us to Define the Array or list of objects at run time
-#include <vector>
-string val;
-vector<string> my_vector; // initialize the vector
-cin >> val;
-my_vector.push_back(val); // will push the value of 'val' into vector ("array") my_vector
-my_vector.push_back(val); // will push the value into the vector again (now having two elements)
-
-// To iterate through a vector we have 2 choices:
-// Either classic looping (iterating through the vector from index 0 to its last index):
-for (int i = 0; i < my_vector.size(); i++) {
-	cout << my_vector[i] << endl; // for accessing a vector's element we can use the operator []
-}
-
-// or using an iterator:
-vector<string>::iterator it; // initialize the iterator for vector
-for (it = my_vector.begin(); it != my_vector.end(); ++it) {
-	cout << *it  << endl;
-}
-
-// Set
-// Sets are containers that store unique elements following a specific order.
-// Set is a very useful container to store unique values in sorted order
-// without any other functions or code.
-
-#include<set>
-set<int> ST;    // Will initialize the set of int data type
-ST.insert(30);  // Will insert the value 30 in set ST
-ST.insert(10);  // Will insert the value 10 in set ST
-ST.insert(20);  // Will insert the value 20 in set ST
-ST.insert(30);  // Will insert the value 30 in set ST
-// Now elements of sets are as follows
-//  10 20 30
-
-// To erase an element
-ST.erase(20);  // Will erase element with value 20
-// Set ST: 10 30
-// To iterate through Set we use iterators
-set<int>::iterator it;
-for(it=ST.begin();it<ST.end();it++) {
-	cout << *it << endl;
-}
-// Output:
-// 10
-// 30
-
-// To clear the complete container we use Container_name.clear()
-ST.clear();
-cout << ST.size();  // will print the size of set ST
-// Output: 0
-
-// NOTE: for duplicate elements we can use multiset
-
-// Map
-// Maps store elements formed by a combination of a key value
-// and a mapped value, following a specific order.
-
-#include<map>
-map<char, int> mymap;  // Will initialize the map with key as char and value as int
-
-mymap.insert(pair<char,int>('A',1));
-// Will insert value 1 for key A
-mymap.insert(pair<char,int>('Z',26));
-// Will insert value 26 for key Z
-
-// To iterate
-map<char,int>::iterator it;
-for (it=mymap.begin(); it!=mymap.end(); ++it)
-    std::cout << it->first << "->" << it->second << '\n';
-// Output:
-// A->1
-// Z->26
-
-// To find the value corresponding to a key
-it = mymap.find('Z');
-cout << it->second;
-
-// Output: 26
-
-
 ///////////////////////////////////
 // Logical and Bitwise operators
 //////////////////////////////////
@@ -1127,7 +1194,6 @@ compl 4    // Performs a bitwise not
 ```
 Further Reading:
 
-An up-to-date language reference can be found at
-<http://cppreference.com/w/cpp>
-
-Additional resources may be found at <http://cplusplus.com>
+* An up-to-date language reference can be found at [CPP Reference](http://cppreference.com/w/cpp).
+* Additional resources may be found at [CPlusPlus](http://cplusplus.com).
+* A tutorial covering basics of language and setting up coding environment is available at [TheChernoProject - C++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb).
diff --git a/c.html.markdown b/c.html.markdown
index 0c6df413..7975a1c2 100644
--- a/c.html.markdown
+++ b/c.html.markdown
@@ -9,6 +9,7 @@ contributors:
     - ["Zachary Ferguson", "https://github.io/zfergus2"]
     - ["himanshu", "https://github.com/himanshu81494"]
     - ["Joshua Li", "https://github.com/JoshuaRLi"]
+    - ["Dragos B. Chirila", "https://github.com/dchirila"]
 ---
 
 Ah, C. Still **the** language of modern high-performance computing.
@@ -18,7 +19,7 @@ it more than makes up for it with raw speed. Just be aware of its manual
 memory management and C will take you as far as you need to go.
 
 > **About compiler flags**
-> 
+>
 > By default, gcc and clang are pretty quiet about compilation warnings and
 > errors, which can be very useful information. Explicitly using stricter
 > compiler flags is recommended. Here are some recommended defaults:
@@ -89,6 +90,8 @@ int main (int argc, char** argv)
 
   // All variables MUST be declared at the top of the current block scope
   // we declare them dynamically along the code for the sake of the tutorial
+  // (however, C99-compliant compilers allow declarations near the point where
+  // the value is used)
 
   // ints are usually 4 bytes
   int x_int = 0;
@@ -101,7 +104,7 @@ int main (int argc, char** argv)
   char y_char = 'y'; // Char literals are quoted with ''
 
   // longs are often 4 to 8 bytes; long longs are guaranteed to be at least
-  // 64 bits
+  // 8 bytes
   long x_long = 0;
   long long x_long_long = 0;
 
@@ -141,6 +144,17 @@ int main (int argc, char** argv)
 
   // You can initialize an array to 0 thusly:
   char my_array[20] = {0};
+  // where the "{0}" part is called an "array initializer".
+  // NOTE that you get away without explicitly declaring the size of the array,
+  // IF you initialize the array on the same line. So, the following declaration
+  // is equivalent:
+  char my_array[] = {0};
+  // BUT, then you have to evaluate the size of the array at run-time, like this:
+  size_t my_array_size = sizeof(my_array) / sizeof(my_array[0]);
+  // WARNING If you adopt this approach, you should evaluate the size *before*
+  // you begin passing the array to function (see later discussion), because
+  // arrays get "downgraded" to raw pointers when they are passed to functions
+  // (so the statement above will produce the wrong result inside the function).
 
   // Indexing an array is like other languages -- or,
   // rather, other languages are like C
@@ -374,8 +388,8 @@ int main (int argc, char** argv)
   // respectively, use the CHAR_MAX, SCHAR_MAX and UCHAR_MAX macros from <limits.h>
 
   // Integral types can be cast to floating-point types, and vice-versa.
-  printf("%f\n", (float)100); // %f formats a float
-  printf("%lf\n", (double)100); // %lf formats a double
+  printf("%f\n", (double) 100); // %f always formats a double...
+  printf("%f\n", (float)  100); // ...even with a float.
   printf("%d\n", (char)100.0);
 
   ///////////////////////////////////////
@@ -433,7 +447,7 @@ int main (int argc, char** argv)
   // or when it's the argument of the `sizeof` or `alignof` operator:
   int arraythethird[10];
   int *ptr = arraythethird; // equivalent with int *ptr = &arr[0];
-  printf("%zu, %zu\n", sizeof arraythethird, sizeof ptr);
+  printf("%zu, %zu\n", sizeof(arraythethird), sizeof(ptr));
   // probably prints "40, 4" or "40, 8"
 
   // Pointers are incremented and decremented based on their type
@@ -449,7 +463,7 @@ int main (int argc, char** argv)
   for (xx = 0; xx < 20; xx++) {
     *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx
   } // Initialize memory to 20, 19, 18, 17... 2, 1 (as ints)
-  
+
   // Be careful passing user-provided values to malloc! If you want
   // to be safe, you can use calloc instead (which, unlike malloc, also zeros out the memory)
   int* my_other_ptr = calloc(20, sizeof(int));
@@ -522,9 +536,11 @@ Example: in-place string reversal
 void str_reverse(char *str_in)
 {
   char tmp;
-  int ii = 0;
+  size_t ii = 0;
   size_t len = strlen(str_in); // `strlen()` is part of the c standard library
-  for (ii = 0; ii < len / 2; ii++) {
+                               // NOTE: length returned by `strlen` DOESN'T include the
+                               //       terminating NULL byte ('\0')
+  for (ii = 0; ii < len / 2; ii++) { // in C99 you can directly declare type of `ii` here
     tmp = str_in[ii];
     str_in[ii] = str_in[len - ii - 1]; // ii-th char from end
     str_in[len - ii - 1] = tmp;
@@ -589,6 +605,14 @@ static int j = 0; //other files using testFunc2() cannot access variable j
 void testFunc2() {
   extern int j;
 }
+// The static keyword makes a variable inaccessible to code outside the
+// compilation unit. (On almost all systems, a "compilation unit" is a .c
+// file.) static can apply both to global (to the compilation unit) variables,
+// functions, and function-local variables. When using static with
+// function-local variables, the variable is effectively global and retains its
+// value across function calls, but is only accessible within the function it
+// is declared in. Additionally, static variables are initialized to 0 if not
+// declared with some other starting value.
 //**You may also declare functions as static to make them private**
 
 ///////////////////////////////////////
@@ -703,7 +727,8 @@ typedef void (*my_fnp_type)(char *);
 "%3.2f"; // minimum 3 digits left and 2 digits right decimal float
 "%7.4s"; // (can do with strings too)
 "%c";    // char
-"%p";    // pointer
+"%p";    // pointer. NOTE: need to (void *)-cast the pointer, before passing
+         //                it as an argument to `printf`.
 "%x";    // hexadecimal
 "%o";    // octal
 "%%";    // prints %
diff --git a/ca-es/html-ca.html.markdown b/ca-es/html-ca.html.markdown
new file mode 100644
index 00000000..351eb722
--- /dev/null
+++ b/ca-es/html-ca.html.markdown
@@ -0,0 +1,176 @@
+---
+language: html
+filename: html-ca.md
+contributors:
+    - ["Christophe THOMAS", "https://github.com/WinChris"]
+translators:
+    - ["Marc Auledas", "https://github.com/Auledas"]
+lang: ca-es
+---
+
+HTML significa llenguatge de marques d'hipertext (HyperText Markup Language).
+
+És un llenguatge que permet escriure pàgines pel sistema web (World Wide Web).
+És un llenguatge de marques que permet escriure pàgines web fent servir codi per indicar
+com s'ha de visualitzar el text i les dades. De fet, els fitxers html són simples
+fitxers de text.
+
+Què són les 'marques'? Són un mètode d'organitzar les dades d'una pàgina mitjançant
+etiquetes d'obertura i tancament. Aquestes marques serveixen per donar
+significat al text que hi ha entre les etiquetes. Com d'altres llenguatges de marques,
+hi ha moltes versions de l'HTML. Aquí es desenvoluparà l'HTML5.
+
+**NOTA:** Pots provar les diferents etiquetes i elements a mesura que progressis a través
+del tutorial a pàgines web com [codepen](http://codepen.io/pen/). D'aquesta manera podràs
+veure'n els efectes, entendre com funcionen i familiaritzar-te amb el llenguatge. Aquest
+article tracta principalment la sintaxi de l'HTML i alguns consells útils.
+
+
+```html
+<!-- Els comentaris s'escriuen com aquesta línia! -->
+
+<!--
+	Els comentaris
+	poden
+	ocupar
+	múltiples
+	línies!
+-->
+
+<!-- #################### Les etiquetes #################### -->
+
+<!-- Aquí hi ha un exemple de fitxer HTML que analitzarem. -->
+
+
+<!doctype html>
+	<html>
+		<head>
+			<title>El meu lloc web</title>
+		</head>
+		<body>
+			<h1>Hola, món!</h1>
+			<a href="http://codepen.io/anon/pen/xwjLbZ">
+				Fes una ullada a com es veu això.
+			</a>
+			<p>Això és un paràgraf.</p>
+			<p>Això és un altre paràgraf.</p>
+			<ul>
+				<li>Això és un element d'una llista no enumerada (llista de punts).</li>
+				<li>Això és un altre element.</li>
+				<li>I aquest és l'últim element de la llista.</li>
+			</ul>
+		</body>
+	</html>
+
+<!--
+	Un fitxer HTML sempre comença indicant al navegador que la pàgina és HTML.
+-->
+<!doctype html>
+
+<!-- Després d'això, es comença obrint l'etiqueta <html>. -->
+<html>
+
+<!-- Aquesta etiqueta s'ha de tancar al final del fitxer amb </html>. -->
+</html>
+
+<!-- No s'ha d'escriure res més després d'aquesta etiqueta final. -->
+
+<!-- Entremig (entre les etiquetes d'obertura i tancament <html></html>), trobem: -->
+
+<!-- Una capçalera definida per <head> (que s'ha de tancar emprant </head>). -->
+<!--
+	La capçalera conté descripcions i informació addicional que no es mostra,
+        això són les metadades.
+-->
+
+<head>
+	<!--
+		L'etiqueta <title> indica al navegador el títol que s'ha de visualitzar 
+                a la finestra del buscador, a la barra del títol, i al nom de la pestanya.
+	-->
+	<title>El meu lloc web</title>
+</head>
+
+<!-- Després de la secció <head>, trobem l'etiqueta <body> -->
+<!-- Fins a aquest punt, res del que s'ha fet apareixerà a la finestra del navegador. -->
+<!-- Hem d'emplenar el cos amb el contingut per visualitzar. -->
+
+<body>
+	<!-- L'etiqueta h1 crea el títol. -->
+	<h1>Hola, món!</h1>
+	<!--
+		També es poden fer subtítols per <h1>, que van des del més important <h2>
+                fins al més precís <h6>.
+	-->
+
+	<!-- També es poden crear enllaços fent servir l'atribut href="" -->
+	<a href="http://codepen.io/anon/pen/xwjLbZ">
+		Fes una ullada a com es veu això.
+	</a>
+
+	<!-- L'etiqueta <p> permet incloure text a una pàgina HTML. -->
+	<p>Això és un paràgraf.</p>
+	<p>Això és un altre paràgraf.</p>
+
+	<!-- L'etiqueta <ul> crea una llista de punts. -->
+	<!--
+		Per tenir una llista enumerada s'hauria de fer servir <ol>, en comptes d'<ul>.
+                El primer element seria 1, el segon element 2, etc.
+	-->
+	<ul>
+		<li>Això és un element d'una llista no enumerada (llista de punts).</li>
+		<li>Això és un altre element.</li>
+		<li>I aquest és l'últim element de la llista.</li>
+	</ul>
+</body>
+
+<!-- I això és tot, crear un fitxer HTML pot ser molt simple. -->
+
+<!-- Però és possible afegir molts altres tipus d'etiquetes HTML addicionals. -->
+
+<!-- L'etiqueta <img /> es fa servir per afegir imatges. -->
+<!--
+	L'origen de la imatge s'indica fent servir l'atribut src=""
+	L'origen pot ser una adreça URL o la ruta a un arxiu del teu ordinador.
+-->
+<img src="http://i.imgur.com/XWG0O.gif"/>
+
+<!-- També es poden crear taules. -->
+
+<!-- L'etiqueta <table> obre la taula. -->
+<table>
+
+	<!-- <tr> permet crear files. -->
+	<tr>
+
+	<!-- <th> permet posar títol a la columna d'una taula. -->
+		<th>Primera capçalera</th>
+		<th>Segona capçalera</th>
+	</tr>
+
+	<tr>
+
+	<!-- <td> permet crear cel·les d'una taula. -->
+		<td>Primera fila, primera columna</td>
+		<td>Primera fila, segona columna</td>
+	</tr>
+
+	<tr>
+		<td>Segona fila, primera columna</td>
+		<td>Segona fila, segona columna</td>
+	</tr>
+</table>
+
+```
+
+## Ús
+
+Els arxius HTML acaben amb les extensions `.html` o `.htm`. El tipus MIME és `text/html`.
+
+**HTML NO és un llenguatge de programació**
+
+## Per aprendre'n més
+
+* [Viquipèdia](https://ca.wikipedia.org/wiki/Hyper_Text_Markup_Language)
+* [Tutorial HTML](https://developer.mozilla.org/ca/docs/Web/HTML)
+* [W3School](http://www.w3schools.com/html/html_intro.asp)
diff --git a/chapel.html.markdown b/chapel.html.markdown
index 9190f462..7e8fc41a 100644
--- a/chapel.html.markdown
+++ b/chapel.html.markdown
@@ -100,7 +100,7 @@ writeln(varCmdLineArg, ", ", constCmdLineArg, ", ", paramCmdLineArg);
 // be made to alias a variable other than the variable it is initialized with.
 // Here, refToActual refers to actual.
 var actual = 10;
-ref refToActual = actual; 
+ref refToActual = actual;
 writeln(actual, " == ", refToActual); // prints the same value
 actual = -123; // modify actual (which refToActual refers to)
 writeln(actual, " == ", refToActual); // prints the same value
@@ -444,7 +444,7 @@ arrayFromLoop = [value in arrayFromLoop] value + 1;
 
 // Procedures
 
-// Chapel procedures have similar syntax functions in other languages. 
+// Chapel procedures have similar syntax functions in other languages.
 proc fibonacci(n : int) : int {
   if n <= 1 then return n;
   return fibonacci(n-1) + fibonacci(n-2);
@@ -708,7 +708,7 @@ class MyClass {
 // We also get the compiler-generated initializer, with one argument per field.
 // Note that soon there will be no compiler-generated initializer when we
 // define any initializer(s) explicitly.
-  proc MyClass(val : real) {
+  proc init(val : real) {
     this.memberInt = ceil(val): int;
   }
 
@@ -893,7 +893,6 @@ foo();
 // We can declare a main procedure, but all the code above main still gets
 // executed.
 proc main() {
-  writeln("PARALLELISM START");
 
 // A begin statement will spin the body of that statement off
 // into one new task.
@@ -1141,11 +1140,13 @@ to see if more topics have been added or more tutorials created.
 Your input, questions, and discoveries are important to the developers!
 -----------------------------------------------------------------------
 
-The Chapel language is still in-development (version 1.16.0), so there are
+The Chapel language is still in active development, so there are
 occasional hiccups with performance and language features. The more information
 you give the Chapel development team about issues you encounter or features you
-would like to see, the better the language becomes. Feel free to email the team
-and other developers through the [sourceforge email lists](https://sourceforge.net/p/chapel/mailman).
+would like to see, the better the language becomes.
+There are several ways to interact with the developers:
++ [Gitter chat](https://gitter.im/chapel-lang/chapel)
++ [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).
@@ -1154,12 +1155,14 @@ It is under the [Apache 2.0 License](http://www.apache.org/licenses/LICENSE-2.0)
 Installing the Compiler
 -----------------------
 
+[The Official Chapel documentation details how to download and compile the Chapel compiler.](https://chapel-lang.org/docs/usingchapel/QUICKSTART.html)
+
 Chapel can be built and installed on your average 'nix machine (and cygwin).
 [Download the latest release version](https://github.com/chapel-lang/chapel/releases/)
 and it's as easy as
 
- 1. `tar -xvf chapel-1.16.0.tar.gz`
- 2. `cd chapel-1.16.0`
+ 1. `tar -xvf chapel-<VERSION>.tar.gz`
+ 2. `cd chapel-<VERSION>`
  3. `source util/setchplenv.bash # or .sh or .csh or .fish`
  4. `make`
  5. `make check # optional`
diff --git a/citron.html.markdown b/citron.html.markdown
new file mode 100644
index 00000000..bd3c398c
--- /dev/null
+++ b/citron.html.markdown
@@ -0,0 +1,212 @@
+---
+language: citron
+filename: learncitron.ctr
+contributors:
+    - ["AnotherTest", ""]
+lang: en-us
+---
+```ruby
+# Comments start with a '#'
+# All comments encompass a single line
+
+###########################################
+## 1. Primitive Data types and Operators
+###########################################
+
+# You have numbers
+3. # 3
+
+# Numbers are all doubles in interpreted mode
+
+# Mathematical operator precedence is not respected.
+# binary 'operators' are evaluated in ltr order
+1 + 1. # 2
+8 - 4. # 4
+10 + 2 * 3. # 36
+
+# Division is always floating division
+35 / 2 # 17.5.
+
+# Integer division is non-trivial, you may use floor
+(35 / 2) floor # 17.
+
+# Booleans are primitives
+True.
+False.
+
+# Boolean messages
+True not. # False
+False not. # True
+1 = 1. # True
+1 !=: 1. # False
+1 < 10. # True
+
+# Here, `not` is a unary message to the object `Boolean`
+# Messages are comparable to instance method calls
+# And they have three different forms:
+#   1. Unary messages: Length > 1, and they take no arguments:
+        False not.
+#   2. Binary Messages: Length = 1, and they take a single argument:
+        False & True.
+#   3. Keyword messages: must have at least one ':', they take as many arguments
+#      as they have `:` s
+        False either: 1 or: 2. # 2
+
+# Strings
+'This is a string'.
+'There are no character types exposed to the user'.
+# "You cannot use double quotes for strings" <- Error
+
+# Strins can be summed
+'Hello, ' + 'World!'. # 'Hello, World!'
+
+# Strings allow access to their characters
+'This is a beautiful string' at: 0. # 'T'
+
+###########################################
+## intermission: Basic Assignment
+###########################################
+
+# You may assign values to the current scope:
+var name is value. # assignes `value` into `name`
+
+# You may also assign values into the current object's namespace
+my name is value. # assigns `value` into the current object's `name` property
+
+# Please note that these names are checked at compile (read parse if in interpreted mode) time
+# but you may treat them as dynamic assignments anyway
+
+###########################################
+## 2. Lists(Arrays?) and Tuples
+###########################################
+
+# Arrays are allowed to have multiple types
+Array new < 1 ; 2 ; 'string' ; Nil. # Array new < 1 ; 2 ; 'string' ; Nil
+
+# Tuples act like arrays, but are immutable.
+# Any shenanigans degrade them to arrays, however
+[1, 2, 'string']. # [1, 2, 'string']
+
+# They can interoperate with arrays
+[1, 'string'] + (Array new < 'wat'). # Array new < 1 ; 'string' ; 'wat'
+
+# Indexing into them
+[1, 2, 3] at: 1. # 2
+
+# Some array operations
+var arr is Array new < 1 ; 2 ; 3.
+
+arr head. # 1
+arr tail. # Array new < 2 ; 3.
+arr init. # Array new < 1 ; 2.
+arr last. # 3
+arr push: 4. # Array new < 1 ; 2 ; 3 ; 4.
+arr pop. # 4
+arr pop: 1. # 2, `arr` is rebound to Array new < 1 ; 3.
+
+# List comprehensions
+[x * 2 + y,, arr, arr + [4, 5],, x > 1]. # Array ← 7 ; 9 ; 10 ; 11
+# fresh variable names are bound as they are encountered,
+# so `x` is bound to the values in `arr`
+# and `y` is bound to the values in `arr + [4, 5]`
+#
+# The general format is: [expr,, bindings*,, predicates*]
+
+
+####################################
+## 3. Functions
+####################################
+
+# A simple function that takes two variables
+var add is {:a:b ^a + b.}.
+
+# this function will resolve all its names except the formal arguments
+# in the context it is called in.
+
+# Using the function
+add applyTo: 3 and: 5. # 8
+add applyAll: [3, 5]. # 8
+
+# Also a (customizable -- more on this later) pseudo-operator allows for a shorthand
+# of function calls
+# By default it is REF[args]
+
+add[3, 5]. # 8
+
+# To customize this behaviour, you may simply use a compiler pragma:
+#:callShorthand ()
+
+# And then you may use the specified operator.
+# Note that the allowed 'operator' can only be made of any of these: []{}()
+# And you may mix-and-match (why would anyone do that?)
+
+add(3, 5). # 8
+
+# You may also use functions as operators in the following way:
+
+3 `add` 5. # 8
+# This call binds as such: add[(3), 5]
+# because the default fixity is left, and the default precedance is 1
+
+# You may change the precedence/fixity of this operator with a pragma
+#:declare infixr 1 add
+
+3 `add` 5. # 8
+# now this binds as such: add[3, (5)].
+
+# There is another form of functions too
+# So far, the functions were resolved in a dynamic fashion
+# But a lexically scoped block is also possible
+var sillyAdd is {\:x:y add[x,y].}.
+
+# In these blocks, you are not allowed to declare new variables
+# Except with the use of Object::'letEqual:in:`
+# And the last expression is implicitly returned.
+
+# You may also use a shorthand for lambda expressions
+var mul is \:x:y x * y.
+
+# These capture the named bindings that are not present in their
+# formal parameters, and retain them. (by ref)
+
+###########################################
+## 5. Control Flow
+###########################################
+
+# inline conditional-expressions
+var citron is 1 = 1 either: 'awesome' or: 'awful'. # citron is 'awesome'
+
+# multiple lines is fine too
+var citron is 1 = 1
+    either: 'awesome'
+    or:     'awful'.
+
+# looping
+10 times: {:x
+    Pen writeln: x.
+}. # 10. -- side effect: 10 lines in stdout, with numbers 0 through 9 in them
+
+# Citron properly supports tail-call recursion in lexically scoped blocks
+# So use those to your heart's desire
+
+# mapping most data structures is as simple as `fmap:`
+[1, 2, 3, 4] fmap: \:x x + 1. # [2, 3, 4, 5]
+
+# You can use `foldl:accumulator:` to fold a list/tuple
+[1, 2, 3, 4] foldl: (\:acc:x acc * 2 + x) accumulator: 4. # 90
+
+# That expression is the same as
+(2 * (2 * (2 * (2 * 4 + 1) + 2) + 3) + 4)
+
+###################################
+## 6. IO
+###################################
+
+# IO is quite simple
+# With `Pen` being used for console output
+# and Program::'input' and Program::'waitForInput' being used for console input
+
+Pen writeln: 'Hello, ocean!' # prints 'Hello, ocean!\n' to the terminal
+
+Pen writeln: Program waitForInput. # reads a line and prints it back
+```
diff --git a/clojure-macros.html.markdown b/clojure-macros.html.markdown
index 3864f676..6154d570 100644
--- a/clojure-macros.html.markdown
+++ b/clojure-macros.html.markdown
@@ -142,11 +142,8 @@ You'll want to be familiar with Clojure. Make sure you understand everything in
 
 ### Further Reading
 
-Writing Macros from [Clojure for the Brave and True](http://www.braveclojure.com/)
-[http://www.braveclojure.com/writing-macros/](http://www.braveclojure.com/writing-macros/)
+[Writing Macros](http://www.braveclojure.com/writing-macros/)
 
-Official docs
-[http://clojure.org/macros](http://clojure.org/macros)
+[Official docs](http://clojure.org/macros)
 
-When to use macros?
-[http://dunsmor.com/lisp/onlisp/onlisp_12.html](http://dunsmor.com/lisp/onlisp/onlisp_12.html)
+[When to use macros?](https://lispcast.com/when-to-use-a-macro/)
diff --git a/clojure.html.markdown b/clojure.html.markdown
index 7830f228..16771e25 100644
--- a/clojure.html.markdown
+++ b/clojure.html.markdown
@@ -150,7 +150,7 @@ x ; => 1
 
 ; You can also use this shorthand to create functions:
 (def hello2 #(str "Hello " %1))
-(hello2 "Fanny") ; => "Hello Fanny"
+(hello2 "Julie") ; => "Hello Julie"
 
 ; You can have multi-variadic functions, too
 (defn hello3
@@ -416,3 +416,6 @@ Clojuredocs.org has documentation with examples for most core functions:
 
 Clojure-doc.org (yes, really) has a number of getting started articles:
 [http://clojure-doc.org/](http://clojure-doc.org/)
+
+Clojure for the Brave and True has a great introduction to Clojure and a free online version:
+[https://www.braveclojure.com/clojure-for-the-brave-and-true/](https://www.braveclojure.com/clojure-for-the-brave-and-true/)
diff --git a/cmake.html.markdown b/cmake.html.markdown
index c705beea..32a7b758 100644
--- a/cmake.html.markdown
+++ b/cmake.html.markdown
@@ -1,5 +1,6 @@
 ---
-language: cmake
+category: tool
+tool: cmake
 contributors:
     - ["Bruno Alano", "https://github.com/brunoalano"]
 filename: CMake
diff --git a/common-lisp.html.markdown b/common-lisp.html.markdown
index e2cf62fb..b12e50ca 100644
--- a/common-lisp.html.markdown
+++ b/common-lisp.html.markdown
@@ -16,7 +16,7 @@ popular and recent book is [Land of Lisp](http://landoflisp.com/). A new book ab
 
 
 
-```common-lisp
+```lisp
 
 ;;;-----------------------------------------------------------------------------
 ;;; 0. Syntax
@@ -181,8 +181,8 @@ nil                    ; false; also, the empty list: ()
 ;;; You can also use unicode characters.
 (defparameter *AΛB* nil)
 
-;;; Accessing a previously unbound variable is an undefined behavior, but
-;;; possible. Don't do it.
+;;; Accessing a previously unbound variable results in an UNBOUND-VARIABLE
+;;; error, however it is defined behavior. Don't do it.
 
 ;;; You can create local bindings with LET. In the following snippet, `me` is
 ;;; bound to "dance with you" only within the (let ...). LET always returns
@@ -284,7 +284,8 @@ nil                    ; false; also, the empty list: ()
 ;;; To access the element at 1, 1, 1:
 
 (aref (make-array (list 2 2 2)) 1 1 1)     ;  => 0
-
+;;; This value is implementation-defined:
+;;; NIL on ECL, 0 on SBCL and CCL.
 
 ;;; Adjustable vectors
 
@@ -502,7 +503,7 @@ nil                    ; false; also, the empty list: ()
 
 (fact 5) ; => 120
 
-(loop :for x :across "abc" :collect x)
+(loop :for x :across "abcd" :collect x)
 ; => (#\a #\b #\c #\d)
 
 (dolist (i '(1 2 3 4))
diff --git a/coq.html.markdown b/coq.html.markdown
new file mode 100644
index 00000000..604a1f56
--- /dev/null
+++ b/coq.html.markdown
@@ -0,0 +1,478 @@
+---
+language: Coq
+filename: learncoq.v
+contributors:
+    - ["Philip Zucker", "http://www.philipzucker.com/"]
+---
+
+The Coq system is a proof assistant. It is designed to build and verify mathematical proofs. The Coq system contains the functional programming language Gallina and is capable of proving properties about programs written in this language.
+
+Coq is a dependently typed language. This means that the types of the language may depend on the values of variables. In this respect, it is similar to other related languages such as Agda, Idris, F*, Lean, and others. Via the Curry-Howard correspondence, programs, properties and proofs are formalized in the same language.
+
+Coq is developed in OCaml and shares some syntactic and conceptual similarity with it. Coq is a language containing many fascinating but difficult topics. This tutorial will focus on the programming aspects of Coq, rather than the proving. It may be helpful, but not necessary to learn some OCaml first, especially if you are unfamiliar with functional programming. This tutorial is based upon its OCaml equivalent
+
+The standard usage model of Coq is to write it with interactive tool assistance, which operates like a high powered REPL. Two common such editors are the CoqIDE and Proof General Emacs mode.
+
+Inside Proof General `Ctrl+C Ctrl+<Enter>` will evaluate up to your cursor.
+
+
+```ocaml
+(*** Comments ***)
+
+(* Comments are enclosed in (* and *). It's fine to nest comments. *)
+
+(* There are no single-line comments. *)
+
+(*** Variables and functions ***)
+
+(* The Coq proof assistant can be controlled and queried by a command language called 
+   the vernacular. Vernacular keywords are capitalized and the commands end with a period.
+   Variable and function declarations are formed with the Definition vernacular. *)
+
+Definition x := 10.
+
+(* Coq can sometimes infer the types of arguments, but it is common practice to annotate
+   with types. *)
+
+Definition inc_nat (x : nat) : nat := x + 1.
+
+(* There exists a large number of vernacular commands for querying information. 
+   These can be very useful. *)
+
+Compute (1 + 1). (* 2 : nat *) (* Compute a result. *)
+
+Check tt. (* tt : unit *) (* Check the type of an expressions *)
+
+About plus. (* Prints information about an object *)
+
+(* Print information including the definition *)
+Print true. (* Inductive bool : Set := true : Bool | false : Bool *)  
+
+Search nat. (* Returns a large list of nat related values *)
+Search "_ + _". (* You can also search on patterns *)
+Search (?a -> ?a -> bool). (* Patterns can have named parameters  *)
+Search (?a * ?a).
+
+(* Locate tells you where notation is coming from. Very helpful when you encounter
+   new notation. *)
+Locate "+". 
+
+(* Calling a function with insufficient number of arguments
+   does not cause an error, it produces a new function. *)
+Definition make_inc x y := x + y. (* make_inc is int -> int -> int *)
+Definition inc_2 := make_inc 2.   (* inc_2 is int -> int *)
+Compute inc_2 3. (* Evaluates to 5 *)
+
+(* Definitions can be chained with "let ... in" construct.
+   This is roughly the same to assigning values to multiple
+   variables before using them in expressions in imperative
+   languages. *)
+Definition add_xy : nat := let x := 10 in
+                           let y := 20 in
+                           x + y.
+
+
+(* Pattern matching is somewhat similar to switch statement in imperative
+   languages, but offers a lot more expressive power. *)
+Definition is_zero (x : nat) :=
+    match x with
+    | 0 => true
+    | _ => false  (* The "_" pattern means "anything else". *)
+    end.
+
+
+(* You can define recursive function definition using the Fixpoint vernacular.*)
+Fixpoint factorial n := match n with
+                        | 0 => 1
+                        | (S n') => n * factorial n'
+                        end.
+
+
+(* Function application usually doesn't need parentheses around arguments *)
+Compute factorial 5. (* 120 : nat *)
+
+(* ...unless the argument is an expression. *)
+Compute factorial (5-1). (* 24 : nat *)
+
+(* You can define mutually recursive functions using "with" *)
+Fixpoint is_even (n : nat) : bool := match n with
+  | 0 => true
+  | (S n) => is_odd n
+end with
+  is_odd n := match n with
+  | 0 => false
+  | (S n) => is_even n
+              end.
+
+(* As Coq is a total programming language, it will only accept programs when it can
+   understand they terminate. It can be most easily seen when the recursive call is
+   on a pattern matched out subpiece of the input, as then the input is always decreasing
+   in size. Getting Coq to understand that functions terminate is not always easy. See the
+   references at the end of the article for more on this topic. *)
+
+(* Anonymous functions use the following syntax: *)
+
+Definition my_square : nat -> nat := fun x => x * x.
+
+Definition my_id (A : Type) (x : A) : A := x.
+Definition my_id2 : forall A : Type, A -> A := fun A x => x.
+Compute my_id nat 3. (* 3 : nat *)
+
+(* You can ask Coq to infer terms with an underscore *)
+Compute my_id _ 3. 
+
+(* An implicit argument of a function is an argument which can be inferred from contextual
+   knowledge. Parameters enclosed in {} are implicit by default *)
+
+Definition my_id3 {A : Type} (x : A) : A := x.
+Compute my_id3 3. (* 3 : nat *)
+
+(* Sometimes it may be necessary to turn this off. You can make all arguments explicit
+   again with @ *)
+Compute @my_id3 nat 3.
+
+(* Or give arguments by name *)
+Compute my_id3 (A:=nat) 3.
+
+(* Coq has the ability to extract code to OCaml, Haskell, and Scheme *)
+Require Extraction.
+Extraction Language OCaml.
+Extraction "factorial.ml" factorial.
+(* The above produces a file factorial.ml and factorial.mli that holds:
+
+type nat =
+| O
+| S of nat
+
+(** val add : nat -> nat -> nat **)
+
+let rec add n m =
+  match n with
+  | O -> m
+  | S p -> S (add p m)
+
+(** val mul : nat -> nat -> nat **)
+
+let rec mul n m =
+  match n with
+  | O -> O
+  | S p -> add m (mul p m)
+
+(** val factorial : nat -> nat **)
+
+let rec factorial n = match n with
+| O -> S O
+| S n' -> mul n (factorial n')
+*)
+
+
+(*** Notation ***)
+
+(* Coq has a very powerful Notation system that can be used to write expressions in more
+   natural forms. *)
+Compute Nat.add 3 4. (* 7 : nat *)
+Compute 3 + 4. (* 7 : nat *)
+
+(* Notation is a syntactic transformation applied to the text of the program before being
+   evaluated. Notation is organized into notation scopes. Using different notation scopes
+   allows for a weak notion of overloading. *)
+
+(* Imports the Zarith module containing definitions related to the integers Z *)
+Require Import ZArith. 
+
+(* Notation scopes can be opened *)
+Open Scope Z_scope.
+
+(* Now numerals and addition are defined on the integers. *)
+Compute 1 + 7. (* 8 : Z *)
+
+(* Integer equality checking *)
+Compute 1 =? 2. (* false : bool *) 
+
+(* Locate is useful for finding the origin and definition of notations *)
+Locate "_ =? _". (* Z.eqb x y : Z_scope *)
+Close Scope Z_scope.
+
+(* We're back to nat being the default interpretation of "+" *)
+Compute 1 + 7. (* 8 : nat *)
+
+(* Scopes can also be opened inline with the shorthand % *)
+Compute (3 * -7)%Z. (* -21%Z : Z *)
+
+(* Coq declares by default the following interpretation scopes: core_scope, type_scope, 
+   function_scope, nat_scope, bool_scope, list_scope, int_scope, uint_scope. You may also
+   want the numerical scopes Z_scope (integers) and Q_scope (fractions) held in the ZArith
+   and QArith module respectively. *)
+
+(* You can print the contents of scopes *)
+Print Scope nat_scope.
+(*
+Scope nat_scope
+Delimiting key is nat
+Bound to classes nat Nat.t
+"x 'mod' y" := Nat.modulo x y
+"x ^ y" := Nat.pow x y
+"x ?= y" := Nat.compare x y
+"x >= y" := ge x y
+"x > y" := gt x y
+"x =? y" := Nat.eqb x y
+"x <? y" := Nat.ltb x y
+"x <=? y" := Nat.leb x y
+"x <= y <= z" := and (le x y) (le y z)
+"x <= y < z" := and (le x y) (lt y z)
+"n <= m" := le n m
+"x < y <= z" := and (lt x y) (le y z)
+"x < y < z" := and (lt x y) (lt y z)
+"x < y" := lt x y
+"x / y" := Nat.div x y
+"x - y" := Init.Nat.sub x y
+"x + y" := Init.Nat.add x y
+"x * y" := Init.Nat.mul x y
+*)
+
+(* Coq has exact fractions available as the type Q in the QArith module. 
+   Floating point numbers and real numbers are also available but are a more advanced
+   topic, as proving properties about them is rather tricky. *)
+
+Require Import QArith.
+
+Open Scope Q_scope.
+Compute 1. (* 1 : Q *)
+Compute 2. (* 2 : nat *) (* only 1 and 0 are interpreted as fractions by Q_scope *) 
+Compute (2 # 3). (* The fraction 2/3 *)
+Compute (1 # 3) ?= (2 # 6). (* Eq : comparison *) 
+Close Scope Q_scope.
+
+Compute ( (2 # 3) / (1 # 5) )%Q. (* 10 # 3 : Q *)
+
+
+(*** Common data structures ***)
+
+(* Many common data types are included in the standard library *)
+
+(* The unit type has exactly one value, tt *)
+Check tt. (* tt : unit *)
+
+(* The option type is useful for expressing computations that might fail *)
+Compute None. (* None : option ?A *)
+Check Some 3. (* Some 3 : option nat *)
+
+(* The type sum A B allows for values of either type A or type B *)
+Print sum.
+Check inl 3. (* inl 3 : nat + ?B *)
+Check inr true. (* inr true : ?A + bool *)
+Check sum bool nat. (* (bool + nat)%type : Set *)
+Check (bool + nat)%type. (* Notation for sum *)
+
+(* Tuples are (optionally) enclosed in parentheses, items are separated
+   by commas. *)
+Check (1, true). (* (1, true) : nat * bool *)
+Compute prod nat bool. (* (nat * bool)%type : Set *)
+
+Definition my_fst {A B : Type} (x : A * B) : A := match x with
+                                                  | (a,b) => a
+                                                  end.
+
+(* A destructuring let is available if a pattern match is irrefutable *)
+Definition my_fst2 {A B : Type} (x : A * B) : A := let (a,b) := x in
+                                                   a.
+
+(*** Lists ***)
+
+(* Lists are built by using cons and nil or by using notation available in list_scope. *)
+Compute cons 1 (cons 2 (cons 3 nil)). (*  (1 :: 2 :: 3 :: nil)%list : list nat *)
+Compute (1 :: 2 :: 3 :: nil)%list. 
+
+(* There is also list notation available in the ListNotations modules *)
+Require Import List.
+Import ListNotations. 
+Compute [1 ; 2 ; 3]. (* [1; 2; 3] : list nat *)
+
+
+(*
+There are a large number of list manipulation functions available, including:
+
+• length
+• head : first element (with default) 
+• tail : all but first element
+• app : appending
+• rev : reverse
+• nth : accessing n-th element (with default)
+• map : applying a function
+• flat_map : applying a function returning lists 
+• fold_left : iterator (from head to tail)
+• fold_right : iterator (from tail to head) 
+
+ *)
+
+Definition my_list : list nat := [47; 18; 34].
+
+Compute List.length my_list. (* 3 : nat *)
+(* All functions in coq must be total, so indexing requires a default value *)
+Compute List.nth 1 my_list 0. (* 18 : nat *) 
+Compute List.map (fun x => x * 2) my_list. (* [94; 36; 68] : list nat *)
+Compute List.filter (fun x => Nat.eqb (Nat.modulo x 2) 0) my_list. (*  [18; 34] : list nat *)
+Compute (my_list ++ my_list)%list. (*  [47; 18; 34; 47; 18; 34] : list nat *)
+
+(*** Strings ***)
+
+Require Import Strings.String.
+
+(* Use double quotes for string literals. *)
+Compute "hi"%string.
+
+Open Scope string_scope.
+
+(* Strings can be concatenated with the "++" operator. *)
+Compute String.append "Hello " "World". (* "Hello World" : string *)
+Compute "Hello " ++ "World". (* "Hello World" : string *)
+
+(* Strings can be compared for equality *)
+Compute String.eqb "Coq is fun!" "Coq is fun!". (* true : bool *)
+Compute "no" =? "way". (* false : bool *)
+
+Close Scope string_scope.
+
+(*** Other Modules ***)
+
+(* Other Modules in the standard library that may be of interest:
+
+• Logic : Classical logic and dependent equality
+• Arith : Basic Peano arithmetic
+• PArith : Basic positive integer arithmetic
+• NArith : Basic binary natural number arithmetic
+• ZArith : Basic relative integer arithmetic
+• Numbers : Various approaches to natural, integer and cyclic numbers (currently 
+            axiomatically and on top of 2^31 binary words)
+• Bool : Booleans (basic functions and results)
+• Lists : Monomorphic and polymorphic lists (basic functions and results),
+          Streams (infinite sequences defined with co-inductive types)
+• Sets : Sets (classical, constructive, finite, infinite, power set, etc.)
+• FSets : Specification and implementations of finite sets and finite maps 
+          (by lists and by AVL trees)
+• Reals : Axiomatization of real numbers (classical, basic functions, integer part, 
+          fractional part, limit, derivative, Cauchy series, power series and results,...)
+• Relations : Relations (definitions and basic results)
+• Sorting : Sorted list (basic definitions and heapsort correctness)
+• Strings : 8-bits characters and strings
+• Wellfounded : Well-founded relations (basic results)
+ *)
+
+(*** User-defined data types ***)
+
+(* Because Coq is dependently typed, defining type aliases is no different than defining
+   an alias for a value. *)
+
+Definition my_three : nat := 3.
+Definition my_nat : Type := nat.
+
+(* More interesting types can be defined using the Inductive vernacular. Simple enumeration
+   can be defined like so *)
+Inductive ml := OCaml | StandardML | Coq.
+Definition lang := Coq.  (* Has type "ml". *)
+
+(* For more complicated types, you will need to specify the types of the constructors. *)
+
+(* Type constructors don't need to be empty. *)
+Inductive my_number := plus_infinity
+                     | nat_value : nat -> my_number.
+Compute nat_value 3. (* nat_value 3 : my_number *)
+
+
+(* Record syntax is sugar for tuple-like types. It defines named accessor functions for
+   the components. Record types are defined with the notation {...} *)
+Record Point2d (A : Set) := mkPoint2d { x2 : A ; y2 : A }.
+(* Record values are constructed with the notation {|...|} *)
+Definition mypoint : Point2d nat :=  {| x2 := 2 ; y2 := 3 |}.
+Compute x2 nat mypoint. (* 2 : nat *)
+Compute mypoint.(x2 nat). (* 2 : nat *) 
+
+(* Types can be parameterized, like in this type for "list of lists
+   of anything". 'a can be substituted with any type. *)
+Definition list_of_lists a := list (list a).
+Definition list_list_nat := list_of_lists nat.
+
+(* Types can also be recursive. Like in this type analogous to
+   built-in list of naturals. *)
+
+Inductive my_nat_list := EmptyList | NatList : nat -> my_nat_list -> my_nat_list.
+Compute NatList 1 EmptyList. (*  NatList 1 EmptyList : my_nat_list *)
+
+(** Matching type constructors **)
+
+Inductive animal := Dog : string -> animal | Cat : string -> animal.
+
+Definition say x :=
+    match x with
+    | Dog x => (x ++ " says woof")%string
+    | Cat x => (x ++ " says meow")%string
+    end.
+
+Compute say (Cat "Fluffy"). (* "Fluffy says meow". *)
+
+(** Traversing data structures with pattern matching **)
+
+(* Recursive types can be traversed with pattern matching easily.
+   Let's see how we can traverse a data structure of the built-in list type.
+   Even though the built-in cons ("::") looks like an infix operator,
+   it's actually a type constructor and can be matched like any other. *)
+Fixpoint sum_list l :=
+    match l with
+    | [] => 0
+    | head :: tail => head + (sum_list tail)
+    end.
+
+Compute sum_list [1; 2; 3]. (* Evaluates to 6 *)
+
+
+(*** A Taste of Proving ***)
+
+(* Explaining the proof language is out of scope for this tutorial, but here is a taste to
+   whet your appetite. Check the resources below for more. *)
+
+(* A fascinating feature of dependently type based theorem provers is that the same
+  primitive constructs underly the proof language as the programming features.
+  For example, we can write and prove the proposition A and B implies A in raw Gallina *)
+
+Definition my_theorem : forall A B, A /\ B -> A := fun A B ab => match ab with
+                                                                 | (conj a b) => a
+                                                                 end.
+
+(* Or we can prove it using tactics. Tactics are a macro language to help build proof terms
+   in a more natural style and automate away some drudgery. *)
+Theorem my_theorem2 : forall A B, A /\ B -> A.
+Proof.
+  intros A B ab.  destruct ab as [ a b ]. apply a.
+Qed.
+
+(* We can prove easily prove simple polynomial equalities using the automated tactic ring. *)
+Require Import Ring.
+Require Import Arith.
+Theorem simple_poly : forall (x : nat), (x + 1) * (x + 2) = x * x + 3 * x + 2.
+  Proof. intros. ring. Qed.
+
+(* Here we prove the closed form for the sum of all numbers 1 to n using induction *)
+
+Fixpoint sumn (n : nat) : nat :=
+  match n with
+  | 0 => 0
+  | (S n') => n + (sumn n')
+  end.
+
+Theorem sum_formula : forall n, 2 * (sumn n) = (n + 1) * n.
+Proof. intros n. induction n.
+       - reflexivity. (* 0 = 0 base case *)
+       - simpl. ring [IHn]. (* induction step *)
+Qed.
+```
+                                
+With this we have only scratched the surface of Coq. It is a massive ecosystem with many interesting and peculiar topics leading all the way up to modern research.
+
+## Further reading
+
+* [The Coq reference manual](https://coq.inria.fr/refman/)
+* [Software Foundations](https://softwarefoundations.cis.upenn.edu/)
+* [Certified Programming with Dependent Types](http://adam.chlipala.net/cpdt/)
+* [Mathematical Components](https://math-comp.github.io/mcb/)
+* [Coq'Art: The Calculus of Inductive Constructions](http://www.cse.chalmers.se/research/group/logic/TypesSS05/resources/coq/CoqArt/)
+* [FRAP](http://adam.chlipala.net/frap/)
diff --git a/crystal.html.markdown b/crystal.html.markdown
index 8210b443..9fae9da3 100644
--- a/crystal.html.markdown
+++ b/crystal.html.markdown
@@ -25,17 +25,19 @@ true.class #=> Bool
 
 1.class #=> Int32
 
-# Four signed integer types
-1_i8.class  #=> Int8
-1_i16.class #=> Int16
-1_i32.class #=> Int32
-1_i64.class #=> Int64
-
-# Four unsigned integer types
-1_u8.class  #=> UInt8
-1_u16.class #=> UInt16
-1_u32.class #=> UInt32
-1_u64.class #=> UInt64
+# Five signed integer types
+1_i8.class   #=> Int8
+1_i16.class  #=> Int16
+1_i32.class  #=> Int32
+1_i64.class  #=> Int64
+1_i128.class #=> Int128
+
+# Five unsigned integer types
+1_u8.class   #=> UInt8
+1_u16.class  #=> UInt16
+1_u32.class  #=> UInt32
+1_u64.class  #=> UInt64
+1_u128.class #=> UInt128
 
 2147483648.class          #=> Int64
 9223372036854775808.class #=> UInt64
diff --git a/cs-cz/javascript.html.markdown b/cs-cz/javascript.html.markdown
index cbf7687e..c05a9138 100644
--- a/cs-cz/javascript.html.markdown
+++ b/cs-cz/javascript.html.markdown
@@ -9,33 +9,28 @@ lang: cs-cz
 filename: javascript-cz.js
 ---
 
-JavaScript byl vytvořen Brendan Eichem v roce 1995 pro Netscape. Byl původně
-zamýšlen jako jednoduchý skriptovací jazyk pro webové stránky, jako doplněk Javy,
-která byla zamýšlena pro více komplexní webové aplikace, ale jeho úzké propojení
-s webovými stránkami a vestavěná podpora v prohlížečích způsobila, že se stala
-více běžná ve webovém frontendu než Java.
+JavaScript byl vytvořen Brendanem Eichem v roce 1995 pro Netscape. Původně byl
+zamýšlen jako jednoduchý skriptovací jazyk pro webové stránky, jako doplněk
+Javy, která byla zamýšlena pro komplexnější webové aplikace. Úzké propojení
+JavaScriptu s webovými stránkami a vestavěná podpora v prohlížečích způsobila,
+že se stal ve webovém frontendu běžnějším než Java.
 
-
-JavaScript není omezen pouze na webové prohlížeče, např. projekt Node.js,
-který zprostředkovává samostatně běžící prostředí V8 JavaScriptového enginu z
-Google Chrome se stává více a více oblíbený pro serverovou část webových aplikací.
-
-Zpětná vazba je velmi ceněná. Autora článku můžete kontaktovat (anglicky) na
-[@adambrenecki](https://twitter.com/adambrenecki), nebo
-[adam@brenecki.id.au](mailto:adam@brenecki.id.au), nebo mě, jakožto překladatele,
-na [martinek@ludis.me](mailto:martinek@ludis.me).
+JavaScript není omezen pouze na webové prohlížeče. Např. projekt Node.js,
+který zprostředkovává samostatně běžící prostředí V8 JavaScriptového jádra z
+Google Chrome se stává stále oblíbenější i pro serverovou část webových
+aplikací.
 
 ```js
-// Komentáře jsou jako v zayku C. Jednořádkové komentáře začínájí dvojitým lomítkem,
+// Jednořádkové komentáře začínají dvojitým lomítkem,
 /* a víceřádkové komentáře začínají lomítkem s hvězdičkou
    a končí hvězdičkou s lomítkem */
 
-// Vyrazu můžou být spuštěny pomocí ;
+// Příkazy mohou být ukončeny středníkem ;
 delejNeco();
 
-// ... ale nemusí, středníky jsou automaticky vloženy kdekoliv,
-// kde končí řádka, kromě pár speciálních případů
-delejNeco()
+// ... ale nemusí, protože středníky jsou automaticky vloženy kdekoliv,
+// kde končí řádka, kromě pár speciálních případů.
+delejNeco();
 
 // Protože tyto případy můžou způsobit neočekávané výsledky, budeme
 // středníky v našem návodu používat.
@@ -44,12 +39,12 @@ delejNeco()
 // 1. Čísla, řetězce a operátory
 
 // JavaScript má jeden číselný typ (čímž je 64-bitový IEEE 754 double).
-// Double má 52-bit přesnost, což je dostatečně přesné pro ukládání celých čísel
-// do 9✕10¹⁵.
+// Double má 52-bitovou přesnost, což je dostatečně přesné pro ukládání celých
+// čísel až do 9✕10¹⁵.
 3; // = 3
 1.5; // = 1.5
 
-// Základní matematické operace fungují, jak byste očekávali
+// Základní matematické operace fungují tak, jak byste očekávali
 1 + 1; // = 2
 0.1 + 0.2; // = 0.30000000000000004
 8 - 1; // = 7
@@ -65,30 +60,30 @@ delejNeco()
 18.5 % 7; // = 4.5
 
 // Bitové operace také fungují; když provádíte bitové operace, desetinné číslo  
-// (float) se převede na celé číslo (int) se znaménkem *do* 32 bitů
+// (float) se převede na celé číslo (int) se znaménkem *až do* 32 bitů
 1 << 2; // = 4
 
 // Přednost se vynucuje závorkami.
 (1 + 3) * 2; // = 8
 
-// Existují 3 hodnoty mimo obor reálných čísel
+// Existují 3 hodnoty mimo obor reálných čísel:
 Infinity; // + nekonečno; výsledek např. 1/0
 -Infinity; // - nekonečno; výsledek např. -1/0
 NaN; // výsledek např. 0/0, znamená, že výsledek není číslo ('Not a Number')
 
-// Také existují hodnoty typu bool
+// Také existují hodnoty typu boolean.
 true; // pravda
 false; // nepravda
 
-// Řetězce znaků jsou obaleny  ' nebo ".
+// Řetězce znaků jsou obaleny ' nebo ".
 'abc';
-"Ahoj světe!";
+"Hello, world";
 
-// Negace se tvoří pomocí !
+// Negace se tvoří pomocí znaku !
 !true; // = false
 !false; // = true
 
-// Rovnost se porovnává ===
+// Rovnost se porovnává pomocí ===
 1 === 1; // = true
 2 === 1; // = false
 
@@ -103,16 +98,16 @@ false; // nepravda
 2 >= 2; // = true
 
 // Řetězce znaků se spojují pomocí +
-"Ahoj " + "světe!"; // = "Ahoj světe!"
+"Hello " + "world!"; // = "Hello world!"
 
-// ... což funguje nejenom s řetězci
+// ... což funguje nejen s řetězci
 "1, 2, " + 3; // = "1, 2, 3"
-"Ahoj " + ["světe", "!"] // = "Ahoj světe,!"
+"Hello " + ["world", "!"]; // = "Hello world,!"
 
 // a porovnávají se pomocí < nebo >
 "a" < "b"; // = true
 
-// Rovnost s převodem typů se dělá pomocí == ...
+// Rovnost s převodem typů se dělá za pomoci dvojitého rovnítka...
 "5" == 5; // = true
 null == undefined; // = true
 
@@ -124,24 +119,24 @@ null === undefined; // = false
 13 + !0; // 14
 "13" + !0; // '13true'
 
-// Můžeme přistupovat k jednotlivým znakům v řetězci pomocí charAt`
+// Můžeme přistupovat k jednotlivým znakům v řetězci pomocí `charAt`
 "Toto je řetězec".charAt(0);  // = 'T'
 
-// ...nebo použít `substring` k získání podřetězce
-"Ahoj světe".substring(0, 4); // = "Ahoj"
+// ...nebo použít `substring` k získání podřetězce.
+"Hello world".substring(0, 5); // = "Hello"
 
-// `length` znamená délka a je to vlastnost, takže nepoužívejte ()
-"Ahoj".length; // = 4
+// `length` znamená délka a je to vlastnost, takže nepoužívejte ().
+"Hello".length; // = 5
 
 // Existují také typy `null` a `undefined`.
-null;      // značí, že žádnou hodnotu
-undefined; // značí, že hodnota nebyla definovaná (ikdyž
+null;      // obvykle označuje něco záměrně bez hodnoty
+undefined; // obvykle označuje, že hodnota není momentálně definovaná (ačkoli
            // `undefined` je hodnota sama o sobě)
 
-// false, null, undefined, NaN, 0 and "" vrací nepravdu (false). Všechno ostatní
-// vrací pravdu (true)..
-// Všimněte si, že 0 vrací nepravdu, ale "0" vrací pravdu, ikdyž 0 == "0"
-// vrací pravdu
+// false, null, undefined, NaN, 0 a "" vrací nepravdu (false). Všechno ostatní
+// vrací pravdu (true).
+// Všimněte si, že 0 vrací nepravdu, ale "0" vrací pravdu, i když 0 == "0"
+// vrací pravdu.
 
 ///////////////////////////////////
 // 2. Proměnné, pole a objekty
@@ -151,11 +146,11 @@ undefined; // značí, že hodnota nebyla definovaná (ikdyž
 // znak `=`.
 var promenna = 5;
 
-// když vynecháte slůvko 'var' nedostanete chybovou hlášku...
+// Když vynecháte slůvko 'var', nedostanete chybovou hlášku...
 jinaPromenna = 10;
 
-// ...ale vaše proměnná bude vytvořena globálně, bude vytvořena  v globálním
-// oblasti působnosti, ne jenom v lokálním tam, kde jste ji vytvořili
+// ...ale vaše proměnná bude vytvořena globálně. Bude vytvořena v globální
+// oblasti působnosti, tedy nejenom v lokální tam, kde jste ji vytvořili.
 
 // Proměnné vytvořené bez přiřazení obsahují hodnotu undefined.
 var dalsiPromenna; // = undefined
@@ -163,114 +158,136 @@ var dalsiPromenna; // = undefined
 // Pokud chcete vytvořit několik proměnných najednou, můžete je oddělit čárkou
 var someFourthVar = 2, someFifthVar = 4;
 
-// Existuje kratší forma pro matematické operace na proměnné
+// Existuje kratší forma pro matematické operace nad proměnnými
 promenna += 5; // se provede stejně jako promenna = promenna + 5;
-// promenna je ted 10
+// promenna je teď 10
 promenna *= 10; // teď je promenna rovna 100
 
 // a tohle je způsob, jak přičítat a odečítat 1
 promenna++; // teď je promenna 101
 promenna--; // zpět na 100
 
-// Pole jsou uspořádané seznamy hodnot jakéhokoliv typu
-var mojePole = ["Ahoj", 45, true];
+// Pole jsou uspořádané seznamy hodnot jakéhokoliv typu.
+var myArray = ["Ahoj", 45, true];
 
 // Jednotlivé hodnoty jsou přístupné přes hranaté závorky.
 // Členové pole se začínají počítat na nule.
 myArray[1]; // = 45
 
-// Pole je proměnlivé délky a členové se můžou měnit
-myArray.push("Světe");
+// Pole je proměnlivé délky a členové se můžou měnit.
+myArray.push("World");
 myArray.length; // = 4
 
 // Přidání/změna na specifickém indexu
 myArray[3] = "Hello";
 
-// JavaScriptové objekty jsou stejné jako asociativní pole v jinných programovacích
+// Přidání nebo odebrání člena ze začátku nebo konce pole
+myArray.unshift(3); // Přidej jako první člen
+someVar = myArray.shift(); // Odstraň prvního člena a vrať jeho hodnotu
+myArray.push(3); // Přidej jako poslední člen
+someVar = myArray.pop(); // Odstraň posledního člena a vrať jeho hodnotu
+
+// Spoj všechny členy pole středníkem
+var myArray0 = [32,false,"js",12,56,90];
+myArray0.join(";") // = "32;false;js;12;56;90"
+
+// Vrať část pole s elementy od pozice 1 (včetně) do pozice 4 (nepočítaje)
+myArray0.slice(1,4); // = [false,"js",12]
+
+// Odstraň čtyři členy od pozice 2, vlož následující
+// "hi","wr" and "ld"; vrať odstraněné členy
+myArray0.splice(2,4,"hi","wr","ld"); // = ["js",12,56,90]
+// myArray0 === [32,false,"hi","wr","ld"]
+
+// JavaScriptové objekty jsou stejné jako asociativní pole v jiných programovacích
 // jazycích: je to neuspořádaná množina páru hodnot - klíč:hodnota.
-var mujObjekt = {klic1: "Ahoj", klic2: "světe"};
+var mujObjekt = {klic1: "Hello", klic2: "World"};
 
-// Klíče jsou řetězce, ale nejsou povinné uvozovky, pokud jsou validní
-// JavaScriptové identifikátory. Hodnoty můžou být jakéhokoliv typu-
+// Klíče jsou řetězce, ale nemusí mít povinné uvozovky, pokud jsou validními
+// JavaScriptovými identifikátory. Hodnoty můžou být jakéhokoliv typu.
 var mujObjekt = {klic: "mojeHodnota", "muj jiny klic": 4};
 
 // K hodnotám můžeme přistupovat opět pomocí hranatých závorek
-myObj["muj jiny klic"]; // = 4
+mujObjekt["muj jiny klic"]; // = 4
 
 // ... nebo pokud je klíč platným identifikátorem, můžeme přistupovat k
 // hodnotám i přes tečku
 mujObjekt.klic; // = "mojeHodnota"
 
 // Objekty jsou měnitelné, můžeme upravit hodnoty, nebo přidat nové klíče.
-myObj.mujDalsiKlic = true;
+mujObjekt.mujDalsiKlic = true;
 
-// Pokud se snažíte přistoupit ke klíči, který není nastaven, dostanete undefined
-myObj.dalsiKlic; // = undefined
+// Pokud se snažíte přistoupit ke klíči, který neexistuje, dostanete undefined.
+mujObjekt.dalsiKlic; // = undefined
 
 ///////////////////////////////////
 // 3. Řízení toku programu
 
-// Syntaxe pro tuto sekci je prakticky stejná jako pro Javu
-
-// `if` (když) funguje, jak byste čekali.
+// Funkce `if` funguje, jak byste čekali.
 var pocet = 1;
 if (pocet == 3){
     // provede, když se pocet rovná 3
 } else if (pocet == 4){
     // provede, když se pocet rovná 4
 } else {
-    // provede, když je pocet cokoliv jinného
+    // provede, když je pocet cokoliv jiného
 }
 
-// Stejně tak cyklus while
+// Stejně tak cyklus `while`.
 while (true){
-    // nekonečný cyklus
+    // nekonečný cyklus!
 }
 
-// Do-while cyklus je stejný jako while, akorát se vždy provede aspoň jednou
+// Do-while cyklus je stejný jako while, akorát se vždy provede aspoň jednou.
 var vstup;
 do {
     vstup = nactiVstup();
 } while (!jeValidni(vstup))
 
-// Cyklus for je stejný jako v Javě nebo jazyku C
+// Cyklus `for` je stejný jako v Javě nebo jazyku C:
 // inicializace; podmínka pro pokračování; iterace.
-for (var i = 0; i < 3; i++){
-    // provede třikrát
+for (var i = 0; i < 5; i++){
+    // provede se pětkrát
 }
 
-// Cyklus For-in iteruje přes každo vlastnost prototypu
-var popis = "";
-var osoba = {prijmeni:"Paul", jmeno:"Ken", vek:18};
-for (var x in osoba){
-    popis += osoba[x] + " ";
+// Opuštění cyklu s návěštím je podobné jako v Javě
+outer:
+for (var i = 0; i < 10; i++) {
+    for (var j = 0; j < 10; j++) {
+        if (i == 5 && j ==5) {
+            break outer;
+            // opustí vnější (outer) cyklus místo pouze vnitřního (inner) cyklu
+        }
+    }
 }
 
-//Když chcete iterovat přes vlastnosti, které jsou přímo na objektu a nejsou
-//zděněné z prototypů, kontrolujte vlastnosti přes hasOwnProperty()
+// Cyklus For-in iteruje přes každou vlastnost prototypu
 var popis = "";
-var osoba = {prijmeni:"Jan", jmeno:"Novák", vek:18};
+var osoba = {prijmeni:"Paul", jmeno:"Ken", vek:18};
 for (var x in osoba){
-    if (osoba.hasOwnProperty(x)){
-        popis += osoba[x] + " ";
-    }
-}
+    popis += osoba[x] + " ";
+} // popis = 'Paul Ken 18 '
 
-// for-in by neměl být použit pro pole, pokud záleží na pořadí indexů.
-// Neexistuje jistota, že for-in je vrátí ve správném pořadí.
+// Příkaz for/of umožňuje iterovat iterovatelné objekty (včetně vestavěných typů
+// String, Array, například polím podobným argumentům nebo NodeList objektům,
+// TypeArray, Map a Set, či uživatelsky definované iterovatelné objekty).
+var myPets = "";
+var pets = ["cat", "dog", "hamster", "hedgehog"];
+for (var pet of pets){
+    myPets += pet + " ";
+} // myPets = 'cat dog hamster hedgehog '
 
 // && je logické a, || je logické nebo
 if (dum.velikost == "velký" && dum.barva == "modrá"){
     dum.obsahuje = "medvěd";
 }
 if (barva == "červená" || barva == "modrá"){
-    // barva je červená nebo modtrá
+    // barva je červená nebo modrá
 }
 
 // && a || jsou praktické i pro nastavení základních hodnot
 var jmeno = nejakeJmeno || "default";
 
-
 // `switch` zkoumá přesnou rovnost (===)
 // Používejte 'break;' po každé možnosti, jinak se provede i možnost za ní.
 znamka = 'B';
@@ -289,8 +306,9 @@ switch (znamka) {
     break;
 }
 
+
 ////////////////////////////////////////////////////////
-// 4. Funckce, Oblast platnosti (scope) a Vnitřní funkce
+// 4. Funkce, Oblast platnosti (scope) a Vnitřní funkce
 
 // JavaScriptové funkce jsou definovány slůvkem `function`.
 function funkce(text){
@@ -302,12 +320,9 @@ funkce("něco"); // = "NĚCO"
 // jako slůvko return, jinak se vrátí 'undefined', kvůli automatickému vkládání
 // středníků. Platí to zejména pro Allmanův styl zápisu.
 
-function funkce()
-{
+function funkce(){
     return // <- zde je automaticky vložen středník
-    {
-        tohleJe: "vlastnost objektu"
-    }
+    { tohleJe: "vlastnost objektu"};
 }
 funkce(); // = undefined
 
@@ -327,9 +342,9 @@ function myFunction(){
 setInterval(myFunction, 5000);
 
 // Objekty funkcí nemusíme ani deklarovat pomocí jména, můžeme je napsat jako
-// ananymní funkci přímo vloženou jako argument
+// anonymní funkci přímo vloženou jako argument
 setTimeout(function(){
-  // tento kód bude zavolán za 5 vteřin    
+  // tento kód bude zavolán za 5 vteřin
 }, 5000);
 
 // JavaScript má oblast platnosti funkce, funkce ho mají, ale jiné bloky ne
@@ -339,21 +354,21 @@ if (true){
 i; // = 5 - ne undefined, jak byste očekávali v jazyku, kde mají bloky svůj
 // rámec působnosti
 
-// Toto je běžný model,který chrání před únikem dočasných proměnných do
+// Toto je běžný model, který chrání před únikem dočasných proměnných do
 //globální oblasti
 (function(){
     var docasna = 5;
-    // Můžeme přistupovat k globálního oblasti přes přiřazování globalním
+    // Můžeme přistupovat ke globálního oblasti přes přiřazování globálním
     // objektům. Ve webovém prohlížeči je to vždy 'window`. Globální objekt
-    // může mít v jiných prostředích jako Node.js jinné jméno.
+    // může mít v jiných prostředích jako Node.js jiné jméno.
     window.trvala = 10;
 })();
 docasna; // způsobí ReferenceError
 trvala; // = 10
 
-// Jedna z nejvice mocných vlastnosti JavaScriptu je vnitřní funkce. Je to funkce
-// definovaná v jinné funkci, vnitřní funkce má přístup ke všem proměnným ve
-// vnější funkci, dokonce i poté, co funkce skončí
+// Jedna z nejmocnějších vlastností JavaScriptu je vnitřní funkce. Je to funkce
+// definovaná v jiné funkci. Vnitřní funkce má přístup ke všem proměnným ve
+// vnější funkci, dokonce i poté, co vnější funkce skončí.
 function ahojPoPetiVterinach(jmeno){
     var prompt = "Ahoj, " + jmeno + "!";
     // Vnitřní funkce je dána do lokální oblasti platnosti, jako kdyby byla
@@ -362,33 +377,33 @@ function ahojPoPetiVterinach(jmeno){
         alert(prompt);
     }
     setTimeout(vnitrni, 5000);
-    // setTimeout je asynchronní, takže funkce ahojPoPetiVterinach se ukončí
-    // okamžitě, ale setTimeout zavolá funkci vnitrni až poté. Avšak protože
-    // vnitrni je definována přes ahojPoPetiVterinach, má pořád přístup k
+    // setTimeout je asynchronní, takže se funkce ahojPoPetiVterinach ukončí
+    // okamžitě, ale setTimeout zavolá funkci vnitrni až poté. Avšak
+    // vnitrni je definována přes ahojPoPetiVterinach a má pořád přístup k
     // proměnné prompt, když je konečně zavolána.
 }
 ahojPoPetiVterinach("Adam"); // otevře popup s  "Ahoj, Adam!" za 5s
 
 ///////////////////////////////////////////////////
-// 5. Více o objektech, konstuktorech a prototypech
+// 5. Více o objektech, konstruktorech a prototypech
 
-// Objekty můžou obsahovat funkce
+// Objekty můžou obsahovat funkce.
 var mujObjekt = {
     mojeFunkce: function(){
-        return "Ahoj světe!";
+        return "Hello world!";
     }
 };
-mujObjekt.mojeFunkce(); // = "Ahoj světe!"
+mujObjekt.mojeFunkce(); // = "Hello world!"
 
 // Když jsou funkce z objektu zavolány, můžou přistupovat k objektu přes slůvko
 // 'this''
 var mujObjekt = {
-    text: "Ahoj světe!",
+    text: "Hello world!",
     mojeFunkce: function(){
         return this.text;
     }
 };
-mujObjekt.mojeFunkce(); // = "Ahoj světe!"
+mujObjekt.mojeFunkce(); // = "Hello world!"
 
 // Slůvko this je nastaveno k tomu, kde je voláno, ne k tomu, kde je definováno
 // Takže naše funkce nebude fungovat, když nebude v kontextu objektu.
@@ -396,23 +411,23 @@ var mojeFunkce = mujObjekt.mojeFunkce;
 mojeFunkce(); // = undefined
 
 // Opačně, funkce může být přiřazena objektu a může přistupovat k objektu přes
-// this, i když nebyla přímo v definici-
+// this, i když nebyla přímo v definici.
 var mojeDalsiFunkce = function(){
     return this.text.toUpperCase();
 }
 mujObjekt.mojeDalsiFunkce = mojeDalsiFunkce;
-mujObjekt.mojeDalsiFunkce(); // = "AHOJ SVĚTE!"
+mujObjekt.mojeDalsiFunkce(); // = "HELLO WORLD!"
 
 // Můžeme také specifikovat, v jakém kontextu má být funkce volána pomocí
 // `call` nebo `apply`.
 
 var dalsiFunkce = function(s){
     return this.text + s;
-}
-dalsiFunkce.call(mujObjekt, " A ahoj měsíci!"); // = "Ahoj světe! A ahoj měsíci!"
+};
+dalsiFunkce.call(mujObjekt, " A ahoj měsíci!"); // = "Hello world! A ahoj měsíci!"
 
-// Funkce `apply`je velmi podobná, akorát bere jako druhý argument pole argumentů
-dalsiFunkce.apply(mujObjekt, [" A ahoj slunce!"]); // = "Ahoj světe! A ahoj slunce!"
+// Funkce `apply`je velmi podobná, pouze bere jako druhý argument pole argumentů
+dalsiFunkce.apply(mujObjekt, [" A ahoj slunce!"]); // = "Hello world! A ahoj slunce!"
 
 // To je praktické, když pracujete s funkcí, která bere sekvenci argumentů a
 // chcete předat pole.
@@ -425,38 +440,42 @@ Math.min.apply(Math, [42, 6, 27]); // = 6
 // použijte `bind`.
 
 var pripojenaFunkce = dalsiFunkce.bind(mujObjekt);
-pripojenaFunkce(" A ahoj Saturne!"); // = "Ahoj světe! A ahoj Saturne!"
+pripojenaFunkce(" A ahoj Saturne!"); // = "Hello world! A ahoj Saturne!"
 
-// `bind` může být použito čatečně částečně i k používání
+// `bind` může být použito částečně k provázání funkcí
 
-var nasobeni = function(a, b){ return a * b; }
+var nasobeni = function(a, b){ return a * b; };
 var zdvojeni = nasobeni.bind(this, 2);
 zdvojeni(8); // = 16
 
 // Když zavoláte funkci se slůvkem 'new', vytvoří se nový objekt a
 // a udělá se dostupný funkcím skrz slůvko 'this'. Funkcím volaným takto se říká
-// konstruktory
+// konstruktory.
 
 var MujKonstruktor = function(){
     this.mojeCislo = 5;
-}
+};
 mujObjekt = new MujKonstruktor(); // = {mojeCislo: 5}
 mujObjekt.mojeCislo; // = 5
 
-// Každý JsavaScriptový objekt má prototyp. Když budete přistupovat k vlasnosti
-// objektu, který neexistuje na objektu, tak se JS koukne do prototypu.
+// Na rozdíl od nejznámějších objektově orientovaných jazyků, JavaScript nezná
+// koncept instancí vytvořených z tříd. Místo toho Javascript kombinuje
+// vytváření instancí a dědění do konceptu zvaného 'prototyp'.
+
+// Každý JavaScriptový objekt má prototyp. Když budete přistupovat k vlastnosti
+// objektu, který neexistuje na objektu, tak se JS podívá do prototypu.
 
 // Některé JS implementace vám umožní přistupovat k prototypu přes magickou
 // vlastnost '__proto__'. I když je toto užitečné k vysvětlování prototypů, není
-// to součást standardu, ke standartní způsobu k používání prototypu se dostaneme
-// později.
+// to součást standardu. Ke standardnímu způsobu používání prototypu se
+// dostaneme později.
 var mujObjekt = {
-    mujText: "Ahoj svete!"
+    mujText: "Hello world!"
 };
 var mujPrototyp = {
     smyslZivota: 42,
     mojeFunkce: function(){
-        return this.mujText.toLowerCase()
+        return this.mujText.toLowerCase();
     }
 };
 
@@ -464,7 +483,7 @@ mujObjekt.__proto__ = mujPrototyp;
 mujObjekt.smyslZivota; // = 42
 
 // Toto funguje i pro funkce
-mujObjekt.mojeFunkce(); // = "Ahoj světe!"
+mujObjekt.mojeFunkce(); // = "Hello world!"
 
 // Samozřejmě, pokud není vlastnost na vašem prototypu, tak se hledá na
 // prototypu od prototypu atd.
@@ -474,21 +493,41 @@ mujPrototyp.__proto__ = {
 mujObjekt.mujBoolean; // = true
 
 
-// Zde neni žádné kopírování; každý objekt ukládá referenci na svůj prototyp
-// Toto znamená, že můžeme měnit prototyp a změny se projeví všude
+// Zde není žádné kopírování; každý objekt ukládá referenci na svůj prototyp
+// Toto znamená, že můžeme měnit prototyp a změny se projeví všude.
 mujPrototyp.smyslZivota = 43;
-mujObjekt.smyslZivota // = 43
+mujObjekt.smyslZivota; // = 43
+
+// Příkaz for/in umožňuje iterovat vlastnosti objektu až do úrovně null
+// prototypu.
+for (var x in myObj){
+    console.log(myObj[x]);
+}
+///Vypíše:
+// Hello world!
+// 43
+// [Function: myFunc]
+
+// Pro výpis pouze vlastností patřících danému objektu a nikoli jeho prototypu,
+// použijte kontrolu pomocí `hasOwnProperty()`.
+for (var x in myObj){
+    if (myObj.hasOwnProperty(x)){
+        console.log(myObj[x]);
+    }
+}
+///Vypíše:
+// Hello world!
 
 // Zmínili jsme již předtím, že '__proto__' není ve standardu a není cesta, jak
 // měnit prototyp existujícího objektu. Avšak existují možnosti, jak vytvořit
-// nový objekt s daným prototypem
+// nový objekt s daným prototypem.
 
 // První je Object.create, což je nedávný přídavek do JS a není dostupný zatím
 // ve všech implementacích.
 var mujObjekt = Object.create(mujPrototyp);
-mujObjekt.smyslZivota // = 43
+mujObjekt.smyslZivota; // = 43
 
-// Druhý způsob, který funguje všude je pomocí konstuktoru. Konstruktor má
+// Druhý způsob, který funguje všude, je pomocí konstruktoru. Konstruktor má
 // vlastnost jménem prototype. Toto *není* prototyp samotného konstruktoru, ale
 // prototyp nového objektu.
 MujKonstruktor.prototype = {
@@ -499,10 +538,10 @@ MujKonstruktor.prototype = {
 };
 var mujObjekt2 = new MujKonstruktor();
 mujObjekt2.ziskejMojeCislo(); // = 5
-mujObjekt2.mojeCislo = 6
+mujObjekt2.mojeCislo = 6;
 mujObjekt2.ziskejMojeCislo(); // = 6
 
-// Vestavěnné typy jako čísla nebo řetězce mají také konstruktory, které vytváří
+// Vestavěné typy jako čísla nebo řetězce mají také konstruktory, které vytváří
 // ekvivalentní obalovací objekty (wrappery).
 var mojeCislo = 12;
 var mojeCisloObj = new Number(12);
@@ -521,7 +560,7 @@ if (new Number(0)){
    // a objekty jsou vždy pravdivé
 }
 
-// Avšak, obalovací objekty a normální vestavěnné typy sdílejí prototyp, takže
+// Avšak, obalovací objekty a normální vestavěné typy sdílejí prototyp, takže
 // můžete přidat funkcionalitu k řetězci
 String.prototype.prvniZnak = function(){
     return this.charAt(0);
@@ -530,45 +569,60 @@ String.prototype.prvniZnak = function(){
 
 // Tento fakt je často používán v polyfillech, což je implementace novějších
 // vlastností JavaScriptu do starších variant, takže je můžete používat třeba
-// ve starých prohlížečích
+// ve starých prohlížečích.
 
-// Pro příkklad, zmínili jsme, že Object.create není dostupný ve všech
-// implementacích, můžeme si avšak přidat pomocí polyfillu
+// Na příklad jsme zmínili, že Object.create není dostupný ve všech
+// implementacích, ale můžeme si ho přidat pomocí polyfillu:
 if (Object.create === undefined){ // nebudeme ho přepisovat, když existuje
     Object.create = function(proto){
         // vytvoříme dočasný konstruktor
         var Constructor = function(){};
         Constructor.prototype = proto;
-        // ten použijeme k vytvoření nového s prototypem
+        // ten použijeme k vytvoření nového objektu s prototypem
         return new Constructor();
-    }
+    };
 }
 ```
 
 ## Kam dál
 
-[Mozilla Developer
-Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) obsahuje
-perfektní dokumentaci pro JavaScript, který je používaný v prohlížečích. Navíc
-je to i wiki, takže jakmile se naučíte více, můžete pomoci ostatním, tím, že
-přispějete svými znalostmi.
+[Mozilla Developer Network][1] obsahuje perfektní dokumentaci pro JavaScript,
+který je používaný v prohlížečích. Navíc je to i wiki, takže jakmile se naučíte
+více, můžete pomoci ostatním tím, že přispějete svými znalostmi.
 
-MDN's [A re-introduction to
-JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+MDN's [A re-introduction to JavaScript][2]
 pojednává o konceptech vysvětlených zde v mnohem větší hloubce. Tento návod
-pokrývá hlavně JavaScript sám o sobě. Pokud se chcete naučit více, jak se používá
-na webových stránkách, začněte tím, že se kouknete na [DOM](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)
+pokrývá hlavně JavaScript sám o sobě. Pokud se chcete naučit, jak se používá
+na webových stránkách, začněte tím, že se podíváte na [DOM][3]
+
+[Learn Javascript by Example and with Challenges][4]
+je varianta tohoto návodu i s úkoly.
+
+[JavaScript Garden][5] je sbírka příkladů těch nejnepředvídatelnějších částí
+tohoto jazyka.
+
+[JavaScript: The Definitive Guide][6] je klasická výuková kniha.
+
+[Eloquent Javascript][8] od Marijn Haverbeke je výbornou JS knihou/e-knihou.
 
-[Learn Javascript by Example and with Challenges](http://www.learneroo.com/modules/64/nodes/350) je varianta tohoto
-návodu i s úkoly-
+[Javascript: The Right Way][10] je průvodcem JavaScriptem pro začínající
+vývojáře i pomocníkem pro zkušené vývojáře, kteří si chtějí prohloubit své
+znalosti.
 
-[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) je sbírka
-příkladů těch nejvíce nepředvídatelných částí tohoto jazyka.
+[Javascript:Info][11] je moderním JavaScriptovým průvodcem, který pokrývá
+základní i pokročilé témata velice výstižným výkladem.
 
-[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/)
-je klasická výuková kniha.
+Jako dodatek k přímým autorům tohoto článku byly na těchto stránkách části
+obsahu převzaty z Pythonního tutoriálu Louiho Dinha, a tak0 z [JS Tutorial][7]
+na stránkách Mozilla Developer Network.
 
-Jako dodatek k přímým autorům tohoto článku, některý obsah byl přizpůsoben z
-Pythoního tutoriálu od Louie Dinh na této stráce, a z [JS
-Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
-z Mozilla Developer Network.
+[1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript
+[2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
+[3]: https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core
+[4]: http://www.learneroo.com/modules/64/nodes/350
+[5]: http://bonsaiden.github.io/JavaScript-Garden/
+[6]: http://www.amazon.com/gp/product/0596805527/
+[7]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
+[8]: http://eloquentjavascript.net/
+[10]: http://jstherightway.org/
+[11]: https://javascript.info/
diff --git a/cs-cz/markdown.html.markdown b/cs-cz/markdown.html.markdown
index 568e4343..35becf94 100644
--- a/cs-cz/markdown.html.markdown
+++ b/cs-cz/markdown.html.markdown
@@ -13,7 +13,7 @@ Markdown byl vytvořen Johnem Gruberem v roce 2004. Je zamýšlen jako lehce či
 a psatelná syntaxe, která je jednoduše převeditelná do HTML (a dnes i do mnoha
 dalších formátů)
 
-```markdown
+```md
 <!-- Markdown je nadstavba nad HTML, takže jakýkoliv kód HTML je validní
 Markdown, to znamená, že můžeme používat HTML elementy, třeba jako komentář, a
 nebudou ovlivněny parserem Markdownu. Avšak, pokud vytvoříte HTML element v
diff --git a/cs-cz/python3.html.markdown b/cs-cz/python3.html.markdown
index 581ed3a3..bd3690a8 100644
--- a/cs-cz/python3.html.markdown
+++ b/cs-cz/python3.html.markdown
@@ -76,9 +76,13 @@ False or True   # => True
 # Používání logických operátorů s čísly
 0 and 2     # => 0
 -5 or 0     # => -5
-0 == False  # => True
-2 == True   # => False
-1 == True   # => True
+
+# Při porovnání s boolean hodnotou nepoužívejte operátor rovnosti "==". 
+# Stejně jako u hodnoty None.
+# Viz PEP8: https://www.python.org/dev/peps/pep-0008/ 
+0 is False  # => True
+2 is True   # => False
+1 is True   # => True
 
 # Rovnost je ==
 1 == 1  # => True
@@ -99,11 +103,11 @@ False or True   # => True
 2 < 3 < 2  # => False
 
 
-# Řetězce používají " nebo ' a mohou obsahovat UTF8 znaky
+# Řetězce používají " nebo ' a mohou obsahovat unicode znaky
 "Toto je řetězec."
 'Toto je také řetězec.'
 
-# Řetězce se také dají sčítat, ale nepoužívejte to
+# Řetězce se také dají slučovat
 "Hello " + "world!"  # => "Hello world!"
 # Dají se spojovat i bez '+'
 "Hello " "world!"  # => "Hello world!"
@@ -133,12 +137,14 @@ None  # => None
 "něco" is None  # => False
 None is None    # => True
 
-# None, 0, a prázdný řetězec/seznam/slovník se vyhodnotí jako False
+# None, 0, a prázdný řetězec/seznam/N-tice/slovník/množina se vyhodnotí jako False
 # Vše ostatní se vyhodnotí jako True
-bool(0)   # => False
-bool("")  # => False
-bool([])  # => False
-bool({})  # => False
+bool(0)        # => False
+bool("")       # => False
+bool([])       # => False
+bool(tuple())  # => False
+bool({})       # => False
+bool(set())    # => False
 
 
 ####################################################
@@ -152,10 +158,12 @@ print("Jsem 3. Python 3.")
 # Konvence je používat male_pismo_s_podtrzitky
 nazev_promenne = 5
 nazev_promenne  # => 5
-# Názvy proměnných mohou obsahovat i UTF8 znaky
+# Názvy proměnných mohou obsahovat i unicode znaky, ale nedělejte to.
+# Viz PEP 3131 -- Supporting Non-ASCII Identifiers: 
+# https://www.python.org/dev/peps/pep-3131/
 název_proměnné = 5
 
-# Přístup k předtím nepoužité proměnné vyvolá výjimku
+# Přístup k předtím nedefinované proměnné vyvolá výjimku
 # Odchytávání vyjímek - viz další kapitola
 neznama_promenna  # Vyhodí NameError
 
@@ -199,7 +207,7 @@ sez[::-1]  # => [3, 4, 2, 1]
 # Odebírat prvky ze seznamu lze pomocí del
 del sez[2]   # sez je nyní [1, 2, 3]
 
-# Seznamy můžete sčítat
+# Seznamy můžete slučovat
 # Hodnoty sez a jiny_seznam přitom nejsou změněny
 sez + jiny_seznam   # => [1, 2, 3, 4, 5, 6]
 
@@ -566,7 +574,7 @@ Clovek.odkaslej_si()  # => "*ehm*"
 
 # Lze importovat moduly
 import math
-print(math.sqrt(16.0))  # => 4
+print(math.sqrt(16.0))  # => 4.0
 
 # Lze také importovat pouze vybrané funkce z modulu
 from math import ceil, floor
@@ -596,18 +604,21 @@ dir(math)
 # Generátory jsou funkce, které místo return obsahují yield
 def nasobicka_2(sekvence):
     for i in sekvence:
+        print("Zpracovávám číslo {}".format(i))
         yield 2 * i
 
 # Generátor generuje hodnoty postupně, jak jsou potřeba. Místo toho, aby vrátil
 # celou sekvenci s prvky vynásobenými dvěma, provádí jeden výpočet v každé iteraci.
-# To znamená, že čísla větší než 15 se v metodě nasobicka_2 vůbec nezpracují.
+for nasobek in nasobicka_2([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]):
+    # Vypíše postupně: "Zpracovávám číslo 1",  ...,  "Zpracovávám číslo 5"
+    if nasobek >= 10:
+        break
 
 # Funkce range() je také generátor - vytváření seznamu 900000000 prvků by zabralo
 # hodně času i paměti, proto se místo toho čísla generují postupně.
-
-for i in nasobicka_2(range(900000000)):
-    print(i)  # Vypíše čísla 0, 2, 4, 6, 8, ... 30
-    if i >= 30:
+for nasobek in nasobicka_2(range(900000000)):
+    # Vypíše postupně: "Zpracovávám číslo 1",  ...,  "Zpracovávám číslo 5"
+    if nasobek >= 10:
         break
 
 
@@ -627,7 +638,7 @@ def nekolikrat(puvodni_funkce):
 def pozdrav(jmeno):
     print("Měj se {}!".format(jmeno))
 
-pozdrav("Pepo")  # Vypíše 3x: Měj se Pepo!
+pozdrav("Pepo")  # Vypíše 3x: "Měj se Pepo!"
 ```
 
 ## Co dál?
diff --git a/csharp.html.markdown b/csharp.html.markdown
index f27adf18..a83df967 100644
--- a/csharp.html.markdown
+++ b/csharp.html.markdown
@@ -14,7 +14,7 @@ filename: LearnCSharp.cs
 
 C# is an elegant and type-safe object-oriented language that enables developers to build a variety of secure and robust applications that run on the .NET Framework.
 
-[Read more here.](http://msdn.microsoft.com/en-us/library/vstudio/z1zx9t92.aspx)
+[Read more here.](https://docs.microsoft.com/dotnet/csharp/getting-started/introduction-to-the-csharp-language-and-the-net-framework)
 
 ```c#
 // Single-line comments start with //
@@ -344,7 +344,7 @@ on a new line! ""Wow!"", the masses cried";
             tryInt.ToString();
 
             // Casting
-            // Cast decimal 15 to a int
+            // Cast decimal 15 to an int
             // and then implicitly cast to long
             long x = (int) 15M;
         }
@@ -552,7 +552,7 @@ on a new line! ""Wow!"", the masses cried";
             }
 
             // PARALLEL FRAMEWORK
-            // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
+            // https://devblogs.microsoft.com/csharpfaq/parallel-programming-in-net-framework-4-getting-started/
 
             var words = new List<string> {"dog", "cat", "horse", "pony"};
 
@@ -960,7 +960,7 @@ on a new line! ""Wow!"", the masses cried";
     /// <summary>
     /// Used to connect to DB for LinqToSql example.
     /// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional)
-    /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
+    /// https://docs.microsoft.com/ef/ef6/modeling/code-first/workflows/new-database
     /// </summary>
     public class BikeRepository : DbContext
     {
@@ -1310,13 +1310,11 @@ namespace Csharp7
 
 ## Further Reading
 
- * [DotNetPerls](http://www.dotnetperls.com)
- * [C# in Depth](http://manning.com/skeet2)
- * [Programming C#](http://shop.oreilly.com/product/0636920024064.do)
- * [LINQ](http://shop.oreilly.com/product/9780596519254.do)
- * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx)
- * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials)
- * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials)
- * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials)
- * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
- * [C# Coding Conventions](http://msdn.microsoft.com/en-us/library/vstudio/ff926074.aspx)
+ * [C# language reference](https://docs.microsoft.com/dotnet/csharp/language-reference/)
+ * [Learn .NET](https://dotnet.microsoft.com/learn)
+ * [C# Coding Conventions](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/inside-a-program/coding-conventions)
+ * [DotNetPerls](https://www.dotnetperls.com/)
+ * [C# in Depth](https://manning.com/skeet3)
+ * [Programming C# 5.0](http://shop.oreilly.com/product/0636920024064)
+ * [LINQ Pocket Reference](http://shop.oreilly.com/product/9780596519254)
+ * [Windows Forms Programming in C#](https://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
diff --git a/css.html.markdown b/css.html.markdown
index 3b378d44..64dc097c 100644
--- a/css.html.markdown
+++ b/css.html.markdown
@@ -135,6 +135,10 @@ selector::after {}
 .parent * { } /* all descendants */
 .parent > * { } /* all children */
 
+/* Group any number of selectors to define styles that affect all selectors
+   in the group */
+selector1, selector2 { }
+
 /* ####################
    ## PROPERTIES
    #################### */
diff --git a/cypher.html.markdown b/cypher.html.markdown
index b7be544a..32868354 100644
--- a/cypher.html.markdown
+++ b/cypher.html.markdown
@@ -16,19 +16,19 @@ Nodes
 
 **Represents a record in a graph.**
 
-```()```
+`()`
 It's an empty *node*, to indicate that there is a *node*, but it's not relevant for the query.
 
-```(n)```
+`(n)`
 It's a *node* referred by the variable **n**, reusable in the query. It begins with lowercase and uses camelCase.
 
-```(p:Person)```
+`(p:Person)`
 You can add a *label* to your node, here **Person**. It's like a type / a class / a category. It begins with uppercase and uses camelCase.
 
-```(p:Person:Manager)```
+`(p:Person:Manager)`
 A node can have many *labels*.
 
-```(p:Person {name : 'Théo Gauchoux', age : 22})```
+`(p:Person {name : 'Théo Gauchoux', age : 22})`
 A node can have some *properties*, here **name** and **age**. It begins with lowercase and uses camelCase.
 
 The types allowed in properties :
@@ -40,7 +40,7 @@ The types allowed in properties :
 
 *Warning : there isn't datetime property in Cypher ! You can use String with a specific pattern or a Numeric from a specific date.*
 
-```p.name```
+`p.name`
 You can access to a property with the dot style.
 
 
@@ -49,16 +49,16 @@ Relationships (or Edges)
 
 **Connects two nodes**
 
-```[:KNOWS]```
-It's a *relationship* with the *label* **KNOWS**. It's a *label* as the node's label. It begins with uppercase and use UPPER_SNAKE_CASE.
+`[:KNOWS]`
+It's a *relationship* with the *label* **KNOWS**. It's a *label* as the node's label. It begins with uppercase and use UPPER\_SNAKE\_CASE.
 
-```[k:KNOWS]```
+`[k:KNOWS]`
 The same *relationship*, referred by the variable **k**, reusable in the query, but it's not necessary.
 
-```[k:KNOWS {since:2017}]```
+`[k:KNOWS {since:2017}]`
 The same *relationship*, with *properties* (like *node*), here **since**.
 
-```[k:KNOWS*..4]```
+`[k:KNOWS*..4]`
 It's a structural information to use in a *path* (seen later). Here, **\*..4** says "Match the pattern, with the relationship **k** which be repeated between 1 and 4 times.
 
 
@@ -67,16 +67,16 @@ Paths
 
 **The way to mix nodes and relationships.**
 
-```(a:Person)-[:KNOWS]-(b:Person)```
+`(a:Person)-[:KNOWS]-(b:Person)`
 A path describing that **a** and **b** know each other.
 
-```(a:Person)-[:MANAGES]->(b:Person)```
+`(a:Person)-[:MANAGES]->(b:Person)`
 A path can be directed. This path describes that **a** is the manager of **b**.
 
-```(a:Person)-[:KNOWS]-(b:Person)-[:KNOWS]-(c:Person)```
+`(a:Person)-[:KNOWS]-(b:Person)-[:KNOWS]-(c:Person)`
 You can chain multiple relationships. This path describes the friend of a friend.
 
-```(a:Person)-[:MANAGES]->(b:Person)-[:MANAGES]->(c:Person)```
+`(a:Person)-[:MANAGES]->(b:Person)-[:MANAGES]->(c:Person)`
 A chain can also be directed. This path describes that **a** is the boss of **b** and the big boss of **c**.
 
 Patterns often used (from Neo4j doc) :
@@ -230,13 +230,13 @@ DELETE n, r
 Other useful clauses
 ---
 
-```PROFILE```
+`PROFILE`
 Before a query, show the execution plan of it.
 
-```COUNT(e)```
+`COUNT(e)`
 Count entities (nodes or relationships) matching **e**.
 
-```LIMIT x```
+`LIMIT x`
 Limit the result to the x first results.
 
 
diff --git a/dart.html.markdown b/dart.html.markdown
index 76857306..07f755f7 100644
--- a/dart.html.markdown
+++ b/dart.html.markdown
@@ -25,42 +25,42 @@ import "dart:math" as DM;
 // The fat arrow function declaration has an implicit return for the result of
 // the expression.
 example1() {
-  example1nested1() {
-    example1nested2() => print("Example1 nested 1 nested 2");
-    example1nested2();
+  nested1() {
+    nested2() => print("Example1 nested 1 nested 2");
+    nested2();
   }
-  example1nested1();
+  nested1();
 }
 
 // Anonymous functions don't include a name.
 example2() {
-  example2nested1(fn) {
+  nested1(fn) {
     fn();
   }
-  example2nested1(() => print("Example2 nested 1"));
+  nested1(() => print("Example2 nested 1"));
 }
 
 // When a function parameter is declared, the declaration can include the
 // number of parameters the function takes by specifying the names of the
 // parameters it takes.
 example3() {
-  example3nested1(fn(informSomething)) {
-    fn("Example3 nested 1");
+  planA(fn(informSomething)) {
+    fn("Example3 plan A");
   }
-  example3planB(fn) { // Or don't declare number of parameters.
+  planB(fn) { // Or don't declare number of parameters.
     fn("Example3 plan B");
   }
-  example3nested1((s) => print(s));
-  example3planB((s) => print(s));
+  planA((s) => print(s));
+  planB((s) => print(s));
 }
 
 // Functions have closure access to outer variables.
 var example4Something = "Example4 nested 1";
 example4() {
-  example4nested1(fn(informSomething)) {
+  nested1(fn(informSomething)) {
     fn(example4Something);
   }
-  example4nested1((s) => print(s));
+  nested1((s) => print(s));
 }
 
 // Class declaration with a sayIt method, which also has closure access
@@ -81,9 +81,9 @@ example5() {
 // Where classBody can include instance methods and variables, but also
 // class methods and variables.
 class Example6Class {
-  var example6InstanceVariable = "Example6 instance variable";
+  var instanceVariable = "Example6 instance variable";
   sayIt() {
-    print(example6InstanceVariable);
+    print(instanceVariable);
   }
 }
 example6() {
@@ -92,12 +92,12 @@ example6() {
 
 // Class methods and variables are declared with "static" terms.
 class Example7Class {
-  static var example7ClassVariable = "Example7 class variable";
+  static var classVariable = "Example7 class variable";
   static sayItFromClass() {
-    print(example7ClassVariable);
+    print(classVariable);
   }
   sayItFromInstance() {
-    print(example7ClassVariable);
+    print(classVariable);
   }
 }
 example7() {
@@ -110,40 +110,40 @@ example7() {
 // or outside of class have to be constant. Strings and numbers are constant
 // by default. But arrays and maps are not. They can be made constant by
 // declaring them "const".
-var example8A = const ["Example8 const array"],
-  example8M = const {"someKey": "Example8 const map"};
+var example8Array = const ["Example8 const array"],
+  example8Map = const {"someKey": "Example8 const map"};
 example8() {
-  print(example8A[0]);
-  print(example8M["someKey"]);
+  print(example8Array[0]);
+  print(example8Map["someKey"]);
 }
 
 // Loops in Dart take the form of standard for () {} or while () {} loops,
 // slightly more modern for (.. in ..) {}, or functional callbacks with many
 // supported features, starting with forEach.
-var example9A = const ["a", "b"];
+var example9Array = const ["a", "b"];
 example9() {
-  for (var i = 0; i < example9A.length; i++) {
-    print("Example9 for loop '${example9A[i]}'");
+  for (var i = 0; i < example9Array.length; i++) {
+    print("Example9 for loop '${example9Array[i]}'");
   }
   var i = 0;
-  while (i < example9A.length) {
-    print("Example9 while loop '${example9A[i]}'");
+  while (i < example9Array.length) {
+    print("Example9 while loop '${example9Array[i]}'");
     i++;
   }
-  for (var e in example9A) {
+  for (var e in example9Array) {
     print("Example9 for-in loop '${e}'");
   }
-  example9A.forEach((e) => print("Example9 forEach loop '${e}'"));
+  example9Array.forEach((e) => print("Example9 forEach loop '${e}'"));
 }
 
 // To loop over the characters of a string or to extract a substring.
-var example10S = "ab";
+var example10String = "ab";
 example10() {
-  for (var i = 0; i < example10S.length; i++) {
-    print("Example10 String character loop '${example10S[i]}'");
+  for (var i = 0; i < example10String.length; i++) {
+    print("Example10 String character loop '${example10String[i]}'");
   }
-  for (var i = 0; i < example10S.length; i++) {
-    print("Example10 substring loop '${example10S.substring(i, i + 1)}'");
+  for (var i = 0; i < example10String.length; i++) {
+    print("Example10 substring loop '${example10String.substring(i, i + 1)}'");
   }
 }
 
@@ -176,23 +176,47 @@ example13() {
   match(s2);
 }
 
-// Boolean expressions need to resolve to either true or false, as no
-// implicit conversions are supported.
+// Boolean expressions support implicit conversions and dynamic type
 example14() {
-  var v = true;
-  if (v) {
-    print("Example14 value is true");
+  var a = true;
+  if (a) {
+    print("true, a is $a");
   }
-  v = null;
+  a = null;
+  if (a) {
+    print("true, a is $a");
+  } else {
+    print("false, a is $a"); // runs here
+  }
+
+  // dynamic typed null can be convert to bool
+  var b;// b is dynamic type
+  b = "abc";
   try {
-    if (v) {
-      // Never runs
+    if (b) {
+      print("true, b is $b");
     } else {
-      // Never runs
+      print("false, b is $b");
     }
   } catch (e) {
-    print("Example14 null value causes an exception: '${e}'");
+    print("error, b is $b"); // this could be run but got error
   }
+  b = null;
+  if (b) {
+    print("true, b is $b");
+  } else {
+    print("false, b is $b"); // runs here
+  }
+
+  // statically typed null can not be convert to bool
+  var c = "abc";
+  c = null;
+  // complie failed
+  // if (c) {
+  //   print("true, c is $c");
+  // } else {
+  //   print("false, c is $c");
+  // }
 }
 
 // try/catch/finally and throw are used for exception handling.
diff --git a/de-de/asciidoc-de.html.markdown b/de-de/asciidoc-de.html.markdown
index 60f8fa61..e3f64a00 100644
--- a/de-de/asciidoc-de.html.markdown
+++ b/de-de/asciidoc-de.html.markdown
@@ -88,7 +88,7 @@ Abteilungstitel
 
 Listen
 
-Um eine Aufzählung zu erstellen verwendest du Sternchen.
+Um eine Aufzählung zu erstellen, verwendest du Sternchen.
 
 ```
 * foo
@@ -96,7 +96,7 @@ Um eine Aufzählung zu erstellen verwendest du Sternchen.
 * baz
 ```
 
-Um eine nummerierte Liste zu erstellen verwendest du Punkte.
+Um eine nummerierte Liste zu erstellen, verwendest du Punkte.
 
 ```
 . item 1
@@ -104,7 +104,7 @@ Um eine nummerierte Liste zu erstellen verwendest du Punkte.
 . item 3
 ```
 
-Um Listen zu verschachteln musst du zusätzliche Sternchen und Punkte hinzufügen. Dies ist bis zu fünf Mal möglich.
+Um Listen zu verschachteln, musst du zusätzliche Sternchen beziehungsweise Punkte hinzufügen. Dies ist bis zu fünf Mal möglich.
 
 ```
 * foo 1
diff --git a/de-de/bash-de.html.markdown b/de-de/bash-de.html.markdown
index 7928b136..3fb3e71f 100644
--- a/de-de/bash-de.html.markdown
+++ b/de-de/bash-de.html.markdown
@@ -180,7 +180,7 @@ esac
 
 # 'for' Schleifen iterieren über die angegebene Zahl von Argumenten:
 # Der Inhalt von $Variable wird dreimal ausgedruckt.
-for $Variable in {1..3}
+for Variable in {1..3}
 do
     echo "$Variable"
 done
@@ -217,7 +217,7 @@ done
 function foo ()
 {
     echo "Argumente funktionieren wie bei skripts: $@"
-    echo Und: $1 $2..."
+    echo "Und: $1 $2..."
     echo "Dies ist eine Funktion"
     return 0
 }
diff --git a/de-de/c++-de.html.markdown b/de-de/c++-de.html.markdown
new file mode 100644
index 00000000..87e75ad6
--- /dev/null
+++ b/de-de/c++-de.html.markdown
@@ -0,0 +1,1158 @@
+---
+language: c++
+filename: learncpp-de.cpp
+contributors:
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Matt Kline", "https://github.com/mrkline"]
+    - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Connor Waters", "http://github.com/connorwaters"]
+    - ["Ankush Goyal", "http://github.com/ankushg07"]
+    - ["Jatin Dhankhar", "https://github.com/jatindhankhar"]
+    - ["Maximilian Sonnenburg", "https://github.com/LamdaLamdaLamda"]
+    - ["caminsha", "https://github.com/caminsha"]
+lang: de-de
+---
+
+C++ ist eine Systemprogrammiersprache die, 
+
+[laut dem Begründer Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote)
+entworfen wurde um,
+
+- "besseres C" zu sein
+- Datenabstraktion zu unterstützen
+- Objektorientierung zu unterstützen
+- generische Programmierung zu unterstützen
+
+Durch seine Syntax kann sie durchaus schwieriger und komplexer als neuere Sprachen sein.
+
+Sie ist weit verbreitet, weil sie in Maschinen-Code kompiliert, welcher direkt vom Prozessor ausgeführt
+werden kann und somit eine strikte Kontrolle über die Hardware bietet und gleichzeitig
+High-Level-Features wie generics, exceptions und Klassen enthält.
+
+Diese Kombination aus Geschwindigkeit und Funktionalität bildet C++ und ist eine der
+weitverbreitesten Programmiersprachen.
+
+```c++
+//////////////////
+// Vergleich zu C
+//////////////////
+
+// C ist fast eine Untermenge von C++ und teilt sich grundsätzlich die
+// Syntax für Variablen Deklarationen, primitiven Typen und Funktionen.
+
+// Wie in C ist der Programmeinsprungpunkt eine Funktion, welche "main" genannt wird und
+// einen Integer als Rückgabetyp besitzt.
+
+// Dieser Wert fungiert als Beendigungsstatus des Programms.
+// Siehe: https://de.wikipedia.org/wiki/Return_Code für weitere Informationen
+int main(int argc, char** argv)
+{
+    // Kommandozeilen Argumente werden genauso wie in C über argc und argv übergeben
+    // argc entspricht der Anzahl von Argumenten und argv ist ein Array von C-style
+    // strings (char*), welche die Argumente repräsentieren.
+    // Das erste Argument ist der Name des Programms, welches aufgerufen wird.
+    // Argc und argv können, wenn nicht benötigt, weg gelassen werden, indem
+    // die Funktionssignatur "int main()" verwendet wird.
+
+    //  Ein Rückgabewert von 0 repräsentiert die erfolgreiche Ausführung.
+    return 0;
+}
+
+// C++ unterscheidet sich in einigen Punkten von C:
+
+// In C++ sind Zeichen-Literale char´s
+sizeof('c') == sizeof(char) == 1
+
+// In C sind Zeichen-Literale int´s
+sizeof('c') == sizeof(int)
+
+// C++ verwendet striktes prototyping
+void func(); // Funktion ohne Argumente
+
+// In C
+void func(); // Funktion mit beliebiger Anzahl von Argumenten
+
+// Verwende nullptr, anstatt von NULL!!!
+int* ip = nullptr;
+
+// C standard header sind in C++ verfügbar.
+// C header enden mit .h, während
+// C++ header das Präfix "c" besitzen und kein ".h" Suffix verwenden.
+
+// Die C++ Standard Version:
+#include <cstdio>
+
+// Die C Standard Version:
+#include <stdio.h>
+
+int main()
+{
+    printf("Hello, world!\n");
+    return 0;
+}
+
+///////////////////////
+// Funktionsüberladung
+///////////////////////
+
+// C++ unterstützt Funktionsüberladung
+// Jede Funktion kann unterschiedliche Parameter erhalten.
+void print(char const* myString)
+{
+    printf("String %s\n", myString);
+}
+
+void print(int myInt)
+{
+    printf("My int is %d", myInt);
+}
+
+int main()
+{
+    print("Hello"); // Wird aufgelöst zu "void print(const char*)"
+    print(15); // Wird aufgelöst zu "void print(int)"
+}
+
+/////////////////////////////
+// Standard Funktionsargumente
+/////////////////////////////
+
+// Argumente können per Standard für eine Funktion gesetzt werden,
+// wenn diese beim Aufruf nicht bereitgestellt werden.
+void doSomethingWithInts(int a = 1, int b = 4)
+{
+    // führe Anweisungen mit "int´s" aus.
+}
+
+int main()
+{
+    doSomethingWithInts();      // a = 1,  b = 4
+    doSomethingWithInts(20);    // a = 20, b = 4
+    doSomethingWithInts(20, 5); // a = 20, b = 5
+}
+
+// Standard-Argumente müssen am Ende der Liste der Argumente stehen.
+void invalidDeclaration(int a = 1, int b) // Fehler!
+{
+}
+
+
+/////////////
+// Namespaces (Namensräume)
+/////////////
+
+// Namespaces stellen einen getrennten Gültigkeitsbereich für Variablen,
+// Funktionen und andere Deklarationen zur Verfügung.
+// Namespaces können geschachtelt werden.
+namespace First
+{
+    namespace Nested
+    {
+        void foo()
+        {
+            printf("This is First::Nested::foo\n");
+        }
+    } // Ende des Namespace "Nested"
+} // Ende des Namespace "First"
+
+namespace Second
+{
+    void foo()
+    {
+        printf("This is Second::foo\n");
+    }
+}
+
+void foo()
+{
+    printf("This is global foo\n");
+}
+
+int main()
+{
+    // Fügt alle Symbole aus dem namespace Second in den aktuellen Gültigkeitsbereich (scope).
+    // "foo()" wird nun nicht länger funktionieren, da es nun doppeldeutig ist, ob foo aus
+    // dem namespace foo oder darüberliegenden aufgerufen wird.
+    using namespace Second;
+
+    Second::foo(); // Gibt "This is Second::foo" aus.
+    First::Nested::foo(); // Gibt "This is First::Nested::foo" aus.
+    ::foo(); // Gibt "This is global foo" aus.
+}
+
+///////////////
+// Eingabe/Ausgabe
+///////////////
+
+// C++ verwendet für die Eingabe und Ausgabe streams.
+// cin, cout und cerr repräsentieren stdin, stdout und stderr.
+// << ist der Einfügeoperator und >> ist der Extraktionsoperator.
+
+#include <iostream> // Include für Eingabe/Ausgabe (I/O) streams
+
+using namespace std; // Streams befinden sich im std namespace (standard library)
+
+int main()
+{
+   int myInt;
+
+   // Ausgabe auf stdout (oder Terminal/Bildschirm)
+   cout << "Enter your favorite number:\n";
+
+   // Empfängt Eingabe
+   cin >> myInt;
+
+   // cout kann ebenfalls formatiert werden
+   cout << "Your favorite number is " << myInt << "\n";
+   // Gibt "Your favorite number is <myInt>" aus
+
+    cerr << "Used for error messages";
+}
+
+//////////
+// Zeichenketten (Strings)
+//////////
+
+// Strings in C++ sind Objekte und haben diverse member-functions
+#include <string>
+
+using namespace std; // Strings sind ebenfalls im namespace std (Standard Bibliothek)
+
+string myString = "Hello";
+string myOtherString = " World";
+
+// + wird für das Anhängen von strings verwendet.
+cout << myString + myOtherString; // "Hello World"
+
+cout << myString + " You"; // "Hello You"
+
+// C++ strings sind mutable.
+myString.append(" Dog");
+cout << myString; // "Hello Dog"
+
+
+/////////////
+// Referenzen
+/////////////
+
+// Zusätzlich zu Pointern, wie jene in C.
+// C++ besitzt _Referenzen_.
+// Diese sind Pointer-Typen, welche nicht erneut zugewiesen werden können
+// und nicht Null sein können.
+// Sie besitzen den selben Syntax wie Variablen.
+// Für die Dereferenzierung ist kein * notwendig und
+// & (die Adresse) wird nicht für die Zuweisung verwendet.
+
+using namespace std;
+
+string foo = "I am foo";
+string bar = "I am bar";
+
+
+string& fooRef = foo; // Erzeugt eine Referenz auf foo.
+fooRef += ". Hi!"; // Verändert foo durch die Referenz
+cout << fooRef; // Gibt "I am foo. Hi!" aus.
+
+
+// Weist "fooRef" nicht erneut zu. Dies ist dasselbe, wie "foo = bar" und 
+// foo == "I am bar"
+// nach dieser Zeile 
+cout << &fooRef << endl; // Gibt die Adresse von foo aus
+fooRef = bar;
+cout << &fooRef << endl; // Gibt ebenfalls die Adresse von foo aus
+cout << fooRef;  // Gibt "I am bar" aus
+
+// Die Adresse von fooRef verbleibt die selbe, sie verweist immer noch auf foo
+
+const string& barRef = bar; // Erzeugt konstante Referenz auf bar.
+// Wie in C, können konstante Werte ( und Pointer bzw. Referenzen) nicht verändert werden.
+
+barRef += ". Hi!"; // Fehler: konstante Referenzen können nicht verändert werden.
+
+// Hinweis: bevor wir genauer Referenzen besprechen, schauen wir uns zuerst ein Konzept an,
+// welches als "temporäres Objekt" bezeichnet wird. Gehen wir von folgenden Code aus:
+string tempObjectFun() { ... }
+string retVal = tempObjectFun();
+
+// Was passiert nun in der zweiten Zeile:
+//  - ein String Objekt wird von "tempObjectFun" zurückgegeben
+//  - ein neuer String wird mit dem zurückgegebenen Objekt als Argument für den Konstruktor erzeugt.
+//  - das zurückgegebene Objekt wird zerstört
+// Das zurückgegbene Objekt wird temporäres Objekt genannt. Temporäre Objekte werden erzeugt
+// wann immer eine Funktion ein Objekt zurückgibt. Zerstört werden diese am Ende der Auswertung des Ausdrucks
+// (dies schreibt der Standard vor, aber Compiler sind berechtigt dieses Verhalten zu ändern. Siehe "return value optimization"
+// für Details). Wie in diesem Code:
+foo(bar(tempObjectFun()))
+
+// Nehmen wir an, foo und bar existieren. Das Objekt wird von "tempObjectFun" zurückgegeben,
+// wird an bar übergeben und ist zerstört bevor foo aufgerufen wird.
+
+// Zurück zu Referenzen. Die Annahme, dass die "am Ende des Ausdrucks" Regel gültig ist,
+// wenn das temporäre Objekt an eine konstante Referenz gebunden ist, ist der Fall, wenn die Lebensdauer
+// auf den aktuellen Gültigkeitsbereich erweitert wird.
+
+void constReferenceTempObjectFun() {
+  // constRef erhält das temporäre Objekt und ist gültig bis ans Ende der Funktion
+  const string& constRef = tempObjectFun();
+  ...
+}
+
+// Eine andere Art von Referenzen wurde in C++11 eingeführt und ist speziell für
+// temporäre Objekte. Es ist nicht möglich Variablen des Typs zu besitzen, aber
+// Vorrechte bei der Auflösung zu besitzen.
+
+void someFun(string& s) { ... }  // Reguläre Referenz
+void someFun(string&& s) { ... }  // Referenz auf ein temporäres Objekt
+
+string foo;
+someFun(foo);  // Ruft die Funktion mit der regulären Referenz auf
+someFun(tempObjectFun());  // Ruft die Funktion mit der temporären Referenz auf
+
+// Zum Beispiel existieren diese zwei Varianten von Konstruktoren für
+// std::basic_string:
+basic_string(const basic_string& other);
+basic_string(basic_string&& other);
+
+// Nehmen wir an, wir erzeugen einen neuen String eines temporären Objekts (welches später
+// zerstört wird), hierbei existiert ein effizienterer Konstruktor. Dieses Konzept wird
+// als "move semantics" bezeichnet (bewegen eines Objekts in ein anderes in C++).
+
+/////////////////////
+// Enumerations (Aufzählungstypen)
+/////////////////////
+
+// Enums sind eine einfachere Art und Weise einen Wert einer Konstante zu zuweisen.
+// Häufig wird dies verwendet, um den Code lesbarer zu gestalten bzw. zu visualisieren.
+enum ECarTypes
+{
+  Sedan,
+  Hatchback,
+  SUV,
+  Wagon
+};
+
+ECarTypes GetPreferredCarType()
+{
+	return ECarTypes::Hatchback;
+}
+
+// Mit C++11 existiert eine einfache Möglichkeit einem Typ dem Enum zuzuweisen. Dies
+// kann durchaus sinnvoll bei der Serialisierung von Daten sein, oder bei der Konvertierung
+// zwischen Typen bzw. Konstanten.
+enum ECarTypes : uint8_t
+{
+  Sedan, // 0
+  Hatchback, // 1
+  SUV = 254, // 254
+  Hybrid // 255
+};
+
+void WriteByteToFile(uint8_t InputValue)
+{
+    // Serialisierung von "InputValue" in eine Datei
+}
+
+void WritePreferredCarTypeToFile(ECarTypes InputCarType)
+{
+    // Das enum wird implizit zu einem "uint8_t" konvertiert. Bedingt dadurch, dass
+    // es sich um ein "enum" handelt.
+	WriteByteToFile(InputCarType);
+}
+
+// Nicht immer ist es gewünscht, dass enum´s zu einem Integer oder zu einem anderen
+// enum umgewandelt werden. Daher ist es möglich eine enum-Klasse zu erzeugen, welche
+// nicht implizit umgewandelt wird.
+enum class ECarTypes : uint8_t
+{
+  Sedan, // 0
+  Hatchback, // 1
+  SUV = 254, // 254
+  Hybrid // 255
+};
+
+void WriteByteToFile(uint8_t InputValue)
+{
+    // Serialisierung von InputValue in eine Datei
+}
+
+void WritePreferredCarTypeToFile(ECarTypes InputCarType)
+{
+  // Wird nicht kompilieren, da "ECarTypes" ein "uint8_t" ist, da das enum
+  // als "enum class" deklariert wurde!
+	WriteByteToFile(InputCarType);
+}
+
+//////////////////////////////////////////
+// Klassen und objekorientierte Programmierung
+//////////////////////////////////////////
+
+// Erstes Beispiel einer Klasse
+#include <iostream>
+
+// Deklaration einer Klasse.
+// Klassen werden üblicherweise im header (.h oder .hpp) deklariert.
+class Dog
+{
+    // Member Variablen und Funktionen sind private per default (standard).
+    std::string name;
+    int weight;
+
+// Alle nachfolgenden member sind "public" bis
+// "private:" oder "protected:" auftritt.
+public:
+
+    // Standard Konstruktor
+    Dog();
+
+    // Member-Funktionsdeklaration (Implementierung folgt).
+    // Bemerkung: std::string statt der Verwendung von namespace std;
+    // "using namespace" sollte niemals in einem header verwendet werden.
+    void setName(const std::string& dogsName);
+
+    void setWeight(int dogsWeight);
+
+    // Funktionen, die Objekte nicht ändern, sollten mit const deklariert werden.
+    // Funktionen müssen explizit als "virtual" deklariert werden, um in einer
+    // abgeleiteten Klassen überschrieben zu werden.
+    // Aus performance Gründen sind Funktionen nicht per default virtual.
+    virtual void print() const;
+
+    // Funktionen können ebenfalls im class body definiert werden.
+    // Derart definierte Funktionen sind automatisch "inline".
+    void bark() const { std::cout << name << " barks!\n"; }
+
+    // Neben Konstruktoren, bietet C++ Destruktoren.
+    // Diese werden aufgerufen, wenn ein Objekt freigegeben wird oder
+    // seinen Wertebereich verlässt.
+    // Dies ermöglicht mächtige Paradigmen, wie auch RAII.
+    // Destruktoren sollten virtual sein, wenn eine Klasse von ihr
+    // abgeleitet wird. Ist dieser nicht virtual, dann wird der
+    // Destruktor der abgeleiteten Klasse nicht aufgerufen, insofern
+    // das Objekt durch eine Referenz/Pointer der Basisklasse entfernt wird.
+    virtual ~Dog();
+
+}; // Ein Semikolon schließt die Definition der Klasse ab.  
+
+// Klassen-Member-Funktionen sind üblicherweise in der .cpp Datei implementiert.
+Dog::Dog()
+{
+    std::cout << "A dog has been constructed\n";
+}
+
+// Objekte sollten als Referenz übergeben werden und wenn diese nicht
+// verändert werden sollen, sollte das Objekt als const Referenz übergeben werden.
+void Dog::setName(const std::string& dogsName)
+{
+    name = dogsName;
+}
+
+void Dog::setWeight(int dogsWeight)
+{
+    weight = dogsWeight;
+}
+
+// "Virtual" wird nur bei der Deklaration benötigt und nicht bei der Definition.
+void Dog::print() const
+{
+    std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
+}
+
+Dog::~Dog()
+{
+    std::cout << "Goodbye " << name << "\n";
+}
+
+int main() 
+{
+    Dog myDog; // Ausgabe: "A dog has been constructed"
+    myDog.setName("Barkley");
+    myDog.setWeight(10);
+    myDog.print(); // Ausgabe: "Dog is Barkley and weighs 10 kg"
+    return 0;
+} // Ausgabe: "Goodbye Barkley"
+
+// Diese Klasse erbt alles was public bzw. protected ist von der Dog-Klasse
+// und darüber hinaus auch private Methoden/Attribute, jedoch kann auf diese
+// nicht direkt zugegriffen werden. Lediglich über public/procted getter/setter.
+class OwnedDog : public Dog {
+
+public:
+    void setOwner(const std::string& dogsOwner);
+
+    // Überschreibt das Verhalten der "print" Funktion für alle "OwnedDogs".
+    // Siehe: http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping
+    // für eine grundlegende Einführung in "Subtype Polymorphismus".
+    // Das "override" Schlüsselwort ist optional, aber stellt sicher, dass die
+    // Methode der Basisklasse tatsächlich überschrieben wurde.
+    void print() const override;
+
+private:
+    std::string owner;
+};
+
+// Die zugehörige .cpp Datei
+void OwnedDog::setOwner(const std::string& dogsOwner)
+{
+    owner = dogsOwner;
+}
+
+void OwnedDog::print() const
+{
+    Dog::print(); // Ruft die "print" Funktion der Basisklasse auf.
+    std::cout << "Dog is owned by " << owner << "\n";
+    // Ausgaben: "Dog is <name> and weights <weight>"
+    //           "Dog is owned by <owner>"
+}
+
+//////////////////////////////////////////
+// Initialisierung und Operatorüberladung
+//////////////////////////////////////////
+
+// In C++ können Operatoren wie: +, -, *, / etc. überladen werden.
+// Dies wird umgesetzt, indem eine entsprechende Funktion definiert wird,
+// welche immer dann aufgerufen wird, sobald der Operator verwendet wird.
+#include <iostream>
+using namespace std;
+
+class Point
+{
+public:
+    // Member Variablen können mit einem default Wert initialisiert werden.
+    double x = 0;
+    double y = 0;
+
+    // Definition des Standard Konstruktor, welcher nichts tut
+    // außer den Punkt auf den default Wert (0,0) zu setzen.
+    Point() { };
+
+    // Die nachfolgende Syntax ist bekannt als "initialization list"
+    // und ist eine gängige Art Klassen-Member zu initialisieren.
+    Point (double a, double b) :
+        x(a),
+        y(b)
+    { /* Außschließliche Initialisierung der Werte */ }
+
+    // Überladung des "+" Operator.
+    Point operator+(const Point& rhs) const;
+
+    // Überladung des "+=" Operator
+    Point& operator+=(const Point& rhs);
+
+    // Sinnhaft wäre es an dieser Stelle den "-" und "-=" Operator
+    // ebenfalls zu überladen.
+};
+
+Point Point::operator+(const Point& rhs) const
+{
+    // Erzeugung eines neuen Punkts, welcher die Summe aus sich
+    // selbst und "rhs" bildet
+    return Point(x + rhs.x, y + rhs.y);
+}
+
+Point& Point::operator+=(const Point& rhs)
+{
+    x += rhs.x;
+    y += rhs.y;
+    return *this;
+}
+
+int main ()
+{
+    Point up (0,1);
+    Point right (1,0);
+
+    // Ruft den + Operator mit den entsprechenden Parametern auf.
+    Point result = up + right;
+    // Ausgabe: "Result is upright (1,1)"
+    cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
+    return 0;
+}
+
+/////////////////////
+// Templates
+/////////////////////
+
+// Templates in C++ werden in erster Linie dafür verwendet generisch zu programmieren.
+// Sie unterstützen explizite und partielle Spezialisierung und darüber hinaus können
+// sie für funktionale Klassen verwendet werden.
+// Tatsächlich bilden Templates die Turing-Vollständigkeit
+// (universelle Programmierbarkeit) ab.
+
+
+// Zu Beginn ein einführendes Beispiel der generischen Programmierung.
+// Die Definition einer Klasse bzw. Funktion, welche mit dem Typ T parametriert wird.
+template<class T>
+class Box
+{
+public:
+    // T repräsentiert an dieser Stelle einen beliebigen Typen.
+    void insert(const T&) { ... }
+};
+
+// Während der Kompilierung generiert der Compiler Kopien für jedes Template, wobei
+// hierbei die Parameter substituiert werden. Somit muss bei jedem Aufruf die gesamte
+// Definition der Klasse zur Verfügung stehen. Aus diesem Grund wird ein Template
+// komplett im header definiert.
+
+// Erzeugung einer Template-Klasse auf dem Stack:
+Box<int> intBox;
+
+// eine der zu erwartenden Verwendungen:
+intBox.insert(123);
+
+// Verschachtelungen von Templates sind möglich.
+Box<Box<int> > boxOfBox;
+boxOfBox.insert(intBox);
+
+// Bis C++11 war es erforderlich ein Leerzeichen zwischen '>' einzufügen,
+// andernfalls wurde es als '>>' geparsed (right shift).
+
+// Manchmal ist folgende Notation anzutreffen:
+// template<typename T>
+// Das 'class' Schlüsselwort und das 'typename' Schlüsselwort
+// sind fast identisch hinsichtlich der Funktionalität. Weitere
+// Informationen auf: http://en.wikipedia.org/wiki/Typename
+
+// Eine Template-Funktion:
+template<class T>
+void barkThreeTimes(const T& input)
+{
+    input.bark();
+    input.bark();
+    input.bark();
+}
+
+// Hierbei ist zu beachten, dass an dieser Stelle nichts über den Typen des Parameters
+// definiert wurde. Der Compiler wird bei jedem Aufruf bzw. jeder Erzeugung den Typen
+// prüfen. Somit funktioniert die zuvor definierte Funktion für jeden Typ 'T', die die
+// const Methode 'bark' implementiert hat.
+
+Dog fluffy;
+fluffy.setName("Fluffy")
+barkThreeTimes(fluffy); // Gibt "Fluffy barks" dreimal aus.
+
+// Template Parameter müssen keine Klassen sein.
+template<int Y>
+void printMessage()
+{
+  cout << "Learn C++ in " << Y << " minutes!" << endl;
+}
+
+// Des Weiteren können Templates aus Effizienzgründen genauer spezifiziert werden.
+// Selbstverständlich sind reale Probleme, welche genauer spezifiziert werden, nicht
+// derart trivial. Auch wenn alle Parameter explizit definiert wurden, muss die
+// Funktion oder Klasse als Template deklariert werden.
+template<>
+void printMessage<10>()
+{
+  cout << "Learn C++ faster in only 10 minutes!" << endl;
+}
+
+printMessage<20>();  // Gibt "Learn C++ in 20 minutes!" aus.
+printMessage<10>();  // Gibt "Learn C++ faster in only 10 minutes!" aus.
+
+
+/////////////////////
+// Ausnahme Behandlungen (Exception-Handling)
+/////////////////////
+
+// Die Standard Bibliothek bietet einige exceptions.
+// Siehe: http://en.cppreference.com/w/cpp/error/exception.
+// Grundsätzlich können alle Typen als exception geworfen werden.
+#include <exception>
+#include <stdexcept>
+
+// Alle exceptions, die in dem "try" Block geworfen werden, können mittels
+// "catch" abgefangen werden.
+try
+{
+    // exceptions sollten nicht auf dem heap mithilfe
+    // von "new" allokiert werden.
+    throw std::runtime_error("A problem occurred");
+}
+
+// Exceptions sollten als const Referenz abgefangen werden
+// insofern diese Objekte sind.
+catch (const std::exception& ex)
+{
+    std::cout << ex.what();
+}
+
+// Abfangen aller Exceptions, welche zuvor nicht abgefangen wurden.
+catch (...)
+{
+    std::cout << "Unknown exception caught";
+    throw; // Erneutes werfen der exception
+}
+
+///////
+// RAII
+///////
+
+// RAII steht für "Resource Acquisition Is Initialization".
+// Oft wird dies als eines der wichtigsten Paradigmen in C++ betrachtet.
+// RAII beschreibt das Konzept, dass der Konstruktor für ein Objekt
+// die Ressourcen akquiriert und der Destruktor diese freigibt.
+
+// Zum Verständnis, warum dies sinnvoll ist, nachfolgend
+// ein einführendes Beispiel:
+void doSomethingWithAFile(const char* filename)
+{
+    // Wir nehmen an, dass nichts schiefgehen wird.
+    FILE* fh = fopen(filename, "r"); // Öffnen der Datei im read-mode.
+
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+    fclose(fh); // Schließen des file-handle.
+}
+
+// Unglücklicherweise ist die Fehlerbehandlung äußerst kompliziert.
+// Sollte fopen fehlschlagen und "doSomethingWithTheFile" bzw.
+// "doSomethingElseWithIt", geben diese einen Fehlercode zurück.
+// (Exceptions sind eine bevorzugte Möglichkeit Fehler abzufangen
+// , allerdings bei einigen Programmierern, besonders solchen die einen C
+// background besitzen, ein unbeliebtes Mittel zur Fehlerbehandlung).
+// Nun müssen wir jeden Aufruf auf mögliche auftretende Fehler überprüfen.
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r"); // Öffnet die Datei im read-mode
+    if (fh == nullptr) // Der Pointer ist bei einem Fehler NULL .
+        return false; // Benachrichtigt den Aufrufer über den Fehler.
+
+    // Wir nehmen an, dass jede Funktion false zurückgibt, in einem Fehlerfall
+    if (!doSomethingWithTheFile(fh))
+    {
+        fclose(fh); // File handle schließen.
+        return false; // Fehler "melden".
+    }
+
+    if (!doSomethingElseWithIt(fh))
+    {
+        fclose(fh); // File handle schließen.
+        return false; // Fehler "melden".
+    }
+
+    fclose(fh); // File handle schließen.
+    return true; // Erfolg "melden".
+}
+
+// C-Programmierer handhaben dies häufig durch goto-Anweisungen:
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r");
+    if (fh == nullptr)
+        return false;
+
+    if (!doSomethingWithTheFile(fh))
+        goto failure;
+
+    if (!doSomethingElseWithIt(fh))
+        goto failure;
+
+    fclose(fh); // File handle schließen.
+    return true; // Erfolg "melden".
+
+failure:
+    fclose(fh);
+    return false; // Fehler "melden".
+}
+
+// Insofern Funktionen Fehler durch exceptions indizieren,
+// ist dies "sauberer", aber immer noch suboptimal.
+void doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r"); // Öffnet die Datei im read-mode
+    if (fh == nullptr)
+        throw std::runtime_error("Could not open the file.");
+
+    try
+    {
+        doSomethingWithTheFile(fh);
+        doSomethingElseWithIt(fh);
+    }
+    catch (...)
+    {
+        // Im Fehlerfall sollte sichergestellt sein, dass die
+        // Datei geschlossen wird.
+        fclose(fh);
+        throw; // Erneutes werfen der exception
+    }
+
+    fclose(fh); // Schließen der Datei
+}
+
+// Folgendes ist mit der C++ file stream Klasse (fstream) zu vergleichen.
+// fstream verwendet den Destruktor, um die Datei zu schließen.
+// Der obige Destruktor wird automatisch aufgerufen, sobald das Objekt
+// den Gültigkeitsbereich verlässt.
+void doSomethingWithAFile(const std::string& filename)
+{
+    // ifstream entspricht der Kurzform von "input file stream".
+    std::ifstream fh(filename); // Öffnen der Datei
+
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+} // Die Datei wird automatisch vom Destruktor geschlossen.
+
+// Diese Vorgehensweise bietet massive Vorteile:
+// 1. Egal was passiert, die Ressource (das Datei-Handle) wird aufgelöst,
+//    insofern der Destruktor korrekt beschrieben wurde. Es ist möglich
+//    zu vergessen das Datei-Handle zu schließen, was zu einem "leak" der
+//    entsprechenden Ressource führt.
+// 2. Der Code selbst ist wesentlich "sauberer".
+//    Der Destruktor wird das Datei-Handle im Hintergrund schließen und der
+//    Programmierer muss sich darum keinerlei Sorgen machen.
+// 3. Der Code ist "exception sicher".
+//    Egal wo die exception geworfen wird, das Aufräumen wird definitiv vollzogen.
+
+// Der gesamte idiomatische C++ Code verwendet RAII für alle Ressourcen.
+// Weitere Beispiele:
+// - Speicher verwenden "unique_ptr" und "shared_ptr".
+// - Container - verkettete Listen (linked list), vector (selbst organisierende
+//   Arrays), hash maps, etc., entfernen deren Inhalt, wenn diese außerhalb des
+//   Gültigkeitsbereichs laufen.
+// - Mutex´s verwenden lock_guard und unique_lock.
+
+/////////////////////
+// Container
+/////////////////////
+
+// Die Container der Standard template Bibliothek beinhaltet einige vordefinierte Templates.
+// Diese verwalten die Speicherbereiche für die eigenen Elemente und stellen Member-Funktionen
+// für den Zugriff und die Manipulation bereit.
+
+// Beispielhafte Container:
+
+// Vector (dynamisches array)
+// Erlaubt das Definieren von Arrays oder Listen zur Laufzeit
+#include <vector>
+string val;
+vector<string> my_vector; // Initialisierung des Vectors.
+cin >> val;
+my_vector.push_back(val); // Fügt den Wert "val" zum Vektor "my_vector" hinzu.
+my_vector.push_back(val); // Fügt den Wert "val" zum Vektor "my_vector" hinzu (nun zwei Elemente).
+
+// Für die Iteration über Vektoren stehen zwei Methodiken zu Verfügung:
+// Entweder die klassische Iteration über den Index:
+for (int i = 0; i < my_vector.size(); i++)
+{
+	cout << my_vector[i] << endl; // Zugriff auf die Elemente des Vektors über den [] Operator
+}
+
+// Oder die Verwendung von Iteratoren:
+vector<string>::iterator it; // Initialisierng des Iterators.
+for (it = my_vector.begin(); it != my_vector.end(); ++it)
+{
+	cout << *it  << endl;
+}
+
+// Set (Mengen)
+// Sets sind Container, welche einzigartige Elemente beinhalten die einer
+// spezifischen Ordnung folgen.
+
+#include<set>
+set<int> ST;    // Initialisierung des Sets mit einem Integer Datentyp.
+ST.insert(30);  // Einfügen des Werts 30 in das Set ST
+ST.insert(10);  // Einfügen des Werts 10 in das Set ST
+ST.insert(20);  // Einfügen des Werts 20 in das Set ST
+ST.insert(30);  // Einfügen des Werts 30 in das Set ST
+// Folgende Elemente befinden sich nun in dem Set:
+//  10 20 30
+
+// Entfernen eines Elements:
+ST.erase(20);
+
+// Set ST: 10 30
+// Für das iterieren verwenden wir Iteratoren:
+set<int>::iterator it;
+
+for(it=ST.begin();it<ST.end();it++)
+{
+	cout << *it << endl;
+}
+
+// Ausgabe:
+// 10
+// 30
+
+// Zum leeren des gesamten Containers wird die Methode
+// Container._name.clear() verwendet.
+ST.clear();
+cout << ST.size();  // Ausgabe der Set-Größe
+
+// Ausgabe: 0
+
+// Bemerkung: für mehrdeutige Elemente werden multisets verwendet.
+// Für hash-Sets sollten unordered_set´s verwendet werden, da diese
+// wesentlich effizienter sind, allerdings keiner Ordnung folgen.
+// Verfügbar sind diese Features ab C++11.
+
+// Map
+// Maps speichern Elemente, welche einer Kombination aus "Key"
+// und "Value" folgen.
+
+#include<map>
+map<char, int> mymap;  // Initialisierung der Map: char -> Key, int -> Value.
+
+mymap.insert(pair<char,int>('A',1)); // Einfügen des Werts "1" für den Key "A".
+
+mymap.insert(pair<char,int>('Z',26)); // Einfügen des Werts "26" für den Key "Z".
+
+// Das Iterieren über Maps:
+map<char,int>::iterator it;
+for (it=mymap.begin(); it!=mymap.end(); ++it)
+    std::cout << it->first << "->" << it->second << '\n';
+
+// Ausgabe:
+// A->1
+// Z->26
+
+// Für das Finden des dazugehörigen Value des Keys.
+it = mymap.find('Z');
+cout << it->second;
+
+// Ausabe: 26
+
+// Bemerkung: für "hash maps" sollten die "unordered_map´s" verwendet werden. Diese
+// sind effizienter und benötigen keine Reihenfolge. "unordered_maps" sind ab
+// C++11 verfügbar.
+
+// Container für nicht-primitive Datentypen benötigen Vergleichsfunktionen im Objekt selbst,
+// oder als Funktionspointer. Primitive Datentypen besitzen default-Vergleichsfunktionen.
+// Allerdings können diese überschrieben werden.
+class Foo
+{
+public:
+    int j;
+    Foo(int a) : j(a) {}
+};
+
+struct compareFunction
+{
+    bool operator()(const Foo& a, const Foo& b) const
+    {
+        return a.j < b.j;
+    }
+};
+
+// Folgender Code ist nicht valide, könnte aber von einigen Compilern
+// als valide angesehen werden:
+// std::map<Foo, int> fooMap;
+std::map<Foo, int, compareFunction> fooMap;
+fooMap[Foo(1)]  = 1;
+fooMap.find(Foo(1)); // Wahr
+
+
+///////////////////////////////////////
+// Lambda Ausdrücke (C++11 und höher)
+///////////////////////////////////////
+
+// Lambdas sind eine gängige Methodik, um anonyme Funktionen an dem
+// Ort der Verwendung zu definieren. Darüber hinaus auch bei der
+// Verwendung von Funktionen als Argument einer Funktion.
+
+// Nehmen wir an, es soll ein Vektor von "pairs" (Paaren) mithilfe
+// des zweiten Werts des "pairs" sortiert werden.
+
+vector<pair<int, int> > tester;
+tester.push_back(make_pair(3, 6));
+tester.push_back(make_pair(1, 9));
+tester.push_back(make_pair(5, 0));
+
+// Übergabe des Lambda-Ausdrucks als drittes Argument für die nachfolgende Sortierfunktion.
+sort(tester.begin(), tester.end(), [](const pair<int, int>& lhs, const pair<int, int>& rhs)
+{
+        return lhs.second < rhs.second;
+});
+
+// Beachte die Syntax von Lambda-Ausdrücken.
+// Die [] im Lambda Ausdruck werden für die Variablen verwendet.
+// Diese so genannte "capture list" definiert, was außerhalb des Lambdas,
+// innerhalb der Funktion verfügbar sein soll und in welcher Form.
+// Dies kann folgendes sein:
+//     1. ein Wert [x]
+//     2. eine Referenz [&x]
+//     3. eine beliebige Variable, welche sich im Gültigkeitsbereich durch
+//        die Referenz [&] befindet.
+//     4. wie bei 3. aber mithilfe des Werts [=]
+// Beispiel:
+
+vector<int> dog_ids;
+
+for(int i = 0; i < 3; i++)
+{
+	dog_ids.push_back(i);
+}
+
+int weight[3] = {30, 50, 10};
+
+// Nehmen wir an wir möchten die "dog_ids" gemäß des Gewichts des Hundes sortieren.
+// So sollten sich die "dog_ids" wie folgt verhalten: [2, 0, 1]
+
+// Hier werden Lambdas praktisch:
+sort(dog_ids.begin(), dog_ids.end(), [&weight](const int &lhs, const int &rhs)
+{
+        return weight[lhs] < weight[rhs];
+});
+
+
+// Weiterführender Link über Lambda-Ausdrücke:
+// http://stackoverflow.com/questions/7627098/what-is-a-lambda-expression-in-c11
+
+///////////////////////////////
+// Range For (C++11 und höher)
+///////////////////////////////
+
+// Range-For Schleifen können verwendet werden, um über Container zu iterieren.
+int arr[] = {1, 10, 3};
+
+for(int elem: arr)
+{
+	cout << elem << endl;
+}
+
+// Insofern "auto" verwendet wird, muss der Typ nicht weiter beachtet werden.
+for(auto elem: arr)
+{
+	// Anweisungen ...
+}
+
+/////////////////////
+// Weiteres:
+/////////////////////
+
+// Einige Aspekte von C++ sind für Neueinsteiger häufig überraschend (aber auch für
+// C++ Veteranen).
+// Der nachfolgende Abschnitt ist leider nicht vollständig:
+// C++ ist eine der Sprachen, bei der es ein Leichtes ist, sich selbst ins Bein zu schießen.
+
+// Private-Methoden können überschrieben werden
+class Foo
+{
+  virtual void bar();
+};
+
+class FooSub : public Foo
+{
+  virtual void bar();  // Überschreibt Foo::bar!
+};
+
+// 0 == false == NULL
+bool* pt = new bool;
+*pt = 0; // Setzt den Wert des Pointers 'pt' auf false.
+pt = 0;  // Setzt 'pt' auf den "null-pointer". Keine Compiler-Warnung.
+
+// nullptr sollte dieses Problem nicht lösen:
+int* pt2 = new int;
+*pt2 = nullptr; // Kompiliert nicht.
+pt2 = nullptr;  // Setzt pt2 auf null.
+
+// Eine Ausnahme bilden bool´s.
+// Dies erlaubt es "null-pointer" zu testen: if(!ptr)
+// Die Konsequenz ist jedoch, dass dem nullptr ein bool zugewiesen werden kann.
+*pt = nullptr;  // Kompiliert auch, wenn '*pt' ein bool ist!
+
+// '=' != '=' != '='!
+// Ruft Foo::Foo(const Foo&) auf, oder den Kopierkonstruktor
+Foo f2;
+Foo f1 = f2;
+
+// Ruft Foo::Foo(const Foo&) auf, aber kopiert lediglich den "Foo" Teil von
+// "fooSub". Alle zusätzlichen Member werden verworfen. Diese eigenartige Verhalten
+// wird auch "object slicing" genannt.
+FooSub fooSub;
+Foo f1 = fooSub;
+
+// Ruft Foo::operator=(Foo&) oder eine andere Variante auf.
+Foo f1;
+f1 = f2;
+
+///////////////////////////////////////
+// Tuple (C++11 und höher)
+///////////////////////////////////////
+
+#include<tuple>
+
+// Konzeptionell sind Tupel alten Datenstrukturen sehr ähnlich, allerdings haben diese keine
+// bezeichneten Daten-Member, sondern werden durch die Reihenfolge angesprochen.
+
+// Erstellen des Tupels und das Einfügen eines Werts.
+auto first = make_tuple(10, 'A');
+const int maxN = 1e9;
+const int maxL = 15;
+auto second = make_tuple(maxN, maxL);
+
+// Ausgabe der Elemente des "first" Tuple.
+cout << get<0>(first) << " " << get<1>(first) << "\n"; // Ausgabe : 10 A
+
+// Ausgabe der Elemente des "second" Tuple.
+cout << get<0>(second) << " " << get<1>(second) << "\n"; // Ausgabe: 1000000000 15
+
+int first_int;
+char first_char;
+tie(first_int, first_char) = first;
+cout << first_int << " " << first_char << "\n";  // Ausgabe : 10 A
+
+// Tuple können auch wie folgt erzeugt werden:
+
+tuple<int, char, double> third(11, 'A', 3.14141);
+// tuple_size  gibt die Anzahl der Elemente in einem Tuple zurück.
+// Als "constexpr".
+
+cout << tuple_size<decltype(third)>::value << "\n"; // prints: 3
+
+// tuple_cat fügt die Elemente eines Tupels aneinander (in der selben Reihenfolge).
+
+auto concatenated_tuple = tuple_cat(first, second, third);
+// concatenated_tuple wird zu = (10, 'A', 1e9, 15, 11, 'A', 3.14141)
+
+cout << get<0>(concatenated_tuple) << "\n"; // Ausgabe: 10
+cout << get<3>(concatenated_tuple) << "\n"; // Ausgabe: 15
+cout << get<5>(concatenated_tuple) << "\n"; // Ausgabe: 'A'
+
+
+///////////////////////////////////
+// Logische- und Bitoperatoren
+//////////////////////////////////
+
+// Die meisten Operatoren in C++ entsprechen denen aus anderen Sprachen
+
+// Logische Operatoren.
+// C++ verwendet so genannte "Short-circuit" Evaluierung für Boolean-Ausdrücke.
+// Das zweite Argument wird ausgeführt bzw. evaluiert, wenn das erste Argument genügt,
+// um den Ausdruck zu bestimmen.
+
+true && false // Führt **logisches und** aus.
+true || false // Führt **logisches oder** aus.
+! true        // Führt **logisches nicht** aus.
+
+// Anstelle von Symbolen können auch Schlüsselwörter verwendet werden.
+true and false // Führt **logisches und** aus.
+true or false  // Führt **logisches oder** aus.
+not true       // Führt **logisches nicht** aus.
+
+// Bitoperationen
+
+// **<<** Links-Shift
+// **>>** Rechts-Shift
+
+~4    // Führt bitweises nicht aus.
+4 | 3 // Führt bitweises oder aus.
+4 & 3 // Führt bitweises und aus.
+4 ^ 3 // Führt bitweises xor aus.
+
+// Gleichwertige Schlüsselwörter:
+compl 4    // Führt bitweises nicht aus.
+4 bitor 3  // Führt bitweises oder aus.
+4 bitand 3 // Führt bitweises und aus.
+4 xor 3    // Führt bitweises xor aus.
+
+
+```
+Weiterführende Literatur:
+
+* Aktuelle Sprachen-Referenz [CPP Reference](http://cppreference.com/w/cpp).
+* Zusätzliches: [CPlusPlus](http://cplusplus.com).
+* Grundlagen Tutorial: [TheChernoProject - C++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb).
diff --git a/de-de/dhall-de.html.markdown b/de-de/dhall-de.html.markdown
new file mode 100644
index 00000000..385c88be
--- /dev/null
+++ b/de-de/dhall-de.html.markdown
@@ -0,0 +1,380 @@
+---
+language: Dhall
+contributors:
+    - ["Gabriel Gonzalez", "http://www.haskellforall.com/"]
+translators:
+    - ["Profpatsch", "http://profpatsch.de"]
+filename: learndhall-de.py
+lang: de-de
+---
+
+Dhall ist eine programmierbare Konfigurationssprache und bietet eine
+nicht-repetetive Alternative zu YAML.
+
+Man kann Dhall sehen als: JSON + Funktionen + Typen + Importsystem
+
+Obwohl Dhall programmierbar ist, ist die Sprache nicht
+turingvollständig. Viele von Dhalls Features benutzen diese
+Einschränkung, um stärkere Sicherheitsgarantien zu bieten und besseres
+Tooling zu ermöglichen.
+
+```haskell
+-- einzeiliger Kommentar
+
+{- mehrzeiliger Kommentar
+
+   Unicode funktioniert 🙂
+
+   Diese Datei ist eine valide Dhall-Expression und evaluiert zu einem
+   großen Record, welcher die Ergebnisse jedes Schritts beinhaltet.
+
+   Das Ergebnis kann angezeigt werden, indem man die Datei evaluiert:
+
+       $ dhall --file learndhall.dhall
+
+   {- Kommentare können verschachtelt sein -}
+-}
+
+let greeting = "Hallo, Welt!"
+
+let fruits = "🍋🍓🍍🍉🍌"
+
+let interpolation = "Ein paar leckere Früchte: ${fruits}"
+
+let multilineText {- Inline-Kommentare funktionieren ebenfalls -} =
+        ''
+        In Multiline-Text-Literals wird Whitespace am Anfang der Zeile
+        entfernt.
+
+        Das bedeutet Text kann frei eingerückt oder ausgerückt werden,
+        ohne dass sich der Inhalt des Strings ändert.
+
+            Relative Einrückungen bleiben erhalten.
+ 
+        Ansonsten wird das Text-Literal verbatim erhalten, ähnlich
+        zu “literal”-Multiline-Strings in YAML.
+        ''
+
+let bool = True
+
+-- Typannotationen für Bindings sind optional, aber hilfreich, also
+-- benutzen wir sie hier.
+let annotation : Bool = True
+
+let renderedBool : Text = if bool then "True" else "False"
+
+-- Natürliche Zahlen sind nicht-negativ und vorzeichenlos.
+let naturalNumber : Natural = 42
+
+-- Integer können negativ sein, brauchen aber ein explizites Vorzeichen.
+let positiveInteger : Integer = +1
+
+let negativeInteger : Integer = -12
+
+let pi : Double = 3.14159265359
+
+{- Identifier dürfen eine große Anzahl an verschiedenen Zeichen
+   beinhalten (wie z.B. Anführungszeichen oder Whitespace), wenn man
+   sie mit Backticks umschließt.
+-}
+let `Avogadro's Number` : Double = 6.0221409e+23
+
+let origin : { x : Double, y : Double } = { x = 0.0, y = 0.0 }
+
+let somePrimes : List Natural = [ 2, 3, 5, 7, 11 ]
+
+{- Ein Schema ist das gleiche wie ein Typ.
+
+   Typnamen beginnen konventionell mit einem Großbuchstaben, was
+   jedoch nicht erzwungen wird.
+-}
+let Profile : Type
+        = { person :
+              { name : Text
+              , age  : Natural
+              }
+          , address :
+              { country : Text
+              , state   : Text
+              , city    : Text
+              }
+          }
+
+let bernd : Profile =
+        { person =
+            { name = "Bernd Lauert"
+            , age  = 67
+            }
+        , address =
+            { country = "Deutschland"
+            , state   = "Bayern"
+            , city    = "Augsburg"
+            }
+        }
+
+let augsburg : Text = bernd.address.city
+
+{- Enum-Alternativen beginnen konventionell auch mit einem
+   Großbuchstaben. Das wird ebenfalls nicht erzwungen.
+-}
+let DNA : Type = < Adenine | Cytosine | Guanine | Thymine >
+
+let dnaSequence : List DNA = [ DNA.Thymine, DNA.Guanine, DNA.Guanine ]
+
+let compactDNASequence : List DNA =
+        let a = DNA.Adenine
+        let c = DNA.Cytosine
+        let g = DNA.Guanine
+        let t = DNA.Thymine
+        in  [ c, t, t, a, t, c, g, g, c ]
+
+-- Enums werden transformiert, indem man einen Record mit einem Feld
+-- pro Alternative angibt.
+let theLetterG : Text =
+            merge
+            { Adenine  = "A"
+            , Cytosine = "C"
+            , Guanine  = "G"
+            , Thymine  = "T"
+            }
+            DNA.Guanine
+
+let presentOptionalValue : Optional Natural = Some 1
+
+let absentOptionalValue : Optional Natural = None Natural
+
+let points : List { x : Double, y : Double } =
+        [ { x = 1.1, y = -4.2 }
+        , { x = 4.4, y = -3.0 }
+        , { x = 8.2, y = -5.5 }
+        ]
+
+{- `Natural -> List Natural` ist der Funktionstyp mit Eingabetyp
+   `Natural` und Ausgabetyp `List Natural`.
+
+   Alle Funktionen in Dhall sind Anonyme Funktionen (aka. „Lambdas“),
+   denen man optional einen Namen geben kann.
+
+   Die folgende Funktion beispielsweise ist äquivalent zu diesem
+   Python Code:
+
+       lambda n : [ n, n + 1 ]
+
+   ... und diesem Javascript Code:
+
+       function (n) { return [ n, n + 1 ]; }
+-}
+let exampleFunction : Natural -> List Natural =
+        \(n : Natural) -> [ n, n + 1 ]
+
+-- Dhall unterstützt auch Unicode-Syntax, aber dieses Tutorial nutzt
+-- die ASCII-Syntax.
+let unicodeFunction : Natural → List Natural =
+        λ(n : Natural) → [ n, n + 1 ]
+
+-- Funktionsargumente brauchen keine Klammern.
+let exampleFunctionApplication : List Natural =
+        exampleFunction 2
+
+let functionOfMultipleArguments : Natural -> Natural -> List Natural =
+        \(x : Natural) -> \(y : Natural) -> [ x, y ]
+
+let functionAppliedToMultipleArguments : List Natural =
+        functionOfMultipleArguments 2 3
+
+{- Wie `exampleFunction`, aber wir geben dem Eingabetypen
+   einen Namen, `n`.
+-}
+let namedArgumentType : forall (n : Natural) -> List Natural =
+        \(n : Natural) -> [ n, n + 1 ]
+
+{- Bekommt der Eingabetyp einen Namen, kann man ihn weiter hinten in
+   der gleichen Typdefinition wiederverwenden.
+
+   Das ermöglicht Funktionen, die mit mehr als einem Eingabetypen
+   arbeiten können (aka. „polymorphe“ Funktionen).
+-}
+let duplicate : forall (a : Type) -> a -> List a =
+        \(a : Type) -> \(x : a) -> [ x, x ] 
+
+let duplicatedNumber : List Natural =
+        duplicate Natural 2
+
+let duplicatedBool : List Bool =
+        duplicate Bool False
+
+{- Die Sprache hat auch eine handvoll eingebauter polymorpher
+   Funktionen, wie zum Beispiel:
+
+       List/head : forall (a : Type) -> List a -> Optional a
+-}
+let firstPrime : Optional Natural = List/head Natural somePrimes
+
+let functionOfARecord : { x : Natural, y : Natural } -> List Natural =
+        \(args : { x : Natural, y : Natural }) -> [ args.x, args.y ]
+
+let functionAppliedToARecord : List Natural =
+        functionOfARecord { x = 2, y = 5 }
+
+{- Alle Typkonversionen sind explizit.
+
+   `Natural/show` ist eine eingebaute Funktion mit dem Typ:
+
+       Natural/show : Natural -> Text
+
+   ... welche `Natural`s in ihre `Text`-Repräsentation konvertiert.
+-}
+let typeConversion : Natural -> Text =
+        \(age : Natural) -> "Ich bin ${Natural/show age} Jahre alt!"
+
+-- Ein „Template“ ist einfach eine Funktion mit Ausgabetyp `Text`.
+let mitLicense : { year : Natural, copyrightHolder : Text } -> Text =
+        \(args : { year : Natural, copyrightHolder : Text }) ->
+''
+Copyright ${Natural/show args.year} ${args.copyrightHolder}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do 
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+''
+
+-- Template-Instanziierung ist das gleiche wie Funktionsanwendung.
+let templatedLicense : Text =
+        mitLicense { year = 2019, copyrightHolder = "Jane Smith" }
+
+{- Expressions können via URL importiert werden.
+
+   Ähnlich wie in Bash kann man Code aus dem lokalen Dateisystem
+   importieren (wird nicht gezeigt).
+
+   Sicherheitsbewusste Nutzer können via URLs importierte Expressions
+   mit einem semantischen Integritätscheck versehen („pinnen“).
+   Für gepinnte Imports wird der Dhall-Interpreter jeden Versuch
+   vereiteln, auf der Remote-Seite die Expression zu manipulieren.
+   Jedoch werden Änderungen, die den Inhalt der importierten
+   Expression nicht verändern trotzdem akzeptiert.
+   
+   Auf diese Weise gepinnte Expressions werden auch in einem
+   Content-Adressable Store lokal gecached (standardmäßig in
+   `~/.cache/dhall`).
+-}
+let Natural/sum : List Natural -> Natural =
+      https://prelude.dhall-lang.org/Natural/sum
+      sha256:33f7f4c3aff62e5ecf4848f964363133452d420dcde045784518fb59fa970037
+
+let twentyEight : Natural = Natural/sum somePrimes
+
+-- Ein „Paket“ ist einfach ein (möglicherweise verschachtelter)
+-- Record, den man importiert.
+let Prelude = https://prelude.dhall-lang.org/package.dhall
+
+let false : Bool = Prelude.Bool.not True
+
+-- Durch das Anhängen von `as Text` wird eine Datei verbatim
+-- importiert und nicht als Dhall-Code interpretiert.
+let sourceCode : Text = https://prelude.dhall-lang.org/Bool/not as Text
+
+-- Environment-Variablen können auch imortiert werden.
+let presentWorkingDirectory = env:PWD as Text
+
+-- Mit `?` kann man eine “Fallback-Expression” angeben, für den Fall
+-- dass ein Import fehlschlägt.
+let home : Optional Text = Some env:HOME ? None Text
+
+-- Fallback-Expressions können auch alternative Imports enthalten.
+let possiblyCustomPrelude =
+        env:DHALL_PRELUDE
+      ? https://prelude.dhall-lang.org/package.dhall
+
+{- Ein ausführliches Beispiel, welches mithilfe der
+   `generate`-Funktion eine Konfiguration für 10 Build-User generiert:
+ 
+       Prelude.List.generate
+           : Natural -> forall (a : Type) -> (Natural -> a) -> List a
+-}
+let buildUsers =
+        let makeUser = \(user : Text) ->
+              let home       = "/home/${user}"
+              let privateKey = "${home}/.ssh/id_ed25519"
+              let publicKey  = "${privateKey}.pub"
+              in  { home = home
+                  , privateKey = privateKey
+                  , publicKey = publicKey
+                  }
+
+        let buildUser =
+                \(index : Natural) -> makeUser "build${Natural/show index}"
+
+        let Config =
+              { home : Text
+              , privateKey : Text
+              , publicKey : Text
+              }
+
+        in  Prelude.List.generate 10 Config buildUser
+
+-- Alle Ergebnisse in einem großen Record
+in  { greeting = greeting
+    , fruits = fruits
+    , interpolation = interpolation
+    , multilineText = multilineText
+    , bool = bool
+    , annotation = annotation
+    , renderedBool = renderedBool
+    , naturalNumber = naturalNumber
+    , positiveInteger = positiveInteger
+    , negativeInteger = negativeInteger
+    , pi = pi
+    , `Avogadro's Number` = `Avogadro's Number`
+    , origin = origin
+    , somePrimes = somePrimes
+    , bernd = bernd
+    , augsburg = augsburg
+    , dnaSequence = dnaSequence
+    , compactDNASequence = compactDNASequence
+    , theLetterG = theLetterG
+    , presentOptionalValue = presentOptionalValue
+    , absentOptionalValue = absentOptionalValue
+    , points = points
+    , exampleFunction = exampleFunction
+    , unicodeFunction = unicodeFunction
+    , exampleFunctionApplication = exampleFunctionApplication
+    , functionOfMultipleArguments = functionOfMultipleArguments
+    , functionAppliedToMultipleArguments = functionAppliedToMultipleArguments
+    , namedArgumentType = namedArgumentType
+    , duplicate = duplicate
+    , duplicatedNumber = duplicatedNumber
+    , duplicatedBool = duplicatedBool
+    , firstPrime = firstPrime
+    , functionOfARecord = functionOfARecord
+    , functionAppliedToARecord = functionAppliedToARecord
+    , typeConversion = typeConversion
+    , mitLicense = mitLicense
+    , templatedLicense = templatedLicense
+    , twentyEight = twentyEight
+    , false = false
+    , sourceCode = sourceCode
+    , presentWorkingDirectory = presentWorkingDirectory
+    , home = home
+    , buildUsers = buildUsers
+    }
+```
+
+Mehr Infos und Lernmaterialien gibt es auf der offiziellen Website
+(Englisch), auf der man Dhall auf im Browser ausprobieren kann:
+
+* [https://dhall-lang.org](http://dhall-lang.org/)
diff --git a/de-de/dynamic-programming-de.html.markdown b/de-de/dynamic-programming-de.html.markdown
index 801d2514..58568b3b 100644
--- a/de-de/dynamic-programming-de.html.markdown
+++ b/de-de/dynamic-programming-de.html.markdown
@@ -68,9 +68,9 @@ for i=0 to n-1
 
 ### Einige bekannte DP Probleme
 
-- Floyd Warshall Algorithm - [Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code)
-- Integer Knapsack Problem - [Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem)
-- Longest Common Subsequence - [Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence)
+- [Floyd Warshall Algorithm - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code)
+- [Integer Knapsack Problem - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem)
+- [Longest Common Subsequence - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence)
 
 ## Online Ressourcen
 
diff --git a/de-de/git-de.html.markdown b/de-de/git-de.html.markdown
index a0ed120f..0896f513 100644
--- a/de-de/git-de.html.markdown
+++ b/de-de/git-de.html.markdown
@@ -10,7 +10,7 @@ lang: de-de
 
 Git ist eine verteilte Versions- und Quellcodeverwaltung. 
 
-Es nimmt Schnappschüsse der Projekte, um mit diesen Schnappschüssen verschiedene Versionen unterscheiden und den Quellcode verwalten zu können.
+Es nimmt Schnappschüsse der Projekte auf, um mit diesen Schnappschüssen verschiedene Versionen unterscheiden und den Quellcode verwalten zu können.
 
 Anmerkung des Übersetzers: Einige englische Begriffe wie *Repository*, *Commit* oder *Head* sind idiomatische Bestandteile im Umgang mit Git. Sie wurden nicht übersetzt.
 
@@ -20,7 +20,7 @@ Anmerkung des Übersetzers: Einige englische Begriffe wie *Repository*, *Commit*
 
 Eine Versionsverwaltung erfasst die Änderungen einer Datei oder eines Verzeichnisses im Verlauf der Zeit.
 
-### Zentrale im Vergleich mit verteilter Versionverwaltung
+### Vergleich zwischen Zentraler und verteilter Versionverwaltung
 
 * Zentrale Versionsverwaltung konzentriert sich auf das Synchronisieren, Verfolgen und Sichern von Dateien.
 * Verteilte Versionsverwaltung konzentriert sich auf das Teilen der Änderungen. Jede Änderung hat eine eindeutige ID.
@@ -43,13 +43,13 @@ Eine Versionsverwaltung erfasst die Änderungen einer Datei oder eines Verzeichn
 
 ### Repository (Repo)
 
-Ein Satz von Dateien, Verzeichnisen, Historieneinträgen, Commits und Heads. Stell es dir wie eine Quellcode-Datenstruktur vor, unter anderem mit der Eigenschaft, dass alle *Elemente* dir Zugriff auf die Revisionshistorie geben.
+Ein Satz von Dateien, Verzeichnissen, Historieneinträgen, Commits und Heads. Stell es dir wie eine Quellcode-Datenstruktur vor, unter anderem mit der Eigenschaft, dass alle *Elemente* dir Zugriff auf die Revisionshistorie geben.
 
 Ein Repository besteht in Git aus dem .git-Verzeichnis und dem Arbeitsverzeichnis.
 
 ### .git-Verzeichnis (Teil des Repositorys)
 
-Das .git-Verzeichnis enthält alle Einstellung, Logs, Branches, den HEAD und mehr.
+Das .git-Verzeichnis enthält alle Einstellungen, Logs, Branches, den HEAD und mehr.
 [Ausführliche Übersicht](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
 
 ### Arbeitsverzeichnis (Teil des Repositorys)
@@ -66,7 +66,7 @@ Ein Commit ist ein Schnappschuss von Änderungen in deinem Arbeitsverzeichnis. W
 
 ### Branch
 
-Ein Branch, ein Ast oder Zweig, ist im Kern ein Pointer auf den letzten Commit, den du gemacht hast. Während des Commits wird der Pointer automatisch auf Stand gebracht und zeigt dann auf den neuen letzten Commit.
+Ein Branch, ein Ast oder Zweig, ist im Kern ein Pointer auf den letzten Commit, den du gemacht hast. Während des Commits wird der Pointer automatisch auf diesen Stand gebracht und zeigt dann auf den neuen letzten Commit.
 
 ### HEAD und head (Teil des .git-Verzeichnisses)
 
@@ -215,7 +215,7 @@ $ git commit --amend -m "Correct message"
 
 ### diff
 
-Zeigt die Unterschiede zwischen Dateien von Arbeitsverzeichnisse, dem Index und Commits an.
+Zeigt die Unterschiede zwischen Dateien vom Arbeitsverzeichnis, dem Index und Commits an.
 
 ```bash
 # Unterschiede zwischen deinem Arbeitsverzeichnis und dem Index anzeigen
@@ -330,7 +330,7 @@ $ git push origin master
 
 ### rebase (mit Vorsicht einsetzen) 
 
-Nimm alle Änderungen, die in einem Branch durch Commits vorgenommen wurden, und übertrage sie auf einen anderen Branch. Achtung: Führe keinen Rebase von Commits durch, die auf ein öffentliches Repo gepusht wurden.
+Nimm alle Änderungen, die in einem Branch durch Commits vorgenommen wurden, und übertrage sie auf einen anderen Branch. Achtung: Führe keinen Rebase von Commits durch, die auf ein öffentliches Repo gepusht wurden!
 
 ```bash
 # Rebase "experimentBranch" in den "master"-Branch
diff --git a/de-de/hq9+-de.html.markdown b/de-de/hq9+-de.html.markdown
new file mode 100644
index 00000000..841de5bb
--- /dev/null
+++ b/de-de/hq9+-de.html.markdown
@@ -0,0 +1,43 @@
+---
+language: HQ9+
+filename: hq9+-de.html
+contributors:
+    - ["Alexey Nazaroff", "https://github.com/rogaven"]
+translators:
+    - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de
+---
+
+HQ9+ ist eine Parodie auf esoterische Programmiersprachen und wurde von Cliff Biffle kreiert.
+Die Sprache hat nur vier Befehle und ist nicht Turing-vollständig.
+
+```
+Es gibt nur vier Befehle, die durch die folgenden vier Zeichen dargestellt werden
+H: druckt "Hello, world!"
+Q: druckt den Quellcode des Programms (ein Quine)
+9: druckt den Liedtext von "99 Bottles of Beer"
++: erhöhe den Akkumulator um Eins (Der Wert des Akkumulators kann nicht gelesen werden)
+Jedes andere Zeichen wird ignoriert.
+
+Ok. Lass uns ein Programm schreiben:
+  HQ
+
+Ergebnis:
+  Hello world!
+  HQ
+
+HQ9+ ist zwar sehr simpel, es erlaubt aber dir Sachen zu machen, die in
+anderen Sprachen sehr schwierig sind. Zum Beispiel druckt das folgende Programm
+drei Mal Kopien von sich selbst auf den Bildschirm:
+  QQQ
+Dies druckt:
+  QQQ
+  QQQ
+  QQQ
+```
+
+Und das ist alles. Es gibt sehr viele Interpreter für HQ9+.
+Unten findest du einen von ihnen.
+
++ [One of online interpreters](https://almnet.de/esolang/hq9plus.php)
++ [HQ9+ official website](http://cliffle.com/esoterica/hq9plus.html)
diff --git a/de-de/make-de.html.markdown b/de-de/make-de.html.markdown
index bc5c7bcb..cf90dc29 100644
--- a/de-de/make-de.html.markdown
+++ b/de-de/make-de.html.markdown
@@ -1,5 +1,6 @@
 ---

-language: make

+category: tool

+tool: make

 contributors:

     - ["Robert Steed", "https://github.com/robochat"]

     - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]

diff --git a/de-de/markdown-de.html.markdown b/de-de/markdown-de.html.markdown
index cccf5e68..729e883c 100644
--- a/de-de/markdown-de.html.markdown
+++ b/de-de/markdown-de.html.markdown
@@ -144,7 +144,7 @@ indem du eine Zeile mit vier Leerzeichen oder einem Tabulator einrückst -->
         puts item
     end
 
-<!-- Innerhalb normalen Texts kannst du Code mit Backticks ` auszeichnen -->
+<!-- Innerhalb normalen Texts kannst du Code mit Backticks \` auszeichnen -->
 
 Hermann hatte nicht die leiseste Ahnung, was dieses `go_to()` bedeuten könnte!
 
diff --git a/de-de/nix-de.html.markdown b/de-de/nix-de.html.markdown
index 79b60d20..ea02e81d 100644
--- a/de-de/nix-de.html.markdown
+++ b/de-de/nix-de.html.markdown
@@ -8,11 +8,11 @@ translators:
 lang: de-de
 ---
 
-Nix ist eine simple funktionale Programmiersprache, die für den 
+Nix ist eine simple funktionale Programmiersprache, die für den
 [Nix package manager](https://nixos.org/nix/) und
 [NixOS](https://nixos.org/) entwickelt wurde.
 
-Du kannst Nix Ausdrücke evaluieren mithilfe von 
+Du kannst Nix Ausdrücke evaluieren mithilfe von
 [nix-instantiate](https://nixos.org/nix/manual/#sec-nix-instantiate)
 oder [`nix-repl`](https://github.com/edolstra/nix-repl).
 
@@ -24,7 +24,7 @@ with builtins; [
 
   # Inline Kommentare sehen so aus.
 
-  /* Multizeilen Kommentare 
+  /* Multizeilen Kommentare
      sehen so aus. */
 
 
@@ -61,7 +61,7 @@ with builtins; [
   "String Literale sind in Anführungszeichen."
 
   "
-    String Literale können mehrere 
+    String Literale können mehrere
     Zeilen umspannen.
   "
 
@@ -95,7 +95,7 @@ with builtins; [
   tutorials/learn.nix
   #=> /the-base-path/tutorials/learn.nix
 
-  # Ein Pfad muss mindestens einen Schrägstrich enthalten. Ein Pfad für eine 
+  # Ein Pfad muss mindestens einen Schrägstrich enthalten. Ein Pfad für eine
   # Datei im selben Verzeichnis benötigt ein ./ Präfix.
   ./learn.nix
   #=> /the-base-path/learn.nix
@@ -238,7 +238,7 @@ with builtins; [
   #=> { d = 2; e = 3; }
 
   # Die Nachkommen eines Attributs können in diesem Feld nicht zugeordnet werden, wenn
-  # das Attribut selbst nicht zugewiesen wurde. 
+  # das Attribut selbst nicht zugewiesen wurde.
   {
     a = { b = 1; };
     a.c = 2;
@@ -261,9 +261,9 @@ with builtins; [
   #=> 7
 
   # Die erste Linie diese Tutorials startet mit "with builtins;",
-  # weil builtins ein Set mit allen eingebauten 
+  # weil builtins ein Set mit allen eingebauten
   # Funktionen (length, head, tail, filter, etc.) umfasst.
-  # Das erspart uns beispielsweise "builtins.length" zu schreiben, 
+  # Das erspart uns beispielsweise "builtins.length" zu schreiben,
   # anstatt nur "length".
 
 
@@ -305,7 +305,7 @@ with builtins; [
   (tryEval (abort "foo"))
   #=> error: evaluation aborted with the following error message: ‘foo’
 
-  # `assert` evaluiert zu dem gegebenen Wert, wenn die Bedingung wahr ist, sonst 
+  # `assert` evaluiert zu dem gegebenen Wert, wenn die Bedingung wahr ist, sonst
   # löst es eine abfangbare Exception aus.
   (assert 1 < 2; 42)
   #=> 42
@@ -319,7 +319,7 @@ with builtins; [
   #=========================================
 
   # Da die Wiederholbarkeit von Builds für den Nix Packetmanager entscheidend ist,
-  # werden in der Nix Sprache reine funktionale Elemente betont. Es gibt aber ein paar 
+  # werden in der Nix Sprache reine funktionale Elemente betont. Es gibt aber ein paar
   # unreine Elemente.
   # Du kannst auf Umgebungsvariablen verweisen.
   (getEnv "HOME")
@@ -355,4 +355,4 @@ with builtins; [
   (https://medium.com/@MrJamesFisher/nix-by-example-a0063a1a4c55)
 
 * [Susan Potter - Nix Cookbook - Nix By Example]
-  (http://funops.co/nix-cookbook/nix-by-example/)
+  (https://ops.functionalalgebra.com/nix-by-example/)
diff --git a/de-de/opencv-de.html.markdown b/de-de/opencv-de.html.markdown
new file mode 100644
index 00000000..223e6cd8
--- /dev/null
+++ b/de-de/opencv-de.html.markdown
@@ -0,0 +1,153 @@
+---
+category: tool
+tool: OpenCV
+filename: learnopencv-de.py
+contributors:
+    - ["Yogesh Ojha", "http://github.com/yogeshojha"]
+translators:
+    - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de
+---
+### Opencv
+
+OpenCV (Open Source Computer Vision) ist eine Bibliothek von Programmierfunktionen, 
+die hauptsächlich auf maschinelles Sehen in Echtzeit ausgerichtet ist.
+Ursprünglich wurde OpenCV von Intel entwickelt. Später wurde es von von 
+Willow Garage und dann Itseez (das später von Intel übernommen wurde) unterstützt.
+OpenCV unterstützt derzeit eine Vielzahl von Sprachen, wie C++, Python, Java uvm.
+
+#### Installation
+
+Bitte lese diese Artikel für die Installation von OpenCV auf deinen Computer.
+
+* Windows Installationsanleitung: [https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_setup/py_setup_in_windows/py_setup_in_windows.html#install-opencv-python-in-windows]()
+* Mac Installationsanleitung (High Sierra): [https://medium.com/@nuwanprabhath/installing-opencv-in-macos-high-sierra-for-python-3-89c79f0a246a]()
+* Linux Installationsanleitung (Ubuntu 18.04): [https://www.pyimagesearch.com/2018/05/28/ubuntu-18-04-how-to-install-opencv]()
+
+### Hier werden wir uns auf die Pythonimplementierung von OpenCV konzentrieren.
+
+```python
+# Bild in OpenCV lesen
+import cv2
+img = cv2.imread('Katze.jpg')
+
+# Bild darstellen
+# Die imshow() Funktion wird verwendet um das Display darzustellen.
+cv2.imshow('Image',img)
+# Das erste Argument ist der Titel des Fensters und der zweite Parameter ist das Bild
+# Wenn du den Fehler Object Type None bekommst ist eventuell dein Bildpfad falsch.
+# Bitte überprüfe dann den Pfad des Bildes erneut.
+cv2.waitKey(0)
+# waitKey() ist eine Tastaturbindungsfunktion, sie nimmt Argumente in 
+# Millisekunden an. Für GUI Ereignisse MUSST du die waitKey() Funktion verwenden.
+
+# Ein Bild schreiben
+cv2.imwrite('graueKatze.png',img)
+# Das erste Arkument ist der Dateiname und das Zweite ist das Bild
+
+# Konveriere das Bild zu Graustufen
+gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+# Videoaufnahme von der Webcam
+cap = cv2.VideoCapture(0)
+# 0 ist deine Kamera, wenn du mehrere Kameras hast musst du deren Id eingeben
+while(True):
+    # Erfassen von Einzelbildern
+    _, frame = cap.read()
+    cv2.imshow('Frame',frame)
+    # Wenn der Benutzer q drückt -> beenden
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+# Die Kamera muss wieder freigegeben werden
+cap.release()
+
+# Wiedergabe von Videos aus einer Datei
+cap = cv2.VideoCapture('film.mp4')
+while(cap.isOpened()):
+    _, frame = cap.read()
+    # Das Video in Graustufen abspielen
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    cv2.imshow('frame',gray)
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+cap.release()
+
+# Zeichne eine Linie in OpenCV
+# cv2.line(img,(x,y),(x1,y1),(color->r,g,b->0 to 255),thickness)
+cv2.line(img,(0,0),(511,511),(255,0,0),5)
+
+# Zeichne ein Rechteck
+# cv2.rectangle(img,(x,y),(x1,y1),(color->r,g,b->0 to 255),thickness)
+# thickness = -1 wird zum Füllen des Rechtecks verwendet
+cv2.rectangle(img,(384,0),(510,128),(0,255,0),3)
+
+# Zeichne ein Kreis
+cv2.circle(img,(xCenter,yCenter), radius, (color->r,g,b->0 to 255), thickness)
+cv2.circle(img,(200,90), 100, (0,0,255), -1)
+
+# Zeichne eine Ellipse
+cv2.ellipse(img,(256,256),(100,50),0,0,180,255,-1)
+
+# Text auf Bildern hinzufügen
+cv2.putText(img,"Hello World!!!", (x,y), cv2.FONT_HERSHEY_SIMPLEX, 2, 255)
+
+# Bilder zusammenfüggen
+img1 = cv2.imread('Katze.png')
+img2 = cv2.imread('openCV.jpg')
+dst = cv2.addWeighted(img1,0.5,img2,0.5,0)
+
+# Schwellwertbild
+# Binäre Schwellenwerte
+_,thresImg = cv2.threshold(img,127,255,cv2.THRESH_BINARY)
+# Anpassbare Schwellenwerte 
+adapThres = cv2.adaptiveThreshold(img,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY,11,2)
+
+# Weichzeichnung von einem Bild
+# Gausßscher Weichzeichner
+blur = cv2.GaussianBlur(img,(5,5),0)
+# Rangordnungsfilter
+medianBlur = cv2.medianBlur(img,5)
+
+# Canny-Algorithmus
+img = cv2.imread('Katze.jpg',0)
+edges = cv2.Canny(img,100,200)
+
+# Gesichtserkennung mit Haarkaskaden
+# Lade die Haarkaskaden von https://github.com/opencv/opencv/blob/master/data/haarcascades/ herunter
+import cv2
+import numpy as np
+face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
+eye_cascade = cv2.CascadeClassifier('haarcascade_eye.xml')
+
+img = cv2.imread('Mensch.jpg')
+gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+aces = face_cascade.detectMultiScale(gray, 1.3, 5)
+for (x,y,w,h) in faces:
+    cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
+    roi_gray = gray[y:y+h, x:x+w]
+    roi_color = img[y:y+h, x:x+w]
+    eyes = eye_cascade.detectMultiScale(roi_gray)
+    for (ex,ey,ew,eh) in eyes:
+        cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)
+
+cv2.imshow('img',img)
+cv2.waitKey(0)
+
+cv2.destroyAllWindows()
+# destroyAllWindows() zerstört alle Fenster
+# Wenn du ein bestimmtes Fenter zerstören möchtest musst du den genauen Namen des 
+# von dir erstellten Fensters übergeben.
+```
+
+### Weiterführende Literatur:
+* Lade Kaskade hier herunter [https://github.com/opencv/opencv/blob/master/data/haarcascades]()
+* OpenCV Zeichenfunktionen [https://docs.opencv.org/2.4/modules/core/doc/drawing_functions.html]()
+* Eine aktuelle Sprachenreferenz kann hier gefunden werden [https://opencv.org]()
+* Zusätzliche Ressourcen können hier gefunden werden [https://en.wikipedia.org/wiki/OpenCV]()
+* Gute OpenCV Tutorials
+    * [https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_tutorials.html]()
+    * [https://realpython.com/python-opencv-color-spaces]()
+    * [https://pyimagesearch.com]()
+    * [https://www.learnopencv.com]()
+    * [https://docs.opencv.org/master/]()
diff --git a/de-de/paren-de.html.markdown b/de-de/paren-de.html.markdown
new file mode 100644
index 00000000..641e226e
--- /dev/null
+++ b/de-de/paren-de.html.markdown
@@ -0,0 +1,200 @@
+---
+
+language: Paren
+filename: learnparen-de.paren
+contributors:
+  - ["KIM Taegyoon", "https://github.com/kimtg"]
+  - ["Claudson Martins", "https://github.com/claudsonm"]
+translators:
+    - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de
+---
+
+[Paren](https://bitbucket.org/ktg/paren) ist ein Dialekt von Lisp.
+Es ist als eingebettete Sprache konzipiert.
+
+Manche Beispiele sind von <http://learnxinyminutes.com/docs/racket/>.
+
+```scheme
+;;; Kommentare
+# Kommentare
+
+;; Einzeilige Kommentare starten mit einem Semikolon oder einem Hashtag
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 1. Primitive Datentypen und Operatoren
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Zahlen
+123 ; int
+3.14 ; double
+6.02e+23 ; double
+(int 3.14) ; => 3 : int
+(double 123) ; => 123 : double
+
+;; Funktionsapplikationen werden so geschrieben: (f x y z ...)
+;; Dabei ist f eine Funktion und x, y, z sind die Operatoren.
+;; Wenn du eine Literalliste von Daten erstelllen möchtest,
+;; verwende (quote) um zu verhindern, dass sie ausgewertet zu werden.
+(quote (+ 1 2)) ; => (+ 1 2)
+;; Nun einige arithmetische Operationen
+(+ 1 1)  ; => 2
+(- 8 1)  ; => 7
+(* 10 2) ; => 20
+(^ 2 3) ; => 8
+(/ 5 2) ; => 2
+(% 5 2) ; => 1
+(/ 5.0 2) ; => 2.5
+
+;;; Wahrheitswerte
+true ; for Wahr
+false ; for Falsch
+(! true) ; => Falsch
+(&& true false (prn "doesn't get here")) ; => Falsch
+(|| false true (prn "doesn't get here")) ; => Wahr
+
+;;; Zeichen sind Ints.
+(char-at "A" 0) ; => 65
+(chr 65) ; => "A"
+
+;;; Zeichenketten sind ein Array von Zahlen mit fester Länge.
+"Hello, world!"
+"Benjamin \"Bugsy\" Siegel"   ; Backslash ist ein Escape-Zeichen
+"Foo\tbar\r\n" ; beinhaltet C Escapes: \t \r \n
+
+;; Zeichenketten können auch verbunden werden!
+(strcat "Hello " "world!") ; => "Hello world!"
+
+;; Eine Zeichenketten kann als Liste von Zeichen behandelt werden
+(char-at "Apple" 0) ; => 65
+
+;; Drucken ist ziemlich einfach
+(pr "Ich bin" "Paren. ") (prn "Schön dich zu treffen!")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 2. Variablen
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Du kannst Variablen setzen indem du (set) verwedest
+;; eine Variable kann alle Zeichen besitzen außer: ();#"
+(set some-var 5) ; => 5
+some-var ; => 5
+
+;; Zugriff auf eine zuvor nicht zugewiesene Variable erzeugt eine Ausnahme
+; x ; => Unknown variable: x : nil
+
+;; Lokale Bindung: Verwende das Lambda Calculus! 'a' und 'b' 
+;; sind nur zu '1' und '2' innerhalb von (fn ...) gebunden.
+((fn (a b) (+ a b)) 1 2) ; => 3
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Sammlungen
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Listen
+
+;; Listen sind Vektrorartige Datenstrukturen. (Zufälliger Zugriff ist O(1).
+(cons 1 (cons 2 (cons 3 (list)))) ; => (1 2 3)
+;; 'list' ist ein komfortabler variadischer Konstruktor für Listen
+(list 1 2 3) ; => (1 2 3)
+;; und ein quote kann als literaler Listwert verwendet werden
+(quote (+ 1 2)) ; => (+ 1 2)
+
+;; Du kannst 'cons' verwenden um ein Element an den Anfang einer Liste hinzuzufügen.
+(cons 0 (list 1 2 3)) ; => (0 1 2 3)
+
+;; Listen sind ein sehr einfacher Typ, daher gibt es eine Vielzahl an Funktionen
+;; für Sie. Ein paar Beispiele:
+(map inc (list 1 2 3))          ; => (2 3 4)
+(filter (fn (x) (== 0 (% x 2))) (list 1 2 3 4))    ; => (2 4)
+(length (list 1 2 3 4))     ; => 4
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Funktionen
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Verwende 'fn' um Funktionen zu erstellen.
+;; eine Funktion gibt immer den Wert ihres letzten Ausdrucks zurück
+(fn () "Hello World") ; => (fn () Hello World) : fn
+
+;; Verwende Klammern um alle Funktionen aufzurufen, inklusive Lambda Ausdrücke
+((fn () "Hello World")) ; => "Hello World"
+
+;; Zuweisung einer Funktion zu einer Variablen
+(set hello-world (fn () "Hello World"))
+(hello-world) ; => "Hello World"
+
+;; Du kannst dies mit syntaktischen Zucker für die Funktionsdefinition verkürzen:
+(defn hello-world2 () "Hello World")
+
+;; Die () von oben ist eine Liste von Argumente für die Funktion.
+(set hello
+  (fn (name)
+    (strcat "Hello " name)))
+(hello "Steve") ; => "Hello Steve"
+
+;; ... oder gleichwertig, unter Verwendung mit syntaktischen Zucker:
+(defn hello2 (name)
+  (strcat "Hello " name))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 4. Gleichheit
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Für Zahlen verwende '=='
+(== 3 3.0) ; => wahr
+(== 2 1) ; => falsch
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 5. Kontrollfluss
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Bedingungen
+
+(if true               ; test Ausdruck
+    "this is true"   ; then Ausdruck
+    "this is false") ; else Ausdruck
+; => "this is true"
+
+;;; Schleifen
+
+;; for Schleifen ist für Zahlen 
+;; (for SYMBOL START ENDE SCHRITT AUSDRUCK ..)
+(for i 0 10 2 (pr i "")) ; => schreibt 0 2 4 6 8 10
+(for i 0.0 10 2.5 (pr i "")) ; => schreibt 0 2.5 5 7.5 10
+
+;; while Schleife
+((fn (i)
+  (while (< i 10)
+    (pr i)
+    (++ i))) 0) ; => schreibt 0123456789
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 6. Mutation
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Verwende 'set' um einer Variablen oder einer Stelle einen neuen Wert zuzuweisen.
+(set n 5) ; => 5
+(set n (inc n)) ; => 6
+n ; => 6
+(set a (list 1 2)) ; => (1 2)
+(set (nth 0 a) 3) ; => 3
+a ; => (3 2)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 7. Makros
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Makros erlauben es dir die Syntax der Sprache zu erweitern.
+;; Parens Makros sind einfach.
+;; Tatsächlich ist (defn) ein Makro.
+(defmacro setfn (name ...) (set name (fn ...)))
+(defmacro defn (name ...) (def name (fn ...)))
+
+;; Lass uns eine Infix Notation hinzufügen
+;; Let's add an infix notation
+(defmacro infix (a op ...) (op a ...))
+(infix 1 + 2 (infix 3 * 4)) ; => 15
+
+;; Makros sind nicht hygenisch, Du kannst bestehende Variablen überschreiben!
+;; Sie sind Codetransformationenen.
+```
diff --git a/de-de/python-de.html.markdown b/de-de/python-de.html.markdown
index ae29d6f9..ee77683e 100644
--- a/de-de/python-de.html.markdown
+++ b/de-de/python-de.html.markdown
@@ -386,25 +386,73 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
 [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. Klassen
+## 5. Module
 ####################################################
 
-# Wir bilden die Unterklasse eines Objekts, um Klassen zu erhalten.
+# Wir können Module importieren
+import math
+print math.sqrt(16) #=> 4.0
+
+# Wir können auch nur spezielle Funktionen eines Moduls importieren
+from math import ceil, floor
+print ceil(3.7)  #=> 4.0
+print floor(3.7) #=> 3.0
+
+# Wir können auch alle Funktionen eines Moduls importieren
+# Warnung: Dies wird nicht empfohlen
+from math import *
+
+# Wir können Modulnamen abkürzen
+import math as m
+math.sqrt(16) == m.sqrt(16) #=> True
+
+# Module sind in Python nur gewöhnliche Dateien. Wir
+# können unsere eigenen schreiben und importieren. Der Name des 
+# Moduls ist der Dateiname.
+
+# Wir können herausfinden, welche Funktionen und Attribute in einem 
+# Modul definiert sind.
+import math
+dir(math)
+
+# Wenn Sie ein Python-Skript namens math.py im selben Ordner 
+# wie Ihr aktuelles Skript haben, wird die Datei math.py 
+# anstelle des integrierten Python-Moduls geladen.
+# Dies geschieht, weil der lokale Ordner Vorrang
+# vor den in Python integrierten Bibliotheken hat.
+
+
+####################################################
+## 6. Klassen
+####################################################
+
+# Wir verwenden das Schlüsselwort "class" um eine Klasse zu erzeugen.
 class Human(object):
 
     # Ein Klassenattribut. Es wird von allen Instanzen einer Klasse geteilt
     species = "H. sapiens"
 
-    # Ein simpler Konstruktor
+    # Ein simpler Konstruktor, wird aufgerufen, wenn diese Klasse instanziiert wird.
+    # Beachten Sie, dass die doppelten vorangestellten und nachgestellten 
+    # Unterstriche Objekte oder Attribute bezeichnen, die von Python verwendet werden, 
+    # aber in benutzergesteuerten Namespaces leben. 
+    # Methoden (oder Objekte oder Attribute) wie: __init__, __str__, __repr__ usw. 
+    # werden als Sondermethoden (oder manchmal als Dundermethoden bezeichnet) bezeichnet.
+    # Sie sollten solche Namen nicht selbst erfinden.
     def __init__(self, name):
         # Wir weisen das Argument name dem name-Attribut der Instanz zu
         self.name = name
 
-    # Eine Instanzmethode. Alle Methoden erhalten self als erstes Argument.
+    # Eine Instanzmethode. Alle Methoden erhalten "self" als erstes Argument.
     def say(self, msg):
        return "%s: %s" % (self.name, msg)
 
+    # Eine weitere Instanzmethode
+    def sing(self):
+        return 'yo... yo... microphone check... one two... one two...'
+
     # Eine Klassenmethode wird von allen Instanzen geteilt.
     # Sie werden mit der aufrufenden Klasse als erstem Argument aufgerufen
     @classmethod
@@ -416,56 +464,287 @@ class Human(object):
     def grunt():
         return "*grunt*"
 
+    # Eine Eigenschaft (Property) ist wie ein Getter.
+    # Es verwandelt die Methode age() in ein schreibgeschütztes Attribut mit demselben Namen.
+    # Es ist jedoch nicht nötig, triviale Getter und Setter in Python zu schreiben.
+    @property
+    def age(self):
+        return self._age
+
+    # Damit kann die Eigenschaft festgelegt werden
+    @age.setter
+    def age(self, age):
+        self._age = age
+
+    # Damit kann die Eigenschaft gelöscht werden
+    @age.deleter
+    def age(self):
+        del self._age
+
+# Wenn ein Python-Interpreter eine Quelldatei liest, führt er den gesamten Code aus.
+# Diese __name__-Prüfung stellt sicher, dass dieser Codeblock nur ausgeführt wird, 
+# wenn dieses Modul das Hauptprogramm ist.
+if __name__ == '__main__':
+    # Eine Instanz einer Klasse erstellen
+    i = Human(name="Ian")
+    i.say("hi")                     # "Ian: hi"
+    j = Human("Joel")
+    j.say("hello")                  # "Joel: hello"
+    # i und j sind Instanzen des Typs Mensch, oder anders ausgedrückt: Sie sind Objekte des Menschen
+
+    # Rufen wir unsere Klassenmethode auf
+    i.say(i.get_species())          # "Ian: H. sapiens"
+
+    # Ändern wir das gemeinsame Attribut
+    Human.species = "H. neanderthalensis"
+    i.say(i.get_species())          # => "Ian: H. neanderthalensis"
+    j.say(j.get_species())          # => "Joel: H. neanderthalensis"
+    
+    # Aufruf der statischen Methode
+    print(Human.grunt())            # => "*grunt*"
+
+    # Kann keine statische Methode mit Instanz des Objekts aufrufen, 
+    # da i.grunt () automatisch "self" (das Objekt i) als Argument verwendet
+    print(i.grunt())                # => TypeError: grunt() takes 0 positional arguments but 1 was given
+
+    # Die Eigenschaft für diese Instanz aktualisieren
+    i.age = 42
+    # die Eigenschaft auslesen
+    i.say(i.age)                    # => "Ian: 42"
+    j.say(j.age)                    # => "Joel: 0"
+    # die Eigenschaft löschen
+    del i.age
+    # i.age                         # => würde einen AttributeError werfen
+    
+####################################################
+## 6.1 Inheritance
+####################################################
+    
+# Vererbung ermöglicht die Definition neuer untergeordneter Klassen, 
+# die Methoden und Variablen von ihrer übergeordneten Klasse erben.
+
+# Wenn Sie die oben definierte Human-Klasse als Basis- oder Elternklasse verwenden, 
+# können Sie eine untergeordnete Klasse, Superhero, definieren, die die Klassenvariablen 
+# wie "species", "name" und "age" sowie Methoden wie "sing" und "grunzen" aus der Klasse Human erbt. 
+# Die Untergeordnete Klasse kann aber auch eigene Eigenschaften haben.
+
+# Um von der Modularisierung per Datei zu profitieren, können Sie die Klassen 
+# in ihren eigenen Dateien platzieren, z. B. human.py
+
+# Um Funktionen aus anderen Dateien zu importieren, verwenden Sie das folgende Format 
+# from "Dateiname-ohne-Erweiterung" impotr "Funktion-oder-Klasse"
+
+from human import Human
+
+# Geben Sie die übergeordnete(n) Klasse(n) als Parameter für die Klassendefinition an
+class Superhero(Human):
+
+    # Wenn die untergeordnete Klasse alle Definitionen des übergeordneten Elements 
+    # ohne Änderungen erben soll, können Sie einfach das Schlüsselwort "pass" 
+    # (und nichts anderes) verwenden. In diesem Fall wird jedoch auskommentiert, 
+    # um eine eindeutige untergeordnete Klasse zuzulassen:
+    # pass
+
+    # Kindklassen können die Attribute ihrer Eltern überschreiben
+    species = 'Superhuman'
+
+    # Kinder erben automatisch den Konstruktor ihrer übergeordneten Klasse 
+    # einschließlich ihrer Argumente, können aber auch zusätzliche Argumente oder 
+    # Definitionen definieren und ihre Methoden zB den Klassenkonstruktor überschreiben.
+    # Dieser Konstruktor erbt das Argument "name" von der Klasse "Human" und 
+    # fügt die Argumente "superpowers" und "movie" hinzu:
+    def __init__(self, name, movie=False,
+                     superpowers=["super strength", "bulletproofing"]):
+
+        # zusätzliche Klassenattribute hinzufügen:
+        self.fictional = True
+        self.movie = movie
+        # Beachten Sie die veränderlichen Standardwerte, da die Standardwerte gemeinsam genutzt werden
+        self.superpowers = superpowers
+        
+        # Mit der Funktion "super" können Sie auf die Methoden der übergeordneten Klasse 
+        # zugreifen, die vom untergeordneten Objekt überschrieben werden, 
+        # in diesem Fall die Methode __init__.
+        # Dies ruft den Konstruktor der übergeordneten Klasse auf:
+        super().__init__(name)
+        
+    # überschreiben der "sing" Methode
+    def sing(self):
+        return 'Dun, dun, DUN!'
+        
+    # eine zusätzliche Instanzmethode hinzufügen
+    def boast(self):
+        for power in self.superpowers:
+            print("I wield the power of {pow}!".format(pow=power))
+
+if __name__ == '__main__':
+    sup = Superhero(name="Tick")
+    
+    # Instanztypprüfungen
+    if isinstance(sup, Human):
+        print('I am human')
+    if type(sup) is Superhero:
+        print('I am a superhero')
+        
+    # Die Reihenfolge der Methodenauflösung (MRO = Method Resolution Order) anzeigen, die sowohl von getattr() als auch von super() verwendet wird.
+    # Dieses Attribut ist dynamisch und kann aktualisiert werden.
+    print(Superhero.__mro__)    # => (<class '__main__.Superhero'>,
+                                # => <class 'human.Human'>, <class 'object'>)
+                                
+    # Ruft die übergeordnete Methode auf, verwendet jedoch das eigene Klassenattribut
+    print(sup.get_species())    # => Superhuman
+    
+    # Ruft die überschriebene Methode auf
+    print(sup.sing())           # => Dun, dun, DUN!
+    
+    # Ruft die Methode von Human auf
+    sup.say('Spoon')            # => Tick: Spoon
+    
+    # Aufruf einer Methode, die nur in Superhero existiert
+    sup.boast()                 # => I wield the power of super strength!
+                                # => I wield the power of bulletproofing!
+                                    
+    # Vererbtes Klassenattribut
+    sup.age = 31
+    print(sup.age)              # => 31
+    
+    # Attribut, das nur in Superhero existiert
+    print('Am I Oscar eligible? ' + str(sup.movie))
+
+####################################################
+## 6.2 Multiple Inheritance
+####################################################
 
-# Eine Instanz einer Klasse erstellen
-i = Human(name="Ian")
-print i.say("hi")     # gibt "Ian: hi" aus
+# Eine weitere Klassendefinition
+# bat.py
 
-j = Human("Joel")
-print j.say("hello")  #gibt "Joel: hello" aus
+class Bat:
 
-# Rufen wir mal unsere Klassenmethode auf
-i.get_species() #=> "H. sapiens"
+    species = 'Baty'
 
-# Ändern wir mal das gemeinsame Attribut
-Human.species = "H. neanderthalensis"
-i.get_species() #=> "H. neanderthalensis"
-j.get_species() #=> "H. neanderthalensis"
+    def __init__(self, can_fly=True):
+        self.fly = can_fly
 
-# Aufruf der statischen Methode
-Human.grunt() #=> "*grunt*"
+    # This class also has a say method
+    def say(self, msg):
+        msg = '... ... ...'
+        return msg
 
+    # And its own method as well
+    def sonar(self):
+        return '))) ... ((('
 
+if __name__ == '__main__':
+    b = Bat()
+    print(b.say('hello'))
+    print(b.fly)
+    
+# Und noch eine andere Klassendefinition, die von Superhero und Bat erbt
+# superhero.py    
+from superhero import Superhero
+from bat import Bat
+
+# Definieren Sie Batman als eine Kindklasse, das von Superheld und Bat erbt
+class Batman(Superhero, Bat):
+
+    def __init__(self, *args, **kwargs):
+        # In der Regel müssen Sie super aufrufen, um Attribute zu erben:
+        # super (Batman, selbst) .__ init__ (* args, ** kwargs)
+        # Allerdings handelt es sich hier um Mehrfachvererbung, und super() 
+        # funktioniert nur mit der nächsten Basisklasse in der MRO-Liste.
+        # Stattdessen rufen wir explizit __init__ für alle Vorfahren auf.
+        # Die Verwendung von *args und **kwargs ermöglicht die saubere Übergabe von 
+        # Argumenten, wobei jedes übergeordnete Element eine Schicht der Zwiebel "abschält".
+        Superhero.__init__(self, 'anonymous', movie=True, 
+                           superpowers=['Wealthy'], *args, **kwargs)
+        Bat.__init__(self, *args, can_fly=False, **kwargs)
+        # überschreibt den Wert für das Namensattribut
+        self.name = 'Sad Affleck'
+
+    def sing(self):
+        return 'nan nan nan nan nan batman!'
+        
+if __name__ == '__main__':
+    sup = Batman()
+    
+    # Die Reihenfolge der Methodenauflösung (MRO = Method Resolution Order) anzeigen, 
+    # die sowohl von getattr() als auch von super() verwendet wird.
+    # Dieses Attribut ist dynamisch und kann aktualisiert werden.
+    print(Batman.__mro__)       # => (<class '__main__.Batman'>, 
+                                # => <class 'superhero.Superhero'>, 
+                                # => <class 'human.Human'>, 
+                                # => <class 'bat.Bat'>, <class 'object'>)
+                                
+    # Ruft die übergeordnete Methode auf, verwendet jedoch das eigene Klassenattribut                                
+    print(sup.get_species())    # => Superhuman                                
+    
+    # Ruft die überschriebene Methode auf
+    print(sup.sing())           # => nan nan nan nan nan batman!
+    
+    # Ruft die Methode von Human auf, weil die Reihenfolge der Vererbung wichtig ist
+    sup.say('I agree')          # => Sad Affleck: I agree
+    
+    # Aufrufmethode, die nur im 2. Vorfahren existiert
+    print(sup.sonar())          # => ))) ... (((
+    
+    # Vererbtes Klassenattribut
+    sup.age = 100
+    print(sup.age)              # => 100
+    
+    # Vererbtes Attribut vom 2. Vorfahren, dessen Standardwert überschrieben wurde.
+    print('Can I fly? ' + str(sup.fly)) # => Can I fly? False
+    
+    
 ####################################################
-## 6. Module
-####################################################
-
-# Wir können Module importieren
-import math
-print math.sqrt(16) #=> 4
+## 7. Fortgeschrittenes
+####################################################    
+    
+# Generatoren helfen Ihnen, lazy Code zu erstellen.
+def double_numbers(iterable):
+    for i in iterable:
+        yield i + i
+        
+# Generatoren sind speichereffizient, da sie nur die Daten laden, 
+# die zur Verarbeitung des nächsten Werts in der iterierbaren Komponente 
+# erforderlich sind. Dadurch können sie ansonsten unzulässig große Wertebereiche ausführen.
+# HINWEIS: `range` ersetzt` xrange` in Python 3.        
+for i in double_numbers(range(1, 900000000)):  # `range` ist ein Generator.
+    print(i)
+    if i >= 30:
+        break
+
+# Genauso wie Sie ein 'list comprehension' (Listen Abstraktion) erstellen können, können Sie auch 'generator comprehension' (Generator Abstraktion) erstellen.
+values = (-x for x in [1,2,3,4,5])
+for x in values:
+    print(x)  # prints -1 -2 -3 -4 -5 to console/terminal
+    
+# Sie können eine Generator Abstraktion auch direkt in eine Liste umwandeln (casten).
+values = (-x for x in [1,2,3,4,5])
+gen_to_list = list(values)
+print(gen_to_list)  # => [-1, -2, -3, -4, -5]
 
-# Wir können auch nur spezielle Funktionen eines Moduls importieren
-from math import ceil, floor
-print ceil(3.7)  #=> 4.0
-print floor(3.7) #=> 3.0
+# Decorators
+# In diesem Beispiel umschliesst "beg" "say". Wenn say_please True ist, wird die zurückgegebene Nachricht geändert.
+from functools import wraps
 
-# Wir können auch alle Funktionen eines Moduls importieren
-# Warnung: Dies wird nicht empfohlen
-from math import *
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, "Please! I am poor :(")
+        return msg
 
-# Wir können Modulnamen abkürzen
-import math as m
-math.sqrt(16) == m.sqrt(16) #=> True
+    return wrapper
 
-# Module sind in Python nur gewöhnliche Dateien. Wir
-# können unsere eigenen schreiben und importieren. Der Name des 
-# Moduls ist der Dateiname.
+@beg
+def say(say_please=False):
+    msg = "Can you buy me a beer?"
+    return msg, say_please
 
-# Wir können auch die Funktionen und Attribute eines
-# Moduls herausfinden.
-import math
-dir(math)
 
+print(say())                 # Can you buy me a beer?
+print(say(say_please=True))  # Can you buy me a beer? Please! I am poor :(
 
 ```
 
diff --git a/de-de/python3-de.html.markdown b/de-de/python3-de.html.markdown
index 33897225..4ef997a1 100644
--- a/de-de/python3-de.html.markdown
+++ b/de-de/python3-de.html.markdown
@@ -14,7 +14,7 @@ Python wurde in den frühen Neunzigern von Guido van Rossum entworfen. Es ist he
 
 Feedback ist herzlich willkommen! Ihr erreicht mich unter [@louiedinh](http://twitter.com/louiedinh) oder louiedinh [at] [google's email service].
 
-Hinweis: Dieser Beitrag bezieht sich insplizit auf Python 3. Falls du lieber Python 2.7 lernen möchtest, schau [hier](http://learnxinyminutes.com/docs/python/) weiter.
+Hinweis: Dieser Beitrag bezieht sich implizit auf Python 3. Falls du lieber Python 2.7 lernen möchtest, schau [hier](http://learnxinyminutes.com/docs/python/) weiter.
 
 ```python
 
@@ -152,7 +152,7 @@ print("Ich bin Python. Schön, dich kennenzulernen!")
 some_var = 5    # kleinschreibung_mit_unterstrichen entspricht der Norm
 some_var #=> 5
 
-# Das Ansprechen einer noch nicht deklarierte Variable löst eine Exception aus.
+# Das Ansprechen einer noch nicht deklarierten Variable löst eine Exception aus.
 # Unter "Kontrollstruktur" kann noch mehr über
 # Ausnahmebehandlung erfahren werden.
 some_unknown_var  # Löst einen NameError aus
@@ -225,7 +225,7 @@ a, b, c = (1, 2, 3)     # a ist jetzt 1, b ist jetzt 2 und c ist jetzt 3
 # Tupel werden standardmäßig erstellt, wenn wir uns die Klammern sparen
 d, e, f = 4, 5, 6
 # Es ist kinderleicht zwei Werte zu tauschen
-e, d = d, e     # d is now 5 and e is now 4
+e, d = d, e     # d ist nun 5 und e ist nun 4
 
 
 # Dictionarys (Wörterbucher) speichern Schlüssel-Werte-Paare
@@ -379,8 +379,8 @@ with open("meineDatei.txt") as f:
         print(line)
 
 # Python bietet ein fundamentales Konzept der Iteration.
-# Das Objekt, auf das die Interation, also die Wiederholung einer Methode angewandt wird heißt auf Englisch "iterable".
-# Die range Method gibt ein solches Objekt aus.
+# Das Objekt, auf das die Iteration, also die Wiederholung einer Methode angewandt wird heißt auf Englisch "iterable".
+# Die range Methode gibt ein solches Objekt aus.
 
 filled_dict = {"one": 1, "two": 2, "three": 3}
 our_iterable = filled_dict.keys()
@@ -396,8 +396,8 @@ our_iterable[1]  # TypeError
 # Ein iterable ist ein Objekt, das weiß wie es einen Iteratoren erschafft.
 our_iterator = iter(our_iterable)
 
-# Unser Iterator ist ein Objekt, das sich merkt, welchen Status es geraden hat während wir durch es gehen.
-# Das jeweeils nächste Objekt bekommen wir mit "next()"
+# Unser Iterator ist ein Objekt, das sich merkt, welchen Status es gerade hat während wir durch es gehen.
+# Das jeweils nächste Objekt bekommen wir mit "next()"
 next(our_iterator)  #=> "one"
 
 # Es hält den vorherigen Status
@@ -442,7 +442,7 @@ def keyword_args(**kwargs):
 # Rufen wir es mal auf, um zu sehen, was passiert
 keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
 
-# Wir können beides gleichzeitig machem, wenn wir wollen
+# Wir können beides gleichzeitig machen, wenn wir wollen
 def all_the_args(*args, **kwargs):
     print(args)
     print(kwargs)
@@ -555,7 +555,7 @@ Human.grunt() #=> "*grunt*"
 
 # Wir können Module importieren
 import math
-print(math.sqrt(16)) #=> 4
+print(math.sqrt(16)) #=> 4.0
 
 # Wir können auch nur spezielle Funktionen eines Moduls importieren
 from math import ceil, floor
diff --git a/de-de/rst-de.html.markdown b/de-de/rst-de.html.markdown
new file mode 100644
index 00000000..072299f5
--- /dev/null
+++ b/de-de/rst-de.html.markdown
@@ -0,0 +1,119 @@
+---
+language: restructured text (RST)
+filename: restructuredtext-de.rst
+contributors:
+    - ["DamienVGN", "https://github.com/martin-damien"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+translators:
+    - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de
+---
+
+RST ist ein Dateiformat, das von der Python Community entwickelt wurde,
+
+um Dokumentation zu schreiben (und ist somit Teil von Docutils). 
+
+RST-Dateien sind simple Textdateien mit einer leichtgewichtigen Syntax (im Vergleich zu HTML).
+
+
+## Installation
+
+Um Restructured Text zu vewenden musst du [Python](http://www.python.org)
+
+installieren und das `docutils` Packet installieren. `docutils` kann mit dem folgenden 
+
+Befehl auf der Kommandozeile installiert werden:
+
+```bash
+$ easy_install docutils
+```
+
+Wenn auf deinem System `pip` installiert kannst du es statdessen auch verwenden:
+
+```bash
+$ pip install docutils
+```
+
+
+## Dateisyntax
+
+Ein einfaches Beispiel für die Dateisyntax:
+
+```
+.. Zeilen, die mit zwei Punkten starten sind spezielle Befehle. 
+
+.. Wenn kein Befehl gefunden wird, wird die Zeile als Kommentar gewertet. 
+
+============================================================================
+Haupttitel werden mit Gleichheitszeichen darüber und darunter gekennzeichnet
+============================================================================
+
+Beachte das es genau so viele Gleichheitszeichen, wie Hauptitelzeichen
+geben muss.
+
+Titel werden auch mit Gleichheitszeichen unterstrichen
+======================================================
+
+Untertitel werden mit Strichen gekennzeichnet
+---------------------------------------------
+
+Text in *kursiv* oder in **fett**. Du kannst Text als Code "makieren", wenn
+du doppelte Backquotes verwendest ``: ``print()``.
+
+Listen sind so einfach wie in Markdown:
+
+- Erstes Element
+- Zweites Element
+    - Unterelement
+
+oder
+
+* Erstes Element
+* Zweites Element
+    * Unterelement
+
+Tabellen sind einfach zu schreiben:
+
+=========== ==========
+Land        Hauptstadt 
+=========== ==========
+Frankreich  Paris
+Japan       Tokyo
+=========== ========
+
+Komplexere Tabellen (zusammengeführte Spalten und Zeilen) können einfach 
+erstellt werden, aber ich empfehle dir dafür die komplette Dokumentation zu lesen :)
+
+Es gibt mehrere Möglichkeiten um Links zu machen:
+
+- Wenn man einen Unterstrich hinter einem Wort hinzufügt: Github_ Zusätzlich 
+muss man die Zielurl nach dem Text hinzufügen. 
+(Dies hat den Vorteil, dass man keine unnötigen Urls in lesbaren Text einfügt.
+- Wenn man die vollständige Url eingibt : https://github.com/
+(Dies wird automatisch in ein Link konvertiert.)
+- Wenn man es mehr Markdown ähnlich eingibt: `Github <https://github.com/>`_ .
+
+.. _Github https://github.com/
+
+```
+
+
+## Wie man es verwendet
+
+RST kommt mit docutils, dort hast du den Befehl `rst2html`, zum Beispiel:
+
+```bash
+$ rst2html myfile.rst output.html
+```
+
+*Anmerkung : Auf manchen Systemen könnte es rst2html.py sein*
+
+Es gibt komplexere Anwendungen, die das RST Format verwenden: 
+
+- [Pelican](http://blog.getpelican.com/), ein statischer Websitengenerator
+- [Sphinx](http://sphinx-doc.org/), Ein Dokumentationsgenerator
+- und viele Andere
+
+## Zum Lesen
+
+- [Offizielle Schnellreferenz](http://docutils.sourceforge.net/docs/user/rst/quickref.html)
diff --git a/de-de/shutit-de.html.markdown b/de-de/shutit-de.html.markdown
new file mode 100644
index 00000000..29ed639e
--- /dev/null
+++ b/de-de/shutit-de.html.markdown
@@ -0,0 +1,330 @@
+---
+category: tool
+filename: learnshutit-de.html
+tool: ShutIt
+contributors:
+    - ["Ian Miell", "http://ian.meirionconsulting.tk"]
+translators:
+    - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de
+---
+
+## ShutIt
+
+ShuIt ist eine Shellautomationsframework, welches für eine einfache 
+Handhabung entwickelt wurde.
+
+Er ist ein Wrapper, der auf einem Python expect Klon (pexpect) basiert.
+
+Es ist damit ein 'expect ohne Schmerzen'.
+
+Es ist verfügbar als pip install.
+
+## Hello World
+
+Starten wir mit dem einfachsten Beispiel. Erstelle eine Datei names example.py
+
+```python
+
+import shutit
+session = shutit.create_session('bash')
+session.send('echo Hello World', echo=True)
+```
+
+Führe es hiermit aus:
+
+```bash
+python example.py
+```
+
+gibt aus:
+
+```bash
+$ python example.py
+echo "Hello World"
+echo "Hello World"
+Hello World
+Ians-MacBook-Air.local:ORIGIN_ENV:RhuebR2T#
+```
+
+Das erste Argument zu 'send' ist der Befehl, den du ausführen möchtest.
+Das 'echo' Argument gibt die Terminalinteraktion aus. ShuIt ist standardmäßig leise.
+
+'Send' kümmert sich um die nervige Arbeiten mit den Prompts und macht 
+alles was du von 'expect' erwarten würdest.
+
+
+## Logge dich auf einen Server ein
+
+Sagen wir du möchtest dich auf einen Server einloggen und einen Befehl ausführen.
+Ändere dafür example.py folgendermaßen:
+
+```python
+import shutit
+session = shutit.create_session('bash')
+session.login('ssh you@example.com', user='du', password='meinpassword')
+session.send('hostname', echo=True)
+session.logout()
+```
+
+Dies erlaubt dir dich auf deinen Server einzuloggen
+(ersetze die Details mit deinen Eigenen) und das Programm gibt dir deinen Hostnamen aus.
+
+```
+$ python example.py
+hostname
+hostname
+example.com
+example.com:cgoIsdVv:heDa77HB#
+```
+
+
+Es ist klar das das nicht sicher ist. Stattdessen kann man Folgendes machen:
+
+```python
+import shutit
+session = shutit.create_session('bash')
+password = session.get_input('', ispass=True)
+session.login('ssh you@example.com', user='du', password=password)
+session.send('hostname', echo=True)
+session.logout()
+```
+
+Dies zwingt dich dein Passwort einzugeben:
+
+```
+$ python example.py
+Input Secret:
+hostname
+hostname
+example.com
+example.com:cgoIsdVv:heDa77HB#
+```
+
+
+Die 'login' Methode übernimmt wieder das veränderte Prompt für den Login.
+Du übergibst ShutIt den User und das Passwort, falls es benötigt wird,
+mit den du dich einloggen möchtest. ShutIt übernimmt den Rest.
+
+'logout' behandelt das Ende von 'login' und übernimmt alle Veränderungen des
+Prompts für dich.
+
+## Einloggen auf mehrere Server
+
+Sagen wir, dass du eine Serverfarm mit zwei Servern hast und du dich in
+beide Server einloggen möchtest. Dafür musst du nur zwei Session und 
+Logins erstellen und kannst dann Befehle schicken:
+
+```python
+import shutit
+session1 = shutit.create_session('bash')
+session2 = shutit.create_session('bash')
+password1 = session1.get_input('Password für server1', ispass=True)
+password2 = session2.get_input('Password für server2', ispass=True)
+session1.login('ssh you@one.example.com', user='du', password=password1)
+session2.login('ssh you@two.example.com', user='du', password=password2)
+session1.send('hostname', echo=True)
+session2.send('hostname', echo=True)
+session1.logout()
+session2.logout()
+```
+
+Gibt aus:
+
+```bash
+$ python example.py
+Password for server1
+Input Secret:
+
+Password for server2
+Input Secret:
+hostname
+hostname
+one.example.com
+one.example.com:Fnh2pyFj:qkrsmUNs# hostname
+hostname
+two.example.com
+two.example.com:Gl2lldEo:D3FavQjA#
+```
+
+## Beispiel: Überwachen mehrerer Server
+
+Wir können das obige Programm in ein einfaches Überwachungstool bringen indem 
+wir Logik hinzufügen um die Ausgabe von einem Befehl zu betrachten.
+
+```python
+import shutit
+capacity_command="""df / | awk '{print $5}' | tail -1 | sed s/[^0-9]//"""
+session1 = shutit.create_session('bash')
+session2 = shutit.create_session('bash')
+password1 = session.get_input('Passwort für Server1', ispass=True)
+password2 = session.get_input('Passwort für Server2', ispass=True)
+session1.login('ssh you@one.example.com', user='du', password=password1)
+session2.login('ssh you@two.example.com', user='du', password=password2)
+capacity = session1.send_and_get_output(capacity_command)
+if int(capacity) < 10:
+	print(kein Platz mehr auf Server1!')
+capacity = session2.send_and_get_output(capacity_command)
+if int(capacity) < 10:
+	print(kein Platz mehr auf Server2!')
+session1.logout()
+session2.logout()
+```
+
+Hier kannst du die 'send\_and\_get\_output' Methode verwenden um die Ausgabe von dem 
+Kapazitätsbefehl (df) zu erhalten.
+
+Es gibt elegantere Wege als oben (z.B. kannst du ein Dictionary verwenden um über 
+die Server zu iterieren), aber es hängt and dir wie clever das Python sein muss.
+
+
+## kompliziertere IO - Expecting
+
+Sagen wir du hast eine Interaktion mit einer interaktiven Kommandozeilenprogramm, 
+die du automatisieren möchtest. Hier werden wir Telnet als triviales Beispiel verwenden:
+
+```python
+import shutit
+session = shutit.create_session('bash')
+session.send('telnet', expect='elnet>', echo=True)
+session.send('open google.com 80', expect='scape character', echo=True)
+session.send('GET /', echo=True, check_exit=False)
+session.logout()
+```
+
+Beachte das 'expect' Argument. Du brauchst nur ein Subset von Telnets 
+Eingabeaufforderung um es abzugleichen und fortzufahren.
+
+Beachte auch das neue Argument 'check\_exit'. Wir werden nachher nochmal 
+darauf zurückkommen. Die Ausgabe von oben ist:
+
+```bash
+$ python example.py
+telnet
+telnet> open google.com 80
+Trying 216.58.214.14...
+Connected to google.com.
+Escape character is '^]'.
+GET /
+HTTP/1.0 302 Found
+Cache-Control: private
+Content-Type: text/html; charset=UTF-8
+Referrer-Policy: no-referrer
+Location: http://www.google.co.uk/?gfe_rd=cr&ei=huczWcj3GfTW8gfq0paQDA
+Content-Length: 261
+Date: Sun, 04 Jun 2017 10:57:10 GMT
+
+<HTML><HEAD><meta http-equiv="content-type" content="text/html;charset=utf-8">
+<TITLE>302 Moved</TITLE></HEAD><BODY>
+<H1>302 Moved</H1>
+The document has moved
+<A HREF="http://www.google.co.uk/?gfe_rd=cr&amp;ei=huczWcj3GfTW8gfq0paQDA">
+here
+</A>.
+</BODY></HTML>
+Connection closed by foreign host.
+```
+
+Nun zurück zu 'check\_exit=False'. Da das Telnet Programm einen Fehler mit 
+Fehlercode (1) zurückgibt und wir nicht möchten das das Skript fehlschlägt
+kannst du 'check\_exit=False' setzen und damit ShuIt wissen lassen, dass 
+der Ausgabecode dich nicht interessiert.
+
+Wenn du das Argument nicht mitgegeben hättest, dann hätte dir ShutIt 
+ein interaktives Terminal zurückgegeben, falls es ein Terminal zum
+kommunizieren gibt. Dies nennt sich ein 'Pause point'.
+
+
+## Pause Points
+
+Du kannst jederzeit 'pause point' auslösen, wenn du Folgendes in deinem Skript aufrufst:
+
+```python
+[...]
+session.pause_point('Das ist ein pause point')
+[...]
+```
+
+Danach kannst du das Skript fortführen, wenn du CTRL und ']' zur selben Zeit drückst.
+Dies ist gut für Debugging: Füge ein Pause Point hinzu und schaue dich um.
+Danach kannst du das Programm weiter ausführen. Probiere folgendes aus:
+
+```python
+import shutit
+session = shutit.create_session('bash')
+session.pause_point('Schaue dich um!')
+session.send('echo "Hat dir der Pause point gefallen?"', echo=True)
+```
+
+Dies würde folgendes ausgeben:
+
+```bash
+$ python example.py
+Schaue dich um!
+
+Ians-Air.home:ORIGIN_ENV:I00LA1Mq#  bash
+imiell@Ians-Air:/space/git/shutit  ⑂ master +    
+CTRL-] caught, continuing with run...
+2017-06-05 15:12:33,577 INFO: Sending:  exit
+2017-06-05 15:12:33,633 INFO: Output (squashed):  exitexitIans-Air.home:ORIGIN_ENV:I00LA1Mq#  [...]
+echo "Hat dir der Pause point gefallen?"
+echo "Hat dir der Pause point gefallen?"
+Hat dir der Pause point gefallen?
+Ians-Air.home:ORIGIN_ENV:I00LA1Mq#
+```
+
+
+## noch kompliziertere IO - Hintergrund
+
+Kehren wir zu unseren Beispiel mit dem Überwachen von mehreren Servern zurück.
+Stellen wir uns vor, dass wir eine langlaufende Aufgabe auf jedem Server durchführen möchten.
+Standardmäßig arbeitet ShutIt seriell, was sehr lange dauern würde.
+Wir können jedoch die Aufgaben im Hintergrund laufen lassen um sie zu beschleunigen.
+
+Hier ist ein Beispiel, welches du ausprobieren kannst.
+Es verwendet den trivialen Befehl: 'sleep'.
+
+
+```python
+import shutit
+import time
+long_command="""sleep 60"""
+session1 = shutit.create_session('bash')
+session2 = shutit.create_session('bash')
+password1 = session1.get_input('Password for server1', ispass=True)
+password2 = session2.get_input('Password for server2', ispass=True)
+session1.login('ssh you@one.example.com', user='du', password=password1)
+session2.login('ssh you@two.example.com', user='du', password=password2)
+start = time.time()
+session1.send(long_command, background=True)
+session2.send(long_command, background=True)
+print('Es hat: ' + str(time.time() - start) + ' Sekunden zum Starten gebraucht')
+session1.wait()
+session2.wait()
+print('Es hat:' + str(time.time() - start) + ' Sekunden zum Vollenden gebraucht')
+```
+
+Mein Computer meint, dass er 0.5 Sekunden gebraucht hat um die Befehle zu starten 
+und dann nur etwas über eine Minute gebraucht um sie zu beenden
+(mit Verwendung der 'wait' Methode).
+
+
+Das alles ist trivial, aber stelle dir vor das du hunderte an Servern so managen
+kannst und man kann nun das Potential sehen, die in ein paar Zeilen Code und ein Python 
+import liegen können.
+
+
+## Lerne mehr
+
+Es gibt noch viel mehr, was mit ShutIt erreicht werden kann.
+
+Um mehr zu erfahren, siehe:
+
+[ShutIt](https://ianmiell.github.io/shutit/)
+[GitHub](https://github.com/ianmiell/shutit/blob/master/README.md)
+
+Es handelt sich um ein breiteres Automatiesierungsframework, und das oben
+genannte ist der sogennante 'standalone Modus'.
+
+Feedback, feature requests, 'Wie mache ich es' sind herzlich willkommen! Erreiche mit unter
+[@ianmiell](https://twitter.com/ianmiell)
diff --git a/de-de/yaml-de.html.markdown b/de-de/yaml-de.html.markdown
index 25f2edc4..ff45dc8d 100644
--- a/de-de/yaml-de.html.markdown
+++ b/de-de/yaml-de.html.markdown
@@ -10,7 +10,7 @@ lang: de-de
 
 YAML ist eine Sprache zur Datenserialisierung, die sofort von Menschenhand geschrieben und gelesen werden kann.
 
-YAML ist ein Erweiterung von von JSON mit der Erweiterung um syntaktisch wichtige Zeilenumbrüche und Einrückungen, ähnlich wie auch in Python. Anders als in Python allerdings erlaubt YAML keine Tabulator-Zeichen.
+YAML ist ein Erweiterung von JSON mit der Erweiterung um syntaktisch wichtige Zeilenumbrüche und Einrückungen, ähnlich wie auch in Python geschrieben werden können. Anders als in Python allerdings erlaubt YAML keine Tabulator-Zeichen.
 
 ```yaml
 # Kommentare in YAML schauen so aus.
@@ -111,7 +111,7 @@ python_komplexe_Zahlen: !!python/komplex 1+2j
 # EXTRA YAML TYPEN #
 ####################
 
-# Strings and Zahlen sind nicht die einzigen Skalare, welche YAML versteht.
+# Strings und Zahlen sind nicht die einzigen Skalare, welche YAML versteht.
 # ISO-formatierte Datumsangaben and Zeiangaben können ebenso geparsed werden.
 DatumZeit: 2001-12-15T02:59:43.1Z
 DatumZeit_mit_Leerzeichen: 2001-12-14 21:59:43.10 -5
diff --git a/dhall.html.markdown b/dhall.html.markdown
new file mode 100644
index 00000000..704a94ee
--- /dev/null
+++ b/dhall.html.markdown
@@ -0,0 +1,362 @@
+---
+language: Dhall
+filename: learndhall.dhall
+contributors:
+    - ["Gabriel Gonzalez", "http://www.haskellforall.com/"]
+---
+
+Dhall is a programmable configuration language that provides a non-repetitive
+alternative to YAML.
+
+You can think of Dhall as: JSON + functions + types + imports
+
+Note that while Dhall is programmable, Dhall is not Turing-complete.  Many
+of Dhall's features take advantage of this restriction to provide stronger
+safety guarantees and more powerful tooling.
+
+```haskell
+-- Single-line comment
+
+{- Multi-line comment
+
+   Unicode is fine 🙂
+
+   This file is a valid Dhall expression that evaluates to a large record
+   collecting the results of each step.
+
+   You can view the results by interpreting the file:
+
+       $ dhall --file learndhall.dhall
+
+   {- Comments can be nested -}
+-}
+
+let greeting = "Hello, world!"
+
+let fruits = "🍋🍓🍍🍉🍌"
+
+let interpolation = "Enjoy some delicious fruit: ${fruits}"
+
+let multilineText {- Inline comments work, too -} =
+        ''
+        Leading whitespace is stripped from multi-line text literals.
+
+        That means you can freely indent or dedent a text literal without
+        changing the result.
+
+            Relative indentation within the literal is still preserved.
+
+        Other than that, the text literal is preserved verbatim, similar to a
+        "literal" YAML multiline string.
+        ''
+
+let bool = True
+
+-- Type annotations on bindings are optional, but helpful, so we'll use them
+let annotation : Bool = True
+
+let renderedBool : Text = if bool then "True" else "False"
+
+-- Natural numbers are non-negative and are unsigned
+let naturalNumber : Natural = 42
+
+-- Integers may be negative, but require an explicit sign, even if positive
+let positiveInteger : Integer = +1
+
+let negativeInteger : Integer = -12
+
+let pi : Double = 3.14159265359
+
+{- You can use a wider character range for identifiers (such as quotation
+   marks and whitespace) if you quote them using backticks
+-}
+let `Avogadro's Number` : Double = 6.0221409e+23
+
+let origin : { x : Double, y : Double } = { x = 0.0, y = 0.0 }
+
+let somePrimes : List Natural = [ 2, 3, 5, 7, 11 ]
+
+{- A schema is the same thing as a type
+
+   Types begin with an uppercase letter by convention, but this convention is
+   not enforced
+-}
+let Profile : Type
+        = { person :
+              { name : Text
+              , age  : Natural
+              }
+          , address :
+              { country : Text
+              , state   : Text
+              , city    : Text
+              }
+          }
+
+let john : Profile =
+        { person =
+            { name = "John Doe"
+            , age  = 67
+            }
+        , address =
+            { country = "United States"
+            , state   = "Pennsylvania"
+            , city    = "Philadelphia"
+            }
+        }
+
+let philadelphia : Text = john.address.city
+
+{- Enum alternatives also begin with an uppercase letter by convention.  This
+   convention is not enforced
+-}
+let DNA : Type = < Adenine | Cytosine | Guanine | Thymine >
+
+let dnaSequence : List DNA = [ DNA.Thymine, DNA.Guanine, DNA.Guanine ]
+
+let compactDNASequence : List DNA =
+        let a = DNA.Adenine
+        let c = DNA.Cytosine
+        let g = DNA.Guanine
+        let t = DNA.Thymine
+        in  [ c, t, t, a, t, c, g, g, c ]
+
+-- You can transform enums by providing a record with one field per alternative
+let theLetterG : Text =
+            merge
+            { Adenine  = "A"
+            , Cytosine = "C"
+            , Guanine  = "G"
+            , Thymine  = "T"
+            }
+            DNA.Guanine
+
+let presentOptionalValue : Optional Natural = Some 1
+
+let absentOptionalValue : Optional Natural = None Natural
+
+let points : List { x : Double, y : Double } =
+        [ { x = 1.1, y = -4.2 }
+        , { x = 4.4, y = -3.0 }
+        , { x = 8.2, y = -5.5 }
+        ]
+
+{- `Natural -> List Natural` is the type of a function whose input type is a
+   `Natural` and whose output type is a `List Natural`
+
+   All functions in Dhall are anonymous functions (a.k.a. "lambdas"),
+   which you can optionally give a name
+
+   For example, the following function is equivalent to this Python code:
+
+       lambda n : [ n, n + 1 ]
+
+   ... and this JavaScript code:
+
+       function (n) { return [ n, n + 1 ]; }
+-}
+let exampleFunction : Natural -> List Natural =
+        \(n : Natural) -> [ n, n + 1 ]
+
+-- Dhall also supports Unicode syntax, but this tutorial will stick to ASCII
+let unicodeFunction : Natural → List Natural =
+        λ(n : Natural) → [ n, n + 1 ]
+
+-- You don't need to parenthesize function arguments
+let exampleFunctionApplication : List Natural =
+        exampleFunction 2
+
+let functionOfMultipleArguments : Natural -> Natural -> List Natural =
+        \(x : Natural) -> \(y : Natural) -> [ x, y ]
+
+let functionAppliedToMultipleArguments : List Natural =
+        functionOfMultipleArguments 2 3
+
+{- Same as `exampleFunction` except we gave the function's input type a
+   name: "n"
+-}
+let namedArgumentType : forall (n : Natural) -> List Natural =
+        \(n : Natural) -> [ n, n + 1 ]
+
+{- If you name a function's input type, you can use that name later within the
+   same type
+
+   This lets you write a function that works for more than one type of input
+   (a.k.a. a "polymorphic" function)
+-}
+let duplicate : forall (a : Type) -> a -> List a =
+        \(a : Type) -> \(x : a) -> [ x, x ] 
+
+let duplicatedNumber : List Natural =
+        duplicate Natural 2
+
+let duplicatedBool : List Bool =
+        duplicate Bool False
+
+{- The language also has some built-in polymorphic functions, such as:
+
+       List/head : forall (a : Type) -> List a -> Optional a
+-}
+let firstPrime : Optional Natural = List/head Natural somePrimes
+
+let functionOfARecord : { x : Natural, y : Natural } -> List Natural =
+        \(args : { x : Natural, y : Natural }) -> [ args.x, args.y ]
+
+let functionAppliedToARecord : List Natural =
+        functionOfARecord { x = 2, y = 5 }
+
+{- All type conversions are explicit
+
+   `Natural/show` is a built-in function of the following type:
+
+       Natural/show : Natural -> Text
+
+   ... that converts `Natural` numbers to their `Text` representation
+-}
+let typeConversion : Natural -> Text =
+        \(age : Natural) -> "I am ${Natural/show age} years old!"
+
+-- A "template" is the same thing as a function whose output type is `Text`
+let mitLicense : { year : Natural, copyrightHolder : Text } -> Text =
+        \(args : { year : Natural, copyrightHolder : Text }) ->
+''
+Copyright ${Natural/show args.year} ${args.copyrightHolder}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do 
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.
+''
+
+-- Template instantiation is the same thing as function application
+let templatedLicense : Text =
+        mitLicense { year = 2019, copyrightHolder = "Jane Smith" }
+
+{- You can import expressions by URL
+
+   Also, like Bash, you can import code from your local filesystem (not shown)
+
+   Security-conscious users can pin remotely-imported expressions by adding a
+   semantic integrity check.  The interpreter rejects any attempt to tamper with
+   an expression pinned in this way.  However, behavior-preserving refactors
+   of imported content will not perturb the hash.
+
+   Imported expressions pinned in this way are also locally cached in a
+   content-addressable store (typically underneath `~/.cache/dhall`)
+-}
+let Natural/sum : List Natural -> Natural =
+      https://prelude.dhall-lang.org/Natural/sum
+      sha256:33f7f4c3aff62e5ecf4848f964363133452d420dcde045784518fb59fa970037
+
+let twentyEight : Natural = Natural/sum somePrimes
+
+-- A "package" is the same thing as a (possibly nested) record that you can import
+let Prelude = https://prelude.dhall-lang.org/package.dhall
+
+let false : Bool = Prelude.Bool.not True
+
+-- You can import the raw contents of a file by adding `as Text` to an import
+let sourceCode : Text = https://prelude.dhall-lang.org/Bool/not as Text
+
+-- You can import environment variables, too:
+let presentWorkingDirectory = env:PWD as Text
+
+-- You can provide a fallback expression if an import fails
+let home : Optional Text = Some env:HOME ? None Text
+
+-- Fallback expressions can contain alternative imports of their own
+let possiblyCustomPrelude =
+        env:DHALL_PRELUDE
+      ? https://prelude.dhall-lang.org/package.dhall
+
+{- Tie everything together by auto-generating configurations for 10 build users
+   using the `generate` function:
+
+       Prelude.List.generate
+           : Natural -> forall (a : Type) -> (Natural -> a) -> List a
+-}
+let buildUsers =
+        let makeUser = \(user : Text) ->
+              let home       = "/home/${user}"
+              let privateKey = "${home}/.ssh/id_ed25519"
+              let publicKey  = "${privateKey}.pub"
+              in  { home = home
+                  , privateKey = privateKey
+                  , publicKey = publicKey
+                  }
+
+        let buildUser =
+                \(index : Natural) -> makeUser "build${Natural/show index}"
+
+        let Config =
+              { home : Text
+              , privateKey : Text
+              , publicKey : Text
+              }
+
+        in  Prelude.List.generate 10 Config buildUser
+
+-- Present all of the results in a final record
+in  { greeting = greeting
+    , fruits = fruits
+    , interpolation = interpolation
+    , multilineText = multilineText
+    , bool = bool
+    , annotation = annotation
+    , renderedBool = renderedBool
+    , naturalNumber = naturalNumber
+    , positiveInteger = positiveInteger
+    , negativeInteger = negativeInteger
+    , pi = pi
+    , `Avogadro's Number` = `Avogadro's Number`
+    , origin = origin
+    , somePrimes = somePrimes
+    , john = john
+    , philadelphia = philadelphia
+    , dnaSequence = dnaSequence
+    , compactDNASequence = compactDNASequence
+    , theLetterG = theLetterG
+    , presentOptionalValue = presentOptionalValue
+    , absentOptionalValue = absentOptionalValue
+    , points = points
+    , exampleFunction = exampleFunction
+    , unicodeFunction = unicodeFunction
+    , exampleFunctionApplication = exampleFunctionApplication
+    , functionOfMultipleArguments = functionOfMultipleArguments
+    , functionAppliedToMultipleArguments = functionAppliedToMultipleArguments
+    , namedArgumentType = namedArgumentType
+    , duplicate = duplicate
+    , duplicatedNumber = duplicatedNumber
+    , duplicatedBool = duplicatedBool
+    , firstPrime = firstPrime
+    , functionOfARecord = functionOfARecord
+    , functionAppliedToARecord = functionAppliedToARecord
+    , typeConversion = typeConversion
+    , mitLicense = mitLicense
+    , templatedLicense = templatedLicense
+    , twentyEight = twentyEight
+    , false = false
+    , sourceCode = sourceCode
+    , presentWorkingDirectory = presentWorkingDirectory
+    , home = home
+    , buildUsers = buildUsers
+    }
+```
+
+To learn more, visit the official website, which also lets you try the
+language live in your browser:
+
+* [https://dhall-lang.org](http://dhall-lang.org/)
diff --git a/directx9.html.markdown b/directx9.html.markdown
new file mode 100644
index 00000000..b51f418d
--- /dev/null
+++ b/directx9.html.markdown
@@ -0,0 +1,827 @@
+---
+category: tool
+tool: DirectX 9
+filename: learndirectx9.cpp
+contributors:
+    - ["Simon Deitermann", "s.f.deitermann@t-online.de"]
+---
+
+**Microsoft DirectX** is a collection of application programming interfaces (APIs) for handling tasks related to
+multimedia, especially game programming and video, on Microsoft platforms. Originally, the names of these APIs
+all began with Direct, such as Direct3D, DirectDraw, DirectMusic, DirectPlay, DirectSound, and so forth. [...]
+Direct3D (the 3D graphics API within DirectX) is widely used in the development of video games for Microsoft
+Windows and the Xbox line of consoles.<sup>[1]</sup>
+
+In this tutorial we will be focusing on DirectX 9, which is not as low-level as it's sucessors, which are aimed at programmers very familiar with how graphics hardware works. It makes a great starting point for learning Direct3D. In this tutorial I will be using the Win32-API for window handling and the DirectX 2010 SDK.
+
+## Window creation
+
+```cpp
+#include <Windows.h>
+
+bool _running{ false };
+
+LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
+    // Handle incoming message.
+    switch (msg) {
+        // Set running to false if the user tries to close the window.
+        case WM_DESTROY:
+            _running = false;
+            PostQuitMessage(0);
+            break;
+    }
+    // Return the handled event.
+    return DefWindowProc(hWnd, msg, wParam, lParam);
+}
+
+int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
+                   LPSTR lpCmdLine, int nCmdShow) {
+    // Set window properties we want to use.
+    WNDCLASSEX wndEx{ };
+    wndEx.cbSize        = sizeof(WNDCLASSEX);        // structure size
+    wndEx.style         = CS_VREDRAW | CS_HREDRAW;   // class styles
+    wndEx.lpfnWndProc   = WndProc;                   // window procedure
+    wndEx.cbClsExtra    = 0;                         // extra memory (struct)
+    wndEx.cbWndExtra    = 0;                         // extra memory (window)
+    wndEx.hInstance     = hInstance;                 // module instance
+    wndEx.hIcon         = LoadIcon(nullptr, IDI_APPLICATION); // icon
+    wndEx.hCursor       = LoadCursor(nullptr, IDC_ARROW);     // cursor
+    wndEx.hbrBackground = (HBRUSH) COLOR_WINDOW;     // background color
+    wndEx.lpszMenuName  = nullptr;                   // menu name
+    wndEx.lpszClassName = "DirectXClass";            // register class name
+    wndEx.hIconSm       = nullptr;                   // small icon (taskbar)
+    // Register created class for window creation.
+    RegisterClassEx(&wndEx);
+    // Create a new window handle.
+    HWND hWnd{ nullptr };
+    // Create a new window handle using the registered class.
+    hWnd = CreateWindow("DirectXClass",      // registered class
+                        "directx window",    // window title
+                        WS_OVERLAPPEDWINDOW, // window style
+                        50, 50,              // x, y (position)
+                        1024, 768,           // width, height (size)
+                        nullptr,             // parent window
+                        nullptr,             // menu
+                        hInstance,           // module instance
+                        nullptr);            // struct for infos
+    // Check if a window handle has been created.
+    if (!hWnd)
+        return -1;   
+    // Show and update the new window.
+    ShowWindow(hWnd, nCmdShow);
+    UpdateWindow(hWnd);
+    // Start the game loop and send incoming messages to the window procedure.
+    _running = true;
+    MSG msg{ };
+    while (_running) {
+        while (PeekMessage(&msg, hWnd, 0, 0, PM_REMOVE)) {
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+        }
+    }  
+    return 0;
+}
+```
+
+This should create a window, that can the moved, resized and closed.
+
+## Direct3D initialization
+
+```cpp
+// Includes DirectX 9 structures and functions.
+// Remember to link "d3d9.lib" and "d3dx9.lib".
+// For "d3dx9.lib" the DirectX SDK (June 2010) is needed.
+// Don't forget to set your subsystem to Windows.
+#include <d3d9.h>
+#include <d3dx9.h>
+// Includes the ComPtr, a smart pointer automatically releasing COM objects.
+#include <wrl.h>
+using namespace Microsoft::WRL;
+// Next we define some Direct3D9 interface structs we need.
+ComPtr<IDirect3D9> _d3d{ };
+ComPtr<IDirect3DDevice9> _device{ };
+```
+
+With all interfaces declared we can now initialize Direct3D.
+
+```cpp
+bool InitD3D(HWND hWnd) {
+    // Store the size of the window rectangle.
+    RECT clientRect{ };
+    GetClientRect(hWnd, &clientRect);
+    // Initialize Direct3D
+    _d3d = Direct3DCreate9(D3D_SDK_VERSION);
+    // Get the display mode which format will be the window format.
+    D3DDISPLAYMODE displayMode{ };
+    _d3d->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, // use default graphics card
+                                &displayMode);      // display mode pointer
+    // Next we have to set some presentation parameters.
+    D3DPRESENT_PARAMETERS pp{ };
+    pp.BackBufferWidth = clientRect.right;    // width is window width
+    pp.BackBufferHeight = clientRect.bottom;  // height is window height
+    pp.BackBufferFormat = displayMode.Format; // use adapter format
+    pp.BackBufferCount = 1;                   // 1 back buffer (default)
+    pp.SwapEffect = D3DSWAPEFFECT_DISCARD;    // discard after presentation
+    pp.hDeviceWindow = hWnd;                  // associated window handle
+    pp.Windowed = true;                       // display in window mode
+    pp.Flags = 0;                             // no special flags
+    // Variable to store results of methods to check if everything succeded.
+    HRESULT result{ };
+    result = _d3d->CreateDevice(D3DADAPTER_DEFAULT, // use default graphics card
+                                D3DDEVTYPE_HAL,     // use hardware acceleration
+                                hWnd,               // the window handle
+                                D3DCREATE_HARDWARE_VERTEXPROCESSING,
+                                    // vertices are processed by the hardware
+                                &pp,       // the present parameters
+                                &_device); // struct to store the device
+    // Return false if the device creation failed.
+    // It is helpful to set breakpoints at the return line.
+    if (FAILED(result))
+        return false;
+    // Create a viewport which hold information about which region to draw to.
+    D3DVIEWPORT9 viewport{ };
+    viewport.X = 0;         // start at top left corner
+    viewport.Y = 0;         // ..
+    viewport.Width = clientRect.right;   // use the entire window
+    viewport.Height = clientRect.bottom; // ..
+    viewport.MinZ = 0.0f;   // minimun view distance
+    viewport.MaxZ = 100.0f; // maximum view distance
+    // Apply the created viewport.
+    result = _device->SetViewport(&viewport);
+    // Always check if something failed.
+    if (FAILED(result))
+        return false;
+    // Everything was successful, return true.
+    return true;
+}
+// ...
+// Back in our WinMain function we call our initialization function.
+// ...
+// Check if Direct3D initialization succeded, else exit the application.
+if (!InitD3D(hWnd))
+    return -1;
+        
+MSG msg{ };
+while (_running) {
+    while (PeekMessage(&msg, hWnd, 0, 0, PM_REMOVE)) {
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+    // Clear to render target to a specified color.
+    _device->Clear(0,               // number of rects to clear
+                   nullptr,         // indicates to clear the entire window
+                   D3DCLEAR_TARGET, // clear all render targets
+                   D3DXCOLOR{ 1.0f, 0.0f, 0.0f, 1.0f }, // color (red)
+                   0.0f,            // depth buffer clear value
+                   0);              // stencil buffer clear value
+    // ...
+    // Drawing operations go here.
+    // ...
+    // Flip the front- and backbuffer.
+    _device->Present(nullptr,  // no source rectangle
+                     nullptr,  // no destination rectangle
+                     nullptr,  // don't change the current window handle
+                     nullptr); // pretty much always nullptr
+}
+// ...
+```
+
+Now the window should be displayed in a bright red color.
+
+## Vertex Buffer
+
+Let's create a vertex buffer to store the vertices for our triangle
+
+```cpp
+// At the top of the file we need to add a include.
+#include <vector>
+// First we declare a new ComPtr holding a vertex buffer.
+ComPtr<IDirect3DVertexBuffer9> _vertexBuffer{ };
+// Lets define a funtion to calculate the byte size of a std::vector
+template <typename T>
+unsigned int GetByteSize(const std::vector<T>& vec) {
+    return sizeof(vec[0]) * vec.size();
+}
+// Define "flexible vertex format" describing the content of our vertex struct.
+// Use the defined color as diffuse color.
+const unsigned long VertexStructFVF = D3DFVF_XYZ | D3DFVF_DIFFUSE;
+// Define a struct representing the vertex data the buffer will hold.
+struct VStruct {
+    float x, y, z;   // store the 3D position
+    D3DCOLOR color;  // store a color
+};
+// Declare a new function to create a vertex buffer.
+IDirect3DVertexBuffer9* CreateBuffer(const std::vector<VStruct>& vertices) {
+    // Declare the buffer to be returned.
+    IDirect3DVertexBuffer9* buffer{ };
+    HRESULT result{ };
+    result = _device->CreateVertexBuffer(
+                 GetByteSize(vertices), // vector size in bytes
+                 0,                     // data usage
+                 VertexStructFVF,       // FVF of the struct
+                 D3DPOOL_DEFAULT,       // use default pool for the buffer
+                 &buffer,               // receiving buffer
+                 nullptr);              // special shared handle
+    // Check if buffer was created successfully.
+    if (FAILED(result))
+        return nullptr;
+    // Create a data pointer for copying the vertex data
+    void* data{ };
+    // Lock the buffer to get a buffer for data storage.
+    result = buffer->Lock(0,                     // byte offset
+                          GetByteSize(vertices), // size to lock
+                          &data,                 // receiving data pointer
+                          0);                    // special lock flags
+    // Check if buffer was locked successfully.
+    if (FAILED(result))
+        return nullptr;
+    // Copy the vertex data using C standard libraries memcpy.
+    memcpy(data, vertices.data(), GetByteSize(vertices));
+    buffer->Unlock();
+    // Set the FVF Direct3D uses for rendering.
+    _device->SetFVF(VertexStructFVF);
+    // If everything was successful return the filled vertex buffer.
+    return buffer;
+}
+```
+
+In our **WinMain** we can now call the new function after the Direct3D initialization.
+
+```cpp
+// ...
+if (!InitD3D(hWnd))
+    return -1;
+// Define the vertices we need to draw a triangle.
+// Values are declared in a clockwise direction else Direct3D would cull them.
+// If you want to diable culling just call:
+// _device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
+std::vector<VStruct> vertices {
+    // Bottom left
+    VStruct{ -1.0f, -1.0f, 1.0f, D3DXCOLOR{ 1.0f, 0.0f, 0.0f, 1.0f } },
+    // Top left
+    VStruct{ -1.0f,  1.0f, 1.0f, D3DXCOLOR{ 0.0f, 1.0f, 0.0f, 1.0f } },
+    // Top right
+    VStruct{  1.0f,  1.0f, 1.0f, D3DXCOLOR{ 0.0f, 0.0f, 1.0f, 1.0f } }
+};
+// Try to create the vertex buffer else exit the application.
+if (!(_vertexBuffer = CreateBuffer(vertices)))
+    return -1;
+// ...
+```
+
+## Transformations
+
+Before we can use the vertex buffer to draw our primitives, we first need to set up the matrices.
+
+```cpp
+// Lets create a new funtions for the matrix transformations.
+bool SetupTransform() {
+    // Create a view matrix that transforms world space to
+    // view space.
+    D3DXMATRIX view{ };
+    // Use a left-handed coordinate system.
+    D3DXMatrixLookAtLH(
+        &view,                              // receiving matrix
+        &D3DXVECTOR3{ 0.0f, 0.0f, -20.0f }, // "camera" position
+        &D3DXVECTOR3{ 0.0f, 0.0f, 0.0f },   // position where to look at
+        &D3DXVECTOR3{ 0.0f, 1.0f, 0.0f });  // positive y-axis is up
+    HRESULT result{ };
+    result = _device->SetTransform(D3DTS_VIEW, &view); // apply the view matrix
+    if (FAILED(result))
+        return false;
+    // Create a projection matrix that defines the view frustrum.
+    // It transforms the view space to projection space.
+    D3DXMATRIX projection{ };
+    // Create a perspective projection using a left-handed coordinate system.
+    D3DXMatrixPerspectiveFovLH(
+        &projection,         // receiving matrix
+        D3DXToRadian(60.0f), // field of view in radians
+        1024.0f / 768.0f,    // aspect ratio (width / height)
+        0.0f,                // minimum view distance
+        100.0f);             // maximum view distance
+    result = _device->SetTransform(D3DTS_PROJECTION, &projection);
+    if (FAILED(result))
+        return false;
+    // Disable lighting for now so we can see what we want to render.
+    result = _device->SetRenderState(D3DRS_LIGHTING, false);
+    // View and projection matrix are successfully applied, return true.
+    return true;
+}
+// ...
+// Back in the WinMain function we can now call the transformation function.
+// ...
+if (!(_vertexBuffer = CreateVertexBuffer(vertices)))
+    return -1;
+// Call the transformation setup function.
+if (!SetupTransform())
+    return -1;
+// ...
+```
+
+## Rendering
+
+Now that everything is setup we can start drawing our first 2D triangle in 3D space.
+
+```cpp
+// ...
+if (!SetupTransform())
+    return -1;
+// First we have to bind our vertex buffer to the data stream.
+HRESULT result{ };
+result = _device->SetStreamSource(0,                   // use the default stream
+                                  _vertexBuffer.Get(), // pass the vertex buffer
+                                  0,                   // no offset
+                                  sizeof(VStruct));    // size of vertex struct
+if (FAILED(result))
+    return -1;
+
+// Create a world transformation matrix and set it to an identity matrix.
+D3DXMATRIX world{ };
+D3DXMatrixIdentity(&world);
+// Create a scalation matrix scaling our primitve by 10 in the x,
+// 10 in the y and keeping the z direction.
+D3DXMATRIX scaling{ };
+D3DXMatrixScaling(&scaling, // matrix to scale
+                  10,       // x scaling
+                  10,       // y scaling
+                  1);       // z scaling
+// Create a rotation matrix storing the current rotation of our primitive.
+// We set the current rotation matrix to an identity matrix for now.
+D3DXMATRIX rotation{ };
+D3DXMatrixIdentity(&rotation);
+// Now we multiply the scalation and rotation matrix and store the result
+// in the world matrix.
+D3DXMatrixMultiply(&world,     // destination matrix
+                   &scaling,   // matrix 1
+                   &rotation); // matrix 2
+// Apply the current world matrix.
+_device->SetTransform(D3DTS_WORLD, &world);
+// Disable culling so we can see the back of our primitive when it rotates.
+_device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
+// The default cullmode is D3DCULL_CW.
+// After we used our the rotation matrix for multiplication we can set it
+// to rotate a small amount.
+// D3DXToRadian() function converts degree to radians.
+D3DXMatrixRotationY(&rotation,           // matrix to rotate
+                    D3DXToRadian(0.5f)); // rotation angle in radians
+
+MSG msg{ };
+    while (_running) {
+    // ...
+        _device->Clear(0, nullptr, D3DCLEAR_TARGET,
+                       D3DXCOLOR{ 0.0f, 0.0f, 0.0f, 1.0f }, 0.0f, 0);
+        // With everything setup we can call the draw function.
+        _device->BeginScene();
+        _device->DrawPrimitive(D3DPT_TRIANGLELIST, // primitive type
+                               0,                  // start vertex
+                               1);                 // primitive count
+        _device->EndScene();
+    
+        _device->Present(nullptr, nullptr, nullptr, nullptr);
+        // We can keep multiplying the world matrix with our rotation matrix
+        // to add it's rotation to the world matrix.
+        D3DXMatrixMultiply(&world, &world, &rotation);
+        // Update the modified world matrix.
+        _device->SetTransform(D3DTS_WORLD, &world);
+    // ...
+```
+
+You should now be viewing a 10x10 units colored triangle from 20 units away, rotating around its origin.<br>
+You can find the complete working code here: [DirectX - 1](https://pastebin.com/YkSF2rkk)
+
+## Indexing
+
+To make it easier to draw primitives sharing a lot of vertices we can use indexing, so we only have to declare the unique vertices and put the order they are called in another array.
+
+```cpp
+// First we declare a new ComPtr for our index buffer.
+ComPtr<IDirect3DIndexBuffer9> _indexBuffer{ };
+// ...
+// Declare a function creating a index buffer from a std::vector
+IDirect3DIndexBuffer9* CreateIBuffer(std::vector<unsigned int>& indices) {
+    IDirect3DIndexBuffer9* buffer{ };
+    HRESULT result{ };
+    result = _device->CreateIndexBuffer(
+                 GetByteSize(indices), // vector size in bytes
+                 0,                    // data usage 
+                 D3DFMT_INDEX32,       // format is 32 bit int
+                 D3DPOOL_DEFAULT,      // default pool
+                 &buffer,              // receiving buffer
+                 nullptr);             // special shared handle
+    if (FAILED(result))
+        return nullptr;
+    // Create a data pointer pointing to the buffer data.
+    void* data{ };
+    result = buffer->Lock(0,                    // byte offset
+                          GetByteSize(indices), // byte size
+                          &data,                // receiving data pointer
+                          0);                   // special lock flag
+    if (FAILED(result))
+        return nullptr;
+    // Copy the index data and unlock after copying.
+    memcpy(data, indices.data(), GetByteSize(indices));
+    buffer->Unlock();
+    // Return the filled index buffer.
+    return buffer;
+}
+// ...
+// In our WinMain we can now change the vertex data and create new index data.
+// ...
+std::vector<VStruct> vertices {
+    VStruct{ -1.0f, -1.0f, 1.0f, D3DXCOLOR{ 1.0f, 0.0f, 0.0f, 1.0f } },
+    VStruct{ -1.0f,  1.0f, 1.0f, D3DXCOLOR{ 0.0f, 1.0f, 0.0f, 1.0f } },
+    VStruct{  1.0f,  1.0f, 1.0f, D3DXCOLOR{ 0.0f, 0.0f, 1.0f, 1.0f } },
+    // Add a vertex for the bottom right.
+    VStruct{  1.0f, -1.0f, 1.0f, D3DXCOLOR{ 1.0f, 1.0f, 0.0f, 1.0f } }
+};
+// Declare the index data, here we build a rectangle from two triangles.
+std::vector<unsigned int> indices {
+    0, 1, 2, // the first triangle (b,left -> t,left -> t,right)
+    0, 2, 3  // the second triangle (b,left -> t,right -> b,right)
+};
+// ...
+// Now we call the "CreateIBuffer" function to create a index buffer.
+// ...
+if (!(_indexBuffer = CreateIBuffer(indices)))
+    return -1;
+// ...
+// After binding the vertex buffer we have to bind the index buffer to
+// use indexed rendering.
+result = _device->SetStreamSource(0, _vertexBuffer.Get(), 0, sizeof(VStruct));
+if (FAILED(result))
+    return -1;
+// Bind the index data to the default data stream.
+result = _device->SetIndices(_indexBuffer.Get())
+if (FAILED(result))
+    return -1;
+// ...
+// Now we replace the "DrawPrimitive" function with an indexed version.
+_device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, // primitive type
+                              0,                  // base vertex index
+                              0,                  // minimum index
+                              indices.size(),     // amount of vertices
+                              0,                  // start in index buffer
+                              2);                 // primitive count
+// ...
+```
+
+Now you should see a colored rectangle made up of 2 triangles. If you set the primitive count in the "DrawIndexedPrimitive" method to 1 only the first triangle should be rendered and if you set the start of the index buffer to 3 and the primitive count to 1 only the second triangle should be rendered.<br>
+You can find the complete working code here: [DirectX - 2](https://pastebin.com/yWBPWPRG)
+
+## Vertex declaration
+
+Instead of using the old "flexible vertex format" we should use vertex declarations instead, as the FVF declarations get converted to vertex declarations internally anyway.
+
+```cpp
+// First we have to REMOVE the following lines:
+const unsigned long VertexStructFVF = D3DFVF_XYZ | D3DFVF_DIFFUSE;
+// and
+_device->SetFVF(VertexStructFVF);
+// ...
+// We also have to change the vertex buffer creation FVF-flag.
+result = _device->CreateVertexBuffer(
+                      GetByteSize(vertices),
+                      0,
+                      0,        // <- 0 indicates we use vertex declarations
+                      D3DPOOL_DEFAULT,
+                      &buffer,
+                      nullptr); 
+// Next we have to declare a new ComPtr.
+ComPtr<IDirect3DVertexDeclaration9> _vertexDecl{ };
+// ...
+result = _device->SetIndices(_indexBuffer.Get());
+if (FAILED(result))
+    return -1;
+// Now we have to declare and apply the vertex declaration.
+// Create a vector of vertex elements making up the vertex declaration.
+std::vector<D3DVERTEXELEMENT9> vertexDeclDesc {
+    { 0,                     // stream index
+      0,                     // byte offset from the struct beginning
+      D3DDECLTYPE_FLOAT3,    // data type (3d float vector)
+      D3DDECLMETHOD_DEFAULT, // tessellator operation
+      D3DDECLUSAGE_POSTION,  // usage of the data
+      0 },                   // index (multiples usage of the same type)
+    { 0,
+      12,                    // byte offset (3 * sizeof(float) bytes)
+      D3DDECLTYPE_D3DCOLOR,
+      D3DDECLMETHOD_DEFAULT,
+      D3DDECLUSAGE_COLOR,
+      0 },
+    D3DDECL_END()            // marks the end of the vertex declaration
+};
+// After having defined the vector we can create a vertex declaration from it.
+result = _device->CreateVertexDeclaration(
+                      vertexDeclDesc.data(), // the vertex element array
+                      &_vertexDecl);         // receiving pointer
+if (FAILED(result)) 
+    return -1;
+// Apply the created vertex declaration.
+_device->SetVertexDeclaration(_vertexDecl.Get());
+// ...
+```
+
+## Shader
+
+The maximum shader model for Direct3D 9 is shader model 3.0. Even though every modern graphics card should support it, it is best to check for capabilities.
+
+```cpp
+// ...
+_device->SetVertexDeclaration(_vertexDecl.Get());
+// First we have to request the device capabilities.
+D3DCAPS9 deviceCaps{ };
+_device->GetDeviceCaps(&deviceCaps);
+// Now we check if shader model 3.0 is supported for the vertex shader.
+if (deviceCaps.VertexShaderVersion < D3DVS_VERSION(3, 0))
+    return -1;
+// And the same for the pixel shader.
+if (deviceCaps.PixelShaderVersion < D3DPS_VERSION(3, 0))
+    return -1;
+```
+
+Now that we are sure shader model 3.0 is supported let's create the vertex and pixel shader files.
+DirectX 9 introduced the HLSL (**High Level Shading Language**), a C-like shader language, which
+simplified the shader programming a lot, as you could only write shaders in shader assembly in DirectX 8.
+Let's create a simple vertex- and pixel shader. 
+
+**Vertex Shader**
+
+```cpp
+// 3 4x4 float matrices representing the matrices we set in the fixed-function
+// pipeline by using the SetTransform() method.
+float4x4 projectionMatrix;
+float4x4 viewMatrix;
+float4x4 worldMatrix;
+// The input struct to the vertex shader.
+// It holds a 3d float vector for the position and a 4d float vector
+// for the color.
+struct VS_INPUT {
+    float3 position : POSITION;
+    float4 color : COLOR;
+};
+// The output struct of the vertex shader, that is passed to the pixel shader.
+struct VS_OUTPUT {
+    float4 position : POSITION;
+    float4 color : COLOR;
+};
+// The main function of the vertex shader returns the output it sends to the
+// pixel shader and receives it's input as a parameter.
+VS_OUTPUT main(VS_INPUT input) {
+    // Declare a empty struct, that the vertex shader returns.
+    VS_OUTPUT output;
+    // Set the output position to the input position and set
+    // the w-component to 1, as the input position is a 3d vector and
+    // the output position a 4d vector.
+    output.position = float4(input.position, 1.0f);
+    // Multiply the output position step by step with the world, view and
+    // projection matrices.
+    output.position = mul(output.position, worldMatrix);	
+    output.position = mul(output.position, viewMatrix);
+    output.position = mul(output.position, projectionMatrix);
+	// Pass the input color unchanged to the pixel shader.
+    output.color = input.color;
+    // Return the output struct to the pixel shader.
+    // The position value is automatically used as the vertex position.
+    return output;
+}
+```
+
+**Pixel Shader**
+
+```cpp
+// The pixel shader input struct must be the same as the vertex shader output!
+struct PS_INPUT {
+    float4 position : POSITION;
+    float4 color : COLOR;
+};
+// The pixel shader simply returns a 4d vector representing the vertex color.
+// It receives it's input as a parameter just like the vertex shader.
+// We have to declare the output semantic as color to it gets interpreted
+// correctly.
+float4 main(PS_INPUT input) : COLOR {
+    return input.color;
+}
+```
+
+For more on semantics: [DirectX - Semantics](https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-semantics#vertex-shader-semantics)
+
+Now we have to do quite some changes to the code.
+
+```cpp
+ComPtr<IDirect3DDevice9> _device{ };
+ComPtr<IDirect3DVertexBuffer9> _vertexBuffer{ };
+ComPtr<IDirect3DIndexBuffer9> _indexBuffer{ };
+ComPtr<IDirect3DVertexDeclaration9> _vertexDecl{ };
+// We have to add a ComPtr for the vertex- and pixel shader, aswell as one
+// for the constants (matrices) in our vertex shader.
+ComPtr<IDirect3DVertexShader9> _vertexShader{ };
+ComPtr<IDirect3DPixelShader9> _pixelShader{ };
+ComPtr<ID3DXConstantTable> _vertexTable{ };
+// Declare the world and rotation matrix as global, because we use them in
+// WinMain and SetupTransform now.
+D3DXMATRIX _worldMatrix{ };
+D3DXMATRIX _rotationMatrix{ };
+// ...
+bool SetupTransform() {
+    // Set the world and rotation matrix to an identity matrix.
+    D3DXMatrixIdentity(&_worldMatrix);
+    D3DXMatrixIdentity(&_rotationMatrix);
+	
+    D3DXMATRIX scaling{ };
+    D3DXMatrixScaling(&scaling, 10, 10, 1);
+    D3DXMatrixMultiply(&_worldMatrix, &scaling, &_rotationMatrix);
+    // After multiplying the scalation and rotation matrix the have to pass
+    // them to the shader, by using a method from the constant table
+    // of the vertex shader.
+    HRESULT result{ };
+    result = _vertexTable->SetMatrix(
+                         _device.Get(),   // direct3d device
+                         "worldMatrix",   // matrix name in the shader
+                          &_worldMatrix); // pointer to the matrix
+    if (FAILED(result))
+        return false;
+
+    D3DXMATRIX view{ };
+    D3DXMatrixLookAtLH(&view, &D3DXVECTOR3{ 0.0f, 0.0f, -20.0f },
+           &D3DXVECTOR3{ 0.0f, 0.0f, 0.0f }, &D3DXVECTOR3{ 0.0f, 1.0f, 0.0f });
+    // Do the same for the view matrix.
+    result = _vertexTable->SetMatrix(
+	                       _device.Get(), // direct 3d device
+	                       "viewMatrix",  // matrix name
+	                       &view);        // matrix
+    if (FAILED(result))
+        return false;
+
+    D3DXMATRIX projection{ };
+    D3DXMatrixPerspectiveFovLH(&projection, D3DXToRadian(60.0f),
+        1024.0f / 768.0f, 0.0f, 100.0f);
+    // And also for the projection matrix.
+    result = _vertexTable->SetMatrix(
+	                       _device.Get(),
+	                       "projectionMatrix",
+	                       &projection);
+    if (FAILED(result))
+        return false;
+
+    D3DXMatrixRotationY(&_rotationMatrix, D3DXToRadian(0.5f));
+    return true;
+}
+// ...
+// Vertex and index buffer creation aswell as initialization stay unchanged.
+// ...
+// After checking that shader model 3.0 is available we have to compile and
+// create the shaders.
+// Declare two temporary buffers storing the compiled shader code.
+ID3DXBuffer* vertexShaderBuffer{ };
+ID3DXBuffer* pixelShaderBuffer{ };
+result = D3DXCompileShaderFromFile("vertex.hlsl",  // shader name
+                                   nullptr,        // macro definitions
+                                   nullptr,        // special includes
+                                   "main",         // entry point name
+                                   "vs_3_0",       // shader model version
+                                   0,              // special flags
+                                   &vertexShaderBuffer, // code buffer
+                                   nullptr,        // error message
+                                   &_vertexTable); // constant table
+if (FAILED(result))
+    return -1;
+// After the vertex shader compile the pixel shader.
+result = D3DXCompileShaderFromFile("pixel.hlsl",
+                                   nullptr,
+                                   nullptr,
+                                   "main",
+                                   "ps_3_0", // pixel shader model 3.0
+                                   0,
+                                   &pixelShaderBuffer,
+                                   nullptr,
+                                   nullptr); // no need for a constant table
+if (FAILED(result))
+    return -1;
+// Create the vertex shader from the code buffer.
+result = _device->CreateVertexShader(
+             (DWORD*)vertexShaderBuffer->GetBufferPointer(), // code buffer
+             &_vertexShader); // vertex shader pointer
+if (FAILED(result))
+    return -1;
+	
+result = _device->CreatePixelShader(
+             (DWORD*)pixelShaderBuffer->GetBufferPointer(),
+             &_pixelShader);
+if (FAILED(result))
+    return -1;
+// Release the temporary code buffers after the shaders are created.
+vertexShaderBuffer->Release();
+pixelShaderBuffer->Release();
+// Apply the vertex- and pixel shader.
+_device->SetVertexShader(_vertexShader.Get());
+_device->SetPixelShader(_pixelShader.Get());
+// Apply the transform after the shaders have been set.
+if (!SetupTransform())
+    return -1;
+// You can also REMOVE the call so set the lighting render state.
+_device->SetRenderState(D3DRS_LIGHTING, false);
+```
+
+You can find the complete code here: [DirectX - 3](https://pastebin.com/y4NrvawY)
+
+## Texturing
+
+```cpp
+// First we need to declare a ComPtr for the texture.
+ComPtr<IDirect3DTexture9> _texture{ };
+// Then we have to change the vertex struct.
+struct VStruct {
+    float x, y, z;
+    float u, v;      // Add texture u and v coordinates
+    D3DCOLOR color;
+};
+// In the vertex declaration we have to add the texture coordinates.
+// the top left of the texture is u: 0, v: 0.
+std::vector<VStruct> vertices {
+    VStruct{ -1.0f, -1.0f, 1.0f, 0.0f, 1.0f, ... }, // bottom left
+    VStruct{ -1.0f,  1.0f, 1.0f, 0.0f, 0.0f, ... }, // top left
+    VStruct{  1.0f,  1.0f, 1.0f, 1.0f, 0.0f, ... }, // top right
+    VStruct{  1.0f, -1.0f, 1.0f, 1.0f, 1.0f, ... }  // bottom right
+};
+// Next is the vertex declaration.
+std::vector<D3DVERTEXELEMENT9> vertexDecl{
+    {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0},
+    // Add a 2d float vector used for texture coordinates.
+    {0, 12, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
+    // The color offset is not (3 + 2) * sizeof(float) = 20 bytes
+    {0, 20, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
+    D3DDECL_END()
+};
+// Now we have to load the texture and pass its to the shader.
+// ...
+_device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
+// Create a Direct3D texture from a png file.
+result = D3DXCreateTextureFromFile(_device.Get(), // direct3d device
+                                   "texture.png", // texture path
+                                   &_texture);    // receiving texture pointer
+if (FAILED(result))
+    return -1;
+// Attach the texture to shader stage 0, which is equal to texture register 0
+// in the pixel shader.
+_device->SetTexture(0, _texture.Get());
+```
+
+With the main code ready we now have to adjust the shaders to these changes.
+
+**Vertex Shader**
+
+```cpp
+float4x4 projectionMatrix;
+float4x4 viewMatrix;
+float4x4 worldMatrix;
+// Add the texture coordinates to the vertex shader in- and output.
+struct VS_INPUT {
+    float3 position : POSITION;
+    float2 texcoord : TEXCOORD;
+    float4 color : COLOR;
+};
+
+struct VS_OUTPUT {
+    float4 position : POSITION;
+    float2 texcoord : TEXCOORD;
+    float4 color : COLOR;
+};
+
+VS_OUTPUT main(VS_INPUT input) {
+    VS_OUTPUT output;
+    
+    output.position = float4(input.position, 1.0f);
+    output.position = mul(output.position, worldMatrix);	
+    output.position = mul(output.position, viewMatrix);
+    output.position = mul(output.position, projectionMatrix);
+
+    output.color = input.color;
+    // Set the texcoord output to the input.
+    output.texcoord = input.texcoord;
+    
+    return output;
+}
+```
+
+**Pixel Shader**
+
+```cpp
+// Create  a sampler called "sam0" using sampler register 0, which is equal
+// to the texture stage 0, to which we passed the texture.
+sampler sam0 : register(s0);
+
+struct PS_INPUT {
+    float4 position : POSITION;
+    float2 texcoord : TEXCOORD;
+    float4 color : COLOR;
+};
+
+float4 main(PS_INPUT input) : COLOR{
+    // Do a linear interpolation between the texture color and the input color
+    // using 75% of the input color.
+    // tex2D returns the texture data at the specified texture coordinate.
+    return lerp(tex2D(sam0, input.texcoord), input.color, 0.75f);
+}
+```
+
+## Quotes
+<sup>[1]</sup>[DirectX - Wikipedia](https://en.wikipedia.org/wiki/DirectX)
diff --git a/dynamic-programming.html.markdown b/dynamic-programming.html.markdown
index 4db8e92e..c73b1845 100644
--- a/dynamic-programming.html.markdown
+++ b/dynamic-programming.html.markdown
@@ -42,10 +42,12 @@ for i=0 to n-1
 
 ### Some Famous DP Problems
 
-- Floyd Warshall Algorithm - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code 
-- Integer Knapsack Problem - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem 
-- Longest Common Subsequence - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence 
+- [Floyd Warshall Algorithm - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code)
+- [Integer Knapsack Problem - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem)
+- [Longest Common Subsequence - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence)
 
 ## Online Resources
 
 * [codechef](https://www.codechef.com/wiki/tutorial-dynamic-programming)
+* [InterviewBit](https://www.interviewbit.com/courses/programming/topics/dynamic-programming/)
+
diff --git a/el-gr/bash-gr.html.markdown b/el-gr/bash-gr.html.markdown
new file mode 100644
index 00000000..2989969d
--- /dev/null
+++ b/el-gr/bash-gr.html.markdown
@@ -0,0 +1,528 @@
+---
+category: tool
+tool: bash
+contributors:
+    - ["Dimitri Kokkonis", "https://github.com/kokkonisd"]
+filename: LearnBash-gr.sh
+lang: el-gr
+---
+
+Η λέξη «bash» είναι ένα από τα ονόματα του unix shell (τερματικός), το οποίο
+διανέμεται επίσης ως προεπιλεγμένος τερματικός για το λειτουργικό σύστημα GNU, τα Linux και τα Mac OS X.
+Σχεδόν όλα τα παραδείγματα που ακολουθούν μπορούν να αποτελέσουν μέρος ενός
+προγράμματος τερματικού (shell script) ή να εκτελεσθούν απευθείας από τον
+τερματικό.
+
+[Διαβάστε περισσότερα εδώ.](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/usr/bin/env bash
+# Η πρώτη γραμμή του προγράμματος είναι το shebang που υποδεικνύει στο σύστημα
+# πώς να εκτελέσει το πρόγραμμα: http://en.wikipedia.org/wiki/Shebang_(Unix)
+# Όπως ήδη θα καταλάβατε, τα σχόλια ξεκινούν με τον χαρακτήρα #. Το shebang
+# είναι επίσης ένα σχόλιο.
+# ΣτΜ.: Τα ονόματα των μεταβλητών είναι γραμμένα σε greeklish καθώς η Bash δεν
+# επιτρέπει την χρήση unicode χαρακτήρων.
+
+# Ένα απλό παράδειγμα τύπου «hello world»:
+echo Καλημέρα, Κόσμε! # => Καλημέρα, Κόσμε!
+
+# Κάθε εντολή ξεκινά σε μια νέα γραμμή, ή μετά από ένα ελληνικό ερωτηματικό:
+echo 'Αυτή είναι η πρώτη γραμμή'; echo 'Αυτή είναι η δεύτερη γραμμή'
+# => Αυτή είναι η πρώτη γραμμή
+# => Αυτή είναι η δεύτερη γραμμή
+
+# Ορίζουμε μεταβλητές ως εξής:
+Metavliti="Κάποιο αλφαριθμητικό"
+
+# Αλλά όχι ως εξής:
+Metavliti = "Κάποιο αλφαριθμητικό" # => επιστρέφει το λάθος
+# «Metavliti: command not found»
+# Η Bash θα καταλάβει πως η Metavliti είναι κάποια εντολή που πρέπει να
+# εκτελέσει και θα επιστρέψει ένα λάθος γιατί δεν μπορεί να την βρει.
+
+# Ούτε έτσι μπορούμε να δηλώσουμε μεταβλητές:
+Metavliti= 'Κάποιο αλφαριθμητικό' # => επιστρέφει το λάθος: «Κάποιο
+                                  # αλφαριθμητικό: command not found»
+# Η Bash θα καταλάβει πως το αλφαριθμητικό «Κάποιο αλφαριθμητικό» είναι μια
+# εντολή που πρέπει να εκτελέσει και θα επιστρέψει ένα λάθος γιατί δεν μπορεί
+# να την βρει. (Σε αυτή την περίπτωση το τμήμα της εντολής «Metavliti=» θα
+# ερμηνευθεί ως ορισμός μεταβλητής ισχύων μόνο στο πλαίσιο της εντολής
+# «Κάποιο αλφαριθμητικό».)
+
+# Ας χρησιμοποιήσουμε την μεταβλητή:
+echo $Metavliti # => Κάποιο αλφαριθμητικό
+echo "$Metavliti" # => Κάποιο αλφαριθμητικό
+echo '$Metavliti' # => $Metavliti
+# Όταν χρησιμοποιούμε την ίδια την μεταβλητή - είτε είναι για να της δώσουμε
+# μια νέα αξία, για να την εξάγουμε ή για οτιδήποτε άλλο - γράφουμε το όνομά
+# της χωρίς τον χαρακτήρα $. Αν θέλουμε να χρησιμοποιήσουμε την αξία της
+# μεταβλητής, πρέπει να χρησιμοποιήσουμε τον χαρατήρα $.
+# Να σημειωθεί πώς ο χαρακτήρας ' δεν θα μετατρέψει τις μεταβλητές στις αξίες
+# τους!
+
+# Επέκταση παραμέτρων ${ }:
+echo ${Metavliti} # => Κάποιο αλφαριθμητικό
+# Αυτή είναι μια απλή χρήση της επέκτασης παραμέτρων.
+# Η επέκταση παραμέτρων εξάγει μια αξία από μια μεταβλητή.
+# Κατά την επέκταση η τιμή ή η παράμετρος μπορεί να τροποποιηθεί.
+# Ακολουθούν άλλες μετατροπές που μπορούν να προστεθούν σε αυτή την επέκταση.
+
+# Αντικατάσταση αλφαριθμητικών μέσα σε μεταβλητές
+echo ${Metavliti/Κάποιο/Ένα} # => Ένα αλφαριθμητικό
+# Αυτή η τροποποίηση θα αντικαταστήσει την πρώτη εμφάνιση της λέξης «Κάποιο»
+# με την λέξη «Ένα».
+
+# Υποαλφαριθμητικό μιας μεταβλητής
+Mikos=7
+echo ${Metavliti:0:Mikos} # => Κάποιο
+# Αυτή η τροποποίηση θα επιστρέψει μόνο τους πρώτους 7 χαρακτήρες της τιμής
+# της μεταβλητής.
+echo ${Metavliti: -5} # => ητικό
+# Αυτή η τροποποίηση θα επιστρέψει τους τελευταίους 5 χαρακτήρες (προσοχή στο
+# κενό πριν το -5).
+
+# Μήκος αλφαριθμητικού
+echo ${#Metavliti} # => 20
+
+# Προεπιλεγμένη αξία για μια μεταβλητή
+echo ${Foo:-"ΠροεπιλεγμένηΑξίαΑνΤοFooΕίναιΑόριστοΉΆδειο"}
+# => ΠροεπιλεγμένηΑξίαΑνΤοFooΕίναιΑόριστοΉΆδειο
+# Αυτό δουλεύει στην περίπτωση που το Foo είναι αόριστο (Foo=) ή άδειο
+# (Foo="")· το μηδέν (Foo=0) επιστρέφει 0.
+# Να σημειωθεί πως αυτή η εντολή απλώς επιστρέφει την προεπιλεγμένη αξία και
+# δεν τροποποιεί την αξία της μεταβλητής.
+
+# Ορισμός ενός πίνακα με 6 στοιχεία
+pinakas0=(ένα δύο τρία τέσσερα πέντε έξι)
+# Εντολή που τυπώνει το πρώτο στοιχείο
+echo $pinakas0 # => "ένα"
+# Εντολή που τυπώνει το πρώτο στοιχείο
+echo ${pinakas0[0]} # => "ένα"
+# Εντολή που τυπώνει όλα τα στοιχεία
+echo ${pinakas0[@]} # => "ένα δύο τρία τέσσερα πέντε έξι"
+# Εντολή που τυπώνει τον αριθμό των στοιχείων
+echo ${#pinakas0[@]} # => "6"
+# Εντολή που τυπώνει τον αριθμό των χαρακτήρων στο τρίτο στοιχείο
+echo ${#pinakas0[2]} # => "4"
+# Εντολή που τυπώνει δύο στοιχεία ξεκινώντας από το τέταρτο
+echo ${pinakas0[@]:3:2} # => "τέσσερα πέντε"
+# Εντολή που τυπώνει όλα τα στοιχεία, το καθένα σε διαφορετική γραμμή
+for i in "${pinakas0[@]}"; do
+    echo "$i"
+done
+
+# Επέκταση αγκίστρων { }
+# Χρησιμοποιείται για την παραγωγή αλφαριθμητικών
+echo {1..10} # => 1 2 3 4 5 6 7 8 9 10
+echo {a..z} # => a b c d e f g h i j k l m n o p q r s t u v w x y z
+# Η εντολή θα τυπώσει όλο το εύρος, από την πρώτη μέχρι την τελευταία αξία
+
+# Ενσωματωμένες μεταβλητές
+# Υπάρχουν κάποιες χρήσιμες ενσωματωμένες μεταβλητές, όπως:
+echo "Η τιμή την οποία επέστρεψε το τελευταίο πρόγραμμα: $?"
+echo "Ο αριθμός PID αυτού του script: $$"
+echo "Ο αριθμός των παραμέτρων που περάστηκαν σε αυτό το script: $#"
+echo "Όλες οι παράμετροι που περάστηκαν σε αυτό το script: $@"
+echo "Οι παράμετροι του script διαχωρισμένες σε μεταβλητές: $1 $2..."
+
+# Τώρα που γνωρίζουμε πως να τυπώνουμε (echo) και να χρησιμοποιούμε μεταβλητές,
+# ας μάθουμε κάποια από τα υπόλοιπα βασικά στοιχεία της Bash!
+
+# Ο τρέχων κατάλογος (ή αλλιώς, φάκελος) μπορεί να βρεθεί μέσω της εντολής
+# `pwd`.
+# `pwd` σημαίνει «print working directory».
+# Μπορούμε επίσης να χρησιμοποιούμε την ενσωματωμένη μεταβλητή `$PWD`.
+# Παρακολουθήστε πως οι δύο εντολές που ακολουθούν είναι ισοδύναμες:
+echo "Είμαι στον κατάλογο $(pwd)" # εκτελεί την εντολή `pwd` και τυπώνει το
+                                  # αποτέλεσμα
+echo "Είμαι στον κατάλογο $PWD" # τυπώνει την αξία της μεταβλητής
+
+# Αν έχετε πολλά μηνύματα στον τερματικό, η εντολή `clear` μπορεί να
+# «καθαρίσει» την οθόνη σας
+clear
+# Η συντόμευση Ctrl-L δουλεύει επίσης όσον αφορά το «καθάρισμα»
+
+# Ας διαβάσουμε μια αξία από κάποια είσοδο:
+echo "Πώς σε λένε;"
+read Onoma # Προσέξτε πως δεν χρειάστηκε να ορίσουμε μια νέα μεταβλητή
+echo Καλημέρα, $Onoma!
+
+# Η δομή των if statements έχει ως εξής:
+# (μπορείτε να εκτελέσετε την εντολή `man test` για περισσότερες πληροφορίες
+# σχετικά με τα conditionals)
+if [ $Onoma != $USER ]
+then
+    echo "Το όνομά σου δεν είναι το όνομα χρήστη σου"
+else
+    echo "Το όνομά σου είναι το όνομα χρήστη σου"
+fi
+# Η συνθήκη είναι αληθής αν η τιμή του $Onoma δεν είναι ίδια με το τρέχον
+# όνομα χρήστη στον υπολογιστή
+
+# ΣΗΜΕΙΩΣΗ: Αν το $Onoma είναι άδειο, η Bash βλέπει την συνθήκη ως:
+if [ != $USER ]
+# το οποίο αποτελεί συντακτικό λάθος
+# οπότε ο «ασφαλής» τρόπος να χρησιμοποιούμε εν δυνάμει άδειες μεταβλητές στην
+# Bash είναι ο εξής:
+if [ "$Onoma" != $USER ] ...
+# ο οποίος, όταν το $Onoma είναι άδειο, θα ερμηνευθεί από την Bash ως:
+if [ "" != $USER ] ...
+# το οποίο και δουλεύει όπως θα περιμέναμε.
+
+# Υπάρχει επίσης η εκτέλεση εντολών βάσει συνθηκών
+echo "Εκτελείται πάντα" || echo "Εκτελείται μόνο αν η πρώτη εντολή αποτύχει"
+# => Εκτελείται πάντα
+echo "Εκτελείται πάντα" && echo "Εκτελείται μόνο αν η πρώτη εντολή ΔΕΝ αποτύχει"
+# => Εκτελείται πάντα
+# => Εκτελείται μόνο αν η πρώτη εντολή ΔΕΝ αποτύχει
+
+
+# Για να χρησιμοποιήσουμε τους τελεστές && και || με τα if statements,
+# χρειαζόμαστε πολλαπλά ζευγάρια αγκύλων:
+if [ "$Onoma" == "Σταύρος" ] && [ "$Ilikia" -eq 15 ]
+then
+    echo "Αυτό θα εκτελεστεί αν το όνομα ($Onoma) είναι Σταύρος ΚΑΙ η ηλικία ($Ilikia) είναι 15."
+fi
+
+if [ "$Onoma" == "Δανάη" ] || [ "$Onoma" == "Ζαχαρίας" ]
+then
+    echo "Αυτό θα εκτελεστεί αν το όνομα ($Onoma) είναι Δανάη Ή Ζαχαρίας."
+fi
+
+# Υπάρχει επίσης ο τελεστής `=~`, που εκτελεί ένα regex πάνω σε ένα
+# αλφαριθμητικό:
+Email=me@example.com
+if [[ "$Email" =~ [a-z]+@[a-z]{2,}\.(com|net|org) ]]
+then
+    echo "Η διεύθυνση email είναι σωστά διατυπωμένη!"
+fi
+# Να σημειωθεί πως ο τελεστής `=~` δουλεύει μόνο με διπλές αγκύλες [[ ]],
+# που είναι ωστόσο διαφορετικές από τις μονές [ ].
+# Δείτε το http://www.gnu.org/software/bash/manual/bashref.html#Conditional-Constructs
+# για περισσότερες πληροφορίες σχετικά με αυτό.
+
+# Επαναπροσδιορισμός της εντολής `ping` ως alias (ψευδώνυμο) για την αποστολή 5
+# πακέτων
+alias ping='ping -c 5'
+# Ακύρωση του alias και χρήση της εντολής όπως είναι κανονικά ορισμένη
+\ping 192.168.1.1
+# Εκτύπωση όλων των aliases
+alias -p
+
+# Οι μαθηματικές εκφράσεις ορίζονται ως εξής:
+echo $(( 10 + 5 )) # => 15
+
+# Αντίθετα με άλλες γλώσσες προγραμματισμού, η Bash είναι επίσης ένα shell, άρα
+# δουλεύει στο πλαίσιο ενός «τρέχοντος καταλόγου». Μπορούμε να δούμε μια λίστα
+# αρχείων και καταλόγων στον τρέχων κατάλογο με την εντολή ls:
+ls # Τυπώνει μια λίστα των αρχείων και υποκαταλόγων που περιέχονται στον τρέχων
+   # κατάλογο
+
+# Αυτή η εντολή έχει επιλογές που ελέγχουν την εκτέλεσή της:
+ls -l # Τυπώνει κάθε αρχείο και κατάλογο σε διαφορετική γραμμή
+ls -t # Ταξινομεί τα περιεχόμενα του καταλόγου με βάσει την ημερομηνία
+      # τελευταίας τροποποίησης (σε φθίνουσα σειρά)
+ls -R # Εκτελεί την εντολή `ls` αναδρομικά στον τρέχων κατάλογο και σε όλους
+      # τους υποκαταλόγους του.
+
+# Τα αποτελέσματα μιας εντολής μπορούν να μεταβιβαστούν σε μιαν άλλη.
+# Η εντολή `grep` φιλτράρει τα δεδομένα που δέχεται βάσει μοτίβων.
+# Έτσι, μπορούμε να τυπώσουμε μια λίστα αρχείων κειμένου (.txt) στον τρέχων
+# κατάλογο:
+ls -l | grep "\.txt"
+
+# Μπορούμε να χρησιμοποιήσουμε την εντολή `cat` για να τυπώσουμε το περιεχόμενο
+# ενός ή περισσότερων αρχείων στην προεπιλεγμένη έξοδο (stdout):
+cat file.txt
+
+# Μπορούμε επίσης να διαβάσουμε το αρχείο μέσω της `cat`:
+Periexomena=$(cat file.txt)
+echo "ΑΡΧΗ ΤΟΥ ΑΡΧΕΙΟΥ\n$Periexomena\nΤΕΛΟΣ ΤΟΥ ΑΡΧΕΙΟΥ" # Ο χαρακτήρας "\n"
+                                                         # δημιουργεί μια νέα
+                                                         # γραμμή
+# => ΑΡΧΗ ΤΟΥ ΑΡΧΕΙΟΥ
+# => [περιεχόμενα του αρχείου file.txt]
+# => ΤΕΛΟΣ ΤΟΥ ΑΡΧΕΙΟΥ
+
+# Μπορούμε να χρησιμοποιήσουμε την εντολή `cp` για να αντιγράψουμε αρχεία ή
+# καταλόγους από ένα σημείο σε ένα άλλο.
+# Η εντολή `cp` δημιουργεί ΝΕΕΣ εκδοχές των πρωτοτύπων, το οποίο σημαίνει ότι
+# μια τροποποίηση του αντιγράφου δεν θα επηρεάσει το πρωτότυπο (και
+# αντιστρόφως).
+# Να σημειωθεί πως αν υπάρχει ήδη αρχείο ή κατάλογος με το ίδιο όνομα στην ίδια
+# θέση με το αντίγραφο, το αντίγραφο θα αντικαταστήσει το αρχείο/κατάλογο και
+# άρα τα δεδομένα του θα χαθούν.
+cp prototipo.txt antigrafo.txt
+cp -r prototipo/ antigrafo/ # Αναδρομική αντιγραφή (αντιγραφή όλων των
+                            # περιεχομένων του καταλόγου prototipo/)
+
+# Ενημερωθείτε σχετικά με τις εντολές `scp` και `sftp` αν σχεδιάζετε να
+# αντιγράψετε αρχεία από έναν υπολογιστή σε έναν άλλο.
+# Η εντολή `scp` μοιάζει πολύ με την `cp`, ενώ η `sftp` είναι πιο διαδραστική.
+
+# Μπορούμε να χρησιμοποιήσουμε την εντολή `mv` για να μετακινήσουμε αρχεία ή
+# καταλόγους από μια θέση σε μια άλλη.
+# Η εντολή `mv` μοιάζει με την `cp`, με τη διαφορά ότι διαγράφει το πρωτότυπο.
+# Η `mv` χρησιμοποιείται επίσης για τη μετονομασία αρχείων!
+mv prototipo.txt prototipo2.txt
+
+# Δεδομένου του ότι η Bash δουλεύει στο πλαίσιο του τρέχοντος καταλόγου,
+# μπορεί να θελήσουμε να τρέξουμε κάποια εντολή σε κάποιον άλλο κατάλογο.
+# Η εντολή `cd` (Change Directory) μας επιτρέπει να αλλάξουμε θέση μέσα στο
+# σύστημα αρχείων:
+cd ~    # Μετατόπιση στον κατάλογο «home»
+cd      # Αυτή η εντολή μας μετατοπίζει επίσης στον κατάλογο «home»
+cd ..   # Μετατόπιση προς τα πάνω κατά έναν κατάλογο
+        # (για παράδειγμα, μετατόπιση από τη θέση /home/username/Downloads
+        # στη θέση /home/username)
+cd /home/username/Documents   # Μετατόπιση προς έναν συγκεκριμένο κατάλογο
+cd ~/Documents/..    # Μετατόπιση προς τον κατάλογο «home»... σωστά;
+cd -    # Μετατόπιση προς τον προηγούμενο κατάλογο
+# => /home/username/Documents
+
+# Μπορούμε να χρησιμοποιήσουμε subshells για να δουλέψουμε σε πολλούς
+# διαφορετικούς καταλόγους:
+(echo "Πρώτα, είμαι εδώ: $PWD") && (cd kapoiosKatalogos; echo "Έπειτα, είμαι εδώ: $PWD")
+pwd # Εδώ θα είμαστε στον πρώτο κατάλογο
+
+# Μπορούμε να χρησιμοποιήσουμε την εντολή `mkdir` για να δημιουργήσουμε νέους
+# καταλόγους.
+mkdir neosKatalogos
+# Η επιλογή `-p` επιτρέπει σε ενδιάμεσους καταλόγους να δημιουργηθούν αν
+# χρειάζεται.
+mkdir -p neosKatalogos/me/epipleon/katalogous
+# Αν οι ενδιάμεσοι κατάλογοι δεν υπήρχαν ήδη, η παραπάνω εντολή χωρίς την
+# επιλογή `-p` θα είχε επιστρέψει κάποιο λάθος.
+
+# Μπορούμε να διευθύνουμε τις εισόδους και εξόδους των εντολών (χρησιμοποιώντας
+# τα κανάλια stdin, stdout και stderr).
+# Για παράδειγμα, μπορούμε να «διαβάσουμε» από το stdin μέχρι να βρεθεί ένα
+# ^EOF$ (End Of File) και να αντικαταστήσουμε το περιεχόμενο του αρχείου
+# hello.py με τις γραμμές που διαβάσαμε έως και πριν το "EOF":
+cat > hello.py << EOF
+#!/usr/bin/env python
+from __future__ import print_function
+import sys
+print("#stdout", file=sys.stdout)
+print("#stderr", file=sys.stderr)
+for line in sys.stdin:
+    print(line, file=sys.stdout)
+EOF
+
+# Μπορούμε να τρέξουμε το πρόγραμμα Python «hello.py» με διάφορες
+# ανακατευθύνσεις χρησιμοποιώντας τα stdin, stdout και stderr:
+python hello.py < "eisodos.in" # Περνάμε το eisodos.in ως είσοδο στο πρόγραμμα
+
+python hello.py > "eksodos.out" # Ανακατευθύνουμε την έξοδο του προγράμματος
+                                # προς το αρχείο eksodos.out
+
+python hello.py 2> "lathos.err" # ανακατευθύνουμε την έξοδο λάθους (stderr)
+                                # προς το αρχείο lathos.err
+
+python hello.py > "eksodos-kai-lathos.log" 2>&1
+# Ανακατευθύνουμε την κανονική έξοδο (stdout) και την έξοδο λάθους (stderr)
+# προς το αρχείο eksodos-kai-lathos.log
+
+python hello.py > /dev/null 2>&1
+# Ανακατευθύνουμε όλες τις εξόδους προς τη «μαύρη τρύπα» που λέγεται /dev/null,
+# δηλαδή τίποτα δεν θα τυπωθεί στον τερματικό
+
+# Αν θέλετε να προσθέσετε την έξοδο σε κάποιο αρχείο αντί να διαγράψετε τα
+# περιεχόμενά του με τη νέα έξοδο, μπορείτε να χρησιμοποιήσετε τον τελεστή
+# `>>` αντί στη θέση του `>`:
+python hello.py >> "eksodos.out" 2>> "lathos.err"
+
+# Αντικατάσταση του αρχείου eksodos.out, προσθήκη στο αρχείο lathos.err, και
+# καταμέτρηση των γραμμών τους:
+info bash 'Basic Shell Features' 'Redirections' > eksodos.out 2>> lathos.err
+wc -l eksodos.out lathos.err
+
+# Μπορούμε να εκτελέσουμε μια εντολή και να τυπώσουμε τον file descriptor της
+# (https://en.wikipedia.org/wiki/File_descriptor)
+# Για παράδειγμα: /dev/fd/123
+# Δείτε επίσης: man fd
+echo <(echo "#καλημέρακόσμε")
+
+# Αντικατάσταση του περιεχομένου του αρχείου eksodos.out με το αλφαριθμητικό
+# «#καλημέρακόσμε»:
+cat > eksodos.out <(echo "#καλημέρακόσμε")
+echo "#καλημέρακόσμε" > eksodos.out
+echo "#καλημέρακόσμε" | cat > eksodos.out
+echo "#καλημέρακόσμε" | tee eksodos.out >/dev/null
+
+# Εκκαθάριση προσωρινών αρχείων με την επιλογή `-v` (verbose) (προσθέστε την
+# επιλογή `-i` για περισσότερη διάδραση)
+# ΠΡΟΣΟΧΗ: τα αποτελέσματα της εντολής `rm` είναι μόνιμα.
+rm -v eksodos.out lathos.err eksodos-kai-lathos.log
+rm -r tempDir/ # Αναδρομική διαγραφή
+
+# Οι εντολές μπορούν να αντικατασταθούν μέσα σε άλλες εντολές χρησιμοποιώντας
+# το μοτίβο $( ).
+# Το παράδειγμα που ακολουθεί τυπώνει τον αριθμό των αρχείων και των καταλόγων
+# στον τρέχων κατάλογο.
+echo "Υπάρχουν $(ls | wc -l) αντικείμενα εδώ."
+
+# Μπορούμε να επιτύχουμε το ίδιο αποτέλεσμα με τους χαρακτήρες ``, αλλά δεν
+# μπορούμε να τους χρησιμοποιήσουμε αναδρομικά (δηλαδή `` μέσα σε ``).
+# Ο προτεινόμενος τρόπος από την Bash είναι το μοτίβο $( ).
+echo "Υπάρχουν `ls | wc -l` αντικείμενα εδώ."
+
+# Η Bash έχει επίσης τη δομή `case` που δουλεύει παρόμοια με τη δομή switch
+# όπως στην Java ή την C++ για παράδειγμα:
+case "$Metavliti" in
+    # Λίστα μοτίβων για τις συνθήκες που θέλετε να ορίσετε:
+    0) echo "Η μεταβλητή έχει ένα μηδενικό.";;
+    1) echo "Η μεταβλητή έχει έναν άσσο.";;
+    *) echo "Η μεταβλητή δεν είναι αόριστη (null).";;
+esac
+
+# Οι βρόγχοι `for` εκτελούνται τόσες φορές όσο είναι το πλήθος των παραμέτρων
+# που τους δίνονται:
+# Το περιεχόμενο της μεταβλητής $Metavliti τυπώνεται τρεις φορές.
+for Metavliti in {1..3}
+do
+    echo "$Metavliti"
+done
+# => 1
+# => 2
+# => 3
+
+# Μπορούμε επίσης να το γράψουμε πιο «παραδοσιακά»:
+for ((a=1; a <= 3; a++))
+do
+    echo $a
+done
+# => 1
+# => 2
+# => 3
+
+# Μπορούμε επίσης να περάσουμε αρχεία ως παραμέτρους.
+# Το παράδειγμα που ακολουθεί θα τρέξει την εντολή `cat` με τα αρχεία file1
+# και file2:
+for Metavliti in file1 file2
+do
+    cat "$Metavliti"
+done
+
+# Μπορούμε ακόμα να χρησιμοποιήσουμε την έξοδο μας εντολής.
+# Το παράδειγμα που ακολουθεί θα τρέξει την εντολή `cat` με την έξοδο της
+# εντολής `ls`.
+for Output in $(ls)
+do
+    cat "$Output"
+done
+
+# Ο βρόγχος `while` έχει ως εξής:
+while [ true ]
+do
+    echo "το «σώμα» του βρόγχου μπαίνει εδώ..."
+    break
+done
+# => το «σώμα» του βρόγχου μπαίνει εδώ...
+
+# Μπορούμε επίσης να ορίσουμε συναρτήσεις, ως εξής:
+function synartisi ()
+{
+    echo "Οι παράμετροι συναρτήσεων δουλεύουν όπως αυτές των προγραμμάτων: $@"
+    echo "Και: $1 $2..."
+    echo "Αυτή είναι μια συνάρτηση"
+    return 0
+}
+# Ας καλέσουμε την συνάρτηση `synartisi` με δύο παραμέτρους, param1 και param2
+synartisi param1 param2
+# => Οι παράμετροι συναρτήσεων δουλεύουν όπως αυτές των προγραμμάτων: param1 param2
+# => Και: param1 param2...
+# => Αυτή είναι μια συνάρτηση
+
+# Ή επίσης:
+synartisi2 ()
+{
+    echo "Ένας άλλος τρόπος να ορίσουμε συναρτήσεις!"
+    return 0
+}
+# Ας καλέσουμε την συνάρτηση `synartisi2` χωρίς παραμέτρους:
+synartisi2 # => Ένας άλλος τρόπος να ορίσουμε συναρτήσεις!
+
+# Ας καλέσουμε την πρώτη συνάρτηση:
+synartisi "Το όνομά μου είναι" $Onoma
+
+# Υπάρχουν πολλές χρήσιμες εντολές που μπορείτε να μάθετε.
+# Για παράδειγμα, αυτή που ακολουθεί τυπώνει τις 10 τελευταίες γραμμές του
+# αρχείου file.txt:
+tail -n 10 file.txt
+
+# Ενώ αυτή τυπώνει τις 10 πρώτες:
+head -n 10 file.txt
+
+# Αυτή ταξινομεί τις γραμμές:
+sort file.txt
+
+# Αυτή αναφέρει ή παραλείπει τις γραμμές που επαναλαμβάνονται (η επιλογή
+# -d τις αναφέρει):
+uniq -d file.txt
+
+# Αυτή τυπώνει μόνο ό,τι βρίσκεται πριν τον πρώτο χαρακτήρα «,» σε κάθε γραμμή:
+cut -d ',' -f 1 file.txt
+
+# Αυτή αντικαθιστά κάθε εμφάνιση της λέξης «οκ» με τη λέξη «τέλεια» στο αρχείο
+# file.txt (δέχεται επίσης μοτίβα regex):
+sed -i 's/οκ/τέλεια/g' file.txt
+
+# Αυτή τυπώνει στο stdout όλες τις γραμμές που είναι συμβατές με κάποιο
+# συγκεκριμένο μοτίβο regex.
+# Για παράδειγμα, όλες τις γραμμές που ξεκινούν με «καλημέρα» και τελειώνουν με
+# «καληνύχτα»:
+grep "^καλημέρα.*καληνύχτα$" file.txt
+
+# Η επιλογή `-c` θα τυπώσει τον αριθμό των γραμμών που περιέχουν το μοτίβο:
+grep -c "^καλημέρα.*καληνύχτα$" file.txt
+
+# Άλλες χρήσιμες επιλογές:
+grep -r "^καλημέρα.*καληνύχτα$" someDir/ # Αναδρομική εκτέλεση μέσα σε κάποιο κατάλογο
+grep -n "^καλημέρα.*καληνύχτα$" file.txt # Τυπώνει επίσης τον αριθμό των γραμμών
+grep -rI "^καλημέρα.*καληνύχτα$" someDir/ # Αναδρομική εκτέλεση αγνοώντας τα αρχεία binary
+
+# Η ίδια εντολή, αλλά τώρα αγνοώντας τις γραμμές που περιέχουν «αντίο»
+grep "^καλημέρα.*καληνύχτα$" file.txt | grep -v "αντίο"
+
+# Αν θέλετε να ψάξετε κυριολεκτικά για ένα αλφαριθμητικό, και όχι για κάποιο
+# μοτίβο, μπορείτε να χρησιμοποιήσετε την εντολή `fgrep` (ή `grep -F`):
+fgrep "καλημέρα" file.txt
+
+# Η εντολή `trap` επιτρέπει την εκτέλεση μιας εντολής μόλις το πρόγραμμά μας
+# λάβει κάποιο σήμα. Στο παράδειγμα που ακολουθεί, η εντολή `trap` θα
+# εκτελέσει την εντολή `rm` αν λάβει κάποιο από τα τρία σήματα που ακολουθούν
+# (SIGHUP, SIGINT, SIGTERM):
+trap "rm $TEMP_FILE; exit" SIGHUP SIGINT SIGTERM
+
+# Η εντολή `sudo` (SuperUser Do) χρησιμοποιείται για να εκτελέσουμε εντολές
+# με προνόμια υπερχρήστη (superuser):
+ONOMA1=$(whoami)
+ONOMA2=$(sudo whoami)
+echo "Ήμουν ο $ONOMA1, και έπειτα έγινα ο πιο ισχυρός $ONOMA2"
+
+# Διαβάστε την ενσωματωμένη documentation της Bash χρησιμοποιώντας την εντολή
+# `help`:
+help
+help help
+help for
+help return
+help source
+help .
+
+# Διαβάστε τα manpages με την εντολή `man`:
+apropos bash
+man 1 bash
+man bash
+
+# Διαβάστε επίσης την info documentation με την εντολή `info`:
+apropos info | grep '^info.*('
+man info
+info info
+info 5 info
+info bash
+info bash 'Bash Features'
+info bash 6
+info --apropos bash
+```
diff --git a/el-gr/html-gr.html.markdown b/el-gr/html-gr.html.markdown
new file mode 100644
index 00000000..0ca6e326
--- /dev/null
+++ b/el-gr/html-gr.html.markdown
@@ -0,0 +1,193 @@
+---
+language: html
+filename: learnhtml-gr.html
+contributors:
+    - ["Dimitri Kokkonis", "https://github.com/kokkonisd"]
+lang: el-gr
+---
+
+Το ακρώνυμο HTML σημαίνει HyperText Markup Language.
+
+Είναι μια γλώσσα που μας επιτρέπει να δημιουργήσουμε σελίδες για το διαδίκτυο.
+Είναι μια γλώσσα σήμανσης (markup), και μας επιτρέπει να γράψουμε ιστοσελίδες
+χρησιμοποιώντας κώδικα για να υποδείξουμε πώς πρέπει να εμφανίζεται το κείμενο
+και τα δεδομένα στη σελίδα. Στην πραγματικότητα, τα αρχεία HTML είναι απλά
+αρχεία κειμένου.
+
+Τι σημαίνει όμως «γλώσσα σήμανσης»; Είναι μια μέθοδος οργάνωσης των δεδομένων
+της σελίδας, που λειτουργεί μέσω ετικετών (tags) που «ανοίγουν» ή «κλείνουν».
+Αυτή η σήμανση έχει ως σκοπό να δώσει κάποια συγκεκριμένη σημασία στο κείμενο
+που περιβάλλει. Όπως και οι περισσότερες γλώσσες υπολογιστών, η HTML έχει
+πολλές διαφορετικές εκδοχές. Εδώ θα μιλήσουμε για την HTML5.
+
+**ΣΗΜΕΙΩΣΗ :** Μπορείτε να δοκιμάσετε τις ετικέτες και τα στοιχεία που
+παρουσιάζονται εδώ σε ένα σάιτ όπως το [codepen](http://codepen.io/pen/), ούτως
+ώστε να δείτε τα αποτελέσματα που παράγουν, να καταλάβετε πώς δουλεύουν και να
+εξοικιωθείτε με την γλώσσα. Αυτό το άρθρο ασχολείται κυρίως με την σύνταξη της
+HTML και κάποιες χρήσιμες συμβουλές σχετικά με αυτήν.
+
+
+```html
+<!-- Τα σχόλια είναι περικυκλωμένα όπως αυτή η γραμμή! -->
+
+<!--
+	Τα
+    σχόλια
+	μπορούν
+	να
+	επεκταθούν
+	σε
+    πολλαπλές
+    γραμμές!
+-->
+
+<!-- #################### Οι ετικέτες #################### -->
+
+<!--Ορίστε ένα παράδειγμα αρχείου HTML, το οποίο θα αναλύσουμε. -->
+
+
+<!doctype html>
+	<html>
+		<head>
+			<title>Η σελίδα μου</title>
+		</head>
+		<body>
+			<h1>Καλημέρα, κόσμε!</h1>
+			<a href="http://codepen.io/anon/pen/xwjLbZ">
+				Δείτε τι κάνει αυτό
+			</a>
+			<p>Αυτή είναι μια παράγραφος.</p>
+			<p>Αυτή είναι μια άλλη παράγραφος.</p>
+			<ul>
+				<li>Αυτό είναι ένα αντικείμενο μέσα σε μια μη-αριθμημένη λίστα
+                (bullet list)</li>
+				<li>Αυτό είναι ένα άλλο αντικείμενο</li>
+				<li>Και αυτό είναι το τελευταίο αντικείμενο της λίστας</li>
+			</ul>
+		</body>
+	</html>
+
+<!--
+    Ένα αρχείο HTML πάντα ξεκινά υποδεικνύοντας στον περιηγητή πως η σελίδα
+    είναι γραμμένη με HTML.
+-->
+<!doctype html>
+
+<!-- Μετά από αυτό, ξεκινά ανοίγοντας μια ετικέτα <html>. -->
+<html>
+
+<!-- την οποία πρέπει να κλείσουμε στο τέλος της σελίδας γράφοντας </html>. -->
+</html>
+
+<!-- Τίποτα δεν πρέπει να βρίσκεται μετά από αυτη την τελευταία ετικέτα. -->
+
+
+<!-- Ανάμεσα από τις ετικέτες <html> και </html>, βρίσκουμε: -->
+
+<!-- Μια επικεφαλίδα ορισμένη από την ετικέτα <head> (πρέπει να την κλείσουμε
+με την ετικέτα </head>) -->
+<!--
+    Η επικεφαλίδα περιέχει κάποια περιγραφή και επιπρόσθετες πληροφορίες που δεν
+    εμφανίζονται· είναι τα λεγόμενα μεταδεδομένα (metadata).
+-->
+
+<head>
+	<!--
+        Η ετικέτα <title> υποδεικνύει στον περιηγητή τον τίτλο που πρέπει να
+        εμφανιστεί στην μπάρα τίτλου και στο όνομα της καρτέλας.
+	-->
+	<title>Η σελίδα μου</title>
+</head>
+
+<!-- Μετά την ενότητα <head>, βρίσκουμε την ετικέτα <body> -->
+<!-- Μέχρι αυτό το σημείο, τίποτα απ' όσα έχουμε περιγράψει δεν θα εμφανιστούν
+στο παράθυρο του περιηγητή. -->
+<!-- Πρέπει να συμπληρώσουμε το «σώμα» της σελίδας με το περιεχόμενο που
+θέλουμε να εμφανίζεται. -->
+
+<body>
+	<!-- Η ετικέτα h1 δημιουργεί έναν τίτλο/επικεφαλίδα. -->
+	<h1>Καλημέρα, κόσμε!</h1>
+	<!--
+		Υπάρχουν επίσης υπότιτλοι/υποκεφαλίδες, από την πιο σημαντική (h2)
+        μέχρι την πιο μικρή και ειδική (h6).
+	-->
+
+	<!-- Ένας υπερσύνδεσμος προς την διεύθυνση που δίνεται από την παράμετρο
+    href="": -->
+	<a href="http://codepen.io/anon/pen/xwjLbZ">
+		Δείτε τι κάνει αυτό
+	</a>
+
+	<!-- Η ετικέτα <p> μας επιτρέπει να εισάγουμε κείμενο στην σελίδα μας. -->
+	<p>Αυτή είναι μια παράγραφος.</p>
+	<p>Αυτή είναι μια άλλη παράγραφος.</p>
+
+	<!-- Η ετικέτα <ul> δημιουργεί μια μη-αριθμημένη λίστα. -->
+	<!--
+		Για μια αριθμημένη λίστα χρησιμοποιούμε την ετικέτα <ol>, που θα μας
+        δώσει 1. για το πρώτο στοιχείο, 2. για το δεύτερο κτλ.
+	-->
+    <ul>
+        <li>Αυτό είναι ένα αντικείμενο μέσα σε μια μη-αριθμημένη λίστα (bullet
+            list)</li>
+        <li>Αυτό είναι ένα άλλο αντικείμενο</li>
+        <li>Και αυτό είναι το τελευταίο αντικείμενο της λίστας</li>
+    </ul>
+</body>
+
+<!-- Αυτό ήταν όλο, είναι εύκολο να δημιουργήσουμε αρχεία HTML. -->
+
+<!-- Ωστόσο έχουμε την δυνατότητα να επιλέξουμε ανάμεσα σε πολλές ακόμη
+ετικέτες HTML. -->
+
+<!-- Η ετικέτα <img /> χρησιμοποιείται για να εισάγουμε μια εικόνα. -->
+<!--
+	Η πηγή της εικόνας υποδεικνύεται μέσω της παραμέτρου src="".
+	Η πηγή μπορεί να είναι μια διεύθυνση (URL) ή ακόμα και μια τοπική διεύθυνση
+    ενός αρχείου που βρίσκεται στον υπολογιστή μας.
+-->
+<img src="http://i.imgur.com/XWG0O.gif"/>
+
+<!-- Υπάρχει επίσης η δυνατότητα να δημιουργήσουμε πίνακες. -->
+
+<!-- Ανοίγουμε μια ετικέτα <table>. -->
+<table>
+
+	<!-- Η ετικέτα <tr> μας επιτρέπει να δημιουργήσουμε μια γραμμή
+    στον πίνακα. -->
+	<tr>
+
+		<!-- Η ετικέτα <th> μας επιτρέπει να δώσουμε έναν τίτλο σε μια στήλη
+        του πίνακα -->
+		<th>Πρώτος τίτλος</th>
+		<th>Δεύτερος τίτλος</th>
+	</tr>
+
+	<tr>
+
+		<!-- Η ετικέτα <td> μας επιτρέπει να δημιουργήσουμε ένα κελί μέσα στον
+        πίνακα. -->
+		<td>Πρώτη γραμμή, πρώτη στήλη</td>
+		<td>Πρώτη γραμμή, δεύτερη στήλη</td>
+	</tr>
+
+	<tr>
+        <td>Δεύτερη γραμμή, πρώτη στήλη</td>
+        <td>Δεύτερη γραμμή, δεύτερη στήλη</td>
+	</tr>
+</table>
+
+```
+
+## Χρήση
+
+Η HTML γράφεται σε αρχεία με την κατάληξη `.html` ή `.htm`. Ο τύπος MIME της
+HTML είναι
+`text/html`.
+**H HTML ΔΕΝ είναι γλώσσα προγραμματισμού.**
+## Μάθετε περισσότερα
+
+* [βικιπαίδεια](https://el.wikipedia.org/wiki/HTML)
+* [Μάθημα HTML](https://developer.mozilla.org/en-US/docs/Web/HTML)
+* [W3School](http://www.w3schools.com/html/html_intro.asp)
diff --git a/el-gr/json-gr.html.markdown b/el-gr/json-gr.html.markdown
new file mode 100644
index 00000000..6f30d819
--- /dev/null
+++ b/el-gr/json-gr.html.markdown
@@ -0,0 +1,60 @@
+---
+language: json
+filename: json-gr.html.markdown
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+  - ["himanshu", "https://github.com/himanshu81494"]
+  - ["Michael Neth", "https://github.com/infernocloud"]
+  - ["Athanasios Emmanouilidis", "https://github.com/athanasiosem"]
+translators:
+  - ["Athanasios Emmanouilidis", "https://github.com/athanasiosem"]
+lang: el-gr
+---
+
+Το JSON (JavaScript Object Notation) είναι ένα πολύ απλό και ελαφρύ μορφότυπο ανταλλαγής δεδομένων. Όπως αναφέρεται και στην ιστοσελίδα [json.org](http://json.org), το JSON διαβάζεται και γράφεται εύκολα από τους ανθρώπους όπως επίσης αναλύεται και παράγεται εύκολα από τις μηχανές.
+
+Ένα κομμάτι JSON δηλώνει ένα από τα παρακάτω:
+
+* Μια συλλογή από ζευγάρια ονομάτων/τιμών (collection of name/value pairs) (`{ }`). Σε πολλές γλώσσες προγραμματισμού αυτό αντιστοιχεί σε ένα αντικείμενo (object), μία εγγραφή (record), μία δομή (struct), ένα λεξικό (dictionary), ένα πίνακα κατακερματισμού (hash table), μια λίστα αριθμημένη με κλειδιά (keyed list) ή έναν πίνακα συσχέτισης (associative array).
+
+* Μια ταξινομημένη λίστα τιμών (`[ ]`). Σε πολλές γλώσσες προγραμματισμού αυτό αντιστοιχεί σε ένα πίνακα (array), σε ένα διάνυσμα (vector), μία λίστα (list), ή μια ακολουθία (sequence). 
+
+Αν και το JSON στην καθαρότερη του μορφή δεν έχει σχόλια (comments), οι περισσότεροι parsers θα δεχτούν σχόλια (comments) του στύλ της γλώσσας C (`//`, `/* */`). Κάποιοι parsers επίσης ανέχονται ένα εξτρά κόμμα στο τέλος (δηλαδή ένα κόμα μετά το τελευταίο στοιχείο ενός πίνακα ή μετά την τελευταία ιδιότητα ενός αντικειμένου) αλλά καλύτερα θα είναι να αποφεύγεται η χρήση του για χάρη της συμβατότητας.
+
+Υποστηριζόμενοι τύποι δεδομένων (data types):
+
+* Συμβολοσειρές (Strings): `"Γεια"`, `"\"Περικοπή.\""`, `"\u0abe"`, `"Νέα γραμμή.\n"`
+* Αριθμοί (Numbers): `23`, `0.11`, `12e10`, `3.141e-10`, `1.23e+4`
+* Αντικείμενα (Objects): `{ "κλειδί": "τιμή" }`
+* Πίνακες (Arrays): `["Τιμή1","Τιμή2","Τιμή3",]`
+* Διάφορα : `true`, `false`, `null`
+
+```json
+{
+  "κλειδί": "τιμή",
+  "κλειδιά": "πρέπει πάντα να περιβάλονται από διπλά quotes",
+  "νούμερα": 0,
+  "συμβολοσειρές": "Γεια, κόσμε. Οι χαρακτήρες unicode επιτρέπονται, καθώς και το \"escaping\".",
+  "διαδικές τιμές": true,
+  "κενό": null,
+  "μεγάλοι αριθμοί": 1.2e+100,
+  "αντικείμενα": {
+    "σχόλια": "Σήμερα έφαγα ένα μήλο.",
+    "πίνακες": [0, 1, 2, 3, "Οι πίνακες μπορούνε να περιλαμβάνουν διαφορετικούς τύπους δεδομένων", 5],
+    "αντικείμενα μέσα σε αντικείμενα": {
+      "σχόλια": "Τα αντικείμενα μπορούνε να εσωκλύουν αντικείμενα."
+    }
+  },
+  
+
+  "κενό διάστημα": "Αναγνωρίζεται χωρίς πρόβλημα αλλά καλύτερα να αποφεύγεται η χρήση του.",
+  "αυτό ήταν": "Πλέον γνωρίζετε πως μπορείτε να χρησιμοποιήσετε το JSON."
+}
+```
+
+## Περαιτέρω διάβασμα
+
+* [JSON.org](http://json.org)
+
+* [JSON Tutorial](https://www.youtube.com/watch?v=wI1CWzNtE-M)
diff --git a/elisp.html.markdown b/elisp.html.markdown
index 518ad985..f839dac0 100644
--- a/elisp.html.markdown
+++ b/elisp.html.markdown
@@ -281,7 +281,7 @@ filename: learn-emacs-lisp.el
 ;; should stop searching at some point in the buffer, and whether it
 ;; should silently fail when nothing is found:
 
-;; (search-forward "Hello" nil 't) does the trick:
+;; (search-forward "Hello" nil t) does the trick:
 
 ;; The `nil' argument says: the search is not bound to a position.
 ;; The `'t' argument says: silently fail when nothing is found.
@@ -295,7 +295,7 @@ filename: learn-emacs-lisp.el
     (mapcar 'hello list-of-names)
     (goto-char (point-min))
     ;; Replace "Hello" by "Bonjour"
-    (while (search-forward "Hello" nil 't)
+    (while (search-forward "Hello" nil t)
       (replace-match "Bonjour"))
     (other-window 1))
 
@@ -306,7 +306,7 @@ filename: learn-emacs-lisp.el
 (defun boldify-names ()
     (switch-to-buffer-other-window "*test*")
     (goto-char (point-min))
-    (while (re-search-forward "Bonjour \\(.+\\)!" nil 't)
+    (while (re-search-forward "Bonjour \\(.+\\)!" nil t)
       (add-text-properties (match-beginning 1)
                            (match-end 1)
                            (list 'face 'bold)))
diff --git a/elixir.html.markdown b/elixir.html.markdown
index a74baa38..7af29202 100644
--- a/elixir.html.markdown
+++ b/elixir.html.markdown
@@ -287,7 +287,11 @@ end
 PrivateMath.sum(1, 2)    #=> 3
 # PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
 
-# Function declarations also support guards and multiple clauses:
+# Function declarations also support guards and multiple clauses.
+# When a function with multiple clauses is called, the first function
+# that satisfies the clause will be invoked.
+# Example: invoking area({:circle, 3}) will call the second area
+# function defined below, not the first:
 defmodule Geometry do
   def area({:rectangle, w, h}) do
     w * h
@@ -448,7 +452,7 @@ Agent.update(my_agent, fn colors -> ["blue" | colors] end)
 ## References
 
 * [Getting started guide](http://elixir-lang.org/getting-started/introduction.html) from the [Elixir website](http://elixir-lang.org)
-* [Elixir Documentation](http://elixir-lang.org/docs/master/)
+* [Elixir Documentation](https://elixir-lang.org/docs.html)
 * ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) by Dave Thomas
 * [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
 * ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) by Fred Hebert
diff --git a/emacs.html.markdown b/emacs.html.markdown
new file mode 100644
index 00000000..ff4d3c03
--- /dev/null
+++ b/emacs.html.markdown
@@ -0,0 +1,320 @@
+---
+category: tool
+tool: emacs
+filename: emacs.txt
+contributors:
+    - ["Joseph Riad", "https://github.com/Joseph-Riad"]
+---
+
+Emacs started its life as ["the extensible, customizable display
+editor"](https://www.gnu.org/software/emacs/emacs-paper.html) and grew
+over the years into a full-blown ecosystem. Many tasks, usually
+relegated to a diverse set of tools can be accomplished from within
+Emacs in a consistent, familiar interface. Examples include directory
+management, viewing PDF documents, editing files over SSH, managing git
+repos,… (the list is quite long). In short, Emacs is yours to make of it
+what you will: the spectrum of users varies from those who use it to
+edit text files to extreme purists who use it to virtually replace their
+operating system.
+
+Emacs is extensible via a specialized dialect of Lisp known as Emacs
+Lisp (Elisp) which has a lot of macros geared towards editing text and
+managing text buffers. Any key (combination) you use in Emacs is bound
+to an Emacs Lisp function and may be remapped to any other function,
+including ones you write
+yourself.
+
+# Key Notation
+
+``` text
+The Emacs manual and the community in general uses a convention to refer to different key combinations used within Emacs. Specifically, Emacs has the notion of a "modifier key" that is pressed along with another key to modify its action.
+
+An example of this notation is "C-c". In this key combination "C" is the modifier and stands for the "Ctrl" key and "c" is the key whose action is being modified (the literal character "c").
+
+The modifier shorthand:
+"C-" --> The "CTRL" key
+"M-" --> The "Meta" key (usually, the "Alt" key)
+"s-" --> The "Super" key (the "Cmd" key on Macs and the "Windows" key on PCs)
+
+There are other, less commonly used modifiers that I will not get into here.
+
+The key combination "C-x C-s" means you press "Ctrl+x" followed by "Ctrl+s"
+
+In addition to the above modifiers, the special keys "Esc", "Return (Enter)" and "Shift" are denoted by "ESC", "RET" and "S", respectively.
+```
+
+# Basic Emacs Concepts
+
+Here, I discuss some basic Emacs concepts and terminology that may be
+confusing to newcomers (especially to people used to Vim terminology)
+
+  - A bunch of text that Emacs is editing is known as a **buffer**
+  - A buffer does not necessarily correspond to an actual file on disk.
+    It may be just a bunch of text in memory.
+  - When a buffer corresponds to a file on disk, we say that the buffer
+    is **visiting** that file.
+  - Emacs typically has many buffers open at once.
+  - The display of Emacs may be split into different **windows** (not to
+    be confused with your operating system's windows: the operating
+    system window for Emacs can have multiple Emacs windows inside it).
+  - An operating system window for Emacs is called an Emacs **frame**.
+    Thus, when the Emacs manual talks about opening a new frame, this
+    essentially means opening a new OS *window* containing an(other)
+    instance of Emacs.
+  - The concepts conventionally known as cutting and pasting are
+    referred to as **killing** and **yanking**, respectively in Emacs
+    parlance.
+  - The current position of the cursor is called the **point** in Emacs.
+    Technically, **point** is defined as the position right before the
+    character where the cursor currently is.
+  - Finally, each buffer may have several **modes** associated with it:
+    a **major mode** and possibly several **minor modes**.
+  - The **major mode** defines the main behavior of Emacs in the
+    currently selected buffer. This can be roughly thought of as the
+    file type. For example, if you're editing a Python file, the major
+    mode is (by default) `python-mode` which causes Emacs to highlight
+    Python syntax and automatically indent and outdent your code blocks
+    as syntactically required by your Python code.
+  - **Minor modes** define subtle changes in behavior and several minor
+    modes may be active at once in the same buffer. An example minor
+    mode is `flyspell-mode` which automatically highlights spelling
+    errors in your
+buffer.
+
+# Navigation Basics
+
+``` text
+The GUI version of Emacs can be navigated with the mouse like you would expect from a conventional GUI text editor.
+
+The aim here is to focus on navigation solely using the keyboard as this enhances productivity immensely.
+
+
+* Line movement
+
+C-n --> Next line
+C-p --> Previous line
+
+* Character movement
+
+C-f --> Go forward one character
+C-b --> Go backward one character
+
+* Word movement
+
+M-f --> Go forward one word
+M-b --> Go backward one word
+
+* Sentence movement
+
+M-a --> Move to the beginning of the sentence
+M-e --> Move to the end of the sentence
+
+* Beginning and end of line
+
+C-a --> Move to the beginning of the line
+C-e --> Move to the end of the line
+
+* Beginning and end of buffer
+
+M-< ("Meta+Shift+,") --> Go to the beginning of the buffer 
+M-> ("Meta+Shift+.") --> Go to the end of the buffer 
+
+* Screen movement
+
+C-v --> Scroll down by one screen-full (the last two lines of the previous screen are kept as overlap for a smoother transition)
+M-v --> Scroll up by one screen-full (same as above but with the first two lines)
+
+* Centering the screen
+
+C-l --> Move current line to the screen's center
+
+The above key combination actually cycles through different states depending on how many times it's been pressed.
+
+C-l --> Move current line to the screen's center
+C-l C-l --> Move current line to the top of the screen
+C-l C-l C-l --> Restore the position of the current line to where it was before the first C-l was pressed
+
+If you press "C-l" a 4th time, it cycles back to centering the current line.
+
+* Repeating movement commands
+
+Most movement commands take a numerical prefix argument that says "repeat the following command that many times".
+
+Example:
+
+C-u 3 C-p  --> Go up 3 lines
+C-u 5 C-f  --> Go forward 5 characters
+
+One notable exception are the screen scrolling commands:
+
+C-u 3 C-v  --> Scroll downward 3 lines (maintaining the position of the cursor)
+```
+
+Bonus: many of the above navigation commands are the default navigation
+commands in Bash (e.g. pressing "C-b" while entering a Bash command
+takes you back one
+character).
+
+# File editing basics
+
+``` text
+* Quitting Emacs [ Now you can't say you don't know how to quit Emacs :-) ]
+
+C-x C-c --> Quit Emacs and get prompted to save any unsaved files (buffers not visiting a file will simply be discarded unless you're running in client-server mode)
+
+* Saving a buffer
+
+C-x C-s --> Save the current buffer. If not visiting a file, it will prompt you for a file name to use to save the buffer.
+
+* Searching within a buffer
+
+C-s --> Search forwards within the buffer. Search is incremental and case-insensitive by default.
+        Press C-s to move to the next match.
+        If you press "RET", point is moved to the currently highlighted word and the search ends.
+C-r --> Same as C-s except it searches backward
+
+C-_ or C-/ --> Undo the last action. Keep pressing it to move up the undo tree.
+C-? or M-_ --> Redo the previous change
+
+The "undo" and "redo" commands can take prefix numerical arguments to undo or redo that many actions:
+
+C-u 3 C-_ --> Undo the last 3 changes.
+```
+
+# Executing Elisp Functions
+
+``` text
+You can execute any currently loaded Elisp functions (including ones you have written yourself) via "M-x"
+
+M-x RET  --> Prompts you for name of function to execute (Tab completion is available).
+
+Example:
+
+M-x RET search-forward-regexp RET --> Prompts you for a regular expression and searches forward in the buffer for it
+```
+
+# Emacs Configuration
+
+Emacs is configured using Elisp. On startup, it looks for a
+configuration file either in `~/.emacs` or `~/.emacs.d/init.el` where
+`~` refers to your home directory. If you're on Windows, consult [this
+article](https://www.gnu.org/software/emacs/manual/html_node/efaq-w32/Location-of-init-file.html)
+for the appropriate location of your configuration file.
+
+# Vim inside Emacs
+
+If you are considering the transition from Vim to Emacs and you're put
+off by the non-modal nature of Emacs editing, there is an Emacs
+extension known as `evil-mode` which lets you have many Vim concepts
+inside Emacs. Here are some things added to Emacs by `evil-mode`:
+
+  - Modal editing: you get normal, insert, visual and block visual modes
+    like Vim. In addition, you get an "Emacs" mode where movement and
+    navigation follow the Emacs bindings.
+  - Same movement keys as Vim in normal mode
+  - Leader key combinations
+  - Pressing ":" in normal mode allows you to execute commands
+    (including system commands)
+
+In my own experience, `evil-mode` helps make the transition seamless and
+allows you to blend the arguably more intuitive and ergonomic
+keybindings of Vim with the unbridled power of Emacs for a truly
+superior editing experience.
+
+# Discoverable Help
+
+Emacs features a pretty powerful help system that allows you to discover
+new functionality all the
+time.
+
+``` text
+Obtaining help on specific topics. Tab completion is available for function and variable names.
+
+C-h f RET --> Prompts you for the name of an elisp function and
+              displays help text on it along with a clickable link
+              to its source code.
+C-h v RET --> Same as above with variables  
+
+C-h k RET --> Allows you to enter a key combination and displays the
+              name of the elisp function bound to it.
+
+Searching for help:
+
+C-h a --> Prompts you for a string to search for a command in the
+          help system. Similar to the 'apropos' or 'man -k'
+          commands in Unix systems.
+
+Starting a tutorial:
+
+C-h C-t --> Starts a tutorial designed to familiarize you with
+            basic Emacs functionality.
+```
+
+# Emacs "Killer Apps"
+
+As I hinted above, Emacs functionality goes way beyond being a mere text
+editor. I will list here a couple of Emacs "apps" that are fairly
+powerful and popular and may interest you in and of themselves.
+
+## Org
+
+Technnically, `org-mode`, a major mode for buffer editing that provides
+organizational tools. It is very difficult to succinctly describe what
+Org can do because it's a behemoth of a tool that has many diverse uses
+to different people. I will attempt to describe the main features I use
+briefly.
+
+  - Divide your file into sections and sub-sections for easy outlining
+    and organizing of concepts.
+  - Different headings in the outline are foldable/expandable so that
+    you can focus on what you need to focus on and eliminate
+    distractions.
+  - You can maintain a TODO list within Org
+  - You can compile TODO lists from many files into an agenda
+  - Track the time you spend on each TODO task
+  - Manage tables in plain text (including spreadsheet-like
+    capabilities)
+  - Using the extension `org-babel`, write and execute code blocks in
+    your file. The results are captured and are re-usable within the
+    file itself. Think Jupyter notebook for any language.
+  - Display inline images and LaTeX formulas as images within your file
+    (makes for a great note-taking system and/or personal wiki)
+  - Export your file into many different formats (LaTeX, PDF, html,…)
+
+Org mode is a very powerful tool to add to your productivity arsenal
+and, on a personal note, was the reason that caused me to start using
+Emacs after years of using Vim.
+
+## Magit
+
+This is a frontend to `git` from within Emacs. It features a very
+intuitive and discoverable interface, yet exposes very powerful
+functionality that allows you to manage commits at the chunk level,
+inspect diffs, rebase, cherry-pick, … all from within the comfort of
+your own editor.
+
+# A Word of Advice
+
+If you are considering using Emacs, a common trap that beginning users
+fall into is to copy someone else's configuration file and use it as is.
+I highly recommend against doing this for several reasons:
+
+  - It will discourage you from learning and finding things out for
+    yourself
+  - Someone else's configuration will probably contain many things
+    relevant to them that you won't need or ever use.
+  - It defeats the purpose of having a customizable text editor that can
+    fit your own needs.
+
+What I encourage you to do is to look at other people's configurations
+and seek to understand them and adapt only what makes sense to you. You
+can find out about new features of Emacs through many YouTube videos,
+screencasts or blog posts and then learn for yourself how to add them to
+your configuration and workflow. This way, you grow your configuration
+incrementally while increasing your knowledge of Emacs along the way.
+
+# Additional Resources
+
+  - [The GNU Emacs Manual](https://www.gnu.org/software/emacs/manual/emacs.html)
+  - [Emacs Stack Exchange](https://emacs.stackexchange.com/)
+  - [Emacs Wiki](https://www.emacswiki.org/emacs/EmacsWiki)
diff --git a/es-es/awk-es.html.markdown b/es-es/awk-es.html.markdown
index 307ba817..8da8f024 100644
--- a/es-es/awk-es.html.markdown
+++ b/es-es/awk-es.html.markdown
@@ -1,5 +1,6 @@
 ---
-language: awk
+category: tool
+tool: awk
 filename: learnawk-es.awk
 contributors:
     - ["Marshall Mason", "http://github.com/marshallmason"]
@@ -166,7 +167,7 @@ function arithmetic_functions(a, b, c,     localvar) {
     # trigonométricas estándar
     localvar = sin(a)
     localvar = cos(a)
-    localvar = atan2(a, b) # arcotangente de b / a
+    localvar = atan2(b, a) # arcotangente de b / a
 
     # Y cosas logarítmicas
     localvar = exp(a)
diff --git a/es-es/c++-es.html.markdown b/es-es/c++-es.html.markdown
index bd1ad07c..2c3762d5 100644
--- a/es-es/c++-es.html.markdown
+++ b/es-es/c++-es.html.markdown
@@ -823,7 +823,6 @@ v.swap(vector<Foo>());
 ```
 Otras lecturas:
 
-Una referencia del lenguaje hasta a la fecha se puede encontrar en
-<http://cppreference.com/w/cpp>
-
-Recursos adicionales se pueden encontrar en <http://cplusplus.com>
+* Una referencia del lenguaje hasta a la fecha se puede encontrar en [CPP Reference](http://cppreference.com/w/cpp).
+* Recursos adicionales se pueden encontrar en [[CPlusPlus]](http://cplusplus.com).
+* Un tutorial que cubre los conceptos básicos del lenguaje y la configuración del entorno de codificación está disponible en [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FF).
diff --git a/es-es/coldfusion-es.html.markdown b/es-es/coldfusion-es.html.markdown
new file mode 100644
index 00000000..2e98f910
--- /dev/null
+++ b/es-es/coldfusion-es.html.markdown
@@ -0,0 +1,330 @@
+---
+language: coldfusion
+filename: learncoldfusion-es.cfm
+contributors:
+    - ["Wayne Boka", "http://wboka.github.io"]
+    - ["Kevin Morris", "https://twitter.com/kevinmorris"]
+translators:
+    - ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+---
+
+ColdFusion es un lenguaje de scripting para desarrollo web.
+[Lea más aquí](Http://www.adobe.com/products/coldfusion-family.html)
+
+### CFML
+_**C**old**F**usion **M**arkup **L**anguage_  
+ColdFusion comenzó como un lenguaje basado en etiquetas. Casi toda la funcionalidad está disponible usando etiquetas.
+
+```cfm
+<em>Se han proporcionado etiquetas HTML para facilitar la lectura.</em>
+
+<!--- Los comentarios comienzan con "<!---" y terminan con "--->" --->
+<!---
+    Los comentarios
+    también
+    pueden ocupar
+    multiples líneas
+--->
+
+<!--- Las etiquetas CFML tienen un formato similar a las etiquetas HTML. --->
+<h1>Variables simples</h1>
+<!--- Declaración de variables: las variables son débilmente tipadas, similar a javascript --->
+<p>Set <b>miVariable</b> to "miValor"</p>
+<cfset miVariable = "miValor" />
+<p>Set <b>miNumero</b> to 3.14</p>
+<cfset miNumero = 3.14 />
+
+<!--- Mostrando datos simples --->
+<!--- Use <cfoutput> para valores simples como cadenas, números y expresiones --->
+<p>Muestra <b>miVariable</b>: <cfoutput>#miVariable#</cfoutput></p><!--- miValor --->
+<p>Muestra <b>miNumero</b>: <cfoutput>#miNumero#</cfoutput></p><!--- 3.14 --->
+
+<hr />
+
+<h1>Variables complejas</h1>
+<!--- Declarar variables complejas. --->
+<!--- Declarar una matriz de 1 dimensión: literal o notación de corchete --->
+<p>Establecer <b>miArreglo1</b> en una matriz de 1 dimensión utilizando la notación literal o de corchete</p>
+<cfset miArreglo1 = [] />
+<!--- Declarar una matriz de 1 dimensión: notación de función --->
+<p>Establecer <b> miArreglo2 </b> en una matriz de 1 dimensión usando la notación de funciones</p>
+<cfset miArreglo2 = ArrayNew(1) />
+
+<!--- Salida de variables complejas. --->
+<p>Contenidos de <b>miArreglo1</b></p>
+<cfdump var="#miArreglo1#" /> <!--- Un objeto de matriz vacío --->
+<p>Contenidos de <b>miArreglo2</b></p>
+<cfdump var="#miArreglo2#" /> <!--- Un objeto de matriz vacío --->
+
+<!--- Los operadores --->
+<!--- Aritméticos --->
+<h1>Operadores</h1>
+<h2>Aritméticos</h2>
+<p>1 + 1 = <cfoutput>#1 + 1#</cfoutput></p>
+<p>10 - 7 = <cfoutput>#10 - 7#<br /></cfoutput></p>
+<p>15 * 10 = <cfoutput>#15 * 10#<br /></cfoutput></p>
+<p>100 / 5 = <cfoutput>#100 / 5#<br /></cfoutput></p>
+<p>120 % 5 = <cfoutput>#120 % 5#<br /></cfoutput></p>
+<p>120 mod 5 = <cfoutput>#120 mod 5#<br /></cfoutput></p>
+
+<hr />
+
+<!--- Comparación --->
+<h2>Comparación</h2>
+<h3>Notación estándar</h3>
+<p>Is 1 eq 1? <cfoutput>#1 eq 1#</cfoutput></p>
+<p>Is 15 neq 1? <cfoutput>#15 neq 1#</cfoutput></p>
+<p>Is 10 gt 8? <cfoutput>#10 gt 8#</cfoutput></p>
+<p>Is 1 lt 2? <cfoutput>#1 lt 2#</cfoutput></p>
+<p>Is 10 gte 5? <cfoutput>#10 gte 5#</cfoutput></p>
+<p>Is 1 lte 5? <cfoutput>#1 lte 5#</cfoutput></p>
+
+<h3>Notación alternativa</h3>
+<p>Is 1 == 1? <cfoutput>#1 eq 1#</cfoutput></p>
+<p>Is 15 != 1? <cfoutput>#15 neq 1#</cfoutput></p>
+<p>Is 10 > 8? <cfoutput>#10 gt 8#</cfoutput></p>
+<p>Is 1 < 2? <cfoutput>#1 lt 2#</cfoutput></p>
+<p>Is 10 >= 5? <cfoutput>#10 gte 5#</cfoutput></p>
+<p>Is 1 <= 5? <cfoutput>#1 lte 5#</cfoutput></p>
+
+<hr />
+
+<!--- Estructuras de Control --->
+<h1>Estructuras de Control</h1>
+
+<cfset miCondicion = "Prueba" />
+
+<p>Condición a probar: "<cfoutput>#miCondicion#</cfoutput>"</p>
+
+<cfif miCondicion eq "Prueba">
+    <cfoutput>#miCondicion#. Estamos probando.</cfoutput>
+<cfelseif miCondicion eq "Producción">
+    <cfoutput>#miCondicion#. Procede con cuidado!!!</cfoutput>
+<cfelse>
+    miCondicion es desconocido
+</cfif>
+
+<hr />
+
+<!--- Bucles --->
+<h1>Bucles</h1>
+<h2>Bucle For</h2>
+<cfloop from="0" to="10" index="i">
+	<p>Index equals <cfoutput>#i#</cfoutput></p>
+</cfloop>
+
+<h2>Bucle For Each (Variables complejas)</h2>
+
+<p>Establecer <b>miArreglo3</b> to [5, 15, 99, 45, 100]</p>
+
+<cfset miArreglo3 = [5, 15, 99, 45, 100] />
+
+<cfloop array="#miArreglo3#" index="i">
+	<p>Index equals <cfoutput>#i#</cfoutput></p>
+</cfloop>
+
+<p>Establecer <b>myArray4</b> to ["Alpha", "Bravo", "Charlie", "Delta", "Echo"]</p>
+
+<cfset myArray4 = ["Alpha", "Bravo", "Charlie", "Delta", "Echo"] />
+
+<cfloop array="#myArray4#" index="s">
+	<p>Index equals <cfoutput>#s#</cfoutput></p>
+</cfloop>
+
+<h2>Declaración Switch</h2>
+
+<p>Establecer <b>miArreglo5</b> to [5, 15, 99, 45, 100]</p>
+
+<cfset miArreglo5 = [5, 15, 99, 45, 100] />
+
+<cfloop array="#miArreglo5#" index="i">
+	<cfswitch expression="#i#">
+		<cfcase value="5,15,45" delimiters=",">
+			<p><cfoutput>#i#</cfoutput> es un múltiplo de 5.</p>
+		</cfcase>
+		<cfcase value="99">
+			<p><cfoutput>#i#</cfoutput> es noventa y nueve.</p>
+		</cfcase>
+		<cfdefaultcase>
+			<p><cfoutput>#i#</cfoutput> no es 5, 15, 45, or 99.</p>
+		</cfdefaultcase> 
+	</cfswitch> 
+</cfloop>
+
+<hr />
+
+<h1>Conversión de tipos</h1>
+
+<style>
+	table.table th, table.table td {
+		border: 1px solid #000000;
+		padding: 2px;
+	}
+	
+	table.table th {
+		background-color: #CCCCCC;
+	}
+</style>
+
+<table class="table" cellspacing="0">
+	<thead>
+		<tr>
+			<th>Valor</th>
+			<th>Como booleano</th>
+			<th>Como número</th>
+			<th>Como fecha</th>
+			<th>Como cadena</th>
+		</tr>
+	</thead>
+	<tbody>
+		<tr>
+			<th>"Si"</th>
+			<td>TRUE</td>
+			<td>1</td>
+			<td>Error</td>
+			<td>"Si"</td>
+		</tr>
+		<tr>
+			<th>"No"</th>
+			<td>FALSE</td>
+			<td>0</td>
+			<td>Error</td>
+			<td>"No"</td>
+		</tr>
+		<tr>
+			<th>TRUE</th>
+			<td>TRUE</td>
+			<td>1</td>
+			<td>Error</td>
+			<td>"Yes"</td>
+		</tr>
+		<tr>
+			<th>FALSE</th>
+			<td>FALSE</td>
+			<td>0</td>
+			<td>Error</td>
+			<td>"No"</td>
+		</tr>
+		<tr>
+			<th>Número</th>
+			<td>True si el número no es 0; False de lo contrario.</td>
+			<td>Número</td>
+			<td>Consulte &#34;Date-time values&#34; anteriormente en este capítulo.</td>
+			<td>Representación de cadena del número (for example, &#34;8&#34;).</td>
+		</tr>
+		<tr>
+			<th>Cadena</th>
+			<td>Si representa una fecha y hora (ver la siguiente columna), se convierte al valor numérico del objeto de fecha y hora correspondiente. <br> Si es una fecha, hora o marca de tiempo ODBC (por ejemplo, "{ts '2001-06-14 11:30:13'}", o si se expresa en un formato de fecha u hora estándar de EE. UU., incluido al usar nombres de mes completos o abreviados, se convierte al valor de fecha y hora correspondiente. <br> Los días de la semana o la puntuación inusual dan como resultado un error. <br> Generalmente se permiten guiones, barras diagonales y espacios. </td>
+			<td>Cadena</td>
+		</tr>
+		<tr>
+			<th>Fecha</th>
+			<td>Error</td>
+			<td>El valor numérico del objeto fecha-hora.</td>
+			<td>Fecha</td>
+			<td>una marca de tiempo de ODBC.</td>
+		</tr>
+	</tbody>
+</table>
+
+<hr />
+
+<h1>Componentes</h1>
+
+<em>Código de referencia (las funciones deben devolver algo para admitir IE)</em>
+```
+```cfs
+<cfcomponent>
+	<cfset this.hola = "Hola" />
+	<cfset this.mundo = "Mundo" />
+
+	<cffunction name="sayHhola">
+		<cfreturn this.hola & ", " & this.mundo & "!" />
+	</cffunction>
+	
+	<cffunction name="setHhola">
+		<cfargument name="newHola" type="string" required="true" />
+		
+		<cfset this.hola = arguments.newHola />
+		 
+		<cfreturn true />
+	</cffunction>
+	
+	<cffunction name="setMundo">
+		<cfargument name="newMundo" type="string" required="true" />
+		
+		<cfset this.mundo = arguments.newMundo />
+		 
+		<cfreturn true />
+	</cffunction>
+	
+	<cffunction name="getHola">
+		<cfreturn this.hola />
+	</cffunction>
+	
+	<cffunction name="getMundo">
+		<cfreturn this.mundo />
+	</cffunction>
+</cfcomponent>
+
+<cfset this.hola = "Hola" />
+<cfset this.mundo = "Mundo" />
+
+<cffunction name="sayHola">
+	<cfreturn this.hola & ", " & this.mundo & "!" />
+</cffunction>
+
+<cffunction name="setHola">
+	<cfargument name="newHola" type="string" required="true" />
+	
+	<cfset this.hola = arguments.newHola />
+	 
+	<cfreturn true />
+</cffunction>
+
+<cffunction name="setMundo">
+	<cfargument name="newMundo" type="string" required="true" />
+	
+	<cfset this.mundo = arguments.newMundo />
+	 
+	<cfreturn true />
+</cffunction>
+
+<cffunction name="getHola">
+	<cfreturn this.hola />
+</cffunction>
+
+<cffunction name="getMundo">
+	<cfreturn this.mundo />
+</cffunction>
+
+
+<b>sayHola()</b>
+<cfoutput><p>#sayHola()#</p></cfoutput>
+<b>getHola()</b>
+<cfoutput><p>#getHola()#</p></cfoutput>
+<b>getMundo()</b>
+<cfoutput><p>#getMundo()#</p></cfoutput>
+<b>setHola("Hola")</b>
+<cfoutput><p>#setHola("Hola")#</p></cfoutput>
+<b>setMundo("mundo")</b>
+<cfoutput><p>#setMundo("mundo")#</p></cfoutput>
+<b>sayHola()</b>
+<cfoutput><p>#sayHola()#</p></cfoutput>
+<b>getHola()</b>
+<cfoutput><p>#getHola()#</p></cfoutput>
+<b>getMundo()</b>
+<cfoutput><p>#getMundo()#</p></cfoutput>
+```
+
+### CFScript
+_**C**old**F**usion **S**cript_  
+En los últimos años, el lenguaje ColdFusion ha agregado sintaxis de script para simular la funcionalidad de etiquetas. Cuando se utiliza un servidor CF actualizado, casi todas las funciones están disponibles mediante la sintaxis de script.
+
+## Otras lecturas
+
+Los enlaces que se proporcionan a continuación son solo para comprender el tema, siéntase libre de buscar en Google y encuentrar ejemplos específicos.
+
+1. [Coldfusion Reference From Adobe](https://helpx.adobe.com/coldfusion/cfml-reference/topics.html)
+2. [Open Source Documentation](http://cfdocs.org/)
diff --git a/es-es/common-lisp-es.html.markdown b/es-es/common-lisp-es.html.markdown
new file mode 100644
index 00000000..526ea621
--- /dev/null
+++ b/es-es/common-lisp-es.html.markdown
@@ -0,0 +1,692 @@
+---
+
+language: "Common Lisp"
+filename: commonlisp-es.lisp
+contributors:
+  - ["Paul Nathan", "https://github.com/pnathan"]
+  - ["Rommel Martinez", "https://ebzzry.io"]
+translators:
+  - ["ivanchoff", "https://github.com/ivanchoff"]
+  - ["Andre Polykanine", "https://github.com/Menelion"]
+lang: es-es
+---
+
+Common Lisp es un lenguaje de proposito general y multiparadigma adecuado para una amplia variedad
+de aplicaciones en la industria. Es frecuentemente referenciado como un lenguaje de programación
+programable.
+
+EL punto de inicio clásico es [Practical Common Lisp](http://www.gigamonkeys.com/book/). Otro libro
+popular y reciente es [Land of Lisp](http://landoflisp.com/). Un nuevo libro acerca de las mejores
+prácticas, [Common Lisp Recipes](http://weitz.de/cl-recipes/), fue publicado recientemente.
+
+```lisp
+
+;;;-----------------------------------------------------------------------------
+;;; 0. Sintaxis
+;;;-----------------------------------------------------------------------------
+
+;;; Forma general
+
+;;; CL tiene dos piezas fundamentales en su sintaxis: ATOM y S-EXPRESSION.
+;;; Típicamente, S-expressions agrupadas son llamadas `forms`.
+
+10            ; un atom; se evalua a sí mismo
+:thing        ; otro atom; evaluando el símbolo :thing
+t             ; otro atom, denotando true
+(+ 1 2 3 4)   ; una s-expression
+'(4 :foo t)   ; otra s-expression
+
+
+;;; Comentarios
+
+;;; comentarios de una sola línea empiezan con punto y coma; usa cuatro para
+;;; comentarios a nivel de archivo, tres para descripciones de sesiones, dos
+;;; adentro de definiciones, y una para líneas simples. Por ejemplo,
+
+;;;; life.lisp
+
+;;; Foo bar baz, porque quu quux. Optimizado para máximo krakaboom y umph.
+;;; Requerido por la función LINULUKO.
+
+(defun sentido (vida)
+  "Retorna el sentido de la vida calculado"
+  (let ((meh "abc"))
+    ;; llama krakaboom
+    (loop :for x :across meh
+       :collect x)))                    ; guarda valores en x, luego lo retorna
+
+;;; Comentarios de bloques, por otro lado, permiten comentarios de forma libre. estos son
+;;; delimitados con #| y |#
+
+#| Este es un comentario de bloque el cual
+   puede abarcar multiples líneas y
+    #|
+       estos pueden ser anidados
+    |#
+|#
+
+
+;;; Entorno
+
+;;; Existe una variedad de implementaciones; La mayoría son conformes a los estándares. SBCL
+;;; es un buen punto de inicio. Bibliotecas de terceros pueden instalarse fácilmente con
+;;; Quicklisp
+
+;;; CL es usualmente desarrollado y un bucle de Lectura-Evaluación-Impresión (REPL), corriendo
+;;; al mismo tiempo. El REPL permite la exploración interactiva del programa mientras este esta
+;;; corriendo
+
+
+;;;-----------------------------------------------------------------------------
+;;; 1. Operadores y tipos de datos primitivos
+;;;-----------------------------------------------------------------------------
+
+;;; Símbolos
+
+'foo ; => FOO  Note que el símbolo es pasado a mayúsculas automáticamente.
+
+;;; INTERN manualmente crea un símbolo a partir de una cadena.
+
+(intern "AAAA")        ; => AAAA
+(intern "aaa")         ; => |aaa|
+
+;;; Números
+
+9999999999999999999999 ; enteros
+#b111                  ; binario=> 7
+#o111                  ; octal => 73
+#x111                  ; hexadecimal => 273
+3.14159s0              ; simple
+3.14159d0              ; double
+1/2                    ; proporciones
+#C(1 2)                ; números complejos
+
+;;; las funciones son escritas como (f x y z ...) donde f es una función y
+;;; x, y, z, ... son los argumentos.
+
+(+ 1 2)                ; => 3
+
+;;; Si deseas crear datos literales use QUOTE para prevenir que estos sean evaluados
+
+(quote (+ 1 2))        ; => (+ 1 2)
+(quote a)              ; => A
+
+;;; La notación abreviada para QUOTE es '
+
+'(+ 1 2)               ; => (+ 1 2)
+'a                     ; => A
+
+;;; Operaciones aritméticas básicas
+
+(+ 1 1)                ; => 2
+(- 8 1)                ; => 7
+(* 10 2)               ; => 20
+(expt 2 3)             ; => 8
+(mod 5 2)              ; => 1
+(/ 35 5)               ; => 7
+(/ 1 3)                ; => 1/3
+(+ #C(1 2) #C(6 -4))   ; => #C(7 -2)
+
+;;; Boleanos
+
+t                      ; true; cualquier valor non-NIL es true
+nil                    ; false; también, la lista vacia: ()
+(not nil)              ; => T
+(and 0 t)              ; => T
+(or 0 nil)             ; => 0
+
+;;; Caracteres
+
+#\A                    ; => #\A
+#\λ                    ; => #\GREEK_SMALL_LETTER_LAMDA
+#\u03BB                ; => #\GREEK_SMALL_LETTER_LAMDA
+
+;;; Cadenas son arreglos de caracteres de longitud fija
+
+"Hello, world!"
+"Benjamin \"Bugsy\" Siegel"   ; la barra invertida es un carácter de escape
+
+;;; Las cadenas pueden ser concatenadas
+
+(concatenate 'string "Hello, " "world!") ; => "Hello, world!"
+
+;;; Una cadena puede ser tratada como una secuencia de caracteres
+
+(elt "Apple" 0) ; => #\A
+
+;;; FORMAT es usado para crear salidas formateadas, va desde simple interpolación de cadenas
+;;; hasta bucles y condicionales. El primer argumento de FORMAT determina donde irá la cadena
+;;; formateada. Si este es NIL, FORMAT simplemente retorna la cadena formateada como un valor;
+;;; si es T, FORMAT imprime a la salida estándar, usualmente la pantalla, luego este retorna NIL.
+
+(format nil "~A, ~A!" "Hello" "world")   ; => "Hello, world!"
+(format t "~A, ~A!" "Hello" "world")     ; => NIL
+
+
+;;;-----------------------------------------------------------------------------
+;;; 2. Variables
+;;;-----------------------------------------------------------------------------
+
+;;; Puedes crear una variable global (ámbito dinámico) usando DEFVAR y DEFPARAMETER
+;;; el nombre de la variable puede usar cualquier carácter excepto: ()",'`;#|\
+
+;;; La diferencia entre DEFVAR y DEFPARAMETER es que reevaluando una expresión
+;;; DEFVAR no cambia el valor de la variable. DEFPARAMETER, por otro lado sí lo hace.
+
+;;; Por convención, variables de ámbito dinámico tienen "orejeras" en sus nombres.
+
+(defparameter *some-var* 5)
+*some-var* ; => 5
+
+;;; Puedes usar también caracteres unicode.
+(defparameter *AΛB* nil)
+
+;;; Accediendo a una variable sin asignar tienen como resultado el error
+;;; UNBOUND-VARIABLE, sin embargo este es el comportamiento definido. no lo hagas
+
+;;; puedes crear enlaces locales con LET. en el siguiente código, `me` es asignado 
+;;; con "dance with you" solo dentro de  (let ...). LET siempre retorna  el valor 
+;;; del último `form`.
+
+(let ((me "dance with you")) me) ; => "dance with you"
+
+
+;;;-----------------------------------------------------------------------------;
+;;; 3. Estructuras y colecciones
+;;;-----------------------------------------------------------------------------;
+
+
+;;; Estructuras
+
+(defstruct dog name breed age)
+(defparameter *rover*
+    (make-dog :name "rover"
+              :breed "collie"
+              :age 5))
+*rover*            ; => #S(DOG :NAME "rover" :BREED "collie" :AGE 5)
+(dog-p *rover*)    ; => T
+(dog-name *rover*) ; => "rover"
+
+;;; DOG-P, MAKE-DOG, y DOG-NAME son creados automáticamente por DEFSTRUCT
+
+
+;;; Pares
+
+;;; CONS crea pares. CAR y CDR retornan la cabeza y la cola de un CONS-pair
+
+(cons 'SUBJECT 'VERB)         ; => '(SUBJECT . VERB)
+(car (cons 'SUBJECT 'VERB))   ; => SUBJECT
+(cdr (cons 'SUBJECT 'VERB))   ; => VERB
+
+
+;;; Listas
+
+;;; Listas  son estructuras de datos de listas enlazadas, hechas de pares CONS y terminan con un
+;;; NIL (o '()) para marcar el final de la lista
+
+(cons 1 (cons 2 (cons 3 nil)))     ; => '(1 2 3)
+
+;;; LIST es una forma conveniente de crear listas
+
+(list 1 2 3)                       ; => '(1 2 3)
+
+;;; Cuando el primer argumento de CONS es un atom y el segundo argumento es una lista,
+;;; CONS retorna un nuevo par CONS con el primer argumento como el primer elemento y el
+;;; segundo argumento como el resto del par CONS
+
+(cons 4 '(1 2 3))                  ; => '(4 1 2 3)
+
+;;; Use APPEND para unir listas
+
+(append '(1 2) '(3 4))             ; => '(1 2 3 4)
+
+;;; o CONCATENATE
+
+(concatenate 'list '(1 2) '(3 4))  ; => '(1 2 3 4)
+
+;;; las listas son un tipo de datos centrales en CL, por lo tanto hay una gran variedad
+;;; de funcionalidades para ellas, algunos ejemplos son:
+
+(mapcar #'1+ '(1 2 3))             ; => '(2 3 4)
+(mapcar #'+ '(1 2 3) '(10 20 30))  ; => '(11 22 33)
+(remove-if-not #'evenp '(1 2 3 4)) ; => '(2 4)
+(every #'evenp '(1 2 3 4))         ; => NIL
+(some #'oddp '(1 2 3 4))           ; => T
+(butlast '(subject verb object))   ; => (SUBJECT VERB)
+
+
+;;; Vectores
+
+;;; Vectores literales son arreglos de longitud fija
+
+#(1 2 3) ; => #(1 2 3)
+
+;;; Use CONCATENATE para juntar vectores
+
+(concatenate 'vector #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6)
+
+
+;;; Arreglos
+
+;;; Vectores y cadenas son casos especiales de arreglos.
+
+;;; Arreglos bidimensionales
+
+(make-array (list 2 2))         ; => #2A((0 0) (0 0))
+(make-array '(2 2))             ; => #2A((0 0) (0 0))
+(make-array (list 2 2 2))       ; => #3A(((0 0) (0 0)) ((0 0) (0 0)))
+
+;;; Precaución: los valores iniciales por defecto de MAKE-ARRAY son implementaciones definidas
+;;; para definirlos explícitamente:
+
+(make-array '(2) :initial-element 'unset)  ; => #(UNSET UNSET)
+
+;;; Para acceder al elemento en 1, 1, 1:
+
+(aref (make-array (list 2 2 2)) 1 1 1)     ;  => 0
+
+;;; Este valor es definido por implementación:
+;;; NIL en ECL, 0 en SBCL and CCL.
+
+;;; vectores ajustables
+
+;;; los vectores ajustables tienen la misma representación en la impresión como los vectores literales
+;;; de longitud fija.
+
+(defparameter *adjvec* (make-array '(3) :initial-contents '(1 2 3)
+                                   :adjustable t :fill-pointer t))
+*adjvec* ; => #(1 2 3)
+
+;;; Agregando nuevos elementos
+
+(vector-push-extend 4 *adjvec*)   ; => 3
+*adjvec*                          ; => #(1 2 3 4)
+
+
+;;; Conjuntos, ingenuamente son listas:
+
+(set-difference '(1 2 3 4) '(4 5 6 7))   ; => (3 2 1)
+(intersection '(1 2 3 4) '(4 5 6 7))     ; => 4
+(union '(1 2 3 4) '(4 5 6 7))            ; => (3 2 1 4 5 6 7)
+(adjoin 4 '(1 2 3 4))                    ; => (1 2 3 4)
+
+;;; Sin embargo, necesitarás una mejor estructura de datos que listas enlazadas
+;;; cuando trabajes con conjuntos de datos grandes
+
+;;; Los Diccionarios son implementados como tablas hash.
+
+;;; Crear tablas hash
+
+(defparameter *m* (make-hash-table))
+
+;;; definir valor
+
+(setf (gethash 'a *m*) 1)
+
+;;; obtener valor
+
+(gethash 'a *m*) ; => 1, T
+
+;;; las expresiones en CL tienen la facultad de retornar multiples valores.
+
+(values 1 2) ; => 1, 2
+
+;;; los cuales pueden ser asignados con MULTIPLE-VALUE-BIND
+
+(multiple-value-bind (x y)
+    (values 1 2)
+  (list y x))
+
+; => '(2 1)
+
+;;; GETHASH es un ejemplo de una función que retorna multiples valores. El primer
+;;; valor es el valor de la llave en la tabla hash: si la llave no existe retorna NIL.
+
+;;; El segundo valor determina si la llave existe en la tabla hash. si la llave no existe
+;;; en la tabla hash retorna NIL. Este comportamiento permite verificar si el valor de una
+;;; llave es actualmente NIL.
+
+;;; Obteniendo un valor no existente retorna NIL
+
+(gethash 'd *m*) ;=> NIL, NIL
+
+;;; Puedes declarar un valor por defecto para las llaves inexistentes
+
+(gethash 'd *m* :not-found) ; => :NOT-FOUND
+
+;;; Vamos a manejar los multiples valores de retornno en el código.
+
+(multiple-value-bind (a b)
+    (gethash 'd *m*)
+  (list a b))
+; => (NIL NIL)
+
+(multiple-value-bind (a b)
+    (gethash 'a *m*)
+  (list a b))
+; => (1 T)
+
+
+;;;-----------------------------------------------------------------------------
+;;; 3. Funciones
+;;;-----------------------------------------------------------------------------
+
+;;; Use LAMBDA para crear funciones anónimas. las funciones siempre retornan el valor 
+;;; de la última expresión. la representación imprimible de una función varia entre
+;;; implementaciones.
+
+(lambda () "Hello World") ; => #<FUNCTION (LAMBDA ()) {1004E7818B}>
+
+;;; Use FUNCALL para llamar funciones anónimas.
+
+(funcall (lambda () "Hello World"))   ; => "Hello World"
+(funcall #'+ 1 2 3)                   ; => 6
+
+;;; Un llamado a FUNCALL es también realizado cuando la expresión lambda es el CAR de
+;;; una lista.
+
+((lambda () "Hello World"))           ; => "Hello World"
+((lambda (val) val) "Hello World")    ; => "Hello World"
+
+;;; FUNCALL es usado cuando los argumentos son conocidos de antemano. 
+;;; de lo contrario use APPLY
+
+(apply #'+ '(1 2 3))   ; => 6
+(apply (lambda () "Hello World") nil) ; => "Hello World"
+
+;;; Para nombrar una funcion use  DEFUN
+
+(defun hello-world () "Hello World")
+(hello-world) ; => "Hello World"
+
+;;; Los () en la definición anterior son la lista de argumentos
+
+(defun hello (name) (format nil "Hello, ~A" name))
+(hello "Steve") ; => "Hello, Steve"
+
+;;; las functiones pueden tener argumentos opcionales; por defecto son NIL
+
+(defun hello (name &optional from)
+  (if from
+      (format t "Hello, ~A, from ~A" name from)
+      (format t "Hello, ~A" name)))
+
+(hello "Jim" "Alpacas")       ; => Hello, Jim, from Alpacas
+
+;;; Los valores por defecto pueden ser especificados
+
+
+(defun hello (name &optional (from "The world"))
+   (format nil "Hello, ~A, from ~A" name from))
+
+(hello "Steve")               ; => Hello, Steve, from The world
+(hello "Steve" "the alpacas") ; => Hello, Steve, from the alpacas
+
+;;; Las funciones también tienen argumentos llaves para permitir argumentos no positionados
+
+(defun generalized-greeter (name &key (from "the world") (honorific "Mx"))
+  (format t "Hello, ~A ~A, from ~A" honorific name from))
+
+(generalized-greeter "Jim")
+; => Hello, Mx Jim, from the world
+
+(generalized-greeter "Jim" :from "the alpacas you met last summer" :honorific "Mr")
+; => Hello, Mr Jim, from the alpacas you met last summer
+
+
+;;;-----------------------------------------------------------------------------
+;;; 4. Igualdad
+;;;-----------------------------------------------------------------------------
+
+;;; CL tiene un sistema sofisticado de igualdad. Una parte es tratada aquí.
+
+;;; Para números use `=`
+(= 3 3.0)               ; => T
+(= 2 1)                 ; => NIL
+
+;;; Para identidad de objetos (aproximadamente) use EQL
+(eql 3 3)               ; => T
+(eql 3 3.0)             ; => NIL
+(eql (list 3) (list 3)) ; => NIL
+
+;;; para listas, cadenas y bit vectores use EQUAL
+(equal (list 'a 'b) (list 'a 'b)) ; => T
+(equal (list 'a 'b) (list 'b 'a)) ; => NIL
+
+
+;;;-----------------------------------------------------------------------------
+;;; 5. Control de flujo
+;;;-----------------------------------------------------------------------------
+
+;;; Condicionales
+
+(if t                ; testar expresión
+    "this is true"   ; then expression
+    "this is false") ; else expression
+; => "this is true"
+
+;;; En condicionales, todo valor non-NIL es tratado como true
+
+(member 'Groucho '(Harpo Groucho Zeppo)) ; => '(GROUCHO ZEPPO)
+(if (member 'Groucho '(Harpo Groucho Zeppo))
+    'yep
+    'nope)
+; => 'YEP
+
+;;; COND en cadena una serie de pruebas para seleccionar un resultado
+(cond ((> 2 2) (error "wrong!"))
+      ((< 2 2) (error "wrong again!"))
+      (t 'ok)) ; => 'OK
+
+;;; TYPECASE evalua sobre el tipo del valor
+(typecase 1
+  (string :string)
+  (integer :int))
+; => :int
+
+
+;;; Bucles
+
+;;; Recursión
+
+(defun fact (n)
+  (if (< n 2)
+      1
+    (* n (fact(- n 1)))))
+
+(fact 5) ; => 120
+
+;;; Iteración
+
+(defun fact (n)
+  (loop :for result = 1 :then (* result i)
+     :for i :from 2 :to n
+     :finally (return result)))
+
+(fact 5) ; => 120
+
+(loop :for x :across "abcd" :collect x)
+; => (#\a #\b #\c #\d)
+
+(dolist (i '(1 2 3 4))
+  (format t "~A" i))
+; => 1234
+
+
+;;;-----------------------------------------------------------------------------
+;;; 6. Mutación
+;;;-----------------------------------------------------------------------------
+
+;;; use SETF para asignar un valor nuevo a una variable existente. Esto fue demostrado
+;;; previamente en el ejemplo de la tabla hash.
+
+(let ((variable 10))
+    (setf variable 2))
+; => 2
+
+;;; Un estilo bueno de lisp es minimizar el uso de funciones destructivas y prevenir
+;;; la mutación cuando sea posible.
+
+
+;;;-----------------------------------------------------------------------------
+;;; 7. Clases y objetos
+;;;-----------------------------------------------------------------------------
+
+;;; No más clases de animales, tengamos transportes mecánicos impulsados por el humano
+
+(defclass human-powered-conveyance ()
+  ((velocity
+    :accessor velocity
+    :initarg :velocity)
+   (average-efficiency
+    :accessor average-efficiency
+   :initarg :average-efficiency))
+  (:documentation "A human powered conveyance"))
+
+;;; Los argumentos de  DEFCLASS, en orden son:
+;;; 1. nombre de la clase
+;;; 2. lista de superclases
+;;; 3. slot list
+;;; 4. Especificadores opcionales
+
+;;; cuando no hay lista de superclase, la lista vacia indica clase de 
+;;; objeto estándar, esto puede ser cambiado, pero no mientras no sepas
+;;; lo que estas haciendo. revisar el arte del protocolo de meta-objetos
+;;; para más información.
+
+(defclass bicycle (human-powered-conveyance)
+  ((wheel-size
+    :accessor wheel-size
+    :initarg :wheel-size
+    :documentation "Diameter of the wheel.")
+   (height
+    :accessor height
+    :initarg :height)))
+
+(defclass recumbent (bicycle)
+  ((chain-type
+    :accessor chain-type
+    :initarg :chain-type)))
+
+(defclass unicycle (human-powered-conveyance) nil)
+
+(defclass canoe (human-powered-conveyance)
+  ((number-of-rowers
+    :accessor number-of-rowers
+    :initarg :number-of-rowers)))
+
+;;; Invocando DESCRIBE en la clase  HUMAN-POWERED-CONVEYANCE en REPL obtenemos:
+
+(describe 'human-powered-conveyance)
+
+; COMMON-LISP-USER::HUMAN-POWERED-CONVEYANCE
+;  [symbol]
+;
+; HUMAN-POWERED-CONVEYANCE names the standard-class #<STANDARD-CLASS
+;                                                    HUMAN-POWERED-CONVEYANCE>:
+;  Documentation:
+;    A human powered conveyance
+;  Direct superclasses: STANDARD-OBJECT
+;  Direct subclasses: UNICYCLE, BICYCLE, CANOE
+;  Not yet finalized.
+;  Direct slots:
+;    VELOCITY
+;      Readers: VELOCITY
+;      Writers: (SETF VELOCITY)
+;    AVERAGE-EFFICIENCY
+;      Readers: AVERAGE-EFFICIENCY
+;      Writers: (SETF AVERAGE-EFFICIENCY)
+
+;;; Tenga en cuenta el comportamiento reflexivo disponible. CL fue diseñado
+;;; para ser un systema interactivo
+
+;;; para definir un método, encontremos la circunferencia de la rueda usando
+;;; la ecuación  C = d * pi
+
+(defmethod circumference ((object bicycle))
+  (* pi (wheel-size object)))
+
+;;; PI es definido internamente en CL
+
+;;; Supongamos que descubrimos que el valor de eficiencia del número de remeros
+;;; en una canoa es aproximadamente logarítmico. Esto probablemente debería
+;;; establecerse en el constructor / inicializador.
+
+;;; Para inicializar su instancia después de que CL termine de construirla:
+
+(defmethod initialize-instance :after ((object canoe) &rest args)
+  (setf (average-efficiency object)  (log (1+ (number-of-rowers object)))))
+
+;;; luego para construir una instancia y revisar la eficiencia promedio
+
+(average-efficiency (make-instance 'canoe :number-of-rowers 15))
+; => 2.7725887
+
+
+;;;-----------------------------------------------------------------------------
+;;; 8. Macros
+;;;-----------------------------------------------------------------------------
+
+;;; las Macros le permiten extender la sintaxis del lenguaje, CL no viene con
+;;; un bucle WHILE, por lo tanto es facil escribirlo, Si obedecemos nuestros
+;;; instintos de ensamblador, terminamos con:
+
+(defmacro while (condition &body body)
+    "While `condition` is true, `body` is executed.
+`condition` is tested prior to each execution of `body`"
+    (let ((block-name (gensym)) (done (gensym)))
+        `(tagbody
+           ,block-name
+           (unless ,condition
+               (go ,done))
+           (progn
+           ,@body)
+           (go ,block-name)
+           ,done)))
+
+;;; revisemos la versión de alto nivel para esto:
+
+(defmacro while (condition &body body)
+    "While `condition` is true, `body` is executed.
+`condition` is tested prior to each execution of `body`"
+  `(loop while ,condition
+         do
+         (progn
+            ,@body)))
+
+;;; Sin embargo, con un compilador moderno, esto no es necesario; El LOOP se 
+;;; compila igualmente bien y es más fácil de leer.
+
+;;; Tenga en cuenta que se utiliza ```, así como `,` y `@`.  ``` es un operador
+;;; de tipo de cita conocido como quasiquote; permite el uso de `,` . `,` permite
+;;; variables "entre comillas". @ interpola las listas.
+
+;;; GENSYM crea un símbolo único que garantiza que no existe en ninguna otra parte
+;;; del sistema. Esto se debe a que las macros se expanden en el momento de la compilación
+;;; y las variables declaradas en la macro pueden colisionar con las variables utilizadas
+;;; en un código regular.
+
+;;; Consulte Practical Common Lisp y On Lisp para obtener más información sobre macros.
+```
+
+
+## Otras Lecturas
+
+- [Practical Common Lisp](http://www.gigamonkeys.com/book/)
+- [Common Lisp: A Gentle Introduction to Symbolic Computation](https://www.cs.cmu.edu/~dst/LispBook/book.pdf)
+
+
+## Información extra
+
+- [CLiki](http://www.cliki.net/)
+- [common-lisp.net](https://common-lisp.net/)
+- [Awesome Common Lisp](https://github.com/CodyReichert/awesome-cl)
+- [Lisp Lang](http://lisp-lang.org/)
+
+
+## Creditos
+
+Muchas Gracias a la gente de Scheme por proveer un gran punto de inicio
+el cual puede ser movido fácilmente a Common Lisp
+
+- [Paul Khuong](https://github.com/pkhuong) para un buen repaso.
diff --git a/es-es/csharp-es.html.markdown b/es-es/csharp-es.html.markdown
index 5d730497..72a0f90c 100644
--- a/es-es/csharp-es.html.markdown
+++ b/es-es/csharp-es.html.markdown
@@ -5,7 +5,7 @@ contributors:
     - ["Irfan Charania", "https://github.com/irfancharania"]
     - ["Max Yankov", "https://github.com/golergka"]
 translators:
-    - ["Olfran Jiménez", "https://twitter.com/neslux"]	
+    - ["Olfran Jiménez", "https://twitter.com/neslux"]
 lang: es-es
 
 ---
diff --git a/es-es/dart-es.html.markdown b/es-es/dart-es.html.markdown
new file mode 100644
index 00000000..d0f57b95
--- /dev/null
+++ b/es-es/dart-es.html.markdown
@@ -0,0 +1,529 @@
+---
+language: dart
+contributors:
+    - ["Joao Pedrosa", "https://github.com/jpedrosa/"]
+translators:
+    - ["Jorge Antonio Atempa", "http://www.twitter.com/atempa09"]
+filename: dart-es.md
+lang: es-es
+---
+
+Dart es un recién llegado al ámbito de los lenguajes de programación.
+Toma prestado mucho de otros lenguajes principales, con el objetivo de no desviarse demasiado de
+su hermano JavaScript. Tal como JavaScript, Dart tiene como objetivo una gran integración en el navegador.
+
+La característica más controvertida de Dart debe ser su escritura opcional.
+
+```dart
+import "dart:collection";
+import "dart:math" as DM;
+
+// Bienvenido a Aprende Dart en 15 minutos. http://www.dartlang.org/
+// Este es un tutorial ejecutable. Puedes ejecutarlo con Dart o en
+// el sitio de ¡Try Dart! solo copiando y pegando en http://try.dartlang.org/
+
+// La declaración de función y de método tienen el mismo aspecto. 
+// Las funciones pueden estar anidadas. 
+// La declaración toma la forma name() {} o name() => expresionEnUnaLinea;
+// La declaración de la función de flecha gorda, tiene un retorno implícito 
+// para el resultado de la expresión.
+example1() {
+  nested1() {
+    nested2() => print("example1 anidado 1 anidado 2");
+    nested2();
+  }
+  nested1();
+}
+
+// Las funciones anónimas no incluyen un nombre.
+example2() {
+  nested1(fn) {
+    fn();
+  }
+  nested1(() => print("example2 anidado 1"));
+}
+
+// Cuando se declara un parámetro de función, la declaración puede incluir el
+// número de parámetros que toma la función especificando los nombres de los
+// parámetros que lleva.
+example3() {
+  planA(fn(informSomething)) {
+    fn("example3 plan A");
+  }
+  planB(fn) { // O no declarar el número de parámetros.
+    fn("example3 plan B");
+  }
+  planA((s) => print(s));
+  planB((s) => print(s));
+}
+
+// Las funciones tienen acceso de cierre a variables externas.
+var example4Something = "Example4 anidado 1";
+example4() {
+  nested1(fn(informSomething)) {
+    fn(example4Something);
+  }
+  nested1((s) => print(s));
+}
+
+// La declaración de la clase con un método sayIt, el cual también tiene acceso de cierre
+// a la variable exterior como si fuera una función como se ha visto antes.
+var example5method = "example5 sayIt";
+class Example5Class {
+  sayIt() {
+    print(example5method);
+  }
+}
+example5() {
+  // Crear una instancia anónima de Example5Class y la llamada del método sayIt
+  new Example5Class().sayIt();
+}
+
+// La declaración de clase toma la forma NombreDeClase { [cuerpoDeClase] }.
+// Donde cuerpoDeClase puede incluir métodos de instancia y variables, pero también
+// métodos y variables de clase.
+class Example6Class {
+  var instanceVariable = "Example6 variable de instancia";
+  sayIt() {
+    print(instanceVariable);
+  }
+}
+example6() {
+  new Example6Class().sayIt();
+}
+
+// Los métodos y variables de clase son declarados con términos "static".
+class Example7Class {
+  static var classVariable = "Example7 variable de clase";
+  static sayItFromClass() {
+    print(classVariable);
+  }
+  sayItFromInstance() {
+    print(classVariable);
+  }
+}
+example7() {
+  Example7Class.sayItFromClass();
+  new Example7Class().sayItFromInstance();
+}
+
+// Las literales son geniales, pero hay una restricción para lo que pueden ser las literales
+// fuera de los cuerpos de función/método. Literales en el ámbito exterior de clase
+// o fuera de clase tienen que ser constantes. Las cadenas de caracteres y los números
+// son constantes por defecto. Pero los arreglos y mapas no lo son. 
+// Ellos pueden hacerse constante anteponiendo en la declaración el término "const".
+var example8Array = const ["Example8 arreglo constante"],
+    example8Map = const {"algunaKey": "Example8 mapa constante"};
+example8() {
+  print(example8Array[0]);
+  print(example8Map["algunaKey"]);
+}
+
+// Los bucles en Dart toman la forma estándar para for () {} o ciclos while () {} ,
+// ligeramente más moderno for (.. in ..) {}, o llamadas funcionales con muchas
+// características soportadas, comenzando con forEach.
+var example9Array = const ["a", "b"];
+example9() {
+  for (var i = 0; i < example9Array.length; i++) {
+    print("example9 ciclo for '${example9Array[i]}'");
+  }
+  var i = 0;
+  while (i < example9Array.length) {
+    print("example9 ciclo while '${example9Array[i]}'");
+    i++;
+  }
+  for (var e in example9Array) {
+    print("example9 ciclo for-in '${e}'");
+  }
+  example9Array.forEach((e) => print("example9 ciclo forEach '${e}'"));
+}
+
+// Para recorrer los caracteres de una cadena o para extraer una subcadena.
+var example10String = "ab";
+example10() {
+  for (var i = 0; i < example10String.length; i++) {
+    print("example10 Recorrido de caracteres en la cadena '${example10String[i]}'");
+  }
+  for (var i = 0; i < example10String.length; i++) {
+    print("example10 ciclo de subcadena '${example10String.substring(i, i + 1)}'");
+  }
+}
+
+// Formato de números Int y double son soportados.
+example11() {
+  var i = 1 + 320, d = 3.2 + 0.01;
+  print("example11 int ${i}");
+  print("example11 double ${d}");
+}
+
+// DateTime ofrece aritmética de fecha/hora.
+example12() {
+  var now = new DateTime.now();
+  print("example12 ahora '${now}'");
+  now = now.add(new Duration(days: 1));
+  print("example12 manana '${now}'");
+}
+
+// Expresiones regulares son soportadas.
+example13() {
+  var s1 = "alguna cadena", s2 = "alguna", re = new RegExp("^s.+?g\$");
+  match(s) {
+    if (re.hasMatch(s)) {
+      print("example13 regexp embona '${s}'");
+    } else {
+      print("example13 regexp no embona '${s}'");
+    }
+  }
+  match(s1);
+  match(s2);
+}
+
+// Las expresiones booleanas admiten conversiones implícitas y tipos dinámicos. 
+example14() {
+  var a = true;
+  if (a) {
+    print("true, a is $a");
+  }
+  a = null;
+  if (a) {
+    print("true, a es $a");
+  } else {
+    print("false, a es $a"); // corre aquí
+  }
+
+  // el tipado dinámico null puede convertirse a bool
+  var b; // b es de tipo dinámico
+  b = "abc";
+  try {
+    if (b) {
+      print("true, b es $b");
+    } else {
+      print("false, b es $b");
+    }
+  } catch (e) {
+    print("error, b es $b"); // esto podría ser ejecutado pero consiguió error
+  }
+  b = null;
+  if (b) {
+    print("true, b es $b");
+  } else {
+    print("false, b es $b"); // corre aquí
+  }
+
+  // tipado estático null no puede ser convertido a bool
+  var c = "abc";
+  c = null;
+  // compilación fallida
+  // if (c) {
+  //   print("true, c is $c");
+  // } else {
+  //   print("false, c is $c");
+  // }
+}
+
+// try/catch/finally y throw son utilizados para el manejo de excepciones.
+// throw toma cualquier objeto como parámetro;
+example15() {
+  try {
+    try {
+      throw "Algun error inesperado.";
+    } catch (e) {
+      print("example15 una excepcion: '${e}'");
+      throw e; // Re-throw
+    }
+  } catch (e) {
+    print("example15 atrapa la excepcion que ha sido relanzada: '${e}'");
+  } finally {
+    print("example15 aún ejecuta finally");
+  }
+}
+
+// Para ser eficiente cuando creas una cadena larga dinámicamente, usa
+// StringBuffer. O podrías unir un arreglo de cadena de caracteres.
+example16() {
+  var sb = new StringBuffer(), a = ["a", "b", "c", "d"], e;
+  for (e in a) { sb.write(e); }
+  print("example16 cadena de caracteres dinamica creada con "
+    "StringBuffer '${sb.toString()}'");
+  print("example16 union de arreglo de cadena de caracteres '${a.join()}'");
+}
+
+// Las cadenas de caracteres pueden ser concatenadas contando solo 
+// con literales una después de la otra sin algún otro operador necesario.
+example17() {
+  print("example17 "
+      "concatenar "
+      "cadenas "
+      "asi");
+}
+
+// Las cadenas de caracteres utilizan comilla simple o comillas dobles como delimitadores
+// sin ninguna diferencia entre ambas. Esto proporciona flexibilidad que puede ser efectiva
+// para evitar la necesidad de 'escapar' el contenido. Por ejemplo,
+// las dobles comillas de los atributos HTML.
+example18() {
+  print('Example18 <a href="etc">'
+      "Don't can't I'm Etc"
+      '</a>');
+}
+
+// Las cadenas de caracteres con triple comilla simple o triple comillas dobles
+// dividen múltiples lineas e incluyen como delimitador el salto de línea.
+example19() {
+  print('''Example19 <a href="etc">
+Example19 Don't can't I'm Etc
+Example19 </a>''');
+}
+
+// Las cadenas de caracteres cuentan con una extraordinaria característica
+// para la interpolación de caracteres utilizando el operador $
+// Con $ { [expresion] }, devolvemos la expresion interpolada.
+// $ seguido por el nombre de una variable interpola el contenido de dicha variable.
+// $ puede ser escapado con \$ para solo agregarlo a la cadena.
+example20() {
+  var s1 = "'\${s}'", s2 = "'\$s'";
+  print("Example20 \$ interpolation ${s1} or $s2 works.");
+}
+
+// Hasta ahora no hemos declarado ningún tipo de dato y los programas
+// han funcionado bien. De hecho, los tipos no se toman en cuenta durante 
+// el tiempo de ejecución.
+// Los tipos incluso pueden estar equivocados y al programa todavía se le dará 
+// el beneficio de la duda y se ejecutará como si los tipos no importaran.
+// Hay un parámetro de tiempo de ejecución que comprueba los errores de tipo que es
+// el modo de verificación, el cuál es útil durante el tiempo de desarrollo,
+// pero que también es más lento debido a la comprobación adicional y, por lo tanto
+// se evita durante el tiempo de ejecución de la implementación.
+class Example21 {
+  List<String> _names;
+  Example21() {
+    _names = ["a", "b"];
+  }
+  List<String> get names => _names;
+  set names(List<String> list) {
+    _names = list;
+  }
+  int get length => _names.length;
+  void add(String name) {
+    _names.add(name);
+  }
+}
+void example21() {
+  Example21 o = new Example21();
+  o.add("c");
+  print("example21 nombres '${o.names}' y longitud '${o.length}'");
+  o.names = ["d", "e"];
+  print("example21 nombres '${o.names}' y longitud '${o.length}'");
+}
+
+// La herencia de clases toma la forma NombreDeClase extends OtraClase {}.
+class Example22A {
+  var _name = "¡Algun Nombre!";
+  get name => _name;
+}
+class Example22B extends Example22A {}
+example22() {
+  var o = new Example22B();
+  print("example22 herencia de clase '${o.name}'");
+}
+
+// La mezcla de clases también esta disponible y toman la forma de
+// NombreDeClase extends AlgunaClase with OtraClase {}.
+// Es necesario extender de alguna clase para poder mezclar con otra.
+// La clase de plantilla de mixin no puede en este momento tener un constructor.
+// Mixin se utiliza principalmente para compartir métodos con clases distantes,
+// por lo que la herencia única no interfiere con el código reutilizable.
+// Mixins se colocan despues de la palabra "with" durante la declaración de la clase.
+class Example23A {}
+class Example23Utils {
+  addTwo(n1, n2) {
+    return n1 + n2;
+  }
+}
+class Example23B extends Example23A with Example23Utils {
+  addThree(n1, n2, n3) {
+    return addTwo(n1, n2) + n3;
+  }
+}
+example23() {
+  var o = new Example23B(), r1 = o.addThree(1, 2, 3),
+    r2 = o.addTwo(1, 2);
+  print("Example23 addThree(1, 2, 3) results in '${r1}'");
+  print("Example23 addTwo(1, 2) results in '${r2}'");
+}
+
+// El método constructor de la clase utiliza el mismo nombre de la clase
+// y toma la forma de AlgunaClase() : super() {}, donde la parte ": super()"
+// es opcional y es utilizado para delegar parametros constantes
+// al método constructor de la clase padre o super clase.
+class Example24A {
+  var _value;
+  Example24A({value: "algunValor"}) {
+    _value = value;
+  }
+  get value => _value;
+}
+class Example24B extends Example24A {
+  Example24B({value: "algunOtroValor"}) : super(value: value);
+}
+example24() {
+  var o1 = new Example24B(),
+    o2 = new Example24B(value: "aunMas");
+  print("example24 llama al método super desde el constructor '${o1.value}'");
+  print("example24 llama al método super desde el constructor '${o2.value}'");
+}
+
+// Hay un atajo para configurar los parámetros del constructor en el caso de clases más simples.
+// Simplemente use el prefijo this.nombreParametro y establecerá el parámetro 
+// en una variable de instancia del mismo nombre.
+class Example25 {
+  var value, anotherValue;
+  Example25({this.value, this.anotherValue});
+}
+example25() {
+  var o = new Example25(value: "a", anotherValue: "b");
+  print("example25 atajo para el constructor '${o.value}' y "
+    "'${o.anotherValue}'");
+}
+
+// Los parámetros con nombre están disponibles cuando se declaran entre {}.
+// El orden de los parámetros puede ser opcional cuando se declara entre {}.
+// Los parámetros pueden hacerse opcionales cuando se declaran entre [].
+example26() {
+  var _name, _surname, _email;
+  setConfig1({name, surname}) {
+    _name = name;
+    _surname = surname;
+  }
+  setConfig2(name, [surname, email]) {
+    _name = name;
+    _surname = surname;
+    _email = email;
+  }
+  setConfig1(surname: "Doe", name: "John");
+  print("example26 name '${_name}', surname '${_surname}', "
+    "email '${_email}'");
+  setConfig2("Mary", "Jane");
+  print("example26 name '${_name}', surname '${_surname}', "
+  "email '${_email}'");
+}
+
+// Las variables declaradas con final solo se pueden establecer una vez.
+// En el caso de las clases, las variables de instancia final se pueden establecer 
+// a través de la constante del parámetro constructor.
+class Example27 {
+  final color1, color2;
+  // Un poco de flexibilidad para establecer variables de instancia finales con la sintaxis
+  // que sigue a :
+  Example27({this.color1, color2}) : color2 = color2;
+}
+example27() {
+  final color = "orange", o = new Example27(color1: "lilac", color2: "white");
+  print("example27 color es '${color}'");
+  print("example27 color es '${o.color1}' y '${o.color2}'");
+}
+
+// Para importar una librería utiliza la palabra reservada import "rutaLibrería" o si es una biblioteca central,
+// import "dart:NombreLibrería". También está el "pub" administrador de paquetes con
+// su propia convensión import "package:NombrePaquete".
+// Ve import "dart:collection"; al inicio. Las importaciones deben venir antes
+// de la delcaración de algún otro código. IterableBase proviene de dart:collection.
+class Example28 extends IterableBase {
+  var names;
+  Example28() {
+    names = ["a", "b"];
+  }
+  get iterator => names.iterator;
+}
+example28() {
+  var o = new Example28();
+  o.forEach((name) => print("example28 '${name}'"));
+}
+
+// Para el control de flujo tenemos:
+// * estandard switch
+// * if-else if-else y el operador ternario ..?..:..
+// * closures y funciones anonimas
+// * sentencias break, continue y return
+example29() {
+  var v = true ? 30 : 60;
+  switch (v) {
+    case 30:
+      print("example29 sentencia switch");
+      break;
+  }
+  if (v < 30) {
+  } else if (v > 30) {
+  } else {
+    print("example29 sentencia if-else");
+  }
+  callItForMe(fn()) {
+    return fn();
+  }
+  rand() {
+    v = new DM.Random().nextInt(50);
+    return v;
+  }
+  while (true) {
+    print("example29 callItForMe(rand) '${callItForMe(rand)}'");
+    if (v != 30) {
+      break;
+    } else {
+      continue;
+    }
+    // Nunca llega aquí.
+  }
+}
+
+// La sentencia int.parse, convierte de tipo double a int, o simplemente mantener int cuando se dividen los números
+// utilizando ~/ como operación. Vamos a jugar un juego de adivinanzas también.
+example30() {
+  var gn, tooHigh = false,
+    n, n2 = (2.0).toInt(), top = int.parse("123") ~/ n2, bottom = 0;
+  top = top ~/ 6;
+  gn = new DM.Random().nextInt(top + 1); // +1 porque nextInt top es exclusivo
+  print("example30 Adivina un número entre 0 y ${top}");
+  guessNumber(i) {
+    if (n == gn) {
+      print("example30 ¡Adivinaste correctamente! El número es ${gn}");
+    } else {
+      tooHigh = n > gn;
+      print("example30 Número ${n} es demasiado "
+        "${tooHigh ? 'high' : 'low'}. Intenta nuevamente");
+    }
+    return n == gn;
+  }
+  n = (top - bottom) ~/ 2;
+  while (!guessNumber(n)) {
+    if (tooHigh) {
+      top = n - 1;
+    } else {
+      bottom = n + 1;
+    }
+    n = bottom + ((top - bottom) ~/ 2);
+  }
+}
+
+// Los programas tienen un solo punto de entrada en la función principal.
+// No se espera que se ejecute nada en el ámbito externo antes de que un programa
+// comience a funcionar con su función principal.
+// Esto ayuda con una carga más rápida e incluso con una carga lenta 
+// de lo que necesita el programa para iniciar.
+main() {
+  print("Learn Dart in 15 minutes!");
+  [example1, example2, example3, example4, example5, example6, example7,
+    example8, example9, example10, example11, example12, example13, example14,
+    example15, example16, example17, example18, example19, example20,
+    example21, example22, example23, example24, example25, example26,
+    example27, example28, example29, example30
+    ].forEach((ef) => ef());
+}
+
+```
+
+## Lecturas adicionales
+
+Dart tiene un sitio web muy completo. Cubre referencias de API, tutoriales, artículos y más, incluyendo una
+útil sección en línea Try Dart.
+[https://www.dartlang.org](https://www.dartlang.org)
+[https://try.dartlang.org](https://try.dartlang.org)
diff --git a/es-es/erlang-es.html.markdown b/es-es/erlang-es.html.markdown
new file mode 100644
index 00000000..bc6317a5
--- /dev/null
+++ b/es-es/erlang-es.html.markdown
@@ -0,0 +1,293 @@
+---
+language: erlang
+lang: es-es
+contributors:
+    - ["Giovanni Cappellotto", "http://www.focustheweb.com/"]
+translators:
+  - ["Ernesto Pelayo", "http://github.com/ErnestoPelayo"]
+filename: learnerlang-es.erl
+---
+
+# Erlang
+%  Signo de porcentaje inicia un comentario de una línea.
+
+%% Se usarán dos por ciento de caracteres para comentar funciones.
+
+%%% Se usarán tres por ciento de caracteres para comentar los módulos.
+
+### Utilizamos tres tipos de puntuación en Erlang.
+
++ **Comas (`,`)**  argumentos separados en llamadas a funciones, constructores de
+datos y patrones.
+
++ **Periodos (`.`)** (seguido de espacios en blanco) separa funciones completas y
+expresiones en el shell.
+
++  **Semicolons (`;`)** cláusulas separadas. Encontramos cláusulas en varios contextos: de definiciones de funciones y en **`case`**,**` if`**, **`try..catch`**, y **` receive`** de expresiones.
+
+ ## 1.-Variables y coincidencia de patrones.
+
+
+- En Erlang, las nuevas variables están vinculadas con una instrucción **`=`**.
+>**Num = 42.**
+
+- Todos los nombres de variables deben comenzar con una letra mayúscula.
+
+- Erlang tiene variables de asignación única; si intentas asignar un diferente de valor a la variable **`Num`**, obtendrá un error.
+Num = 43. **error de excepción**: no coincide con el valor del lado derecho 43
+
+- En la mayoría de los idiomas, **`=`** denota una declaración de asignación. En Erlang, sin embargo,**`=`** denota una operación de coincidencia de patrones.
+
+- Cuando se usa una variable vacía en el del lado izquierdo del operador `=` to está vinculado (asignado), pero cuando está atado variable se usa en el lado izquierdo, se observa el siguiente comportamiento.
+>**`Lhs = Rhs`** realmente significa esto: evaluar el lado derecho (**` Rhs`**),  y luego coincide con el resultado contra el patrón en el lado izquierdo (**`Lhs`**).
+>**Num = 7 * 6.**
+
+- Número de punto flotante.
+Pi = 3.14159.
+
+- Los átomos se usan para representar diferentes valores constantes no numéricos.
+
+- Átomos comienza con letras minúsculas, seguido de una secuencia de caracteres
+
+- alfanuméricos de caracteres o el signo de subrayado (**`_`**) o en (**` @ `**).
+>**Hola = hola.**
+  **OtherNode = ejemplo @ nodo.**
+
+- Los átomos con valores no alfanuméricos se pueden escribir al encerrar los átomos con apóstrofes.
+>**AtomWithSpace = 'algún átomo con espacio'.**
+
++ Tuples son similares a las estructuras en C.
+>**Point = {point, 10, 45}.**
+
+- Si queremos extraer algunos valores de una tupla, usamos el patrón de coincidencia
+ operador **`=`**.
+> **{punto, X, Y} = Punto. % X = 10, Y = 45**
+
+- Podemos usar **`_`** como marcador de posición para variables que no nos interesan.
+
+- El símbolo **`_`** se llama una variable anónima. A diferencia de las variables  regulares,varias apariciones de `_` en el mismo patrón no tienen que vincularse a mismo valor.
+>**Person = {person, {name, {first, joe}, {last, armstrong}}, {footsize, 42}}.**
+**{_, {_, {_, who }, _}, _} = Persona. % Who = joe**
+
++ Creamos una lista al encerrar los elementos de la lista entre corchetes y separándolos con comas.
+
++ Los elementos individuales de una lista pueden ser de cualquier tipo.
+
+- El primer elemento de una lista es el encabezado de la lista. Si te imaginas eliminar del encabezado de la lista, lo que queda se llama cola de la lista.
+>**ThingsToBuy = [{manzanas, 10}, {peras, 6}, {leche, 3}].**
+
+- Si `T` es una lista, entonces **` [H | T] `** también es una lista, con la cabeza **` H`** y la cola **`T`**.
+
++ La barra vertical (**`|`**) separa el encabezado de una lista de su cola.
+  **`[]`** es la lista vacía.
+
++ Podemos extraer elementos de una lista con una operación de coincidencia de
+  patrones. Si nosotros tiene una lista no vacía **`L`**, luego la expresión **` [X | Y] = L`**, donde **`X`** y **` Y`** son variables independientes, extraerán el encabezado de la lista en **`X`** y la cola de la lista en **`Y`**.
+>**[FirstThing | OtherThingsToBuy] = ThingsToBuy.**
+**FirstThing = {manzanas, 10}**
+**OtherThingsToBuy = [{peras, 6}, {leche, 3}]**
+
++ No hay cadenas en Erlang. Las cadenas son realmente solo listas de enteros.
+
++ Las cadenas están entre comillas dobles (**`" `**).
+>**Nombre = "Hola".
+[72, 101, 108, 108, 111] = "Hola".**
+
+##  2. Programación secuencial.
+
+
+- Los módulos son la unidad básica de código en Erlang. Todas las funciones que escribimos son almacenado en módulos.
+
+- Los módulos se almacenan en archivos con extensiones **`.erl`**.
+- Los módulos deben compilarse antes de poder ejecutar el código. Un módulo compilado tiene el extensión **`.beam`**.
+>**-módulo (geometría).
+-export ([area / 1]).  de la lista de funciones exportadas desde el módulo.**
+
++ La función **`área`** consta de dos cláusulas. Las cláusulas están separadas por un punto y coma, y ​​la cláusula final termina con punto-espacio en blanco. Cada cláusula tiene una cabeza y un cuerpo; la cabeza consiste en un nombre de función seguido de un patrón (entre paréntesis), y el cuerpo consiste en una secuencia de expresiones, que se evalúan si el patrón en la cabeza es exitoso coincide con los argumentos de llamada. Los patrones se combinan en el orden aparecen en la definición de la función.
+>**área ({rectángulo, ancho, Ht}) -> ancho * Ht;
+área ({círculo, R}) -> 3.14159 * R * R** .
+
+ ### Compila el código en el archivo geometry.erl.
+c (geometría).  {ok, geometría}
+
++ Necesitamos incluir el nombre del módulo junto con el nombre de la función para identifica exactamente qué función queremos llamar.
+>**geometría: área ({rectángulo, 10, 5}). % 50**
+**geometría: área ({círculo, 1.4}). % 6.15752**
+
++ En Erlang, dos funciones con el mismo nombre y arity diferente (número de argumentos) en el mismo módulo representan funciones completamente diferentes.
+>-**module (lib_misc)**.
+-**export ([sum / 1])**.  
+
+- función de exportación **`suma`** de arity 1  acepta un argumento:
+>**lista de enteros.
+suma (L) -> suma (L, 0).
+suma ([], N) -> N;
+suma ([H | T], N) -> suma (T, H + N).**
++ Funs son funciones **"anónimas"**. Se llaman así porque tienen sin nombre. Sin embargo, pueden asignarse a variables.
+Doble = diversión (X) -> 2 * X final.  **`Doble`** apunta a una función anónima con el controlador: **#Fun <erl_eval.6.17052888>
+Doble (2). % 4**
+
+- Functions acepta funs como sus argumentos y puede devolver funs.
+>**Mult = diversión (Times) -> (fun (X) -> X * Times end) end.
+Triple = Mult (3).
+Triple (5). % 15**
+
+- Las listas de comprensión son expresiones que crean listas sin tener que usar
+ funs, mapas o filtros.
+ - La notación **`[F (X) || X <- L] `** significa" la lista de **`F (X)`** donde se toma **`X`**% de la lista **`L`."**
+>**L = [1,2,3,4,5].
+[2 * X || X <- L]. % [2,4,6,8,10]**
+
+- Una lista de comprensión puede tener generadores y filtros, que seleccionan un subconjunto de los valores generados
+>**EvenNumbers = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4]**
+
+- Los protectores son construcciones que podemos usar para aumentar el poder del patrón coincidencia. Usando guardias, podemos realizar pruebas simples y comparaciones en el de variables en un patrón.
+Puede usar guardias en la cabeza de las definiciones de funciones donde están introducido por la palabra clave **`when`**, o puede usarlos en cualquier lugar del lenguaje donde se permite una expresión.
+>**max (X, Y) cuando X> Y -> X;
+max (X, Y) -> Y.**
+
+- Un guardia es una serie de expresiones de guardia, separadas por comas (**`,`**).
+- La guardia **`GuardExpr1, GuardExpr2, ..., GuardExprN`** es verdadera si todos los guardias expresiones **`GuardExpr1`,` GuardExpr2`, ..., `GuardExprN`** evalúan **`true`**.
+>**is_cat (A) cuando is_atom (A), A =: = cat -> true;
+is_cat (A) -> false.
+is_dog (A) cuando is_atom (A), A =: = dog -> true;
+is_dog (A) -> false.**
+
+No nos detendremos en el operador **`=: =`** aquí; Solo tenga en cuenta que está acostumbrado a comprueba si dos expresiones de Erlang tienen el mismo valor * y * del mismo tipo. Contrasta este comportamiento con el del operador **`==`**:
+
+>**1 + 2 =: = 3.% true
+1 + 2 =: = 3.0. % false
+1 + 2 == 3.0. % true**
+
+ Una secuencia de guardia es una guardia individual o una serie de guardias, separadas por punto y coma (**`;`**). La secuencia de guardia **`G1; G2; ...; Gn`** es verdadero si en menos uno de los guardias **`G1`,` G2`, ..., `Gn`** se evalúa como **` true`**.
+>**is_pet (A) cuando is_atom (A), (A =: = dog); (A =: = cat) -> true;
+is_pet (A) -> false.**
+
+- **Advertencia**: no todas las expresiones de Erlang válidas se pueden usar como expresiones de guarda; en particular, nuestras funciones **`is_cat`** y **`is_dog`** no se pueden usar dentro del secuencia de protección en la definición de **`is_pet`**. Para una descripción de expresiones permitidas en secuencias de guarda, consulte la sección específica en el manual de referencia de Erlang:
+### http://erlang.org/doc/reference_manual/expressions.html#guards
+
+- Los registros proporcionan un método para asociar un nombre con un elemento particular en un de tupla De las definiciones de registros se pueden incluir en los archivos de código fuente de Erlang o poner en archivos con la extensión **`.hrl`**, que luego están incluidos en el código fuente de Erlang de archivos.
+
+>**-record (todo, {
+  status = recordatorio,% valor predeterminado
+  quien = joe,
+  texto
+}).**
+
+- Tenemos que leer las definiciones de registro en el shell antes de que podamos definir un
+ de registro. Usamos la función shell **`rr`** (abreviatura de los registros de lectura) para hacer esto.
+
+>**rr ("records.hrl").** % [que hacer]
+
+- **Creando y actualizando registros:**
+>**X = #todo {}.
+% #todo {status = recordatorio, who = joe, text = undefined}
+X1 = #todo {estado = urgente, texto = "Corregir errata en el libro"}.
+% #todo {status = urgent, who = joe, text = "Corregir errata en el libro"}
+X2 = X1 # todo {estado = hecho}.
+% #todo {status = done, who = joe, text = "Corregir errata en el libro"}
+expresiones `case`**.
+
+**`filter`** devuelve una lista de todos los elementos **` X`** en una lista **`L`** para la cual **` P (X) `** es true.
+>**filter(P, [H|T]) ->
+  case P(H) of
+    true -> [H|filter(P, T)];
+    false -> filter(P, T)
+  end;
+filter(P, []) -> [].
+filter(fun(X) -> X rem 2 == 0 end, [1, 2, 3, 4]). % [2, 4]**
+
+expresiones **`if`**.
+>**max(X, Y) ->
+  if
+    X > Y -> X;
+    X < Y -> Y;
+    true -> nil
+  end.**
+
+**Advertencia:** al menos uno de los guardias en la expresión **`if`** debe evaluar a **`true`**; de lo contrario, se generará una excepción.
+
+## 3. Excepciones.
+
+
+- El sistema genera excepciones cuando se encuentran errores internos o explícitamente en el código llamando **`throw (Exception)`**, **`exit (Exception)`**, o **`erlang: error (Exception)`**.
+>**generate_exception (1) -> a;
+generate_exception (2) -> throw (a);
+generate_exception (3) -> exit (a);
+generate_exception (4) -> {'EXIT', a};
+generate_exception (5) -> erlang: error (a).**
+
+- Erlang tiene dos métodos para atrapar una excepción. Una es encerrar la llamada a de la función que genera la excepción dentro de una expresión **`try ... catch`**.
+>**receptor (N) ->
+  prueba generar_excepción (N) de
+    Val -> {N, normal, Val}
+  captura
+    throw: X -> {N, atrapado, arrojado, X};
+    exit: X -> {N, atrapado, salido, X};
+    error: X -> {N, atrapado, error, X}
+  end.**
+
+- El otro es encerrar la llamada en una expresión **`catch`**. Cuando atrapas un de excepción, se convierte en una tupla que describe el error.
+>**catcher (N) -> catch generate_exception (N).**
+
+## 4. Concurrencia
+
+- Erlang se basa en el modelo de actor para concurrencia. Todo lo que necesitamos para escribir de programas simultáneos en Erlang son tres primitivos: procesos de desove, de envío de mensajes y recepción de mensajes.
+
+- Para comenzar un nuevo proceso, usamos la función **`spawn`**, que toma una función como argumento.
+
+>**F = diversión () -> 2 + 2 final. % #Fun <erl_eval.20.67289768>
+spawn (F). % <0.44.0>**
+
+- **`spawn`** devuelve un pid (identificador de proceso); puedes usar este pid para enviar de mensajes al proceso. Para pasar mensajes, usamos el operador **`!`**.
+
+- Para que todo esto sea útil, debemos poder recibir mensajes. Esto es logrado con el mecanismo **`receive`**:
+
+>**-module (calcular Geometría).
+-compile (export_all).
+calculateArea () ->
+    recibir
+      {rectángulo, W, H} ->
+        W * H;
+      {circle, R} ->
+        3.14 * R * R;
+      _ ->
+        io: format ("Solo podemos calcular el área de rectángulos o círculos")
+    end.**
+
+- Compile el módulo y cree un proceso que evalúe **`calculateArea`** en cáscara.
+>**c (calcular Geometría).
+CalculateArea = spawn (calcular Geometría, calcular Área, []).
+CalculateArea! {círculo, 2}. % 12.56000000000000049738**
+
+- El shell también es un proceso; puedes usar **`self`** para obtener el pid actual.
+**self(). % <0.41.0>**
+
+## 5. Prueba con EUnit
+
+- Las pruebas unitarias se pueden escribir utilizando los generadores de prueba de EUnits y afirmar macros
+>**-módulo (fib).
+-export ([fib / 1]).
+-include_lib ("eunit / include / eunit.hrl").**
+
+>**fib (0) -> 1;
+fib (1) -> 1;
+fib (N) when N> 1 -> fib (N-1) + fib (N-2).**
+
+>**fib_test_ () ->
+    [? _assert (fib (0) =: = 1),
+     ? _assert (fib (1) =: = 1),
+     ? _assert (fib (2) =: = 2),
+     ? _assert (fib (3) =: = 3),
+     ? _assert (fib (4) =: = 5),
+     ? _assert (fib (5) =: = 8),
+     ? _assertException (error, function_clause, fib (-1)),
+     ? _assert (fib (31) =: = 2178309)
+    ]**
+
+- EUnit exportará automáticamente a una función de prueba () para permitir la ejecución de las pruebas en el shell Erlang
+fib: test ()
+
+- La popular barra de herramientas de construcción de Erlang también es compatible con EUnit
+**`` ` de la unidad de barras de refuerzo
+ ``**
diff --git a/es-es/fsharp-es.html.markdown b/es-es/fsharp-es.html.markdown
new file mode 100644
index 00000000..b7f80c44
--- /dev/null
+++ b/es-es/fsharp-es.html.markdown
@@ -0,0 +1,629 @@
+---
+language: F#
+lang: es-es
+contributors:
+  - ['Scott Wlaschin', 'http://fsharpforfunandprofit.com/']
+translators:
+  - ['Angel Arciniega', 'https://github.com/AngelsProjects']
+filename: learnfsharp-es.fs
+---
+
+F# es un lenguaje de programación funcional y orientado a objetos. Es gratis y su código fuente está abierto. Se ejecuta en Linux, Mac, Windows y más.
+
+Tiene un poderoso sistema de tipado que atrapa muchos errores de tiempo de compilación, pero usa inferencias de tipados que le permiten ser leídos como un lenguaje dinámico.
+
+La sintaxis de F# es diferente de los lenguajes que heredan de C.
+
+- Las llaves no se usan para delimitar bloques de código. En cambio, se usa sangría (como en Python).
+- Los espacios se usan para separar parámetros en lugar de comas.
+
+Si quiere probar el siguiente código, puede ir a [tryfsharp.org](http://www.tryfsharp.org/Create) y pegarlo en [REPL](https://es.wikipedia.org/wiki/REPL).
+
+```fsharp
+// Los comentarios de una línea se escibren con una doble diagonal
+(* Los comentarios multilínea usan parentesis (* . . . *)
+
+-final del comentario multilínea- *)
+
+// ================================================
+// Syntaxis básica
+// ================================================
+
+// ------ "Variables" (pero no realmente) ------
+// La palabra reservada "let" define un valor (inmutable)
+let miEntero = 5
+let miFlotante = 3.14
+let miCadena = "hola"           // Tenga en cuenta que no es necesario ningún tipado
+
+// ------ Listas ------
+let dosACinco = [2;3;4;5]        // Los corchetes crean una lista con
+                                 // punto y coma para delimitadores.
+let unoACinco = 1 :: dosACinco   // :: Crea una lista con un nuevo elemento
+// El resultado es [1;2;3;4;5]
+let ceroACinco = [0;1] @ dosACinco   // @ Concatena dos listas
+
+// IMPORTANTE: las comas no se usan para delimitar,
+// solo punto y coma !
+
+// ------ Funciones ------
+// La palabra reservada "let" también define el nombre de una función.
+let cuadrado x = x * x          // Tenga en cuenta que no se usa paréntesis.
+cuadrado 3                      // Ahora, ejecutemos la función.
+                              // De nuevo, sin paréntesis.
+
+let agregar x y = x + y           // ¡No use add (x, y)! Eso significa
+                              // algo completamente diferente.
+agregar 2 3                       // Ahora, ejecutemos la función.
+
+// Para definir una función en varias líneas, usemos la sangría.
+// Los puntos y coma no son necesarios.
+let pares lista =
+   let esPar x = x%2 = 0     // Establece "esPar" como una función anidada
+   List.filter esPar lista    // List.filter es una función de la biblioteca
+                              // dos parámetros: una función que devuelve un
+                              // booleano y una lista en la que trabajar
+
+pares unoACinco               // Ahora, ejecutemos la función.
+
+// Puedes usar paréntesis para aclarar.
+// En este ejemplo, "map" se ejecuta primero, con dos argumentos,
+// entonces "sum" se ejecuta en el resultado.
+// Sin los paréntesis, "List.map" se pasará como argumento a List.sum.
+let sumaDeCuadradosHasta100 =
+   List.sum ( List.map cuadrado [1..100] )
+
+// Puedes redirigir la salida de una función a otra con "|>"
+// Redirigir datos es muy común en F#, como con los pipes de UNIX.
+
+// Aquí está la misma función sumOfSquares escrita usando pipes
+let sumaDeCuadradosHasta100piped =
+   [1..100] |> List.map cuadrado |> List.sum  // "cuadrado" se declara antes
+
+// Puede definir lambdas (funciones anónimas) gracias a la palabra clave "fun"
+let sumaDeCuadradosHasta100ConFuncion =
+   [1..100] |> List.map (fun x -> x*x) |> List.sum
+
+// En F#, no hay palabra clave "return". Una función siempre regresa
+// el valor de la última expresión utilizada.
+
+// ------ Coincidencia de patrones ------
+// Match..with .. es una sobrecarga de la condición de case/ switch.
+let coincidenciaDePatronSimple =
+   let x = "a"
+   match x with
+    | "a" -> printfn "x es a"
+    | "b" -> printfn "x es b"
+    | _ -> printfn "x es algo mas"   // guion bajo corresponde con todos los demás
+
+// F# no permite valores nulos por defecto - debe usar el tipado de Option
+// y luego coincide con el patrón.
+// Some(..) y None son aproximadamente análogos a los envoltorios Nullable
+let valorValido = Some(99)
+let valorInvalido = None
+
+// En este ejemplo, match..with encuentra una coincidencia con "Some" y "None",
+// y muestra el valor de "Some" al mismo tiempo.
+let coincidenciaDePatronDeOpciones entrada =
+   match entrada with
+    | Some i -> printfn "la entrada es un int=%d" i
+    | None -> printfn "entrada faltante"
+
+coincidenciaDePatronDeOpciones validValue
+coincidenciaDePatronDeOpciones invalidValue
+
+// ------ Viendo ------
+// Las funciones printf/printfn son similares a las funciones
+// Console.Write/WriteLine de C#.
+printfn "Imprimiendo un int %i, a float %f, a bool %b" 1 2.0 true
+printfn "Un string %s, y algo generico %A" "hola" [1;2;3;4]
+
+// También hay funciones printf/sprintfn para formatear datos
+// en cadena. Es similar al String.Format de C#.
+
+// ================================================
+// Mas sobre funciones
+// ================================================
+
+// F# es un verdadero lenguaje funcional - las funciones son
+// entidades de primer nivel y se pueden combinar fácilmente
+// para crear construcciones poderosas
+
+// Los módulos se utilizan para agrupar funciones juntas.
+// Se requiere sangría para cada módulo anidado.
+module EjemploDeFuncion =
+
+    // define una función de suma simple
+    let agregar x y = x + y
+
+    // uso básico de una función
+    let a = agregar 1 2
+    printfn "1+2 = %i" a
+
+    // aplicación parcial para "hornear en" los parámetros (?)
+    let agregar42 = agregar 42
+    let b = agregar42 1
+    printfn "42+1 = %i" b
+
+    // composición para combinar funciones
+    let agregar1 = agregar 1
+    let agregar2 = agregar 2
+    let agregar3 = agregar1 >> agregar2
+    let c = agregar3 7
+    printfn "3+7 = %i" c
+
+    // funciones de primer nivel
+    [1..10] |> List.map agregar3 |> printfn "la nueva lista es %A"
+
+    // listas de funciones y más
+    let agregar6 = [agregar1; agregar2; agregar3] |> List.reduce (>>)
+    let d = agregar6 7
+    printfn "1+2+3+7 = %i" d
+
+// ================================================
+// Lista de colecciones
+// ================================================
+
+// Il y a trois types de collection ordonnée :
+// * Les listes sont les collections immutables les plus basiques
+// * Les tableaux sont mutables et plus efficients
+// * Les séquences sont lazy et infinies (e.g. un enumerator)
+//
+// Des autres collections incluent des maps immutables et des sets
+// plus toutes les collections de .NET
+
+module EjemplosDeLista =
+
+    // las listas utilizan corchetes
+    let lista1 = ["a";"b"]
+    let lista2 = "c" :: lista1    // :: para una adición al principio
+    let lista3 = lista1 @ lista2   // @ para la concatenación
+
+    // Lista de comprensión (alias generadores)
+    let cuadrados = [for i in 1..10 do yield i*i]
+
+    //  Generador de números primos
+    let rec tamiz = function
+        | (p::xs) -> p :: tamiz [ for x in xs do if x % p > 0 then yield x ]
+        | []      -> []
+    let primos = tamiz [2..50]
+    printfn "%A" primos
+
+    // coincidencia de patrones para listas
+    let listaDeCoincidencias unaLista =
+        match unaLista with
+        | [] -> printfn "la lista esta vacia"
+        | [primero] -> printfn "la lista tiene un elemento %A " primero
+        | [primero; segundo] -> printfn "la lista es %A y %A" primero segundo
+        | _ -> printfn "la lista tiene mas de dos elementos"
+
+    listaDeCoincidencias [1;2;3;4]
+    listaDeCoincidencias [1;2]
+    listaDeCoincidencias [1]
+    listaDeCoincidencias []
+
+    // Récursion en utilisant les listes
+    let rec suma unaLista =
+        match unaLista with
+        | [] -> 0
+        | x::xs -> x + suma xs
+    suma [1..10]
+
+    // -----------------------------------------
+    // Funciones de la biblioteca estándar
+    // -----------------------------------------
+
+    // mapeo
+    let agregar3 x = x + 3
+    [1..10] |> List.map agregar3
+
+    // filtrado
+    let par x = x % 2 = 0
+    [1..10] |> List.filter par
+
+    // mucho más - consulte la documentación
+
+module EjemploDeArreglo =
+
+    // los arreglos usan corchetes con barras.
+    let arreglo1 = [| "a";"b" |]
+    let primero = arreglo1.[0]        // se accede al índice usando un punto
+
+    // la coincidencia de patrones de los arreglos es la misma que la de las listas
+    let coincidenciaDeArreglos una Lista =
+        match unaLista with
+        | [| |] -> printfn "la matriz esta vacia"
+        | [| primero |] -> printfn "el arreglo tiene un elemento %A " primero
+        | [| primero; second |] -> printfn "el arreglo es %A y %A" primero segundo
+        | _ -> printfn "el arreglo tiene mas de dos elementos"
+
+    coincidenciaDeArreglos [| 1;2;3;4 |]
+
+    // La biblioteca estándar funciona como listas
+    [| 1..10 |]
+    |> Array.map (fun i -> i+3)
+    |> Array.filter (fun i -> i%2 = 0)
+    |> Array.iter (printfn "el valor es %i. ")
+
+module EjemploDeSecuencia =
+
+    // Las secuencias usan llaves
+    let secuencia1 = seq { yield "a"; yield "b" }
+
+    // Las secuencias pueden usar yield y
+    // puede contener subsecuencias
+    let extranio = seq {
+        // "yield" agrega un elemento
+        yield 1; yield 2;
+
+        // "yield!" agrega una subsecuencia completa
+        yield! [5..10]
+        yield! seq {
+            for i in 1..10 do
+              if i%2 = 0 then yield i }}
+    // prueba
+    extranio |> Seq.toList
+
+    // Las secuencias se pueden crear usando "unfold"
+    // Esta es la secuencia de fibonacci
+    let fib = Seq.unfold (fun (fst,snd) ->
+        Some(fst + snd, (snd, fst + snd))) (0,1)
+
+    // prueba
+    let fib10 = fib |> Seq.take 10 |> Seq.toList
+    printf "Los primeros 10 fib son %A" fib10
+
+// ================================================
+// Tipos de datos
+// ================================================
+
+module EejemploDeTipoDeDatos =
+
+    // Todos los datos son inmutables por defecto
+
+     // las tuplas son tipos anónimos simples y rápidos
+     // - Usamos una coma para crear una tupla
+    let dosTuplas = 1,2
+    let tresTuplas = "a",2,true
+
+    // Combinación de patrones para desempaquetar
+    let x,y = dosTuplas  // asignado x=1 y=2
+
+    // ------------------------------------
+    // Los tipos de registro tienen campos con nombre
+    // ------------------------------------
+
+    // Usamos "type" con llaves para definir un tipo de registro
+    type Persona = {Nombre:string; Apellido:string}
+
+    // Usamos "let" con llaves para crear un registro
+    let persona1 = {Nombre="John"; Apellido="Doe"}
+
+    // Combinación de patrones para desempaquetar
+    let {Nombre=nombre} = persona1    // asignado nombre="john"
+
+    // ------------------------------------
+    // Los tipos de unión (o variantes) tienen un conjunto de elección
+     // Solo un caso puede ser válido a la vez.
+    // ------------------------------------
+
+    // Usamos "type" con barra/pipe para definir una unión estándar
+    type Temp =
+        | GradosC of float
+        | GradosF of float
+
+    // Una de estas opciones se usa para crear una
+    let temp1 = GradosF 98.6
+    let temp2 = GradosC 37.0
+
+    // Coincidencia de patrón en todos los casos para desempaquetar (?)
+    let imprimirTemp = function
+       | GradosC t -> printfn "%f gradC" t
+       | GradosF t -> printfn "%f gradF" t
+
+    imprimirTemp temp1
+    imprimirTemp temp2
+
+    // ------------------------------------
+    // Tipos recursivos
+    // ------------------------------------
+
+    // Los tipos se pueden combinar recursivamente de formas complejas
+    // sin tener que crear subclases
+    type Empleado =
+      | Trabajador of Persona
+      | Gerente of Empleado lista
+
+    let jdoe = {Nombre="John";Apellido="Doe"}
+    let trabajador = Trabajador jdoe
+
+    // ------------------------------------
+    // Modelado con tipados (?)
+    // ------------------------------------
+
+    // Los tipos de unión son excelentes para modelar el estado sin usar banderas (?)
+    type DireccionDeCorreo =
+        | DireccionDeCorreoValido of string
+        | DireccionDeCorreoInvalido of string
+
+    let intentarEnviarCorreo correoElectronico =
+        match correoElectronico with // uso de patrones de coincidencia
+        | DireccionDeCorreoValido direccion -> ()   // enviar
+        | DireccionDeCorreoInvalido direccion -> () // no enviar
+
+    // Combinar juntos, los tipos de unión y tipos de registro
+     // ofrece una base excelente para el diseño impulsado por el dominio.
+     // Puedes crear cientos de pequeños tipos que reflejarán fielmente
+     // el dominio.
+
+    type ArticuloDelCarrito = { CodigoDelProducto: string; Cantidad: int }
+    type Pago = Pago of float
+    type DatosActivosDelCarrito = { ArticulosSinPagar: ArticuloDelCarrito lista }
+    type DatosPagadosDelCarrito = { ArticulosPagados: ArticuloDelCarrito lista; Pago: Pago}
+
+    type CarritoDeCompras =
+        | CarritoVacio  // sin datos
+        | CarritoActivo of DatosActivosDelCarrito
+        | CarritoPagado of DatosPagadosDelCarrito
+
+    // ------------------------------------
+    // Comportamiento nativo de los tipos
+    // ------------------------------------
+
+    // Los tipos nativos tienen el comportamiento más útil "listo para usar", sin ningún código para agregar.
+     // * Inmutabilidad
+     // * Bonita depuración de impresión
+     // * Igualdad y comparación
+     // * Serialización
+
+     // La impresión bonita se usa con %A
+    printfn "dosTuplas=%A,\nPersona=%A,\nTemp=%A,\nEmpleado=%A"
+             dosTuplas persona1 temp1 trabajador
+
+    // La igualdad y la comparación son innatas
+     // Aquí hay un ejemplo con tarjetas.
+    type JuegoDeCartas = Trebol | Diamante | Espada | Corazon
+    type Rango = Dos | Tres | Cuatro | Cinco | Seis | Siete | Ocho
+                | Nueve | Diez | Jack | Reina | Rey | As
+
+    let mano = [ Trebol,As; Corazon,Tres; Corazon,As;
+                 Espada,Jack; Diamante,Dos; Diamante,As ]
+
+    // orden
+    List.sort mano |> printfn "la mano ordenada es (de menos a mayor) %A"
+    List.max mano |> printfn "la carta más alta es%A"
+    List.min mano |> printfn "la carta más baja es %A"
+
+// ================================================
+// Patrones activos
+// ================================================
+
+module EjemplosDePatronesActivos =
+
+    // F# tiene un tipo particular de coincidencia de patrón llamado "patrones activos"
+    // donde el patrón puede ser analizado o detectado dinámicamente.
+
+    // "clips de banana" es la sintaxis de los patrones activos
+
+    // por ejemplo, definimos un patrón "activo" para que coincida con los tipos de "caracteres" ...
+    let (|Digito|Latra|EspacioEnBlanco|Otros|) ch =
+       if System.Char.IsDigit(ch) then Digito
+       else if System.Char.IsLetter(ch) then Letra
+       else if System.Char.IsWhiteSpace(ch) then EspacioEnBlanco
+       else Otros
+
+    // ... y luego lo usamos para hacer que la lógica de análisis sea más clara
+    let ImprimirCaracter ch =
+      match ch with
+      | Digito -> printfn "%c es un Digito" ch
+      | Letra -> printfn "%c es una Letra" ch
+      | Whitespace -> printfn "%c es un Espacio en blanco" ch
+      | _ -> printfn "%c es algo mas" ch
+
+    // ver una lista
+    ['a';'b';'1';' ';'-';'c'] |> List.iter ImprimirCaracter
+
+    // -----------------------------------------
+    // FizzBuzz usando patrones activos
+    // -----------------------------------------
+
+    // Puede crear un patrón de coincidencia parcial también
+    // Solo usamos un guión bajo en la definición y devolvemos Some si coincide.
+    let (|MultDe3|_|) i = if i % 3 = 0 then Some MultDe3 else None
+    let (|MultDe5|_|) i = if i % 5 = 0 then Some MultDe5 else None
+
+    // la función principal
+    let fizzBuzz i =
+      match i with
+      | MultDe3 & MultDe5 -> printf "FizzBuzz, "
+      | MultDe3 -> printf "Fizz, "
+      | MultDe5 -> printf "Buzz, "
+      | _ -> printf "%i, " i
+
+    // prueba
+    [1..20] |> List.iter fizzBuzz
+
+// ================================================
+// concisión
+// ================================================
+
+module EjemploDeAlgoritmo =
+
+    // F# tiene una alta relación señal / ruido, lo que permite leer el código
+    // casi como un algoritmo real
+
+    // ------ Ejemplo: definir una función sumaDeCuadrados ------
+    let sumaDeCuadrados n =
+       [1..n]                   // 1) Tome todos los números del 1 al n
+       |> List.map cuadrado     // 2) Elevar cada uno de ellos al cuadrado
+       |> List.sum              // 3) Realiza su suma
+
+    // prueba
+    sumaDeCuadrados 100 |> printfn "Suma de cuadrados = %A"
+
+    // ------ Ejemplo: definir una función de ordenación ------
+    let rec ordenar lista =
+       match lista with
+       // Si la lista está vacía
+       | [] ->
+            []                              // devolvemos una lista vacía
+       // si la lista no está vacía
+       | primerElemento::otrosElementos ->  // tomamos el primer elemento
+            let elementosMasPequenios =     // extraemos los elementos más pequeños
+                otrosElementos              // tomamos el resto
+                |> List.filter (fun e -> e < primerElemento)
+                |> ordenar                  // y los ordenamos
+            let elementosMasGrandes =       // extraemos el mas grande
+                otrosElementos              // de los que permanecen
+                |> List.filter (fun e -> e >= primerElemento)
+                |> ordenar                  // y los ordenamos
+            // Combinamos las 3 piezas en una nueva lista que devolvemos
+            List.concat [elementosMasPequenios; [primerElemento]; elementosMasGrandes]
+
+    // prueba
+    ordenar [1;5;23;18;9;1;3] |> printfn "Ordenado = %A"
+
+// ================================================
+// Código asíncrono
+// ================================================
+
+module AsyncExample =
+
+    // F# incluye características para ayudar con el código asíncrono
+    // sin conocer la "pirámide del destino"
+    //
+    // El siguiente ejemplo descarga una secuencia de página web en paralelo.
+
+    open System.Net
+    open System
+    open System.IO
+    open Microsoft.FSharp.Control.CommonExtensions
+
+    // Recuperar el contenido de una URL de forma asincrónica
+    let extraerUrlAsync url =
+        async {   // La palabra clave "async" y llaves
+                  // crear un objeto "asincrónico"
+            let solicitud = WebRequest.Create(Uri(url))
+            use! respuesta = solicitud.AsyncGetResponse()
+                // use! es una tarea asincrónica
+            use flujoDeDatos = resp.GetResponseStream()
+                // "use" dispara automáticamente la funcion close()
+                // en los recursos al final de las llaves
+            use lector = new IO.StreamReader(flujoDeDatos)
+            let html = lector.ReadToEnd()
+            printfn "terminó la descarga %s" url
+            }
+
+    // una lista de sitios para informar
+    let sitios = ["http://www.bing.com";
+                 "http://www.google.com";
+                 "http://www.microsoft.com";
+                 "http://www.amazon.com";
+                 "http://www.yahoo.com"]
+
+    // ¡Aqui vamos!
+    sitios
+    |> List.map extraerUrlAsync // crear una lista de tareas asíncrona
+    |> Async.Parallel           // decirle a las tareas que se desarrollan en paralelo
+    |> Async.RunSynchronously   // ¡Empieza!
+
+// ================================================
+// Compatibilidad .NET
+// ================================================
+
+module EjemploCompatibilidadNet =
+
+    // F# puede hacer casi cualquier cosa que C# pueda hacer, y se ajusta
+    // perfectamente con bibliotecas .NET o Mono.
+
+    // ------- Trabaja con las funciones de las bibliotecas existentes  -------
+
+    let (i1success,i1) = System.Int32.TryParse("123");
+    if i1success then printfn "convertido como %i" i1 else printfn "conversion fallida"
+
+    // ------- Implementar interfaces sobre la marcha! -------
+
+    // Crea un nuevo objeto que implemente IDisposable
+    let crearRecurso name =
+       { new System.IDisposable
+         with member this.Dispose() = printfn "%s creado" name }
+
+    let utilizarYDisponerDeRecursos =
+        use r1 = crearRecurso "primer recurso"
+        printfn "usando primer recurso"
+        for i in [1..3] do
+            let nombreDelRecurso = sprintf "\tinner resource %d" i
+            use temp = crearRecurso nombreDelRecurso
+            printfn "\thacer algo con %s" nombreDelRecurso
+        use r2 = crearRecurso "segundo recurso"
+        printfn "usando segundo recurso"
+        printfn "hecho."
+
+    // ------- Código orientado a objetos -------
+
+    // F# es también un verdadero lenguaje OO.
+    // Admite clases, herencia, métodos virtuales, etc.
+
+    // interfaz de tipo genérico
+    type IEnumerator<'a> =
+        abstract member Actual : 'a
+        abstract MoverSiguiente : unit -> bool
+
+    // Clase base abstracta con métodos virtuales
+    [<AbstractClass>]
+    type Figura() =
+        // propiedades de solo lectura
+        abstract member Ancho : int with get
+        abstract member Alto : int with get
+        // método no virtual
+        member this.AreaDelimitadora = this.Alto * this.Ancho
+        // método virtual con implementación de la clase base
+        abstract member Imprimir : unit -> unit
+        default this.Imprimir () = printfn "Soy una Figura"
+
+    // clase concreta que hereda de su clase base y sobrecarga
+    type Rectangulo(x:int, y:int) =
+        inherit Figura()
+        override this.Ancho = x
+        override this.Alto = y
+        override this.Imprimir ()  = printfn "Soy un Rectangulo"
+
+    // prueba
+    let r = Rectangulo(2,3)
+    printfn "La anchura es %i" r.Ancho
+    printfn "El area es %i" r.AreaDelimitadora
+    r.Imprimir()
+
+    // ------- extensión de método  -------
+
+    // Al igual que en C#, F# puede extender las clases existentes con extensiones de método.
+    type System.String with
+       member this.EmpiezaConA = this.EmpiezaCon "A"
+
+    // prueba
+    let s = "Alice"
+    printfn "'%s' empieza con una 'A' = %A" s s.EmpiezaConA
+
+    // ------- eventos -------
+
+    type MiBoton() =
+        let eventoClick = new Event<_>()
+
+        [<CLIEvent>]
+        member this.AlHacerClick = eventoClick.Publish
+
+        member this.PruebaEvento(arg) =
+            eventoClick.Trigger(this, arg)
+
+    // prueba
+    let miBoton = new MiBoton()
+    miBoton.AlHacerClick.Add(fun (sender, arg) ->
+            printfn "Haga clic en el evento con arg=%O" arg)
+
+    miBoton.PruebaEvento("Hola Mundo!")
+```
+
+## Más información
+
+Para más demostraciones de F#, visite el sitio [Try F#](http://www.tryfsharp.org/Learn), o sigue la serie [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/).
+
+Aprenda más sobre F# en [fsharp.org](http://fsharp.org/).
diff --git a/es-es/kotlin-es.html.markdown b/es-es/kotlin-es.html.markdown
index 045f92d1..80d7a4bb 100644
--- a/es-es/kotlin-es.html.markdown
+++ b/es-es/kotlin-es.html.markdown
@@ -2,6 +2,7 @@
 language: kotlin
 contributors:
 - ["S Webber", "https://github.com/s-webber"]
+- ["Aitor Escolar", "https://github.com/aiescola"]
 translators:
 - ["Ivan Alburquerque", "https://github.com/AlburIvan"]
 lang: es-es
@@ -40,6 +41,12 @@ fun main(args: Array<String>) {
     Podemos declarar explícitamente el tipo de una variable así:
     */
     val foo: Int = 7
+    
+    /* 
+    A diferencia de JavaScript, aunque el tipo se infiera, es tipado, por lo que no se puede cambiar el tipo a posteriori
+    */
+    var fooInt = 14 // Se infiere tipo Int
+    fooInt = "Cadena" // ERROR en tiempo de compilación: Type mismatch
 
     /*
     Las cadenas pueden ser representadas de la misma manera que Java.
@@ -84,7 +91,6 @@ fun main(args: Array<String>) {
     println(fooNullable?.length) // => null
     println(fooNullable?.length ?: -1) // => -1
 
-
     /*
     Las funciones pueden ser declaras usando la palabra clave "fun".
     Los argumentos de las funciones son especificados entre corchetes despues del nombre de la función.
@@ -122,6 +128,40 @@ fun main(args: Array<String>) {
     fun even(x: Int) = x % 2 == 0
     println(even(6)) // => true
     println(even(7)) // => false
+    
+    /* 
+    Kotlin permite el uso de lambdas, o funciones anónimas
+    */
+    
+    // Sin lambda:
+    interface MyListener {
+        fun onClick(foo: Foo)
+    }
+
+    fun listenSomething(listener: MyListener) {
+        listener.onClick(Foo())
+    }
+    
+    listenSomething(object: MyListener {
+        override fun onClick(foo: Foo) {
+            //...
+        }
+    })
+    
+    // Con lambda:
+    fun listenSomethingLambda(listener: (Foo) -> Unit) {
+        listener(Foo())
+    }
+    
+    listenSomethingLambda {
+        //Se recibe foo
+    }
+    
+    // el operador typealias permite, entre otras cosas, simplificar las expresiones con lambdas
+    typealias MyLambdaListener = (Foo) -> Unit
+    fun listenSomethingLambda(listener: MyLambdaListener) {
+        listener(Foo())
+    }
 
     // Las funciones pueden tomar funciones como argumentos y 
     // retornar funciones.
@@ -219,6 +259,11 @@ fun main(args: Array<String>) {
     val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
     // Se puede acceder a los valores del mapa por su llave.
     println(fooMap["a"]) // => 8
+    
+    // Tanto Map como cualquier colección iterable, tienen la función de extensión forEach
+    fooMap.forEach {
+        println("${it.key} ${it.value}")
+    }
 
     /*
     Las secuencias representan colecciones evaluadas diferidamente.
@@ -245,7 +290,7 @@ fun main(args: Array<String>) {
     val y = fibonacciSequence().take(10).toList()
     println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
 
-    // Kotlin provee funciones de Orden-Mayor para trabajar con colecciones.
+    // Kotlin provee funciones de orden superior para trabajar con colecciones.
     val z = (1..9).map {it * 3}
             .filter {it < 20}
             .groupBy {it % 2 == 0}
@@ -305,17 +350,11 @@ fun main(args: Array<String>) {
     ese tipo sin convertido de forma explícita.
      */
     fun smartCastExample(x: Any) : Boolean {
-        if (x is Boolean) {
-            // x es automaticamente convertido a Boolean
-            return x
-        } else if (x is Int) {
-            // x es automaticamente convertido a Int
-            return x > 0
-        } else if (x is String) {
-            // x  es automaticamente convertido a String
-            return x.isNotEmpty()
-        } else {
-            return false
+        return when (x) {
+            is Boolean -> x // x es automaticamente convertido a Boolean
+            is Int -> x > 0 // x es automaticamente convertido a Int
+            is String -> x.isNotEmpty() // x  es automaticamente convertido a String
+            else -> false
         }
     }
     println(smartCastExample("Hola, mundo!")) // => true
@@ -345,7 +384,8 @@ enum class EnumExample {
 /*
 La palabra clave "object" se puede utilizar para crear objetos únicos.
 No podemos asignarlo a una variable, pero podemos hacer referencia a ella por su nombre.
-Esto es similar a los objetos únicos de Scala
+Esto es similar a los objetos únicos de Scala.
+En la mayoría de ocasiones, los objetos únicos se usan como alternativa a los Singleton.
 */
 object ObjectExample {
     fun hello() : String {
diff --git a/es-es/lambda-calculus-es.html.markdown b/es-es/lambda-calculus-es.html.markdown
new file mode 100644
index 00000000..d49545c2
--- /dev/null
+++ b/es-es/lambda-calculus-es.html.markdown
@@ -0,0 +1,216 @@
+---
+category: Algorithms & Data Structures
+name: Lambda Calculus
+contributors:
+    - ["Max Sun", "http://github.com/maxsun"]
+    - ["Yan Hui Hang", "http://github.com/yanhh0"]
+translators:
+    - ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+---
+
+# Cálculo Lambda
+
+Cálculo Lambda (Cálculo-λ), originalmente creado por 
+[Alonzo Church](https://es.wikipedia.org/wiki/Alonzo_Church),
+es el lenguaje de programación más pequeño del mundo.
+A pesar de no tener números, cadenas, valores booleanos o cualquier 
+tipo de datos no funcional, el cálculo lambda se puede utilizar para 
+representar cualquier máquina de Turing.
+
+El cálculo lambda se compone de 3 elementos: **variables**, **funciones** y
+**aplicaciones**.
+
+| Nombre        | Sintaxis                             | Ejemplo   | Explicación                                   |
+|-------------|------------------------------------|-----------|-----------------------------------------------|
+| Variable    | `<nombre>`                           | `x`       | una variable llamada "x"                          |
+| Función    | `λ<parámetro>.<cuerpo>`             | `λx.x`    | una función con parámetro "x" y cuerpo "x"    |
+| Aplicación | `<función><variable o función>` | `(λx.x)a` | llamando a la función "λx.x" con el argumento "a" |
+
+La función más básica es la función de identidad: `λx.x` que es equivalente a
+`f(x) = x`. La primera "x" es el argumento de la función y la segunda es el 
+cuerpo de la función.
+
+## Variables Libres vs. Enlazadas:
+
+- En la función `λx.x`, "x" se llama una variable enlazada porque está tanto en
+ el cuerpo de la función como en el parámetro.
+- En `λx.y`, "y" se llama variable libre porque nunca se declara de antemano.
+
+## Evaluación:
+
+Evaluación se realiza a través de
+[β-Reduction](https://es.wikipedia.org/wiki/C%C3%A1lculo_lambda#%CE%B2-reducci%C3%B3n),
+que es, esencialmente, sustitución de ámbito léxico.
+
+Al evaluar la expresión `(λx.x)a`, reemplazamos todas las ocurrencias de "x" 
+en el cuerpo de la función con "a".
+
+- `(λx.x)a` evalúa a: `a`
+- `(λx.y)a` evalúa a: `y`
+
+Incluso puedes crear funciones de orden superior:
+
+- `(λx.(λy.x))a` evalúa a: `λy.a`
+
+Aunque el cálculo lambda tradicionalmente solo admite funciones 
+de un solo parámetro, podemos crear funciones multiparamétricas usando 
+una técnica llamada [Currificación](https://es.wikipedia.org/wiki/Currificación).
+
+- `(λx.λy.λz.xyz)` es equivalente a `f(x, y, z) = ((x y) z)`
+
+Algunas veces `λxy.<cuerpo>` es usado indistintamente con: `λx.λy.<cuerpo>`
+
+----
+
+Es importante reconocer que el cálculo lambda tradicional **no tiene números, 
+caracteres ni ningún tipo de datos que no sea de función.**
+
+## Lógica Booleana:
+
+No hay "Verdadero" o "Falso" en el cálculo lambda. Ni siquiera hay un 1 o un 0.
+
+En vez:
+
+`T` es representado por: `λx.λy.x`
+
+`F` es representado por: `λx.λy.y`
+
+Primero, podemos definir una función "if" `λbtf` que devuelve 
+`t` si `b` es Verdadero y `f` si `b` es Falso
+
+`IF` es equivalente a: `λb.λt.λf.b t f`
+
+Usando `IF` podemos definir los operadores lógicos booleanos básicos:
+
+`a AND b` es equivalente a: `λab.IF a b F`
+
+`a OR b` es equivalente a: `λab.IF a T b`
+
+`a NOT b` es equivalente a: `λa.IF a F T`
+
+*Note: `IF a b c` es esencialmente diciendo: `IF((a b) c)`*
+
+## Números:
+
+Aunque no hay números en el cálculo lambda, podemos codificar números usando 
+[Númeral de Church](https://en.wikipedia.org/wiki/Church_encoding).
+
+Para cualquier número n: <code>n = λf.f <sup> n </sup></code> así:
+
+`0 = λf.λx.x`
+
+`1 = λf.λx.f x`
+
+`2 = λf.λx.f(f x)`
+
+`3 = λf.λx.f(f(f x))`
+
+Para incrementar un númeral de Church, usamos la función sucesora 
+`S(n) = n + 1` que es:
+
+`S = λn.λf.λx.f((n f) x)`
+
+Usando el sucesor, podemos definir AGREGAR:
+
+`AGREGAR = λab.(a S)n`
+
+**Desafío:** intenta definir tu propia función de multiplicación!
+
+## Vamos más pequeño: SKI, SK y Iota
+
+### Combinador de SKI
+
+Sean S, K, I las siguientes funciones:
+
+`I x = x`
+
+`K x y =  x`
+
+`S x y z = x z (y z)`
+
+Podemos convertir una expresión en el cálculo lambda en una expresión 
+en el cálculo del combinador de SKI:
+
+1. `λx.x = I`
+2. `λx.c = Kc`
+3. `λx.(y z) = S (λx.y) (λx.z)`
+
+Tome el número 2 de Church por ejemplo:
+
+`2 = λf.λx.f(f x)`
+
+Para la parte interior `λx.f(f x)`:
+```
+  λx.f(f x)
+= S (λx.f) (λx.(f x))          (case 3)
+= S (K f)  (S (λx.f) (λx.x))   (case 2, 3)
+= S (K f)  (S (K f) I)         (case 2, 1)
+```
+
+Así que:
+```
+  2
+= λf.λx.f(f x)
+= λf.(S (K f) (S (K f) I))
+= λf.((S (K f)) (S (K f) I))
+= S (λf.(S (K f))) (λf.(S (K f) I)) (case 3)
+```
+
+Para el primer argumento `λf.(S (K f))`:
+```
+  λf.(S (K f))
+= S (λf.S) (λf.(K f))       (case 3)
+= S (K S) (S (λf.K) (λf.f)) (case 2, 3)
+= S (K S) (S (K K) I)       (case 2, 3)
+```
+
+Para el segundo argumento `λf.(S (K f) I)`:
+```
+  λf.(S (K f) I)
+= λf.((S (K f)) I)
+= S (λf.(S (K f))) (λf.I)             (case 3)
+= S (S (λf.S) (λf.(K f))) (K I)       (case 2, 3)
+= S (S (K S) (S (λf.K) (λf.f))) (K I) (case 1, 3)
+= S (S (K S) (S (K K) I)) (K I)       (case 1, 2)
+```
+
+Uniéndolos:
+```
+  2
+= S (λf.(S (K f))) (λf.(S (K f) I))
+= S (S (K S) (S (K K) I)) (S (S (K S) (S (K K) I)) (K I))
+```
+
+Al expandir esto, terminaríamos con la misma expresión para el número 2 de Church nuevamente.
+
+### Cálculo del combinador SKI
+
+El cálculo del combinador SKI puede reducirse aún más. Podemos eliminar 
+el combinador I observando que `I = SKK`. Podemos sustituir 
+todos los 'I' con `SKK`.
+
+### Combinador Iota
+
+El cálculo del combinador SK todavía no se encuentra en su expresión mínima. 
+Definiendo:
+
+```
+ι = λf.((f S) K)
+```
+
+Tenemos que:
+
+```
+I = ιι
+K = ι(ιI) = ι(ι(ιι))
+S = ι(K) = ι(ι(ι(ιι)))
+```
+
+## Para una lectura más avanzada:
+
+1. [A Tutorial Introduction to the Lambda Calculus](http://www.inf.fu-berlin.de/lehre/WS03/alpi/lambda.pdf)
+2. [Cornell CS 312 Recitation 26: The Lambda Calculus](http://www.cs.cornell.edu/courses/cs3110/2008fa/recitations/rec26.html)
+3. [Wikipedia - Lambda Calculus](https://es.wikipedia.org/wiki/Cálculo_lambda)
+4. [Wikipedia - SKI combinator calculus](https://en.wikipedia.org/wiki/SKI_combinator_calculus)
+5. [Wikipedia - Iota and Jot](https://en.wikipedia.org/wiki/Iota_and_Jot)
diff --git a/es-es/learnsmallbasic-es.html.markdown b/es-es/learnsmallbasic-es.html.markdown
index 21208792..ff320afb 100644
--- a/es-es/learnsmallbasic-es.html.markdown
+++ b/es-es/learnsmallbasic-es.html.markdown
@@ -18,7 +18,7 @@ SmallBASIC fue desarrollado originalmente por Nicholas Christopoulos a finales d
 Versiones de SmallBASIC se han hecho para una serie dispositivos de mano antiguos, incluyendo Franklin eBookman y el Nokia 770. También se han publicado varias versiones de escritorio basadas en una variedad de kits de herramientas GUI, algunas de las cuales han desaparecido. Las plataformas actualmente soportadas son Linux y Windows basadas en SDL2 y Android basadas en NDK. También está disponible una versión de línea de comandos de escritorio, aunque no suele publicarse en formato binario.
 Alrededor de 2008 una gran corporación lanzó un entorno de programación BASIC con un nombre de similar. SmallBASIC no está relacionado con este otro proyecto.
 
-```SmallBASIC
+```
 REM Esto es un comentario
 ' y esto tambien es un comentario
 
diff --git a/es-es/markdown-es.html.markdown b/es-es/markdown-es.html.markdown
index 0505b4cb..e23a94ea 100644
--- a/es-es/markdown-es.html.markdown
+++ b/es-es/markdown-es.html.markdown
@@ -14,7 +14,7 @@ fácilmente a HTML (y, actualmente, otros formatos también).
 ¡Denme toda la retroalimentación que quieran! / ¡Sientanse en la libertad de hacer forks o pull requests!
 
 
-```markdown
+```md
 <!-- Markdown está basado en HTML, así que cualquier archivo HTML es Markdown
 válido, eso significa que podemos usar elementos HTML en Markdown como, por
 ejemplo, el comentario y no serán afectados por un parseador Markdown. Aún 
diff --git a/es-es/matlab-es.html.markdown b/es-es/matlab-es.html.markdown
new file mode 100644
index 00000000..9f1656bb
--- /dev/null
+++ b/es-es/matlab-es.html.markdown
@@ -0,0 +1,568 @@
+---
+language: Matlab
+filename: learnmatlab-es.mat
+contributors:
+    - ["mendozao", "http://github.com/mendozao"]
+    - ["jamesscottbrown", "http://jamesscottbrown.com"]
+    - ["Colton Kohnke", "http://github.com/voltnor"]
+    - ["Claudson Martins", "http://github.com/claudsonm"]
+translators:
+    - ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+---
+
+MATLAB significa 'MATrix LABoratory'. Es un poderoso lenguaje de computación numérica comúnmente usado en ingeniería y matemáticas.
+
+Si tiene algún comentario, no dude en ponerse en contacto el autor en
+[@the_ozzinator](https://twitter.com/the_ozzinator), o
+[osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com).
+
+```matlab
+%% Una sección de código comienza con dos símbolos de porcentaje. Los títulos de la sección van en la misma líneas.
+% Los comentarios comienzan con un símbolo de porcentaje.
+
+%{
+Los Comentarios de multiples líneas se
+ven
+como 
+esto
+%}
+
+% Dos símbolos de porcentaje denotan el comienzo de una nueva sección de código.
+% Secciones de código individuales pueden ser ejecutadas moviendo el cursor hacia la sección,
+% seguida por un clic en el botón de “Ejecutar Sección”
+% o usando Ctrl+Shift+Enter (Windows) o Cmd+Shift+Return (OS X)
+
+%% Este es el comienzo de una sección de código
+% Una forma de usar las secciones es separar un código de inicio costoso que no cambia, como cargar datos
+load learnmatlab.mat y
+
+%% Esta es otra sección de código
+% Esta sección puede ser editada y ejecutada de manera repetida por sí misma, 
+% y es útil para la programación exploratoria y demostraciones.
+A = A * 2;
+plot(A);
+
+%% Las secciones de código también son conocidas como celdas de código o modo celda (no ha de ser confundido con arreglo de celdas)
+
+
+% Los comandos pueden abarcar varias líneas, usando '...'
+ a = 1 + 2 + ...
+ + 4
+
+% Los comandos se pueden pasar al sistema operativo
+!ping google.com
+
+who % Muestra todas las variables en la memoria
+whos % Muestra todas las variables en la memoria con sus tipos
+clear % Borra todas tus variables de la memoria
+clear('A') % Borra una variable en particular
+openvar('A') % Variable abierta en editor de variables
+
+clc % Borra la escritura en la ventana de Comando
+diary % Alterna la escritura del texto de la ventana de comandos al archivo
+ctrl-c % Aborta el cálculo actual
+
+edit('myfunction.m') % Abrir función/script en el editor
+type('myfunction.m') % Imprime la fuente de la función/script en la ventana de comandos
+
+profile on 	% Enciende el generador de perfilador de código
+profile off 	% Apaga el generador de perfilador de código
+profile viewer 	% Abre el perfilador de código
+
+help command 	% Muestra la documentación del comando en la ventana de comandos
+doc command 	% Muestra la documentación del comando en la ventana de Ayuda
+lookfor command % Busca el comando en la primera línea comentada de todas las funciones
+lookfor command -all % busca el comando en todas las funciones
+
+
+% Formato de salida
+format short 	% 4 decimales en un número flotante
+format long 	% 15 decimales
+format bank 	% solo dos dígitos después del punto decimal - para cálculos financieros
+fprintf('texto') % imprime "texto" en la pantalla
+disp('texto') 	% imprime "texto" en la pantalla
+
+% Variables y expresiones
+myVariable = 4 	% Espacio de trabajo de aviso muestra la variable recién creada
+myVariable = 4; % Punto y coma suprime la salida a la Ventana de Comando
+4 + 6  		% ans = 10
+8 * myVariable 	% ans = 32
+2 ^ 3 		% ans = 8
+a = 2; b = 3;
+c = exp(a)*sin(pi/2) % c = 7.3891
+
+% Llamar funciones se pueden realizar de dos maneras:
+% Sintaxis de función estándar:
+load('myFile.mat', 'y') % argumentos entre paréntesis, separados por comas
+% Sintaxis del comando:
+load myFile.mat y 	% sin paréntesis, y espacios en lugar de comas
+% Tenga en cuenta la falta de comillas en el formulario de comandos: 
+% las entradas siempre se pasan como texto literal; no pueden pasar valores de variables.
+% Además, no puede recibir salida:
+[V,D] = eig(A);  % esto no tiene equivalente en forma de comando
+[~,D] = eig(A);  % si solo se quiere D y no V
+
+
+
+% Operadores lógicos
+1 > 5 % ans = 0
+10 >= 10 % ans = 1
+3 ~= 4 % No es igual a -> ans = 1
+3 == 3 % Es igual a -> ans = 1
+3 > 1 && 4 > 1 % AND -> ans = 1
+3 > 1 || 4 > 1 % OR -> ans = 1
+~1 % NOT -> ans = 0
+
+% Los operadores lógicos se pueden aplicar a matrices:
+A > 5
+% para cada elemento, si la condición es verdadera, ese elemento es 1 en la matriz devuelta
+A( A > 5 )
+% devuelve un vector que contiene los elementos en A para los que la condición es verdadera
+
+% Cadenas
+a = 'MiCadena'
+length(a) % ans = 8
+a(2) % ans = y
+[a,a] % ans = MiCadenaMiCadena
+
+
+% Celdas
+a = {'uno', 'dos', 'tres'}
+a(1) % ans = 'uno' - retorna una celda
+char(a(1)) % ans = uno - retorna una cadena
+
+% Estructuras
+A.b = {'uno','dos'};
+A.c = [1 2];
+A.d.e = false;
+
+% Vectores
+x = [4 32 53 7 1]
+x(2) % ans = 32, los índices en Matlab comienzan 1, no 0
+x(2:3) % ans = 32 53
+x(2:end) % ans = 32 53 7 1
+
+x = [4; 32; 53; 7; 1] % Vector de columna
+
+x = [1:10] % x = 1 2 3 4 5 6 7 8 9 10
+x = [1:2:10] % Incrementa por 2, i.e. x = 1 3 5 7 9
+
+% Matrices
+A = [1 2 3; 4 5 6; 7 8 9]
+% Las filas están separadas por un punto y coma; los elementos se separan con espacio o coma
+% A =
+
+%     1     2     3
+%     4     5     6
+%     7     8     9
+
+A(2,3) % ans = 6, A(fila, columna)
+A(6) % ans = 8
+% (concatena implícitamente columnas en el vector, luego indexa en base a esto)
+
+
+A(2,3) = 42 % Actualiza la fila 2 col 3 con 42
+% A =
+
+%     1     2     3
+%     4     5     42
+%     7     8     9
+
+A(2:3,2:3) % Crea una nueva matriz a partir de la anterior
+%ans =
+
+%     5     42
+%     8     9
+
+A(:,1) % Todas las filas en la columna 1
+%ans =
+
+%     1
+%     4
+%     7
+
+A(1,:) % Todas las columnas en la fila 1
+%ans =
+
+%     1     2     3
+
+[A ; A] % Concatenación de matrices (verticalmente)
+%ans =
+
+%     1     2     3
+%     4     5    42
+%     7     8     9
+%     1     2     3
+%     4     5    42
+%     7     8     9
+
+% esto es lo mismo que
+vertcat(A,A);
+
+
+[A , A] % Concatenación de matrices (horizontalmente)
+
+%ans =
+
+%     1     2     3     1     2     3
+%     4     5    42     4     5    42
+%     7     8     9     7     8     9
+
+% esto es lo mismo que
+horzcat(A,A);
+
+
+A(:, [3 1 2]) % Reorganiza las columnas de la matriz original
+%ans =
+
+%     3     1     2
+%    42     4     5
+%     9     7     8
+
+size(A) % ans = 3 3
+
+A(1, :) =[] % Elimina la primera fila de la matriz
+A(:, 1) =[] % Elimina la primera columna de la matriz
+
+transpose(A) % Transponer la matriz, que es lo mismo que:
+A one
+ctranspose(A) % Hermitian transpone la matriz
+% (la transposición, seguida de la toma del conjugado complejo de cada elemento)
+A' % Versión concisa de transposición compleja
+A.' % Versión concisa de transposición (sin tomar complejo conjugado)
+
+
+
+
+% Elemento por elemento Aritmética vs. Matriz Aritmética
+% Por sí solos, los operadores aritméticos actúan sobre matrices completas. Cuando preceden
+% por un punto, actúan en cada elemento en su lugar. Por ejemplo:
+A * B % Multiplicación de matrices
+A .* B % Multiplica cada elemento en A por su elemento correspondiente en B
+
+% Hay varios pares de funciones, donde una actúa sobre cada elemento y 
+% la otra (cuyo nombre termina en m) actúa sobre la matriz completa.
+exp(A) % exponencializar cada elemento
+expm(A) % calcular la matriz exponencial
+sqrt(A) % tomar la raíz cuadrada de cada elemento
+sqrtm(A) % encuentra la matriz cuyo cuadrado es A
+
+
+% Trazando
+x = 0:.10:2*pi; % Crea un vector que comienza en 0 y termina en 2 * pi con incrementos de .1
+y = sin(x);
+plot(x,y)
+xlabel('x axis')
+ylabel('y axis')
+title('Plot of y = sin(x)')
+axis([0 2*pi -1 1]) % x rango de 0 a 2 * pi, y rango de -1 a 1
+
+plot(x,y1,'-',x,y2,'--',x,y3,':') % Para múltiples funciones en una parcela.
+legend('Line 1 label', 'Line 2 label') % Etiquetar curvas con una leyenda.
+
+% Método alternativo para trazar múltiples funciones en una parcela.
+% mientras 'hold' está activado, los comandos se agregan al gráfico existente en lugar de reemplazarlo.
+plot(x, y)
+hold on
+plot(x, z)
+hold off
+
+loglog(x, y) % Un diagrama de log-log.
+semilogx(x, y) % Un diagrama con el eje x logarítmico.
+semilogy(x, y) % Un diagrama con el eje y logarítmico.
+
+fplot (@(x) x^2, [2,5]) % Un diagrama con el eje y logarítmico...
+
+grid on % Muestra la cuadrícula; apague con 'grid off'.
+axis square % Hace que la región actual de los ejes sea cuadrada.
+axis equal % Establece la relación de aspecto para que las unidades de datos sean las mismas en todas las direcciones.
+
+scatter(x, y); % Gráfico de dispersión
+hist(x); % Histograma
+stem(x); % Traza los valores como tallos, útiles para mostrar datos discretos.
+bar(x); % Diagrama de barras
+
+z = sin(x);
+plot3(x,y,z); % Trazado de línea 3D.
+
+pcolor(A) % Trazado de línea 3D...
+contour(A) % Diagrama de contorno de la matriz.
+mesh(A) % Traza una superficie de malla.
+
+h = figure % Crea nuevo objeto figura, con el mango h.
+figure(h) % Hace que la figura correspondiente al mango h la figura actual.
+close(h) % Cierra la figura con mango h.
+close all % Cierra todas las ventanas con figura abierta.
+close % Cierra ventana de figura actual.
+
+shg % Trae una ventana gráfica existente hacia adelante, o crea una nueva si es necesario.
+clf clear % Borra la ventana de la figura actual y restablece la mayoría de las propiedades de la figura.
+
+% Las propiedades se pueden establecer y cambiar a través de un identificador de figura.
+% Puede guardar un identificador de una figura cuando la crea.
+% La función get devuelve un handle a la figura actual
+h = plot(x, y); % Puedes guardar un control de una figura cuando la creas
+set(h, 'Color', 'r')
+% 'y' yellow; 'm' magenta, 'c' cyan, 'r' red, 'g' green, 'b' blue, 'w' white, 'k' black
+set(h, 'LineStyle', '--')
+% '--' es línea continua, '---' discontinua, ':' punteada, '-.' dash-dot, 'none' es sin línea
+get (h, 'LineStyle')
+
+
+% La función gca devuelve un mango a los ejes para la figura actual
+set(gca, 'XDir', 'reverse'); % invierte la dirección del eje x
+
+% Para crear una figura que contenga varios ejes en posiciones de mosaico, use 'subplot'
+subplot(2,3,1); % seleccione la primera posición en una grilla de subtramas de 2 por 3
+plot(x1); title('First Plot') % traza algo en esta posición
+subplot(2,3,2); % selecciona la segunda posición en la grilla
+plot(x2); title('Second Plot') % trazar algo allí
+
+
+% Para usar funciones o scripts, deben estar en su ruta o directorio actual
+path % muestra la ruta actual
+addpath /path/to/dir % agrega a la ruta
+rmpath /path/to/dir % elimina de la ruta
+cd /path/to/move/into % cambia de directorio
+
+
+% Las variables se pueden guardar en archivos .mat
+save('myFileName.mat') % Guarda las variables en su espacio de trabajo
+load('myFileName.mat') % Carga las variables guardadas en espacio de trabajo
+
+% M-file Scripts
+% Un archivo de script es un archivo externo que contiene una secuencia de instrucciones.
+% Permiten evitar escribir repetidamente el mismo código en la ventana de comandos
+% Tienen extensiones .m
+
+% M-file Functions
+% Al igual que los scripts, y tienen la misma extensión .m
+% Pero pueden aceptar argumentos de entrada y devolver una salida
+% Además, tienen su propio espacio de trabajo (es decir, diferente alcance variable).
+% El nombre de la función debe coincidir con el nombre del archivo (por lo tanto, guarde este ejemplo como double_input.m).
+% 'help double_input.m' devuelve los comentarios en la línea que comienza la función
+function output = double_input(x)
+	% double_input(x) devuelve el doble del valor de x
+	output = 2*x;
+end
+double_input(6) % ans = 12
+
+
+% También puede tener subfunciones y funciones anidadas.
+% Las subfunciones están en el mismo archivo que la función primaria, y solo pueden ser
+% llamadas por funciones en el archivo. Las funciones anidadas se definen dentro de otra
+% otras funciones y tienen acceso tanto a su área de trabajo como a su propio espacio de trabajo.
+
+% Si desea crear una función sin crear un nuevo archivo, puede usar una
+% función anónima. Útil cuando se define rápidamente una función para pasar a
+% otra función (por ejemplo, trazar con fplot, evaluar una integral indefinida
+% con quad, encuentra roots con fzero, o encuentra mínimo con fminsearch).
+% Ejemplo que devuelve el cuadrado de su entrada, asignado al identificador sqr:
+sqr = @(x) x.^2;
+sqr(10) % ans = 100
+doc function_handle % averiguar más
+
+% User input
+a = input('Ingrese el valor:')
+
+% Detiene la ejecución del archivo y le da control al teclado: el usuario puede examinar
+% o cambiar las variables. Escriba 'return' para continuar la ejecución, o 'dbquit' para salir del teclado
+
+% Lectura de datos (también xlsread / importdata / imread para archivos de excel / CSV / image)
+fopen(filename)
+
+% Salida
+disp(a) % Imprime el valor de la variable a
+disp('Hola Mundo') % Imprime una cadena
+fprintf % Imprime en la ventana de comandos con más control
+
+% Declaraciones condicionales (los paréntesis son opcionales, pero buen estilo)
+if (a > 15)
+	disp('Mayor que 15')
+elseif (a == 23)
+	disp('a es 23')
+else
+	disp('Ninguna condicion se ha cumplido')
+end
+
+% Bucles
+% NB. haciendo un bucle sobre los elementos de un vector / matriz es lento!
+% Siempre que sea posible, use funciones que actúen en todo el vector / matriz a la vez
+for k = 1:5
+	disp(k)
+end
+
+k = 0;
+while (k < 5)
+	k = k + 1;
+end
+
+% Ejecución del código de tiempo: 'toc' imprime el tiempo desde que se llamó 'tic'
+tic
+A = rand(1000);
+A*A*A*A*A*A*A;
+toc
+
+% Conectarse a una base de datos MySQL
+dbname = 'database_name';
+username = 'root';
+password = 'root';
+driver = 'com.mysql.jdbc.Driver';
+dburl = ['jdbc:mysql://localhost:8889/' dbname];
+javaclasspath('mysql-connector-java-5.1.xx-bin.jar'); %xx depende de la versión, descarga disponible en http://dev.mysql.com/downloads/connector/j/
+conn = database(dbname, username, password, driver, dburl);
+sql = ['SELECT * from table_name where id = 22'] % Ejemplo de instrucción sql
+a = fetch(conn, sql) %a contendrá sus datos
+
+
+% Funciones matemáticas comunes
+sin(x)
+cos(x)
+tan(x)
+asin(x)
+acos(x)
+atan(x)
+exp(x)
+sqrt(x)
+log(x)
+log10(x)
+abs(x) % Si x es complejo, devuelve la magnitud
+min(x)
+max(x)
+ceil(x)
+floor(x)
+round(x)
+rem(x)
+rand % Números pseudoaleatorios distribuidos uniformemente
+randi % Enteros pseudoaleatorios distribuidos uniformemente
+randn % Números pseudoaleatorios distribuidos normalmente
+
+% Operaciones matemáticas complejas
+abs(x) 	 % Magnitud de la variable compleja x
+phase(x) % Fase (o ángulo) de la variable compleja x
+real(x)  % Retorna la parte real de x (es decir, devuelve a si x = a + jb)
+imag(x)  % Retorna la parte imaginaria de x (es decir, devuelve b si x = a + jb)
+conj(x)  % Retorna el complejo conjugado 
+
+
+% Constantes comunes
+pi
+NaN
+inf
+
+% Resolviendo ecuaciones matriciales (si no hay solución, devuelve una solución de mínimos cuadrados)
+%Los operadores \ y / son equivalentes a las funciones mldivide y mrdivide
+x=A\b % Resuelve Ax = b. Más rápido y más numéricamente preciso que usar inv (A) * b.
+x=b/A % Resuelve xA = b
+
+inv(A) % calcular la matriz inversa
+pinv(A) % calcular el pseudo-inverso
+
+% Funciones de matriz comunes
+zeros(m,n) % m x n matriz de 0
+ones(m,n) % m x n matriz de 1
+diag(A) % Extrae los elementos diagonales de una matriz A
+diag(x) % Construya una matriz con elementos diagonales enumerados en x, y ceros en otra parte
+eye(m,n) % Matriz de identidad
+linspace(x1, x2, n) % Devuelve n puntos equiespaciados, con min x1 y max x2
+inv(A) % Inverso de la matriz A
+det(A) % Determinante de A
+eig(A) % Valores propios y vectores propios de A
+trace(A) % Traza de la matriz: equivalente a sum(diag(A))
+isempty(A) % Determina si la matriz está vacía
+all(A) % Determina si todos los elementos son distintos de cero o verdaderos
+any(A) % Determina si alguno de los elementos es distinto de cero o verdadero
+isequal(A, B) % Determina la igualdad de dos matrices
+numel(A) % Cantidad de elementos en matriz
+triu(x) % Devuelve la parte triangular superior de x
+tril(x) % Devuelve la parte triangular inferior de x
+cross(A,B) % Devuelve el producto cruzado de los vectores A y B
+dot(A,B) % Devuelve un producto escalar de dos vectores (debe tener la misma longitud)
+transpose(A) % Devuelve la transposición de A
+fliplr(A) % Voltea la matriz de izquierda a derecha
+flipud(A) % Voltea la matriz de arriba hacia abajo
+
+% Factorizaciones de matrices
+[L, U, P] = lu(A) % Descomposición LU: PA = LU, L es triangular inferior, U es triangular superior, P es matriz de permutación
+[P, D] = eig(A) % eigen-decomposition: AP = PD, las columnas de P son autovectores y las diagonales de D'son valores propios
+[U,S,V] = svd(X) % SVD: XV = US, U y V son matrices unitarias, S tiene elementos diagonales no negativos en orden decreciente
+
+% Funciones comunes de vectores
+max     % componente más grande
+min     % componente más pequeño
+length  % longitud de un vector
+sort    % ordenar en orden ascendente
+sum     % suma de elementos
+prod    % producto de elementos
+mode    % valor modal
+median  % valor mediano
+mean    % valor medio
+std     % desviación estándar
+perms(x) % enumera todas las permutaciones de elementos de x
+find(x) % Encuentra todos los elementos distintos de cero de x y devuelve sus índices, puede usar operadores de comparación,
+        % i.e. find( x == 3 ) devuelve índices de elementos que son iguales a 3
+        % i.e. find( x >= 3 ) devuelve índices de elementos mayores o iguales a 3
+
+
+% Clases
+% Matlab puede soportar programación orientada a objetos.
+% Las clases deben colocarse en un archivo del nombre de la clase con la extensión .m. 
+% Para comenzar, creamos una clase simple para almacenar puntos de referencia de GPS.
+% Comience WaypointClass.m
+classdef WaypointClass % El nombre de la clase.
+  properties % Las propiedades de la clase se comportan como Estructuras
+    latitude 
+    longitude 
+  end
+  methods 
+    % Este método que tiene el mismo nombre de la clase es el constructor.
+    function obj = WaypointClass(lat, lon)
+      obj.latitude = lat;
+      obj.longitude = lon;
+    end
+
+    % Otras funciones que usan el objeto Waypoint
+    function r = multiplyLatBy(obj, n)
+      r = n*[obj.latitude];
+    end
+
+    % Si queremos agregar dos objetos Waypoint juntos sin llamar
+    % a una función especial, podemos sobrecargar la aritmética de Matlab así:
+    function r = plus(o1,o2)
+      r = WaypointClass([o1.latitude] +[o2.latitude], ...
+                        [o1.longitude]+[o2.longitude]);
+    end
+  end
+end
+% Fin WaypointClass.m
+
+% Podemos crear un objeto de la clase usando el constructor
+a = WaypointClass(45.0, 45.0)
+
+% Las propiedades de clase se comportan exactamente como estructuras de Matlab.
+a.latitude = 70.0
+a.longitude = 25.0
+
+% Los métodos se pueden llamar de la misma manera que las funciones
+ans = multiplyLatBy(a,3)
+
+% El método también se puede llamar usando notación de puntos. En este caso, el objeto
+% no necesita ser pasado al método.
+ans = a.multiplyLatBy(a,1/3)
+
+% Las funciones de Matlab pueden sobrecargarse para manejar objetos.
+% En el método anterior, hemos sobrecargado cómo maneja Matlab
+% la adición de dos objetos Waypoint.
+b = WaypointClass(15.0, 32.0)
+c = a + b
+
+```
+
+## Más sobre Matlab
+
+* [The official website (EN)](http://www.mathworks.com/products/matlab/)
+* [The official MATLAB Answers forum (EN)](http://www.mathworks.com/matlabcentral/answers/)
+* [Loren on the Art of MATLAB (EN)](http://blogs.mathworks.com/loren/)
+* [Cleve's Corner (EN)](http://blogs.mathworks.com/cleve/)
+
diff --git a/es-es/objective-c-es.html.markdown b/es-es/objective-c-es.html.markdown
index bdbce524..26cd14d9 100644
--- a/es-es/objective-c-es.html.markdown
+++ b/es-es/objective-c-es.html.markdown
@@ -13,7 +13,7 @@ Objective C es el lenguaje de programación principal utilizado por Apple para l
 Es un lenguaje de programación para propósito general que le agrega al lenguaje de programación C una mensajería estilo "Smalltalk".
 
 
-```objective_c
+```objectivec
 // Los comentarios de una sola línea inician con //
 
 /*
diff --git a/es-es/pascal-es.html.markdown b/es-es/pascal-es.html.markdown
new file mode 100644
index 00000000..8328fa1e
--- /dev/null
+++ b/es-es/pascal-es.html.markdown
@@ -0,0 +1,205 @@
+---
+language: Pascal
+filename: learnpascal-es.pas
+contributors:
+    - ["Ganesha Danu", "http://github.com/blinfoldking"]
+    - ["Keith Miyake", "https://github.com/kaymmm"]
+translators:
+    - ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+---
+
+
+>Pascal es un lenguaje de programación imperativo y de procedimiento, que Niklaus Wirth diseñó en 1968–69 y publicó en 1970, como un lenguaje pequeño y eficiente destinado a fomentar las buenas prácticas de programación utilizando programación estructurada y estructuración de datos. Se nombra en honor al matemático, filósofo y físico francés Blaise Pascal. fuente: [wikipedia](https://es.wikipedia.org/wiki/Pascal_(lenguaje_de_programación)))
+
+Para compilar y ejecutar un programa pascal puede usar un compilador pascal gratuito. [Descargar aquí](https://www.freepascal.org/)
+
+```pascal
+//Anatomía de un programa en Pascal 
+//Esto es un comentario
+{
+    Esto es un
+    comentario multilínea
+}
+
+//nombre del programa
+program learn_pascal; //<-- no olvides el punto y coma
+
+const
+    {
+        Aquí es donde se debe declarar valores constantes.
+    }
+type
+    {
+       Aquí es donde se debe declarar un tipo de datos personalizado
+    }
+var
+    {
+        aquí es donde se debe declarar una variable
+    }
+
+//área principal del programa
+begin
+    {
+        área para declarar su instrucción
+    }
+end. // El final de un área principal del programa debe requerir un símbolo "." 
+```
+
+```pascal
+//declarando variable
+//puedes hacer esto
+var a:integer;
+var b:integer;
+//o esto
+var 
+    a : integer;
+    b : integer;
+//o esto
+var a,b : integer;
+```
+
+```pascal
+program Learn_More;
+//Aprendamos sobre los tipos de datos y sus operaciones.
+
+const
+    PI = 3.141592654;
+    GNU = 'GNU No Es Unix';
+        // las constantes se nombran convencionalmente usando CAPS (mayúscula)
+        // sus valores son fijos y no se pueden cambiar durante el tiempo de ejecución
+        // tiene cualquier tipo de datos estándar (enteros, reales, booleanos, characteres, cadenas)
+
+type
+    ch_array : array [0..255] of char;
+        // los  son nuevos 'tipos' que especifican la longitud y el tipo de datos
+        // esto define un nuevo tipo de datos que contiene 255 caracteres
+        // (esto es funcionalmente equivalente a una variable string[256])
+    md_array : array of array of integer;
+        // los arreglos anidados son equivalentes a los arreglos multidimensionales
+        // puede definir arreglos de longitud cero (0) que son de tamaño dinámico
+        // esta es una matriz bidimensional de enteros
+
+//Declarando variables
+var
+    int, c, d  : integer;
+           // Tres variables que contienen números enteros.
+           // los enteros son de 16 bits y están limitados al rango [-32,768..32,767]
+    r    : real;
+           // una variable que contiene un número real como tipos de datos
+           // el rango de los reales pueden variar entre [3.4E-38..3.4E38]
+    bool : boolean;
+           // una variable que contiene un valor booleano (True/False)
+    ch   : char;
+           // una variable que contiene un valor de carácter
+           // Las variables char se almacenan como tipos de datos de 8 bits, por lo que no hay UTF
+    str  : string;
+           // una variable no estándar que contiene un valor de cadena
+           // Las cadenas son una extensión incluida en la mayoría de los compiladores de Pascal.
+           // se almacenan como una matriz de caracteres con una longitud predeterminada de 255.
+    s    : string[50];
+           // una cadena con longitud máxima de 50 caracteres.
+           // puede especificar la longitud de la cadena para minimizar el uso de memoria
+    my_str: ch_array;
+           // Puedes declarar variables de tipos personalizados.
+    my_2d : md_array;
+           // Las matrices de tamaño dinámico deben dimensionarse antes de que puedan usarse.
+
+    // tipos de datos enteros adicionales
+    b    : byte;     // rango [0..255]
+    shi  : shortint; // rango [-128..127]
+    smi  : smallint; // rango [-32,768..32,767] (entero estándar)
+    w    : word;     // rango [0..65,535]
+    li   : longint;  // rango [-2,147,483,648..2,147,483,647]
+    lw   : longword; // rango [0..4,294,967,295]
+    c    : cardinal; // longword
+    i64  : int64;    // rango [-9223372036854775808..9223372036854775807]
+    qw   : qword;    // rango [0..18,446,744,073,709,551,615]
+
+    // tipos reales adicionales
+    rr   : real;     // rango depende de la plataforma (i.e., 8-bit, 16-bit, etc.)
+    rs   : single;   // rango [1.5E-45..3.4E38]
+    rd   : double;   // rango [5.0E-324 .. 1.7E308]
+    re   : extended; // rango [1.9E-4932..1.1E4932]
+    rc   : comp;     // rango [-2E64+1 .. 2E63-1]
+
+Begin
+    int := 1;// como asignar un valor a una variable
+    r   := 3.14;
+    ch  := 'a';
+    str := 'manzana';
+    bool := true;
+    //pascal no es un lenguaje sensible a mayúsculas y minúsculas
+    //operación aritmética
+    int := 1 + 1; // int = 2 sobrescribiendo la asignacion anterior
+    int := int + 1; // int = 2 + 1 = 3;
+    int := 4 div 2; //int = 2 operación de división donde el resultado será redondeado.
+    int := 3 div 2; //int = 1
+    int := 1 div 2; //int = 0
+
+    bool := true or false; // bool = true
+    bool := false and true; // bool = false
+    bool := true xor true; // bool = false
+
+    r := 3 / 2; // un operador de división para reales
+    r := int; // Puede asignar un entero a una variable real pero no a la inversa
+
+    c := str[1]; // asigna la primera letra de str a c
+    str := 'hola' + 'mundo'; // combinando cadenas
+
+    my_str[0] := 'a'; // asignación de matriz necesita un índice
+
+    setlength(my_2d,10,10); // inicializa matrices de tamaño dinámico: matriz 10 × 10
+    for c := 0 to 9 do // los arreglos comienzan en 0 y terminan en longitud - 1
+        for d := 0 to 9 do // Para los contadores de bucle hay que declarar variables.
+        my_2d[c,d] := c * d;
+          // aborda las matrices multidimensionales con un único conjunto de corchete
+
+End.
+```
+
+```pascal
+program Functional_Programming;
+
+Var
+    i, dummy : integer;
+
+function recursion_factorial(const a: integer) : integer;
+{ calcula recursivamente el factorial del parámetro entero a }
+
+// Declare variables locales dentro de la función.
+// e.g.:
+// Var
+//    local_a : integer;
+
+Begin
+    If a >= 1 Then
+    // devuelva valores de las funciones asignando un valor al nombre de la función
+        recursion_factorial := a * recursion_factorial(a-1)
+    Else
+        recursion_factorial := 1;
+End; // termine una función usando un punto y coma después de la instrucción End.
+
+procedure obtener_entero(var i : integer; dummy : integer);
+{ obten la entrada del usuario y almacenarla en el parámetro entero i. 
+  los parámetros que preceden a 'var' son variables, lo que significa que su valor 
+  puede cambiar fuera del parámetro. Los parámetros de valor (sin 'var') como 'dummy' 
+  son estáticos y los cambios realizados dentro del alcance de la función/procedimiento 
+  no afectan la variable que se pasa como parámetro }
+
+Begin
+    write('Escriba un entero: ');
+    readln(i);
+    dummy := 4; // dummy no cambiará el valor fuera del procedimiento
+End;
+
+Begin // bloque de programa principal
+    dummy := 3;
+    obtener_entero(i, dummy);
+    writeln(i, '! = ', recursion_factorial(i));
+    // muestra i!
+    writeln('dummy = ', dummy); // siempre muestra '3' ya que dummy no ha cambiado.
+End.
+
+```
+
diff --git a/es-es/pyqt-es.html.markdown b/es-es/pyqt-es.html.markdown
new file mode 100644
index 00000000..6d4fdde7
--- /dev/null
+++ b/es-es/pyqt-es.html.markdown
@@ -0,0 +1,82 @@
+---
+category: tool
+tool: PyQT
+filename: learnpyqt-es.py
+contributors:
+    - ["Nathan Hughes", "https://github.com/sirsharpest"]
+translators:
+    - ["Adrian Rocamora", "https://github.com/adrianrocamora"]
+lang: es-es
+---
+
+**Qt** es un sistema altamente reconocido que permite desarrollar software multiplataforma que puede correr en diferentes entornos de software y hardware con pocos o ningún cambio. Aun así conserva la velocidad y poder de una aplicación nativa. **Qt** fue originalmente escrito en *C++*.
+
+Esta es una adaptación de la introducción a QT con C++ por [Aleksey Kholovchuk](https://github.com/vortexxx192), parte del código ejemplo debería resultar en la misma funcionalidad ¡pero usando python con PyQT!
+
+```python
+import sys
+from PyQt4 import QtGui
+	
+def window():
+    # Crear el objeto de la aplicación
+    app = QtGui.QApplication(sys.argv)
+    # Crear un widget en el que colocaremos nuestra etiqueta
+    w = QtGui.QWidget()
+    # Agregamos nuestra etiqueta al widget
+    b = QtGui.QLabel(w)
+    # Agregamos texto a nuestra etiqueta
+    b.setText("Hello World!")
+    # Fijemos información de posición y tamaño del widget
+    w.setGeometry(100, 100, 200, 50)
+    b.move(50, 20)
+    # Proporcionemos un título a nuestra ventana
+    w.setWindowTitle("PyQt")
+    # Mostremos todo
+    w.show()
+    # Ejecutemos lo que hayamos solicitado ya inicializado el resto
+    sys.exit(app.exec_())
+
+if __name__ == '__main__':
+    window()
+
+```
+
+Para poder hacer uso de las funciones más avanzades en **pyqt** necesitamos agregar elementos adicionales.
+Aquí mostramos cómo introducir una caja de diálogo popup, útil para permitir al usuario confirmar su decisión o para brindarnos información.
+
+```Python 
+import sys
+from PyQt4.QtGui import *
+from PyQt4.QtCore import *
+
+
+def window():
+    app = QApplication(sys.argv)
+    w = QWidget()
+    # Crear un botón y adjuntarlo al widget w
+    b = QPushButton(w)
+    b.setText("Press me")
+    b.move(50, 50)
+    # Indicar al botón b que llame esta función cuando reciba un click
+    # Nótese la falta de "()" en la llamada de la función
+    b.clicked.connect(showdialog)
+    w.setWindowTitle("PyQt Dialog")
+    w.show()
+    sys.exit(app.exec_())
+	
+# Esta función debería crear una ventana de diálogo con un botón
+# que espera a recibir un click y luego sale del programa
+def showdialog():
+    d = QDialog()
+    b1 = QPushButton("ok", d)
+    b1.move(50, 50)
+    d.setWindowTitle("Dialog")
+    # Esta modalidad le indica al popup que bloquee al padre mientras activo
+    d.setWindowModality(Qt.ApplicationModal)
+    # Al recibir un click me gustaría que el proceso termine
+    b1.clicked.connect(sys.exit)
+    d.exec_()
+
+if __name__ == '__main__':
+    window()
+```
diff --git a/es-es/python-es.html.markdown b/es-es/python-es.html.markdown
index a27203d1..2b8f498a 100644
--- a/es-es/python-es.html.markdown
+++ b/es-es/python-es.html.markdown
@@ -467,7 +467,7 @@ Humano.roncar() #=> "*roncar*"
 
 # Puedes importar módulos
 import math
-print math.sqrt(16) #=> 4
+print math.sqrt(16) #=> 4.0
 
 # Puedes obtener funciones específicas desde un módulo
 from math import ceil, floor
diff --git a/es-es/python3-es.html.markdown b/es-es/python3-es.html.markdown
index 05fd7065..3236e73a 100644
--- a/es-es/python3-es.html.markdown
+++ b/es-es/python3-es.html.markdown
@@ -14,8 +14,6 @@ Es básicamente pseudocódigo ejecutable.
 
 ¡Comentarios serán muy apreciados! Pueden contactarme en [@louiedinh](http://twitter.com/louiedinh) o louiedinh [at] [servicio de email de google]
 
-Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser aplicable a Python 2.x. ¡Pronto un recorrido por Python 3!
-
 ```python
 
 # Comentarios de una línea comienzan con una almohadilla (o signo gato)
@@ -39,6 +37,8 @@ Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser apl
 
 # Excepto la división la cual por defecto retorna un número 'float' (número de coma flotante)
 35 / 5  # => 7.0
+# Sin embargo también tienes disponible división entera
+34 // 5 # => 6
 
 # Cuando usas un float, los resultados son floats
 3 * 2.0 # => 6.0
@@ -87,11 +87,14 @@ not False  # => True
 # .format puede ser usaro para darle formato a los strings, así:
 "{} pueden ser {}".format("strings", "interpolados")
 
-# Puedes repetir los argumentos de formateo para ahorrar tipeos.
+# Puedes reutilizar los argumentos de formato si estos se repiten.
 "{0} sé ligero, {0} sé rápido, {0} brinca sobre la {1}".format("Jack", "vela") #=> "Jack sé ligero, Jack sé rápido, Jack brinca sobre la vela"
 # Puedes usar palabras claves si no quieres contar.
-"{nombre} quiere comer {comida}".format(nombre="Bob", food="lasaña") #=> "Bob quiere comer lasaña"
-
+"{nombre} quiere comer {comida}".format(nombre="Bob", comida="lasaña") #=> "Bob quiere comer lasaña"
+# También puedes interpolar cadenas usando variables en el contexto
+nombre = 'Bob'
+comida = 'Lasaña'
+f'{nombre} quiere comer {comida}'  #=> "Bob quiere comer lasaña"
 
 # None es un objeto
 None  # => None
@@ -101,12 +104,13 @@ None  # => None
 "etc" is None #=> False
 None is None  #=> True
 
-# None, 0, y strings/listas/diccionarios vacíos(as) todos se evalúan como False.
+# None, 0, y strings/listas/diccionarios/conjuntos vacíos(as) todos se evalúan como False.
 # Todos los otros valores son True
 bool(0)  # => False
 bool("")  # => False
 bool([]) #=> False
 bool({}) #=> False
+bool(set()) #=> False
 
 
 ####################################################
@@ -170,7 +174,7 @@ lista + otra_lista #=> [1, 2, 3, 4, 5, 6] - Nota: lista y otra_lista no se tocan
 # Concatenar listas con 'extend'
 lista.extend(otra_lista) # lista ahora es [1, 2, 3, 4, 5, 6]
 
-# Chequea la existencia en una lista con 'in'
+# Verifica la existencia en una lista con 'in'
 1 in lista #=> True
 
 # Examina el largo de una lista con 'len'
@@ -196,7 +200,7 @@ d, e, f = 4, 5, 6
 e, d = d, e     # d ahora es 5 y e ahora es 4
 
 
-# Diccionarios almacenan mapeos
+# Diccionarios relacionan llaves y valores
 dicc_vacio = {}
 # Aquí está un diccionario prellenado
 dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
@@ -213,7 +217,7 @@ list(dicc_lleno.keys()) #=> ["tres", "dos", "uno"]
 list(dicc_lleno.values()) #=> [3, 2, 1]
 # Nota - Lo mismo que con las llaves, no se garantiza el orden.
 
-# Chequea la existencia de una llave en el diccionario con 'in'
+# Verifica la existencia de una llave en el diccionario con 'in'
 "uno" in dicc_lleno #=> True
 1 in dicc_lleno #=> False
 
@@ -253,7 +257,7 @@ conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
 # Haz diferencia de conjuntos con -
 {1,2,3,4} - {2,3,5} #=> {1, 4}
 
-# Chequea la existencia en un conjunto con 'in'
+# Verifica la existencia en un conjunto con 'in'
 2 in conjunto_lleno #=> True
 10 in conjunto_lleno #=> False
 
@@ -262,7 +266,7 @@ conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
 ## 3. Control de Flujo
 ####################################################
 
-# Let's just make a variable
+# Creemos una variable para experimentar
 some_var = 5
 
 # Aquí está una declaración de un 'if'. ¡La indentación es significativa en Python!
@@ -275,18 +279,17 @@ else:           # Esto también es opcional.
     print("una_variable es de hecho 10.")
 
 """
-For itera sobre listas
+For itera sobre iterables (listas, cadenas, diccionarios, tuplas, generadores...)
 imprime:
     perro es un mamifero
     gato es un mamifero
     raton es un mamifero
 """
 for animal in ["perro", "gato", "raton"]:
-    # Puedes usar % para interpolar strings formateados
     print("{} es un mamifero".format(animal))
 
 """
-`range(número)` retorna una lista de números
+`range(número)` retorna un generador de números
 desde cero hasta el número dado
 imprime:
     0
@@ -323,7 +326,7 @@ except IndexError as e:
 
 dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
 nuestro_iterable = dicc_lleno.keys()
-print(nuestro_iterable) #=> range(1,10). Este es un objeto que implementa nuestra interfaz Iterable
+print(nuestro_iterable) #=> dict_keys(['uno', 'dos', 'tres']). Este es un objeto que implementa nuestra interfaz Iterable
 
 Podemos recorrerla.
 for i in nuestro_iterable:
@@ -420,6 +423,10 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
 # Podemos usar listas por comprensión para mapeos y filtros agradables
 [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]
+# también hay diccionarios
+{k:k**2 for k in range(3)} #=> {0: 0, 1: 1, 2: 4}
+# y conjuntos por comprensión
+{c for c in "la cadena"} #=> {'d', 'l', 'a', 'n', ' ', 'c', 'e'}
 
 ####################################################
 ## 5. Classes
diff --git a/es-es/pythonstatcomp-es.html.markdown b/es-es/pythonstatcomp-es.html.markdown
index 0130b72a..b3d2f0ff 100644
--- a/es-es/pythonstatcomp-es.html.markdown
+++ b/es-es/pythonstatcomp-es.html.markdown
@@ -1,5 +1,6 @@
 ---
-language: Statistical computing with Python
+category: tool
+tool: Statistical Computing with Python
 contributors:
     - ["e99n09", "https://github.com/e99n09"]
 filename: pythonstatcomp-es.py
diff --git a/es-es/scala-es.html.markdown b/es-es/scala-es.html.markdown
new file mode 100644
index 00000000..2dcb9e7f
--- /dev/null
+++ b/es-es/scala-es.html.markdown
@@ -0,0 +1,741 @@
+---
+language: Scala
+filename: learnscala-es.scala
+contributors:
+    - ["George Petrov", "http://github.com/petrovg"]
+    - ["Dominic Bou-Samra", "http://dbousamra.github.com"]
+    - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Ha-Duong Nguyen", "http://reference-error.org"]
+translators:
+    - ["Pablo Arranz Ropero", "http://arranzropablo.com"]
+lang: es-es
+---
+
+Scala - El lenguaje escalable
+
+```scala
+
+/////////////////////////////////////////////////
+// 0. Básicos
+/////////////////////////////////////////////////
+/*
+  Configurar Scala:
+
+  1) Descarga Scala - http://www.scala-lang.org/downloads
+  2) Unzip/untar a tu carpeta elegida y pon la subcarpeta bin en tu variable de entorno `PATH`
+*/
+
+/*
+  Prueba REPL
+
+  Scala tiene una herramienta llamada REPL (Read-Eval-Print Loop, en español: Bucle de lectura-evaluación-impresión) que es analogo a interpretes de la linea de comandos en muchos otros lenguajes. 
+  Puedes escribir cualquier expresión en Scala y el resultado será evaluado e impreso.  
+
+  REPL es una herramienta muy práctica para testear y verificar código.
+  Puedes usarla mientras lees este tutorial para explorar conceptos por tu cuenta.
+*/
+
+// Inicia Scala REPL ejecutando `scala` en tu terminal. Deberías ver:
+$ scala
+scala>
+
+// Por defecto cada expresión que escribes es guardada como un nuevo valor numerado:
+scala> 2 + 2
+res0: Int = 4
+
+// Los valores por defecto pueden ser reusados. Fíjate en el tipo del valor mostrado en el resultado...
+scala> res0 + 2
+res1: Int = 6
+
+// Scala es un lenguaje fuertemente tipado. Puedes usar REPL para comprobar el tipo sin evaluar una expresión.
+scala> :type (true, 2.0)
+(Boolean, Double)
+
+// Las sesiones REPL pueden ser guardadas
+scala> :save /sites/repl-test.scala
+
+// Se pueden cargar archivos en REPL
+scala> :load /sites/repl-test.scala
+Loading /sites/repl-test.scala...
+res2: Int = 4
+res3: Int = 6
+
+// Puedes buscar en tu historial reciente
+scala> :h?
+1 2 + 2
+2 res0 + 2
+3 :save /sites/repl-test.scala
+4 :load /sites/repl-test.scala
+5 :h?
+
+// Ahora que sabes como jugar, aprendamos un poco de Scala...
+
+/////////////////////////////////////////////////
+// 1. Básicos
+/////////////////////////////////////////////////
+
+// Los comentarios de una linea comienzan con dos barras inclinadas
+
+/*
+  Los comentarios de varias lineas, como ya has visto arriba, se hacen de esta manera.
+*/
+
+// Así imprimimos forzando una nueva linea en la siguiente impresión
+println("Hola mundo!")
+println(10)
+// Hola mundo!
+// 10
+
+// Así imprimimos sin forzar una nueva linea en la siguiente impresión
+print("Hola mundo")
+print(10)
+// Hola mundo10
+
+// Para declarar valores usamos var o val.
+// Valores decalrados con val son inmutables, mientras que los declarados con var son mutables. 
+// La inmutabilidad es algo bueno.
+val x = 10 // x es 10
+x = 20     // error: reassignment to val
+var y = 10
+y = 20     // y es 20
+
+/*
+  Scala es un lenguaje tipado estáticamente, aunque se puede ver en las expresiones anteriores que no hemos especificado un tipo. 
+  Esto es debido a una funcionalidad del lenguaje llamada inferencia. En la mayoría de los casos, el compilador de Scala puede adivinar cual es el tipo de una variable, así que no hace falta escribirlo siempre.
+  Podemos declarar explicitamente el tipo de una variable de la siguiente manera:
+*/
+val z: Int = 10
+val a: Double = 1.0
+
+// Observa la conversión automática de Int a Double, el resultado será 10.0, no 10
+val b: Double = 10
+
+// Valores Booleanos
+true
+false
+
+// Operaciones Booleanas
+!true         // false
+!false        // true
+true == false // false
+10 > 5        // true
+
+// Las operaciones matemáticas se realizan como siempre
+1 + 1   // 2
+2 - 1   // 1
+5 * 3   // 15
+6 / 2   // 3
+6 / 4   // 1
+6.0 / 4 // 1.5
+6 / 4.0 // 1.5
+
+
+// Evaluar una expresión en REPL te da el tipo y valor del resultado
+
+1 + 7
+
+/* La linea superior tienen como resultado:
+
+  scala> 1 + 7
+  res29: Int = 8
+
+  Esto quiere decir que el resultado de evaluar 1 + 7 es un objeto de tipo Int con valor 8
+
+  Observa que "res29" es un nombre de variable secuencialmente generado para almacenar los resultados de las expresiones escritas, la salida que observes puede diferir en este sentido.
+*/
+
+"Las cadenas en Scala están rodeadas por comillas dobles"
+'a' // Un caracter en Scala
+// 'Las cadenas con comillas simples no existen' <= Esto causa un error
+
+// Las cadenas tienen los los típicos metodos de Java definidos
+"hello world".length
+"hello world".substring(2, 6)
+"hello world".replace("C", "3")
+
+// También tienen algunos métodos extra de Scala. Ver: scala.collection.immutable.StringOps
+"hello world".take(5)
+"hello world".drop(5)
+
+// Interpolación de cadenas: Observa el prefijo "s"
+val n = 45
+s"Tengo $n manzanas" // => "Tengo 45 manzanas"
+
+// Es posible colocar expresiones dentro de cadenas interpoladas
+val a = Array(11, 9, 6)
+s"Mi segunda hija tiene ${a(0) - a(2)} años."         // => "Mi segunda hija tiene 5 años."
+s"Hemos doblado la cantidad de ${n / 2.0} manzanas."  // => "Hemos doblado la cantidad de 22.5 manzanas."
+s"Potencia de 2: ${math.pow(2, 2)}"                   // => "Potencia de 2: 4"
+
+// Podemos formatear cadenas interpoladas con el prefijo "f"
+f"Potencia de 5: ${math.pow(5, 2)}%1.0f"         // "Potencia de 5: 25"
+f"Raiz cuadrada de 122: ${math.sqrt(122)}%1.4f" // "Raiz cuadrada de 122: 11.0454"
+
+// Las cadenas puras ignoran caracteres especiales.
+raw"Nueva linea: \n. Retorno: \r." // => "Nueva linea: \n. Retorno: \r."
+
+// Algunos caracteres necesitn ser escapados, por ejemplo unas comillas dobles dentro de una cadena:
+"Se quedaron fuera de \"Rose and Crown\"" // => "Se quedaron fuera de "Rose and Crown""
+
+// Las triples comillas dobles dejan que las cadenas se expandan por multiples filas y contengan comillas dobles o simples
+val html = """<form id="daform">
+                <p>Press belo', Joe</p>
+                <input type="submit">
+              </form>"""
+
+
+/////////////////////////////////////////////////
+// 2. Funciones
+/////////////////////////////////////////////////
+
+// Las funciones se definen de la siguiente manera:
+//
+//   def nombreFuncion(argumentos...): TipoRetorno = { cuerpo... }
+//
+// Si estás acostumbrado a lenguajes más tradicionales, observa la omisión de la palabra return.
+// En Scala, la última expresión en el bloque de función es el valor de retorno.
+def sumaDeCuadrados(x: Int, y: Int): Int = {
+  val x2 = x * x
+  val y2 = y * y
+  x2 + y2
+}
+
+// Los { } pueden omitirse si el cuerpo de la función es una única expresión:
+def sumaDeCuadradosCorta(x: Int, y: Int): Int = x * x + y * y
+
+// La sintaxis para llamar funciones es familiar:
+sumaDeCuadrados(3, 4)  // => 25
+
+// Puedes usar los nombres de los parámetros para llamarlos en orden diferente
+def restar(x: Int, y: Int): Int = x - y
+
+restar(10, 3)     // => 7
+restar(y=10, x=3) // => -7
+
+// En la mayoría de los casos (siendo las funciones recursivas la excepción más notable),
+// el tipo de retorno de la función puede ser omitido, y la misma inferencia de tipos que vimos con las variables
+// funcionará con los valores de retorno de las funciones:
+def sq(x: Int) = x * x  // El compilador puede adivinar que el tipo de retorno es Int
+
+// Las funciones pueden tener parametros por defecto:
+def sumarConDefecto(x: Int, y: Int = 5) = x + y
+sumarConDefecto(1, 2) // => 3
+sumarConDefecto(1)    // => 6
+
+
+// Las funciones anónimas se escriben así:
+(x: Int) => x * x
+
+// Al contrario que los defs, incluso el tipo de entrada de las funciones anónimas puede ser omitido si
+// el contexto lo deja claro. Observa el tipo "Int => Int" que significa que es una función
+// que recibe Int y retorna Int.
+val sq: Int => Int = x => x * x
+
+// Las funciones anónimas pueden ser llamadas como las demás:
+sq(10)   // => 100
+
+// Si cada argumento en tu función anónima es usado solo una vez,
+// Scala te da una manera incluso más corta de definirlos.
+// Estas funciones anónimas son extremadamente comunes, 
+// como será obvio en la sección de estructuras de datos.
+val sumarUno: Int => Int = _ + 1
+val sumaRara: (Int, Int) => Int = (_ * 2 + _ * 3)
+
+sumarUno(5)       // => 6
+sumaRara(2, 4)    // => 16
+
+
+// La palabra return existe en Scala, pero solo retorna desde la función más interna que la rodea.
+// ADVERTENCIA: Usar return en Scala puede inducir a errores y debe ser evitado
+// No tiene efecto en funciones anónimas. Por ejemplo:
+def foo(x: Int): Int = {
+  val funcAnon: Int => Int = { z =>
+    if (z > 5)
+      return z // Esta línea hace que z sea el valor de retorno de foo!
+    else
+      z + 2    // Esta línea es el valor de retorno de funcAnon
+  }
+  anonFunc(x)  // Esta línea es el valor de retorno de foo
+}
+
+
+/////////////////////////////////////////////////
+// 3. Control del flujo
+/////////////////////////////////////////////////
+
+1 to 5
+val r = 1 to 5
+r.foreach(println)
+
+r foreach println
+// Nota: Scala es un lenguaje muy permisivo cuando se trata de puntos y parentesis - estudia las
+// reglas separadamente. Esto ayuda a escribir DSLs y APIs que se lean en lenguaje natural.
+
+// Por qué `println` no necesita parámetros aquí?
+// Presta atención a las funciones de primera clase en la sección de Programación Funcional más abajo!
+(5 to 1 by -1) foreach (println)
+
+// Un bucle while
+var i = 0
+while (i < 10) { println("i " + i); i += 1 }
+
+while (i < 10) { println("i " + i); i += 1 }   // Si, de nuevo. Qué ocurrió? Por qué?
+
+i    // Muestra el valor de i. Observa que while es un loop en el sentido clásico -
+     // se ejecuta secuencialmente mientras cambia la variable del bucle. while es muy
+     // rápido, pero los combinadores y comprensiones anteriores son más sencillos
+     // de entender y paralelizar
+
+// Un bucle do-while
+i = 0
+do {
+  println("i es aún menor que 10")
+  i += 1
+} while (i < 10)
+
+// La recursion es la manera idiomática de repetir una acción en Scala (como en la mayoría de
+// lenguajes funcionales).
+// Las funciones recursivas necesitan un tipo de retorno explicito, el compilador no puede inferirlo.
+// En Scala tenemos Unit, que es análogo al tipo de retorno `void` en Java
+def enseñaNumerosEnUnRango(a: Int, b: Int): Unit = {
+  print(a)
+  if (a < b)
+    enseñaNumerosEnUnRango(a + 1, b)
+}
+enseñaNumerosEnUnRango(1, 14)
+
+
+// Condicionales
+
+val x = 10
+
+if (x == 1) println("yeah")
+if (x == 10) println("yeah")
+if (x == 11) println("yeah")
+if (x == 11) println("yeah") else println("nay")
+
+println(if (x == 10) "yeah" else "nope")
+val text = if (x == 10) "yeah" else "nope"
+
+
+/////////////////////////////////////////////////
+// 4. Estructuras de datos
+/////////////////////////////////////////////////
+
+val a = Array(1, 2, 3, 5, 8, 13)
+a(0)     // Int = 1
+a(3)     // Int = 5
+a(21)    // Lanza una excepción
+
+val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo")
+m("fork")         // java.lang.String = tenedor
+m("spoon")        // java.lang.String = cuchara
+m("bottle")       // Lanza una excepción
+
+val mapaSeguro = m.withDefaultValue("no lo se")
+mapaSeguro("bottle")   // java.lang.String = no lo se
+
+val s = Set(1, 3, 7)
+s(0)      // Boolean = false
+s(1)      // Boolean = true
+
+/* Hecha un vistazo a la documentación de Map aquí -
+ * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map
+ * y asegúrate de que puedes leerla
+ */
+
+
+// Tuplas
+
+(1, 2)
+
+(4, 3, 2)
+
+(1, 2, "three")
+
+(a, 2, "three")
+
+// Por qué tener esto?
+val dividirEnteros = (x: Int, y: Int) => (x / y, x % y)
+
+// La función dividirEnteros te da el resultado y el resto
+dividirEnteros(10, 3)    // (Int, Int) = (3,1)
+
+// Para acceder a los elementos de una tupla, usa _._n donde n es el indice (comenzando por 1)
+// del elemento
+val d = dividirEnteros(10, 3)    // (Int, Int) = (3,1)
+
+d._1    // Int = 3
+d._2    // Int = 1
+
+// Alternativamente puedes asignar multiples variables desde una tupla, lo que
+// resulta más conveniente y legible en muchos casos.
+val (div, mod) = dividirEnteros(10, 3)
+
+div     // Int = 3
+mod     // Int = 1
+
+
+/////////////////////////////////////////////////
+// 5. Programación Orientada a Objetos
+/////////////////////////////////////////////////
+
+/*
+  Nota: Todo lo que hemos hecho hasta ahora en este tutorial han sido
+  simples expresiones (valores, funciones, etc). Estas expresiones son validas 
+  para hacer pruebas rapidas en el interprete de la linea de comandos, 
+  pero no pueden existir por si solas en un archivo de Scala. Por ejemplo, 
+  no puedes tener simplemente "val x = 5" en un archivo Scala. En lugar de eso,
+  las únicas construcciones de alto nivel en Scala son:
+
+  - Objetos
+  - Clases
+  - Case clases
+  - Traits
+
+  Y ahora explicaremos lo que son estas.
+*/
+
+// Las clases son similares a las clases de otros lenguajes. Los argumentos del constructor 
+// son declarados despues del nombre de la clase, y la inicialización se hace en el cuerpo de la clase.
+class Perro(r: String) {
+  // Código del constructor aquí
+  var raza: String = r
+
+  // Define un método llamado ladrar, que devuelva un String
+  def ladrar = "Woof, woof!"
+
+  // Los valores y métodos son asumidos como públicos. 
+  // Las palabras "protected" y "private" también son válidas.
+  private def dormir(horas: Int) =
+    println(s"Estoy durmiendo $horas horas")
+
+  // Los métodos abstractos son simplemente métodos sin cuerpo. 
+  // Si descomentamos la linea de debajo, la clase Perro necesitaría ser abstracta:
+  //   abstract class Perro(...) { ... }
+  // def perseguir(algo: String): String
+}
+
+val miperro = new Dog("greyhound")
+println(mydog.raza) // => "greyhound"
+println(mydog.ladrar)  // => "Woof, woof!"
+
+
+// La palabra "object" crea un tipo y una instancia singleton de ese tipo.
+// Es común que las clases en Scala tengan un "companion object", de manera que 
+// el comportamiento por instancia es controlado por las clases y el comportamiento 
+// relacionado a todas las instancias de esa clase es controlado por el objeto
+// La relación es similar a los métodos de las clases con los métodos estáticos 
+// en otros lenguajes. Observa que los objetos y clases pueden tener el mismo nombre.
+object Perro {
+  def todasLasRazasConocidas = List("pitbull", "shepherd", "retriever")
+  def crearPerro(raza: String) = new Dog(breed)
+}
+
+
+// Case clases son clases que tienen funcionalidad extra añadida. Una pregunta
+// común para los principiantes en Scala es cuando usar case clases y cuando usar 
+// clases. La linea no está bien definida, pero en general, las clases tienden a
+// enfocarse en la encapsulación, polimorfismo y comportamiento. Los valores en
+// estas clases tienden a ser privados, y solo se exponen los métodos. 
+// El propósito principal de las case clases es tener datos inmutables.
+// A menudo tienen pocos métodos, y los métodos raramente tienen efectos secundarios.
+case class Persona(nombre: String, telefono: String)
+
+// Para crear instancia nuevas, observa que las case clases no necesitan "new"
+val george = Persona("George", "1234")
+val kate = Persona("Kate", "4567")
+
+// Con las case clases tienes unas pocas ventajas, como el acceso a los campos:
+george.telefono  // => "1234"
+
+// Para la igualdad de campos no necesitas sobreescribir el método equals
+Persona("George", "1234") == Persona("Kate", "1236")  // => false
+
+// Manera fácil de copiar
+// otroGeorge == Persona("George", "9876")
+val otroGeorge = george.copy(telefono = "9876")
+
+// Y muchas otras. Las case clases también tienen comparación de patrones, que veremos más abajo.
+
+// Traits
+// De manera similar a las interfaces Java, los traits definen un tipo de objeto y métodos.
+// Scala permite la implementación parcial de dichos métodos.
+// No se permiten parámetros de constructor. Los traits pueden heredar de otros traits o
+// clases sin parámetros.
+
+trait Perro {
+	def raza: String
+	def color: String
+	def ladra: Boolean = true
+	def muerde: Boolean
+}
+class SanBernardo extends Perro {
+	val raza = "San Bernardo"
+	val color = "marrón"
+	def muerde = false
+}  
+
+scala> b  
+res0: SanBernardo = SanBernardo@3e57cd70  
+scala> b.raza  
+res1: String = San Bernardo  
+scala> b.ladra
+res2: Boolean = true  
+scala> b.muerde
+res3: Boolean = false  
+
+// Un trait tambien puede ser usado mezclado con otros traits. 
+// La clase extiende el primer trait, pero la palabra "with" 
+// puede añadir traits adicionales.
+
+trait Ladra {
+	def ladra: String = "Guau"
+}
+trait Perro {
+	def raza: String
+	def color: String
+}
+class SanBernardo extends Perro with Ladra {
+	val raza = "San Bernardo"
+	val color = "marrón"
+}
+
+scala> val b = new SanBernardo
+b: SanBernardo = SanBernardo@7b69c6ba
+scala> b.ladra
+res0: String = Guau
+
+
+/////////////////////////////////////////////////
+// 6. Comparación de patrones
+/////////////////////////////////////////////////
+
+// La comparación de patrones es una poderosa función de Scala.
+// Ahora veremos como comparar patrones en una case clase. 
+// Nota: A diferencia de otros lenguajes, Scala "cases" no necesitan
+// "break", porque no ejecuta los "case" posteriores.
+
+def comparaPersona(persona: Persona): String = persona match {
+  // Aqui especificas los patrones:
+  case Persona("George", telefono) => "Hemos encontrado a George! Su número es " + telefono
+  case Persona("Kate", telefono)   => "Hemos encontrado a Kate! Su número es " + telefono
+  case Persona(nombre, telefono)     => "Hemos encontrado alguien : " + nombre + ", teléfono : " + telefono
+}
+
+// Las expresiones regulares también están incorporadas.
+// Creas una expresión regular con el método `r` en una cadena:
+val email = "(.*)@(.*)".r
+
+// La comparación de patrones puede parecerse al bloque switch en la familia de lenguajes de C,
+// pero aquí es mucho más poderosa. En Scala, puedes hacer más comparaciones:
+def comparaTodo(obj: Any): String = obj match {
+  // Puedes comparar valores:
+  case "Hola mundo" => "Tengo la cadena Hola mundo"
+
+  // Puedes comparar tipos:
+  case x: Double => "Tengo un double: " + x
+
+  // Puedes especificar condiciones:
+  case x: Int if x > 10000 => "Tengo un número muy grande!"
+
+  // Puedes comparar case clases como antes:
+  case Persona(nombre, telefono) => s"Tengo la información de contacto de $nombre!"
+
+  // Puedes comparar expresiones regulares:
+  case email(nombre, dominio) => s"Tengo la dirección de correo $nombre@$dominio"
+
+  // Puedes comparar tuplas:
+  case (a: Int, b: Double, c: String) => s"Tengo la tupla: $a, $b, $c"
+
+  // Puedes comparar estructuras:
+  case List(1, b, c) => s"Tengo un alista con tres elementos que empieza con 1: 1, $b, $c"
+
+  // Puedes anidar patrones:
+  case List(List((1, 2, "YAY"))) => "Tengo una lista de listas de tuplas"
+
+  // Comparar cualquier case (default) si todos los anteriores no han coincido
+  case _ => "Tengo un objeto desconocido"
+}
+
+// De hecho puedes comparar un patrón con cualquier objeto con el método "unapply". 
+// Esta función es tan poderosa que Scala te deja definir funciones enteras como patrones:
+val funcPatron: Person => String = {
+  case Persona("George", telefono) => s"Teléfono de George: $telefono"
+  case Persona(nombre, telefono) => s"Teléfono de una persona aleatoria: $telefono"
+}
+
+
+/////////////////////////////////////////////////
+// 7. Programación funcional
+/////////////////////////////////////////////////
+
+// Scala permite a los métodos y funciones devolver o 
+// recibir como parámetros otras funciones o métodos
+
+val suma10: Int => Int = _ + 10 // Una función que recibe y devuelve un Int
+List(1, 2, 3) map suma10 // List(11, 12, 13) - suma10 es aplicado a cada elemento
+
+// Las funciones anónimas pueden ser usadas en vez de funciones con nombre:
+List(1, 2, 3) map (x => x + 10)
+
+// Y la barra baja puede ser usada si solo hay un argumento en la función anónima.
+// Se usa como la variable. 
+List(1, 2, 3) map (_ + 10)
+
+// Si el bloque anónimo Y la función que estás usando usan los dos un argumento, 
+// puedes incluso omitir la barra baja.
+List("Dom", "Bob", "Natalia") foreach println
+
+
+// Combinadores
+// Usando s de arriba:
+// val s = Set(1, 3, 7)
+
+s.map(sq)
+
+val sCuadrado = s. map(sq)
+
+sSquared.filter(_ < 10)
+
+sSquared.reduce (_+_)
+
+// La función filter toma un predicado (una función A -> Boolean) y
+// selecciona todos los elementos que satisfacen el predicado.
+List(1, 2, 3) filter (_ > 2) // List(3)
+case class Persona(nombre: String, edad: Int)
+List(
+  Persona(nombre = "Dom", edad = 23),
+  Persona(nombre = "Bob", edad = 30)
+).filter(_.edad > 25) // List(Persona("Bob", 30))
+
+
+// Ciertas colecciones (como List) en Scala tienen un método `foreach`,
+// que toma como argumento un tipo que devuelva Unit (un método void)
+val unaListaDeNumeros = List(1, 2, 3, 4, 10, 20, 100)
+unaListaDeNumeros foreach (x => println(x))
+unaListaDeNumeros foreach println
+
+// Para comprensiones
+
+for { n <- s } yield sq(n)
+
+val nCuadrado2 = for { n <- s } yield sq(n)
+
+for { n <- nSquared2 if n < 10 } yield n
+
+for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
+
+/* Nota: Esos no son bucles. La semántica de un bucle es repetir, mientras que un for de comprension define una relación entre dos conjuntos de datos.*/
+
+
+/////////////////////////////////////////////////
+// 8. Implicitos
+/////////////////////////////////////////////////
+
+/* ATENCIÓN ATENCIÓN: Los implicitos son un conjunto de poderosas características de Scala
+ * y es fácil abusar de ellos. Si eres principiante en Scala deberías resistir la tentación
+ * de usarlos hasta que entiendas no solo como funcionan, sino también las mejores prácticas
+ * con ellos. Nosotros solo incluiremos esta sección en el tutorial porque son tan comunes
+ * en las librerias de Scala que es imposible hacer algo significativo sin usar una librería
+ * que tenga implicitos. Esto es para que entiendas como funcionan los implicitos, no para 
+ * que definas los tuyos propios.
+ */
+
+// Cualquier valor (val, funciones, objetos, etc) puede ser declarado como implicito usando
+// la palabra "implicit". Observa que usamos la clase Perro de la sección 5.
+implicit val miEnteroImplicito = 100
+implicit def miFunciónImplicita(raza: String) = new Perro("Golden " + raza)
+
+// Por si misma, la palabra implicit no cambia el comportamiento de un valor,
+// así que estos valores pueden ser usados como siempre.
+miEnteroImplicito + 2              // => 102
+miFunciónImplicita("Pitbull").raza // => "Golden Pitbull"
+
+// La diferencia es que estos valores ahora pueden ser usados cuando otra pieza de código
+// necesite un valor implicito. Una situación así puede darse con argumentos implicitos de función:
+def enviaSaludos(aQuien: String)(implicit cuantos: Int) =
+  s"Hola $aQuien, $cuantos saludos a ti y a los tuyos!"
+
+// Si proporcionamos un valor para "cuantos", la función se comporta como siempre
+enviaSaludos("John")(1000)  // => "Hola John, 1000 saludos a ti y a los tuyos!"
+
+// Pero si omitimos el parámetro implicito, un valor implicito del mismo tipo es usado,
+// en este caso, "miEnteroImplicito":
+enviaSaludos("Jane")  // => "Hello Jane, 100 blessings to you and yours!"
+
+// Los parámetros de función implicit nos permiten simular clases tipo en otros lenguajes funcionales. 
+// Es usado tan a menudo que tiene su propio atajo. Las dos siguientes lineas significan lo mismo:
+// def foo[T](implicit c: C[T]) = ...
+// def foo[T : C] = ...
+
+
+// Otra situación en la que el compilador busca un implicit es si tienes
+//   obj.método(...)
+// pero "obj" no tiene "método" como un método. En este caso, si hay una conversión 
+// implicita de tipo A => B, donde A es el tipo de obj y B tiene un método llamado
+// "método", esa conversión es aplicada. Así que teniendo miFunciónImplicita, podemos decir:
+"Retriever".raza // => "Golden Retriever"
+"Sheperd".ladra    // => "Woof, woof!"
+
+// Aquí la cadena es convertida primero a Perro usando nuestra función miFunciónImplicita, 
+// y entonces el método apropiado es llamado. Esta es una herramienta extremadamente poderosa
+// pero de nuevo, no puede usarse con ligereza. De hecho, cuando definiste la función implicita, 
+// tu compilador debería haber mostrado una advertencia, diciendo que no deberías hacer esto 
+// a no ser que realmente sepas lo que estás haciendo.
+
+/////////////////////////////////////////////////
+// 9. Misc
+/////////////////////////////////////////////////
+
+// Importando cosas
+import scala.collection.immutable.List
+
+// Importando todos los "sub paquetes"
+import scala.collection.immutable._
+
+// Importando multiples clases en una línea
+import scala.collection.immutable.{List, Map}
+
+// Renombrar un import usando '=>'
+import scala.collection.immutable.{List => ImmutableList}
+
+// Importar todas las clases, excepto algunas. La siguiente linea excluye Map y Set:
+import scala.collection.immutable.{Map => _, Set => _, _}
+
+// Las clases de Java pueden ser importadas también con sintaxis de Scala:
+import java.swing.{JFrame, JWindow}
+
+// El punto de entrada de tus programas está definido en un fichero scala usando un object, 
+// con un solo método, main:
+object Application {
+  def main(args: Array[String]): Unit = {
+    // Aquí va tu código.
+  }
+}
+
+// Los ficheros pueden contener multiples clases y objetos. Compila con scalac
+
+
+// Salida y entrada
+
+// Leer un fichero línea por línea
+import scala.io.Source
+for(line <- Source.fromFile("miarchivo.txt").getLines())
+  println(line)
+
+// Para escribir un archivo usa el PrintWriter de Java
+val writer = new PrintWriter("miarchivo.txt")
+writer.write("Escribiendo linea por linea" + util.Properties.lineSeparator)
+writer.write("Otra linea" + util.Properties.lineSeparator)
+writer.close()
+
+```
+
+## Más recursos
+
+* [Scala para los impacientes](http://horstmann.com/scala/)
+* [Escuela de Scala en Twitter](http://twitter.github.io/scala_school/)
+* [La documentación de Scala](http://docs.scala-lang.org/)
+* [Prueba Scala en tu navegador](http://scalatutorials.com/tour/)
+* Unete al [grupo de usuarios de Scala](https://groups.google.com/forum/#!forum/scala-user)
diff --git a/es-es/visualbasic-es.html.markdown b/es-es/visualbasic-es.html.markdown
index c7f581c0..c677c20f 100644
--- a/es-es/visualbasic-es.html.markdown
+++ b/es-es/visualbasic-es.html.markdown
@@ -4,13 +4,11 @@ contributors:
     - ["Brian Martin", "http://brianmartin.biz"]
 translators:
     - ["Adolfo Jayme Barrientos", "https://github.com/fitojb"]
-author: Brian Martin
-author_url: https://github.com/fitojb
 filename: learnvisualbasic-es.vb
 lang: es-es
 ---
 
-```vb
+```
 Module Module1
 
     Sub Main()
diff --git a/factor.html.markdown b/factor.html.markdown
index 79596d83..53c692df 100644
--- a/factor.html.markdown
+++ b/factor.html.markdown
@@ -9,7 +9,7 @@ Factor is a modern stack-based language, based on Forth, created by Slava Pestov
 
 Code in this file can be typed into Factor, but not directly imported because the vocabulary and import header would make the beginning thoroughly confusing.
 
-```
+```factor
 ! This is a comment
 
 ! Like Forth, all programming is done by manipulating the stack.
diff --git a/fi-fi/markdown-fi.html.markdown b/fi-fi/markdown-fi.html.markdown
index c5ee52b0..defc7100 100644
--- a/fi-fi/markdown-fi.html.markdown
+++ b/fi-fi/markdown-fi.html.markdown
@@ -10,7 +10,7 @@ lang: fi-fi
 
 John Gruber loi Markdownin vuona 2004. Sen tarkoitus on olla helposti luettava ja kirjoitettava syntaksi joka muuntuu helposti HTML:ksi (ja nyt myös moneksi muuksi formaatiksi).
 
-```markdown
+```md
 <!-- Jokainen HTML-tiedosto on pätevää Markdownia. Tämä tarkoittaa että voimme
 käyttää HTML-elementtejä Markdownissa, kuten kommentteja, ilman että markdown
 -jäsennin vaikuttaa niihin. Tästä johtuen et voi kuitenkaan käyttää markdownia
diff --git a/fr-fr/awk-fr.html.markdown b/fr-fr/awk-fr.html.markdown
new file mode 100644
index 00000000..75c48811
--- /dev/null
+++ b/fr-fr/awk-fr.html.markdown
@@ -0,0 +1,377 @@
+---
+category: tool
+tool: awk
+filename: learnawk-fr.awk
+contributors:
+     - ["Marshall Mason", "http://github.com/marshallmason"]
+translators:
+    - ["GannonTdW", "https://github.com/GannonTdW"]
+lang: fr-fr
+
+---
+
+AWK est un outil standard présent dans chaque système UNIX conforme aux normes POSIX.
+C’est un outil en ligne de commande qui ressemble au Perl et qui est excellent dans les tâches de traitement de fichiers texte.
+Vous pouvez l’appeler à partir d’un script shell, ou l’utiliser comme un langage de script autonome.
+
+Pourquoi utiliser AWK au lieu du langage Perl ?
+Principalement, car AWK fait partie d'UNIX et est donc présent par défaut sur une très grande partie des systèmes d'exploitation UNIX et Linux. 
+AWK est aussi plus facile à lire que le langage Perl ; et est l'outil idéal pour ce qui concerne le traitement de texte simple. Notamment le traitement de ceux qui necéssitent de lire des fichiers ligne par ligne ; chaque ligne comportant des champs séparés par des délimiteur.
+
+
+```awk
+#!/usr/bin/awk -f
+
+# Les commentaires commencent par un #
+
+
+# les programmes AWK consistent en une collection de règles et d'actions
+règle1 { action; }
+règle2 { action; }
+
+# AWK lit et analyse automatiquement chaque ligne de chaque fichier fourni.
+# Chaque ligne est divisée par un délimiteur FS qui est par défaut l'espace (plusieurs espaces ou une tabulation comptent pour un espace). Ce délimiteur peut être changer grâce à l'option -F ou être renseigné au début d'un bloc (exemple: FS = " ").
+
+# BEGIN est une règle spécifique exécutée au début du programme. C'est à cet endroit que vous mettrez tout le code à exécuter avant de traiter les fichiers texte. Si vous ne disposez pas de fichiers texte, considérez BEGIN comme le point d’entrée principal du script.
+# A l'opposé de BEGIN, il existe la règle END. Cette règle est présente après chaque fin de fichier (EOF : End Of File).
+
+BEGIN {
+
+    # Les variables sont globales. Pas besoin de les déclarer.
+    count = 0;
+
+    # les opérateurs sont identiques au langage C et aux langages similaires (exemple: C#, C++)
+    a = count + 1; # addition
+    b = count - 1; # soustraction
+    c = count * 1; # multiplication
+    d = count / 1; # division entière
+    e = count % 1; # modulo, reste de la division entière
+    f = count ^ 1; # exponentiel
+
+    a += 1;
+    b -= 1;
+    c *= 1;
+    d /= 1;
+    e %= 1;
+    f ^= 1;
+
+    # Incrémenter et décrémenter par un
+    a++;
+    b--;
+
+    # En tant qu'opérateur préfixé, c'est la valeur incrémentée qui est retournée
+    ++a;
+    --b;
+
+    # Instruction de contrôle
+    if (conteur == 0)
+        print "Nombre de départ 0";
+    else
+        print "Hein?";
+
+    # Vous pouvez aussi utiliser l'opérateur ternaire
+    print (compteur == 0) ? "Nombre de départ 0" : "Hein?";
+
+    # Les blocs sont composés d'une multitude de lignes entre accolades
+    while (a < 10) {
+        print "La concaténation de chaînes de caractères" " se fait avec des séries de chaînes "    " séparées par des espaces";
+        print a;
+
+        a++;
+    }
+
+    for (i = 0; i < 10; i++)
+        print "le bon vieux for pour les boucles";
+
+    # Les opérateurs de comparaison sont standard
+    # a < b   # plus petit que
+    # a <= b  # plus petit ou égale à
+    # a != b  # non égale
+    # a == b  # égale
+    # a > b   # Plus grand que
+    # a >= b  # Plus grand ou égale à
+
+    # Les opérateurs logiques sont
+    # a && b  # ET
+    # a || b  # OU
+
+    # En plus, il y a les expressions régulières
+    if ("foo" ~ "^fo+$")
+        print "Fooey!";
+    if ("boo" !~ "^fo+$")
+        print "Boo!";
+
+    # Les Tableaux
+    arr[0] = "foo";
+    arr[1] = "bar";
+
+    # Vous pouvez aussi initialiser un tableau avec la fonction split()
+
+    n = split("foo:bar:baz", arr, ":");
+
+    # Il y a aussi les tableaux associatifs
+    assoc["foo"] = "bar";
+    assoc["bar"] = "baz";
+
+    # et les tableaux multi-dimentions, avec certaines limitations que l'on ne mentionnera pas ici
+    multidim[0,0] = "foo";
+    multidim[0,1] = "bar";
+    multidim[1,0] = "baz";
+    multidim[1,1] = "boo";
+
+    # Vous pouvez tester l'appartenance à un tableau
+    if ("foo" in assoc)
+        print "Fooey!";
+
+    # Vous pouvez aussi utilisez l'opérateur 'in' pour parcourir les clés d'un tableau
+    for (key in assoc)
+        print assoc[key];
+
+    # La ligne de commande est dans un tableau spécifique appelé ARGV
+    for (argnum in ARGV)
+        print ARGV[argnum];
+
+    # Vous pouvez supprimer des éléments d'un tableau
+    # C'est utile pour empêcher AWK de supposer que certains arguments soient des fichiers à traiter.
+    delete ARGV[1];
+
+    # Le nombre d'arguments de la ligne de commande est dans une variable appellée ARGC
+    print ARGC;
+
+    # AWK inclue trois catégories de fonction.
+    # On les examinera plus tard
+
+    return_value = arithmetic_functions(a, b, c);
+    string_functions();
+    io_functions();
+}
+
+# Voici comment définir une fonction
+function arithmetic_functions(a, b, c,     d) {
+
+    # La partie la plus ennuieuse de AWK est probablement l’absence de variables locales.
+    # Tout est global. Pour les scripts courts, c'est très utile, mais pour les scripts plus longs,
+    # cela peut poser problème.
+
+    # Il y a cepandant une solution de contournement (enfin ... une bidouille).
+    # Les arguments d'une fonction sont locaux à cette fonction.
+    # Et AWK vous permet de définir plus d'arguments à la fonction que nécessaire.
+    # Il suffit donc de mettre une variable locale dans la déclaration de fonction,
+    # comme ci-dessus. La convention veut que vous mettiez quelques espaces supplémentaires
+    # pour faire la distinction entre les paramètres réels et les variables locales.
+    # Dans cet exemple, a, b et c sont des paramètres réels,
+    # alors que d est simplement une variable locale.
+
+    # Maintenant, les fonctions arithmétiques
+
+    # La plupart des implémentations de AWK ont des fonctions trigonométriques standards
+    localvar = sin(a);
+    localvar = cos(a);
+    localvar = atan2(b, a); # arc tangente de b / a
+
+    # Les exponentiels et logarithmes décimaux sont aussi là
+    localvar = exp(a);
+    localvar = log(a);
+
+    # Les racines carrées
+    localvar = sqrt(a);
+
+    # Tronquer un nombre décimal en nombre entier
+    localvar = int(5.34); # localvar => 5
+
+    # Les nombres aléatoires
+    srand(); 
+    # L'argument de la fonction srand() est la valeur de départ pour générer
+    # les nombres aléatoires . Par défaut, il utilise l'heure du système
+    
+    localvar = rand(); # Nombre aléatoire entre 0 et 1.
+
+    # Maintenant on retourne la valeur
+    return localvar;
+}
+
+function string_functions(    localvar, arr) {
+
+    # AWK a plusieurs fonctions pour le traitement des chaînes de caractères,
+    # dont beaucoup reposent sur des expressions régulières.
+
+    # Chercher et remplacer, la première occurence (sub) ou toutes les occurences (gsub)
+    # Les deux renvoient le nombre de correspondances remplacées
+    localvar = "fooooobar";
+    sub("fo+", "Meet me at the ", localvar); # localvar => "Meet me at the bar"
+    gsub("e+", ".", localvar); # localvar => "m..t m. at th. bar"
+
+    # Rechercher une chaîne de caractères qui correspond à une expression régulière
+    # index() fait la même chose, mais n'autorise pas les expressions régulières
+    match(localvar, "t"); # => 4, puisque 't' est le quatrième caractère
+
+    # Séparer par un délimiteur
+    n = split("foo-bar-baz", arr, "-"); # a[1] = "foo"; a[2] = "bar"; a[3] = "baz"; n = 3
+
+    # Autre astuces utiles
+    sprintf("%s %d %d %d", "Testing", 1, 2, 3); # => "Testing 1 2 3"
+    substr("foobar", 2, 3); # => "oob"
+    substr("foobar", 4); # => "bar"
+    length("foo"); # => 3
+    tolower("FOO"); # => "foo"
+    toupper("foo"); # => "FOO"
+}
+
+function io_functions(    localvar) {
+
+    # Vous avez déjà vu print
+    print "Hello world";
+
+    # Mais il y a aussi printf
+    printf("%s %d %d %d\n", "Testing", 1, 2, 3);
+
+    # AWK n'a pas de descripteur de fichier en soi. Il ouvrira automatiquement
+    # un descripteur de fichier lorsque vous utilisez quelque chose qui en a besoin.
+    # La chaîne de caractères que vous avez utilisée pour cela peut être traitée
+    # comme un descripteur de fichier à des fins d'entrée / sortie.
+
+    outfile = "/tmp/foobar.txt";
+
+    print "foobar" > outfile;
+
+    # Maintenant, la chaîne de caractères "outfile" est un descripteur de fichier.
+    # Vous pouvez le fermer
+    close(outfile);
+
+    # Voici comment exécuter quelque chose dans le shell
+    system("echo foobar"); # => affiche foobar
+
+    # Lire quelque chose depuis l'entrée standard et la stocker dans une variable locale
+    getline localvar;
+
+    # Lire quelque chose à partir d'un pipe (encore une fois, utilisez une chaine de caractère
+    # que vous fermerez proprement)
+    "echo foobar" | getline localvar # localvar => "foobar"
+    close("echo foobar")
+
+    # Lire une ligne d'un fichier et la stocker dans une variable locale
+    infile = "/tmp/foobar.txt";
+    getline localvar < infile;
+    close(infile);
+}
+
+# Comme dit au début, AWK consiste en une collection de règles et d'actions.
+# Vous connaissez déjà les règles BEGIN et END. Les autres règles ne sont utilisées que si vous traitez 
+# des lignes à partir de fichiers ou l'entrée standard (stdin).
+# Quand vous passez des arguments à AWK, ils sont considérés comme des noms de fichiers à traiter.
+# AWK les traitera tous dans l'ordre. Voyez les comme dans à une boucle implicite,
+# parcourant les lignes de ces fichiers.
+# Ces règles et ces actions ressemblent à des instructions switch dans la boucle.
+
+/^fo+bar$/ {
+
+    # Cette action sera exécutée pour chaque ligne qui correspond à l'expression régulière,
+    # /^fo+bar$/, et sera ignorée pour toute ligne qui n'y correspond pas.
+    # Imprimons simplement la ligne:
+
+    print;
+
+    # Pas d'argument ! C'est parce que print a un défaut : $0.
+    # $0 est le nom de la ligne en cours de traitement. Il est créé automatiquement.
+
+    # Vous devinez probablement qu'il existe d'autres variables $.
+    # Chaque ligne est divisée implicitement avant que chaque action soit exécutée, comme
+    # le fait le shell. Et, comme le shell, chaque champ est accessible avec un signe dollar
+
+     # Ceci affichera les deuxième et quatrième champs de la ligne.
+    print $2, $4;
+
+    # AWK défini automatiquement beaucoup d'autres variables qui peuvent vous aider
+    # à inspecter et traiter chaque ligne. La plus importante est NF
+
+    # Affiche le nombre de champs de la ligne
+    print NF;
+
+    # Afficher le dernier champ de la ligne
+    print $NF;
+}
+
+# Chaque règle est en réalité un test conditionel. 
+
+a > 0 {
+    # Ceci s’exécutera une fois pour chaque ligne, tant que le test est positif
+}
+
+# Les expressions régulières sont également des tests conditionels.
+#Si le test de l'expression régulières n'est pas vrais alors le bloc n'est pas executé
+$0 /^fobar/ { 
+   print "la ligne commance par fobar"  
+}
+
+# Dans le cas où vous voulez tester votre chaine de caractères sur la ligne en cours de traitement
+# $0 est optionnelle.
+
+/^[a-zA-Z0-9]$/ {
+    print "La ligne courante ne contient que des caractères alphanumériques.";
+}
+
+
+# AWK peut parcourir un fichier texte ligne par ligne et exécuter des actions en fonction de règles établies
+# Cela est si courant sous UNIX qu'AWK est un langage de script.
+
+# Ce qui suit est un exemple rapide d'un petit script, pour lequel AWK est parfait.
+# Le script lit un nom à partir de l'entrée standard, puis affiche l'âge moyen de toutes les
+# personnes portant ce prénom.
+# Supposons que vous fournissiez comme argument le nom d'un fichier comportant ces données:
+#
+# Bob Jones 32
+# Jane Doe 22
+# Steve Stevens 83
+# Bob Smith 29
+# Bob Barker 72
+#
+# Le script est le suivant :
+
+BEGIN {
+
+    # Premièrement, on demande à l'utilisateur le prénom voulu
+    print "Pour quel prénom vouldriez vous savoir l'age moyen ?";
+
+    # On récupère la ligne à partir de l'entrée standard, pas de la ligne de commande
+    getline name < "/dev/stdin";
+}
+
+# Maintenant, pour chaque ligne dont le premier champ est le prénom donné
+$1 == name {
+
+    # Ici, nous avons accès à un certain nombre de variables utiles déjà préchargées :
+    # $0 est la ligne entière
+    # $3 est le troisième champ. Ici il correspond à l'age qui nous intéresse
+    # NF est le nombre de champs et vaut 3
+    # NR est le nombre d'enregistrements (lignes) vus jusqu'à présent
+    # FILENAME est le nom du fichier en cours de traitement
+    # FS est séparateur de champs, ici c'est " " (un espace)
+    # ...etc. Et beaucoup d'autre que vous pouvez connaître dans le manuel de man.
+    # Pour cela exécutez "man awk" dans votre terminal
+
+    # Garder une trace du total accumulé et du nombre de lignes correspondant.
+    sum += $3;
+    nlines++;
+}
+
+# Un autre motif spécial est END. Il fonctionnera après le traitement de tous
+# les fichiers texte. Contrairement à BEGIN, il ne fonctionne que si vous lui
+# donnez une entrée à traiter. Il sera exécuté une fois que tous les fichiers
+# auront été lus et traités conformément aux règles et aux actions que vous
+# avez fournies. Le but est généralement de produire un rapport final
+# ou de faire quelque chose avec l'ensemble des données que vous avez
+# accumulées au cours du script.
+
+
+END {
+    if (nlines)
+        print "L'age moyen pour le prénom " name " est " sum / nlines;
+}
+
+```
+Pour plus d'informations :
+
+* [Awk tutorial](http://www.grymoire.com/Unix/Awk.html)
+* [Awk man page](https://linux.die.net/man/1/awk)
+* [The GNU Awk User's Guide](https://www.gnu.org/software/gawk/manual/gawk.html) GNU Awk est dans la majorité des systèmes Linux.
+* [AWK one-liner collection](http://tuxgraphics.org/~guido/scripts/awk-one-liner.html)
diff --git a/fr-fr/c++-fr.html.markdown b/fr-fr/c++-fr.html.markdown
index acbaed58..863162f7 100644
--- a/fr-fr/c++-fr.html.markdown
+++ b/fr-fr/c++-fr.html.markdown
@@ -910,7 +910,6 @@ v.swap(vector<Foo>());
 ```
 Lecture complémentaire :
 
-Une référence à jour du langage est disponible à
-<http://cppreference.com/w/cpp>
-
-Des ressources supplémentaires sont disponibles à <http://cplusplus.com>
+* Une référence à jour du langage est disponible à [CPP Reference](http://cppreference.com/w/cpp).
+* Des ressources supplémentaires sont disponibles à [CPlusPlus](http://cplusplus.com).
+* Un tutoriel couvrant les bases du langage et la configuration d'un environnement de codage est disponible à l'adresse [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb).
diff --git a/fr-fr/dynamic-programming-fr.html.markdown b/fr-fr/dynamic-programming-fr.html.markdown
index 24e8c95f..ea547dae 100644
--- a/fr-fr/dynamic-programming-fr.html.markdown
+++ b/fr-fr/dynamic-programming-fr.html.markdown
@@ -8,7 +8,6 @@ translators:
 lang: fr-fr
 ---
 
-
 # Programmation dynamique
 
 ## Introduction
@@ -17,9 +16,9 @@ La programmation dynamique est une technique très efficace pour résoudre une c
 
 ## Moyens de résoudre ces problèmes
 
-1.) *De haut en bas* : Commençons à résoudre le problème en le séparant en morceaux. Si nous voyons que le problème a déjà été résolu, alors nous retournons la réponse précédemment sauvegardée. Si le problème n'a pas été résolu, alors nous le résolvons et sauvegardons la réponse. C'est généralement facile et intuitif de réfléchir de cette façon. Cela s'appelle la Mémorisation.
+1. *De haut en bas* : Commençons à résoudre le problème en le séparant en morceaux. Si nous voyons que le problème a déjà été résolu, alors nous retournons la réponse précédemment sauvegardée. Si le problème n'a pas été résolu, alors nous le résolvons et sauvegardons la réponse. C'est généralement facile et intuitif de réfléchir de cette façon. Cela s'appelle la Mémorisation.
 
-2.) *De bas en haut* : Il faut analyser le problème et trouver les sous-problèmes, et l'ordre dans lequel il faut les résoudre. Ensuite, nous devons résoudre les sous-problèmes et monter jusqu'au problème que nous voulons résoudre. De cette façon, nous sommes assurés que les sous-problèmes sont résolus avant de résoudre le vrai problème. Cela s'appelle la Programmation Dynamique.
+2. *De bas en haut* : Il faut analyser le problème et trouver les sous-problèmes, et l'ordre dans lequel il faut les résoudre. Ensuite, nous devons résoudre les sous-problèmes et monter jusqu'au problème que nous voulons résoudre. De cette façon, nous sommes assurés que les sous-problèmes sont résolus avant de résoudre le vrai problème. Cela s'appelle la Programmation Dynamique.
 
 ## Exemple de Programmation Dynamique
 
@@ -27,7 +26,7 @@ Le problème de la plus grande sous-chaîne croissante est de trouver la plus gr
 Premièrement, nous avons à trouver la valeur de la plus grande sous-chaîne (LSi) à chaque index `i`, avec le dernier élément de la sous-chaîne étant ai. Alors, la plus grande sous-chaîne sera le plus gros LSi. Pour commencer, LSi est égal à 1, car ai est le seul élément de la chaîne (le dernier). Ensuite, pour chaque `j` tel que `j<i` et `aj<ai`, nous trouvons le plus grand LSj et ajoutons le à LSi. L'algorithme fonctionne en temps *O(n2)*.   
 
 Pseudo-code pour trouver la longueur de la plus grande sous-chaîne croissante :
-La complexité de cet algorithme peut être réduite en utilisant une meilleure structure de données qu'un tableau. Par exemple, si nous sauvegardions le tableau d'origine, ou une variable comme plus_grande_chaîne_jusqu'à_maintenant et son index, nous pourrions sauver beaucoup de temps. 
+La complexité de cet algorithme peut être réduite en utilisant une meilleure structure de données qu'un tableau. Par exemple, si nous sauvegardions le tableau d'origine, ou une variable comme `plus_grande_chaîne_jusqu'à_maintenant` et son index, nous pourrions sauver beaucoup de temps. 
 
 Le même concept peut être appliqué pour trouver le chemin le plus long dans un graphe acyclique orienté.  
 
@@ -43,12 +42,9 @@ Le même concept peut être appliqué pour trouver le chemin le plus long dans u
 
 ### Problèmes classiques de programmation dynamique
 
-L'algorithme de Floyd Warshall(EN)) - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code
-
-Problème du sac à dos(EN) - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem
-
-
-Plus longue sous-chaîne commune(EN) - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence
+- [L'algorithme de Floyd Warshall(EN) - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code)
+- [Problème du sac à dos(EN) - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem)
+- [Plus longue sous-chaîne commune(EN) - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence)
 
 ## Online Resources
 
diff --git a/fr-fr/elixir-fr.html.markdown b/fr-fr/elixir-fr.html.markdown
new file mode 100644
index 00000000..90cdad7c
--- /dev/null
+++ b/fr-fr/elixir-fr.html.markdown
@@ -0,0 +1,479 @@
+---
+language: elixir
+contributors:
+    - ["Joao Marques", "http://github.com/mrshankly"]
+    - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+    - ["Ryan Plant", "https://github.com/ryanplant-au"]
+    - ["Ev Bogdanov", "https://github.com/evbogdanov"]
+translator:
+    - ["Timothé Pardieu", "https://github.com/timprd"]
+filename: learnelixir-fr.ex
+lang: fr-fr
+---
+Elixir est un langage de programmation fonctionnel moderne reposant sur la machine virtuelle BEAM, qui héberge aussi Erlang.
+Il est totalement compatible avec Erlang mais dispose d'une syntaxe plus agréable et apporte de nouvelles fonctionnalités. 
+
+
+```elixir
+
+# Un commentaire simple sur une seule ligne commence par un dièse.
+
+# Il n'y a pas de commentaire multi-ligne,
+# Mais il est possible de les empiler comme ici.
+
+# La commande `iex` permet de lancer le shell Elixir.
+# La commande `elixirc` permet de compiler vos modules.
+
+# Les deux devraient être dans votre path si vous avez installé Elixir correctement.
+
+## ---------------------------
+## -- Types basiques
+## ---------------------------
+
+# Il y a les nombres
+3    # Integer 
+0x1F # Integer
+3.0  # Float
+
+# Les atomes, des littéraux, qui sont des constantes avec comme valeur leur nom. 
+# Ils commencent par `:`.
+
+:hello # atom
+
+# Il existe également des n-uplets dont les valeurs sont stockés de manière contiguë 
+# en mémoire.
+
+{1,2,3} # tuple
+
+# Il est possible d'accéder à un element d'un tuple avec la fonction 
+# `elem`:
+elem({1, 2, 3}, 0) #=> 1
+
+# Les listes sont implémentées sous forme de listes chainées.
+[1,2,3] # list
+
+# La tête et le reste d'une liste peuvent être récupérés comme cela :
+[head | tail] = [1,2,3]
+head #=> 1
+tail #=> [2,3]
+
+# En Elixir, comme en Erlang, le `=` dénote un 'pattern matching' 
+# (Filtrage par motif) et non une affectation.
+# Cela signifie que la partie de gauche (pattern) est comparé (match) à 
+# la partie de droite. 
+
+
+# Une erreur sera lancée si aucun model (match) est trouvé.
+# Dans cet exemple les tuples ont des tailles différentes
+# {a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
+
+# Il y a aussi les binaires
+<<1,2,3>> # binary
+
+# Chaine de caractères et liste de caractères
+"hello" # string
+'hello' # char list
+
+# Chaine de caractères sur plusieurs lignes
+"""
+Je suis une chaine de caractères
+sur plusieurs lignes.
+"""
+#=> "Je suis une chaine de caractères\nsur plusieurs lignes.\n"
+
+# Les chaines de caractères sont encodées en UTF-8 :
+"héllò" #=> "héllò"
+
+# Les chaines de caractères sont des binaires tandis que
+# les listes de caractères sont des listes.
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c]   #=> 'abc'
+
+# `?a` en Elixir retourne le code ASCII (Integer) de la lettre `a`
+?a #=> 97
+
+# Pour concaténer des listes il faut utiliser `++`, et `<>` pour les
+# binaires
+[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
+'hello ' ++ 'world'  #=> 'hello world'
+
+<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
+"hello " <> "world"  #=> "hello world"
+
+# Les intervalles sont représentés de cette sorte `début..fin`
+# (tout deux inclusifs)
+1..10 #=> 1..10
+bas..haut = 1..10 # Possibilité d'utiliser le pattern matching sur les intervalles aussi.
+[bas, haut] #=> [1, 10]
+
+# Les Maps (Tableau associatif) sont des paires clée - valeur
+genders = %{"david" => "male", "gillian" => "female"}
+genders["david"] #=> "male"
+
+# Les maps avec des atomes peuvent être utilisés comme cela
+genders = %{david: "male", gillian: "female"}
+genders.gillian #=> "female"
+
+## ---------------------------
+## -- Operateurs
+## ---------------------------
+
+# Mathématiques
+1 + 1  #=> 2
+10 - 5 #=> 5
+5 * 2  #=> 10
+10 / 2 #=> 5.0
+
+# En Elixir l'opérateur `/` retourne toujours un Float (virgule flottante).
+
+# Pour faire une division avec entier il faut utiliser `div`
+div(10, 2) #=> 5
+
+# Pour obtenir le reste de la division il faut utiliser `rem`
+rem(10, 3) #=> 1
+
+# Il y a aussi les opérateurs booléen: `or`, `and` et `not`.
+# Ces opérateurs attendent un booléen en premier argument.
+true and true #=> true
+false or true #=> true
+# 1 and true
+#=> ** (BadBooleanError) expected a booléens on left-side of "and", got: 1
+
+# Elixir fournit aussi `||`, `&&` et `!` qui acceptent des arguments de
+# tout type.
+# Chaque valeur sauf `false` et `nil` seront évalués à vrai (true).
+1 || true  #=> 1
+false && 1 #=> false
+nil && 20  #=> nil
+!true #=> false
+
+# Pour les comparaisons il y a : `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` et `>`
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2  #=> true
+
+# `===` et `!==` sont plus stricts en comparant les Integers (entiers) 
+# et les Floats (nombres à virgules) :
+1 == 1.0  #=> true
+1 === 1.0 #=> false
+
+# On peut aussi comparer deux types de données différents :
+1 < :hello #=> true
+
+# L'ordre est défini de la sorte :
+# number < atom < reference < functions < port < pid < tuple < list < bit string
+
+# Pour citer Joe Armstrong : "The actual order is not important,
+# but that a total ordering is well defined is important."
+
+## ---------------------------
+## -- Structure de contrôle
+## ---------------------------
+
+# Condition avec `if` (si)
+if false do
+  "Cela ne sera pas vu"
+else
+  "Cela le sera"
+end
+
+# Condition avec `unless` (sauf).
+# Il correspond à la négation d'un `if` (si) 
+unless true do
+  "Cela ne sera pas vu"
+else
+  "Cela le sera"
+end
+
+# Beaucoup de structures en Elixir se basent sur le pattern matching.
+# `case` permet de comparer une valeur à plusieurs modèles:
+case {:one, :two} do
+  {:four, :five} ->
+    "Ne match pas"
+  {:one, x} ->
+    "Match et lie `x` à `:two` dans ce cas"
+  _ ->
+    "Match toutes les valeurs"
+end
+
+# Il est commun de lier la valeur à `_` si on ne l'utilise pas.
+# Par exemple, si seulement la tête d'une liste nous intéresse:
+[head | _] = [1,2,3]
+head #=> 1
+
+# Pour plus de lisibilité, ce procédé est utilisé:
+[head | _tail] = [:a, :b, :c]
+head #=> :a
+
+# `cond` permet de vérifier plusieurs conditions à la fois.
+# Il est conseillé d'utiliser `cond` plutôt que des `if` imbriqués.
+cond do
+  1 + 1 == 3 ->
+    "Je ne serai pas vu"
+  2 * 5 == 12 ->
+    "Moi non plus"
+  1 + 2 == 3 ->
+    "Mais moi oui"
+end
+
+# Il est commun d'attribuer la dernière condition à true (vrai), qui
+# matchera toujours.
+cond do
+  1 + 1 == 3 ->
+    "Je ne serai pas vu"
+  2 * 5 == 12 ->
+    "Moi non plus"
+  true ->
+    "Mais moi oui (représente un else)" 
+end
+
+# `try/catch` est utilisé pour attraper les valeurs rejetées. 
+# Il supporte aussi un 
+# `after` qui est appelé autant si une valeur est jetée ou non.
+try do
+  throw(:hello)
+catch
+  message -> "Message : #{message}."
+after
+  IO.puts("Je suis la clause after (après).")
+end
+#=> Je suis la clause after (après).
+# "Message : :hello"
+
+## ---------------------------
+## -- Modules et Fonctions
+## ---------------------------
+
+# Fonctions anonymes (notez le point).
+square = fn(x) -> x * x end
+square.(5) #=> 25
+
+# Les fonctions anonymes acceptent aussi de nombreuses clauses et guards (gardes).
+# Les guards permettent d'affiner le pattern matching,
+# ils sont indiqués par le mot-clef `when` :
+f = fn
+  x, y when x > 0 -> x + y
+  x, y -> x * y
+end
+
+f.(1, 3)  #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir propose aussi de nombreuses fonctions internes.
+is_number(10)    #=> true
+is_list("hello") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# Il est possible de grouper plusieurs fonctions dans un module.
+# Dans un module, les fonctions sont définies par `def`
+defmodule Math do
+  def sum(a, b) do
+    a + b
+  end
+
+  def square(x) do
+    x * x
+  end
+end
+
+Math.sum(1, 2)  #=> 3
+Math.square(3) #=> 9
+
+# Pour compiler notre module `Math`,
+# il faut le sauvegarder en tant que `math.ex` et utiliser `elixirc`.
+# Executez ainsi `elixirc math.ex` dans le terminal.
+
+# Au sein d'un module, nous pouvons définir les fonctions avec `def`
+# et `defp` pour les fonctions privées.
+# Une fonction définie par `def` est disponible dans les autres
+# modules. Une fonction privée est disponible localement seulement.
+defmodule PrivateMath do
+  def sum(a, b) do
+    do_sum(a, b)
+  end
+
+  defp do_sum(a, b) do
+    a + b
+  end
+end
+
+PrivateMath.sum(1, 2)    #=> 3
+# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
+
+# La déclaration de fonction supporte également les guards (gardes) 
+# et les clauses. 
+# Quand une fonction avec plusieurs clauses est appelée,
+# la première fonction dont la clause est satisfaite par les arguments sera appelée.
+# Exemple: le code `area({:circle, 3})` appelle la deuxième fonction definie plus bas,
+# et non la première car ses arguments correspondent à la signature de cette dernière:
+defmodule Geometry do
+  def area({:rectangle, w, h}) do
+    w * h
+  end
+
+  def area({:circle, r}) when is_number(r) do
+    3.14 * r * r
+  end
+end
+
+Geometry.area({:rectangle, 2, 3}) #=> 6
+Geometry.area({:circle, 3})       #=> 28.25999999999999801048
+# Geometry.area({:circle, "not_a_number"})
+#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
+
+# En raison de l'immutabilité, la récursivité est une grande partie
+# d'Elixir
+defmodule Recursion do
+  def sum_list([head | tail], acc) do
+    sum_list(tail, acc + head)
+  end
+
+  def sum_list([], acc) do
+    acc
+  end
+end
+
+Recursion.sum_list([1,2,3], 0) #=> 6
+
+# Les modules Elixir supportent des attributs internes,
+# ceux-ci peuvent aussi être personnalisés.
+defmodule MyMod do
+  @moduledoc """
+  This is a built-in attribute on a example module.
+  """
+
+  @my_data 100 # Attribut personnel.
+  IO.inspect(@my_data) #=> 100
+end
+
+# L'opérateur pipe (|>) permet de passer la sortie d'une expression
+# en premier paramètre d'une fonction. 
+
+Range.new(1,10)
+|> Enum.map(fn x -> x * x end)
+|> Enum.filter(fn x -> rem(x, 2) == 0 end)
+#=> [4, 16, 36, 64, 100]
+
+## ---------------------------
+## -- Structs et Exceptions
+## ---------------------------
+
+# Les Structs sont des extensions des Maps.
+# Apportant en plus les valeurs par defaut, le polymorphisme et 
+# la vérification à la compilation dans Elixir.
+defmodule Person do
+  defstruct name: nil, age: 0, height: 0
+end
+
+jean_info = %Person{ name: "Jean", age: 30, height: 180 }
+#=> %Person{age: 30, height: 180, name: "Jean"}
+
+# Access the value of name
+jean_info.name #=> "Jean"
+
+# Update the value of age
+older_jean_info = %{ jean_info | age: 31 }
+#=> %Person{age: 31, height: 180, name: "Jean"}
+
+# Le bloc `try` avec le mot-clef `rescue` est utilisé pour gérer les exceptions
+try do
+  raise "some error"
+rescue
+  RuntimeError -> "rescued a runtime error"
+  _error -> "this will rescue any error"
+end
+#=> "rescued a runtime error"
+
+# Chaque exception possède un message
+try do
+  raise "some error"
+rescue
+  x in [RuntimeError] ->
+    x.message
+end
+#=> "some error"
+
+## ---------------------------
+## -- Concurrence
+## ---------------------------
+
+# Elixir se repose sur le modèle d'acteur pour gérer la concurrence.
+# Pour écrire un programme concurrent en Elixir il faut trois 
+# primitives: spawning processes (création), sending messages (envoi) 
+# et receiving messages (réception).
+
+# Pour débuter un nouveau processus, il faut utiliser 
+# la fonction `spawn` qui prend en argument une fonction.
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+spawn(f) #=> #PID<0.40.0>
+
+# `spawn` retourn un pid (identifiant de processus), il est possible 
+# d'utiliser ce pid pour envoyer un message au processus.
+# Pour faire parvenir le message il faut utiliser l'opérateur `send`.
+# Pour que cela soit utile il faut être capable de recevoir les 
+# messages.
+# Cela est possible grâce au mechanisme de `receive`:
+
+# Le bloc `receive do` est utilisé pour écouter les messages et les traiter
+# au moment de la réception. Un bloc `receive do` pourra traiter un seul
+# message reçu.
+# Pour traiter plusieurs messages, une fonction avec un bloc `receive do` 
+# doit s'appeler elle-même récursivement.
+
+defmodule Geometry do
+  def area_loop do
+    receive do
+      {:rectangle, w, h} ->
+        IO.puts("Area = #{w * h}")
+        area_loop()
+      {:circle, r} ->
+        IO.puts("Area = #{3.14 * r * r}")
+        area_loop()
+    end
+  end
+end
+
+# Ceci compile le module et créer un processus qui évalue dans le terminal `area_loop`
+pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
+# Alternativement
+pid = spawn(Geometry, :area_loop, [])
+
+# On envoi un message au `pid` qui correspond à la régle de réception.
+send pid, {:rectangle, 2, 3}
+#=> Area = 6
+#   {:rectangle,2,3}
+
+send pid, {:circle, 2}
+#=> Area = 12.56000000000000049738
+#   {:circle,2}
+
+# Le shell est aussi un processus, il est possible d'utiliser `self`
+# pour obtenir le pid du processus courant.
+self() #=> #PID<0.27.0>
+
+## ---------------------------
+## -- Agents
+## ---------------------------
+
+# Un agent est un processus qui garde les traces des valeurs modifiées.
+
+# Pour créer un agent on utilise `Agent.start_link` avec une fonction.
+# L'état initial de l'agent sera ce que la fonction retourne
+{ok, my_agent} = Agent.start_link(fn -> ["red", "green"] end)
+
+# `Agent.get` prend un nom d'agent et une fonction (`fn`).
+# Qu'importe ce que cette `fn` retourne, l'état sera ce qui est retourné.
+Agent.get(my_agent, fn colors -> colors end) #=> ["red", "green"]
+
+# Modification de l'état de l'agent
+Agent.update(my_agent, fn colors -> ["blue" | colors] end)
+```
+
+## Références
+
+* [Guide de debut](http://elixir-lang.org/getting-started/introduction.html) depuis le site [Elixir](http://elixir-lang.org)
+* [Documentation Elixir ](https://elixir-lang.org/docs.html)
+* ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) de Dave Thomas
+* [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
+* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) de Fred Hebert
+* ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) de Joe Armstrong
diff --git a/fr-fr/erlang-fr.html.markdown b/fr-fr/erlang-fr.html.markdown
index 55453c56..1073d6ad 100644
--- a/fr-fr/erlang-fr.html.markdown
+++ b/fr-fr/erlang-fr.html.markdown
@@ -28,7 +28,7 @@ lang: fr-fr
 %% 1. Variables et filtrage par motif
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
-(L'équivalent anglais de *filtrage par motif* est *pattern patching*.)
+(L'équivalent anglais de *filtrage par motif* est *pattern matching*.)
 
 Nb = 42.  % Chaque nom de variable doit commencer par une lettre majuscule.
 
@@ -64,7 +64,7 @@ Point = {point, 10, 45}.
 {point, X, Y} = Point.  % X = 10, Y = 45
 
 % On peut utiliser `_` comme caractère joker pour les variables qui ne nous
-% intéressent pas. Le symbol `_` est appelé variable muette. Contrairement
+% intéressent pas. Le symbole `_` est appelé variable muette. Contrairement
 % aux variables normales, de multiples apparitions de `_` dans un même motif
 % ne lient pas nécessairement à la même valeur.
 Personne = {personne, {nom, {prenom, joe}, {famille, armstrong}},
diff --git a/fr-fr/java-fr.html.markdown b/fr-fr/java-fr.html.markdown
index d0f91611..d6c68343 100644
--- a/fr-fr/java-fr.html.markdown
+++ b/fr-fr/java-fr.html.markdown
@@ -11,7 +11,7 @@ contributors:
     - ["Michael Dähnert", "https://github.com/JaXt0r"]
     - ["Rob Rose", "https://github.com/RobRoseKnows"]
     - ["Sean Nam", "https://github.com/seannam"]
-filename: JavaFr.java
+filename: java-fr.java
 translators:
     - ['Mathieu Gemard', 'https://github.com/mgemard']
 lang: fr-fr
diff --git a/fr-fr/jquery-fr.html.markdown b/fr-fr/jquery-fr.html.markdown
index 1842e02b..1a5baf71 100644
--- a/fr-fr/jquery-fr.html.markdown
+++ b/fr-fr/jquery-fr.html.markdown
@@ -13,6 +13,7 @@ jQuery est une bibliothèque JavaScript dont le but est de permettre de "faire p
 C'est pourquoi aujourd'hui, jQuery est utilisée par de nombreuses grandes entreprises et par des développeurs du monde entier.
 
 Étant donné que jQuery est une bibliothèque JavaScript, vous devriez d'abord [apprendre le JavaScript](https://learnxinyminutes.com/docs/fr-fr/javascript-fr/)
+
 ```js
 
 
@@ -138,5 +139,5 @@ $('p').each(function() {
 });
 
 
-``
+```
 
diff --git a/fr-fr/lambda-calculus-fr.html.markdown b/fr-fr/lambda-calculus-fr.html.markdown
new file mode 100644
index 00000000..c91f21d6
--- /dev/null
+++ b/fr-fr/lambda-calculus-fr.html.markdown
@@ -0,0 +1,106 @@
+---
+category: Algorithms & Data Structures
+name: Lambda Calculus
+contributors:
+    - ["Max Sun", "http://github.com/maxsun"]
+translators:
+    - ["Yvan Sraka", "https://github.com/yvan-sraka"]
+lang: fr-fr
+---
+
+# Lambda-calcul
+
+Le Lambda-calcul (λ-calcul), créé à l'origine par [Alonzo Church](https://en.wikipedia.org/wiki/Alonzo_Church), est le plus petit langage de programmation au monde. En dépit de ne pas avoir de nombres, de chaînes, de booléens, ou de tout type de données sans fonction, le lambda calcul peut être utilisé pour représenter n'importe quelle machine de Turing!
+
+Le Lambda-calcul est composé de 3 éléments : **variables**, **fonctions** et **applications**.
+
+
+| Nom         | Syntaxe                            | Exemple   | Explication                                       |
+|-------------|------------------------------------|-----------|---------------------------------------------------|
+| Variable    | `<nom>`                            | `x`       | une variable nommée "x"                           |
+| Fonction    | `λ<paramètres>.<corps>`            | `λx.x`    | une fonction avec le paramètre "x" et le corps "x"|
+| Application | `<fonction><variable ou function>` | `(λx.x)a` | appel de la fonction "λx.x" avec l'argument "a"   |
+
+La fonction la plus fondamentale est la fonction identité: `λx.x` qui est équivalente à `f(x) = x`. Le premier "x" est l'argument de la fonction, et le second est le corps de la fonction.
+
+## Variables libres et liées :
+
+- Dans la fonction `λx.x`, "x" s'appelle une variable liée car elle est à la fois dans le corps de la fonction et l'un des paramètres.
+- Dans `λx.y`, "y" est appelé une variable libre car elle n'a pas été déclarée plus tôt.
+
+## Évaluation :
+
+L'évaluation est réalisée par [β-Réduction](https://en.wikipedia.org/wiki/Lambda_calculus#Beta_reduction), qui est essentiellement une substitution lexicale.
+
+Lors de l'évaluation de l'expression `(λx.x)a`, nous remplaçons toutes les occurrences de "x" dans le corps de la fonction par "a".
+
+- `(λx.x)a` vaut après évaluation: `a`
+- `(λx.y)a` vaut après évaluation: `y`
+
+Vous pouvez même créer des fonctions d'ordre supérieur:
+
+- `(λx.(λy.x))a` vaut après évaluation: `λy.a`
+
+Bien que le lambda-calcul ne prenne traditionnellement en charge que les fonctions à un seul paramètre, nous pouvons créer des fonctions multi-paramètres en utilisant une technique appelée currying.
+
+- `(λx.λy.λz.xyz)` est équivalent à `f(x, y, z) = x(y(z))`
+
+Parfois, `λxy.<corps>` est utilisé de manière interchangeable avec: `λx.λy.<corps>`
+
+----
+
+Il est important de reconnaître que le lambda-calcul traditionnel n'a pas de nombres, de caractères ou tout autre type de données sans fonction!
+
+## Logique booléenne :
+
+Il n'y a pas de "Vrai" ou de "Faux" dans le calcul lambda. Il n'y a même pas 1 ou 0.
+
+Au lieu:
+
+`T` est représenté par: `λx.λy.x`
+
+`F` est représenté par: `λx.λy.y`
+
+Premièrement, nous pouvons définir une fonction "if" `λbtf` qui renvoie `t` si `b` est vrai et `f` si `b` est faux
+
+`IF` est équivalent à: `λb.λt.λf.b t f`
+
+En utilisant `IF`, nous pouvons définir les opérateurs logiques de base booléens:
+
+`a AND b` est équivalent à: `λab.IF a b F`
+
+`a OR b` est équivalent à: `λab.IF a T b`
+
+`a NOT b` est équivalent à: `λa.IF a F T`
+
+*Note: `IF a b c` est equivalent à : `IF(a(b(c)))`*
+
+## Nombres :
+
+Bien qu'il n'y ait pas de nombres dans le lambda-calcul, nous pouvons encoder des nombres en utilisant les [nombres de Church](https://en.wikipedia.org/wiki/Church_encoding).
+
+Pour tout nombre n: <code>n = λf.f<sup>n</sup></code> donc:
+
+`0 = λf.λx.x`
+
+`1 = λf.λx.f x`
+
+`2 = λf.λx.f(f x)`
+
+`3 = λf.λx.f(f(f x))`
+
+Pour incrémenter un nombre de Church, nous utilisons la fonction successeur `S(n) = n + 1` qui est:
+
+`S = λn.λf.λx.f((n f) x)`
+
+En utilisant `S`, nous pouvons définir la fonction `ADD`:
+
+`ADD = λab.(a S)n`
+
+**Défi:** essayez de définir votre propre fonction de multiplication!
+
+## Pour aller plus loin :
+
+1. [A Tutorial Introduction to the Lambda Calculus](http://www.inf.fu-berlin.de/lehre/WS03/alpi/lambda.pdf)
+2. [Cornell CS 312 Recitation 26: The Lambda Calculus](http://www.cs.cornell.edu/courses/cs3110/2008fa/recitations/rec26.html)
+3. [Wikipedia - Lambda Calculus](https://en.wikipedia.org/wiki/Lambda_calculus)
diff --git a/fr-fr/make-fr.html.markdown b/fr-fr/make-fr.html.markdown
index 48d24549..7b4864b5 100644
--- a/fr-fr/make-fr.html.markdown
+++ b/fr-fr/make-fr.html.markdown
@@ -1,5 +1,6 @@
 ---
-language: make
+category: tool
+tool: make
 contributors:
     - ["Robert Steed", "https://github.com/robochat"]
 translators:
diff --git a/fr-fr/markdown-fr.html.markdown b/fr-fr/markdown-fr.html.markdown
index 8518f35c..26c2546a 100644
--- a/fr-fr/markdown-fr.html.markdown
+++ b/fr-fr/markdown-fr.html.markdown
@@ -6,52 +6,69 @@ filename: markdown-fr.md
 lang: fr-fr
 ---
 
+
 Markdown a été créé par John Gruber en 2004. Il se veut être d'une syntaxe
-facile à lire et à écrire, aisément convertible en HTML
- (et beaucoup d'autres formats aussi à présent).
+facile à lire et à écrire, aisément convertible en HTML (et dans beaucoup
+d'autres formats aussi).
+
+Les implémentations du Markdown varient d'un analyseur syntaxique à un autre.
+Ce guide va essayer de clarifier quand une fonctionnalité est universelle ou
+quand elle est specifique à un certain analyseur syntaxique.
+
+- [Balises HTML](#balises-html)
+- [En-têtes](#en-tetes)
+- [Styles de texte basiques](#style-de-text-basiques)
+- [Paragraphes](#paragraphes)
+- [Listes](#listes)
+- [Blocs de code](#blocs-de-code)
+- [Séparateur horizontal](#separateur-horizontal)
+- [Liens hypertextes](#liens-hypertextes)
+- [Images](#images)
+- [Divers](#divers)
 
-Faites moi autant de retours que vous voulez! Sentez vous libre de "forker" 
-et envoyer des pull request!
+## Balises HTML
 
+Markdown est un sur-ensemble du HTML, donc tout fichier HTML est un ficher
+Markdown valide.
 
 ```md
-<!-- Markdown est une sorte de cousin du HTML, si bien que tout document HTML 
-est un document Markdown valide. Autrement dit, vous pouvez utiliser des 
-balises HTML dans un fichier Markdown, comme la balise commentaire dans 
-laquelle nous sommes à présent, car celle-ci ne sera pas affectée par 
-le parser( analyseur syntaxique ) Markdown. -->
+<!-- Ce qui veut dire que vous pouvez utiliser des balises HTML dans un fichier
+Markdown, comme la balise commentaire dans laquelle nous sommes à présent, car
+celle-ci ne sera pas affectée par l'analyseur syntaxique du Markdown.
+Toutefois, si vous voulez créer une balise HTML dans un fichier Markdown,
+vous ne pourrez pas utiliser du Markdown à l'intérieur de cette derniere. -->
+```
 
-<!-- Toutefois, si vous voulez créer un élément HTML dans un fichier Markdown,
- vous ne pourrez pas utiliser du Markdown à l'intérieur de ce dernier. -->
+## En-têtes
 
-<!--  Le Markdown est implémenté de différentes manières, selon le parser. 
-Ce guide va alors tenter de trier les fonctionnalités universelles de celles
-spécifiques à un parser.  -->
+Vous pouvez facilement créer des balises HTML `<h1>` à `<h6>` en précédant le
+texte de votre futur titre par un ou plusieurs dièses ( # ), de un à six, selon
+le niveau de titre souhaité.
 
-<!-- Headers ( En-têtes ) -->
-<!-- Vous pouvez facilement créer des éléments HTML <h1> à <h6> en précédant
- le texte de votre futur titre par un ou plusieurs dièses ( # ), de un à six,
-  selon le niveau de titre souhaité. -->
+```md
 # Ceci est un <h1>
 ## Ceci est un <h2>
 ### Ceci est un <h3>
 #### Ceci est un <h4>
 ##### Ceci est un <h5>
 ###### Ceci est un <h6>
+```
 
-<!-- 
-Markdown fournit également une façon alternative de marquer les h1 et h2 
--->
+Markdown fournit également une façon alternative de marquer les `<h1>` et `<h2>`
 
+```md
 Ceci est un h1
 =============
 
 Ceci est un h2
 -------------
+```
+
+## Styles de texte basiques
 
-<!-- Styles basiques pour du texte -->
-<!-- On peut facilement rendre un texte "gras" ou "italique" en Markdown -->
+On peut facilement rendre un texte "gras" ou "italique" en Markdown.
 
+```md
 *Ce texte est en italique.*
 _Celui-ci aussi._
 
@@ -61,15 +78,21 @@ __Celui-là aussi.__
 ***Ce texte a les deux styles.***
 **_Pareil ici_**
 *__Et là!__*
+```
 
-<!-- Dans le "GitHub Flavored Markdown", utilisé pour interpréter le Markdown 
-sur GitHub, on a également le strikethrough ( texte barré ) : -->
+Dans le "GitHub Flavored Markdown", utilisé pour interpréter le Markdown sur
+GitHub, on a également le texte barré.
 
-~~Ce texte est barré avec strikethrough.~~
+```md
+~~Ce texte est barré.~~
+```
+
+## Paragraphes
 
-<!--  Les Paragraphes sont représentés par une ou plusieurs lignes de texte 
-séparées par une ou plusieurs lignes vides. -->
+Les paragraphes sont représentés par une ou plusieurs lignes de texte séparées
+par une ou plusieurs lignes vides.
 
+```md
 Ceci est un paragraphe. Là, je suis dans un paragraphe, facile non?
 
 Maintenant je suis dans le paragraphe 2.
@@ -77,21 +100,23 @@ Je suis toujours dans le paragraphe 2!
 
 
 Puis là, eh oui, le paragraphe 3!
+```
 
-<!--  
-Si jamais vous souhaitez insérer une balise HTML <br />, vous pouvez ajouter 
-un ou plusieurs espaces à la fin de votre paragraphe, et en commencer 
-un nouveau.
--->
+Si jamais vous souhaitez insérer une balise HTML `<br />`, vous pouvez ajouter
+un ou plusieurs espaces à la fin de votre paragraphe, et en commencer un
+nouveau.
 
-J'ai deux espaces vides à la fin (sélectionnez moi pour les voir). 
+```md
+J'ai deux espaces vides à la fin (sélectionnez moi pour les voir).
 
 Bigre, il y a un <br /> au dessus de moi!
+```
 
-<!-- Les 'Blocs de Citations' sont générés aisément, grâce au caractère > -->
+Les blocs de citations sont générés aisément, grâce au caractère `>`.
 
+```md
 > Ceci est une superbe citation. Vous pouvez même
-> revenir à la ligne quand ça vous chante, et placer un `>` 
+> revenir à la ligne quand ça vous chante, et placer un `>`
 > devant chaque bout de ligne faisant partie
 > de la citation.
 > La taille ne compte pas^^ tant que chaque ligne commence par un `>`.
@@ -99,191 +124,244 @@ Bigre, il y a un <br /> au dessus de moi!
 > Vous pouvez aussi utiliser plus d'un niveau
 >> d'imbrication!
 > Classe et facile, pas vrai?
+```
+
+## Listes
 
-<!-- les Listes -->
-<!-- les Listes non ordonnées sont marquées par des asterisques, 
-signes plus ou signes moins. -->
+Les listes non ordonnées sont marquées par des asterisques, signes plus ou
+signes moins.
 
+```md
 * Item
 * Item
 * Un autre item
+```
 
 ou
 
+```md
 + Item
 + Item
 + Encore un item
+```
 
 ou
 
+```md
 - Item
 - Item
 - Un dernier item
+```
 
-<!-- les Listes Ordonnées sont générées via un nombre suivi d'un point -->
+Les listes ordonnées sont générées via un nombre suivi d'un point.
 
+```md
 1. Item un
 2. Item deux
 3. Item trois
+```
 
-<!-- Vous pouvez même vous passer de tout numéroter, et Markdown générera 
-les bons chiffres. Ceci dit, cette variante perd en clarté.-->
+Vous pouvez même vous passer de tout numéroter, et Markdown générera les bons
+chiffres. Ceci dit, cette variante perd en clarté.
 
+```md
 1. Item un
 1. Item deux
 1. Item trois
-<!-- ( cette liste sera interprétée de la même façon que celle au dessus ) -->
+```
+
+(Cette liste sera interprétée de la même façon que celle au dessus)
 
-<!-- Vous pouvez également utiliser des sous-listes -->
+Vous pouvez également utiliser des sous-listes.
 
+```md
 1. Item un
 2. Item deux
 3. Item trois
 * Sub-item
 * Sub-item
 4. Item quatre
+```
 
-<!-- Il y a même des "listes de Taches". Elles génèrent des champs HTML 
-de type checkbox. -->
-
-Les [ ] ci dessous, n'ayant pas de [ x ], 
-deviendront des cases à cocher HTML non-cochées.
+Il y a même des listes de taches. Elles génèrent des champs HTML de type case à
+cocher.
 
+```md
+Les [ ] ci-dessous, n'ayant pas de [ x ], deviendront des cases à cocher HTML
+non-cochées.
 - [ ] Première tache à réaliser.
 - [ ] Une autre chose à faire.
 La case suivante sera une case à cocher HTML cochée.
 - [x] Ça ... c'est fait!
+```
 
-<!-- les Blocs de Code -->
-<!-- Pour marquer du texte comme étant du code, il suffit de commencer 
-chaque ligne en tapant 4 espaces (ou un Tab) -->
+## Blocs de code
 
+Pour marquer du texte comme étant du code (qui utilise la balise `<code>`), il
+suffit d'indenter chaque ligne avec 4 espaces ou une tabulation.
+
+```md
     echo "Ça, c'est du Code!";
     var Ça = "aussi !";
+```
 
-<!-- L'indentation par tab ou série de quatre espaces 
-fonctionne aussi à l'intérieur du bloc de code -->
+L'indentation par tabulation (ou série de quatre espaces) fonctionne aussi à
+l'intérieur du bloc de code.
 
+```md
     my_array.each do |item|
        puts item
     end
+```
 
-<!-- Des bouts de code en mode 'inline' s'ajoutent en les entourant de ` -->
+Des bouts de code en mode en ligne s'ajoutent en utilisant le caractères
+`` ` ``.
 
+```md
 La fonction `run()` ne vous oblige pas à aller courir!
+```
+
+En Markdown GitHub, vous pouvez utiliser des syntaxes spécifiques.
 
-<!-- Via GitHub Flavored Markdown, vous pouvez utiliser 
-des syntaxes spécifiques -->
+    ```ruby 
+    def foobar
+    puts "Hello world!"
+    end
+    ```
 
-\`\`\`ruby 
-<!-- mais enlevez les backslashes quand vous faites ça, 
-gardez juste ```ruby ( ou nom de la syntaxe correspondant à votre code )-->
-def foobar
-puts "Hello world!"
-end
-\`\`\` <!-- pareil, pas de backslashes, juste ``` en guise de fin -->
+Pas besoin d'indentation pour le code juste au-dessus, de plus, GitHub 
+va utiliser une coloration syntaxique pour le langage indiqué après les ```.
 
-<-- Pas besoin d'indentation pour le code juste au dessus, de plus, GitHub 
-va utiliser une coloration syntaxique pour le langage indiqué après les ``` -->
+## Ligne Horizontale
 
-<!-- Ligne Horizontale (<hr />) -->
-<!-- Pour en insérer une, utilisez trois ou plusieurs astérisques ou tirets, 
-avec ou sans espaces entre chaque un. -->
+Pour insérer une ligne horizontale, utilisez trois ou plusieurs astérisques ou tirets, avec ou sans espaces entre.
 
+```md
 ***
 ---
 - - -
 ****************
+```
 
-<!-- Liens -->
-<!-- Une des fonctionnalités sympathiques du Markdown est la facilité 
-d'ajouter des liens. Le texte du lien entre [ ], l'url entre ( ), 
-et voilà l'travail.
--->
+## Liens hypertextes
 
+Une des fonctionnalités sympathiques du Markdown est la facilité d'ajouter des
+liens hypertextes. Le texte du lien entre crochet `` [] ``, l'url entre
+parenthèses `` () ``, et voilà le travail.
+
+```md
 [Clic moi!](http://test.com/)
+```
 
-<!-- 
-Pour ajouter un attribut Title, collez le entre guillemets, avec le lien. 
--->
+Pour ajouter un attribut `Title`, collez-le entre guillemets, avec le lien.
 
+```md
 [Clic moi!](http://test.com/ "Lien vers Test.com")
+```
 
-<!-- les Liens Relatifs marchent aussi -->
+Markdown supporte aussi les liens relatifs.
 
+```md
 [En avant la musique](/music/).
+```
 
-<!-- Les liens façon "références" sont eux aussi disponibles en Markdown -->
+Les liens de références sont eux aussi disponibles en Markdown.
 
+```md
 [Cliquez ici][link1] pour plus d'information!
 [Regardez aussi par ici][foobar] si vous voulez.
 
 [link1]: http://test.com/ "Cool!"
-[foobar]: http://foobar.biz/ "Alright!"
+[foobar]: http://foobar.biz/ "Génial!"
+```
 
-<!--  Le titre peut aussi être entouré de guillemets simples, 
-entre parenthèses ou absent. Les références peuvent être placées 
-un peu où vous voulez dans le document, et les identifiants 
-(link1, foobar, ...) quoi que ce soit tant qu'ils sont uniques -->
+Le titre peut aussi être entouré de guillemets simples, ou de parenthèses, ou
+absent. Les références peuvent être placées où vous voulez dans le document et
+les identifiants peuvent être n'importe quoi tant qu'ils sont uniques.
 
-<!-- Il y a également le "nommage implicite" qui transforme le texte du lien
- en identifiant -->
+Il y a également le nommage implicite qui transforme le texte du lien en
+identifiant.
 
+```md
 [Ceci][] est un lien.
 
 [ceci]: http://ceciestunlien.com/
+```
+
+Mais ce n'est pas beaucoup utilisé.
 
-<!-- mais ce n'est pas beaucoup utilisé. -->
+## Images
 
-<!-- Images -->
-<!-- Pour les images, la syntaxe est identique aux liens, sauf que précédée
- d'un point d'exclamation! -->
+Pour les images, la syntaxe est identique à celle des liens, sauf que précédée
+d'un point d'exclamation!
 
+```md
 ![Attribut ALT de l'image](http://imgur.com/monimage.jpg "Titre optionnel")
+```
+
+Là aussi, on peut utiliser le mode "références".
 
-<!-- Là aussi, on peut utiliser le mode "références" -->
 
+```md
 ![Ceci est l'attribut ALT de l'image][monimage]
 
 [monimage]: relative/urls/cool/image.jpg "si vous voulez un titre, c'est ici."
+```
+
+## Divers
 
-<!-- Divers -->
-<!-- Liens Automatiques -->
+### Liens Automatiques
 
+```md
 <http://testwebsite.com/> est équivalent à :
 [http://testwebsite.com/](http://testwebsite.com/)
+```
 
-<!-- Liens Automatiques pour emails -->
+### Liens Automatiques pour emails
 
+```md
 <foo@bar.com>
+```
+
+### Caracteres d'echappement
 
-<!-- Escaping -->
-Il suffit de précéder les caractères spécifiques à ignorer par des backslash \
+Il suffit de précéder les caractères spécifiques à ignorer par des backslash `\`.
 
-Pour taper *ce texte* entouré d'astérisques mais pas en italique : 
+```md
+Pour taper *ce texte* entouré d'astérisques mais pas en italique :
 Tapez \*ce texte\*.
+```
+
+### Touches de clavier
 
-<!-- Tableaux -->
-<!-- les Tableaux ne sont disponibles que dans le GitHub Flavored Markdown
- et c'est ce n'est pas super agréable d'utilisation. 
- Mais si vous en avez besoin :
- -->
+Avec le "Github Flavored Markdown", vous pouvez utiliser la balise `<kdb>`
+pour représenter une touche du clavier.
 
+```md
+Ton ordinateur a planté? Essayer de taper :
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
+```
+
+### Tableaux
+
+Les tableaux ne sont disponibles que dans le "GitHub Flavored Markdown" et
+ne sont pas tres agréable d'utilisation. Mais si vous en avez besoin :
+
+```md
 | Col1 | Col2 | Col3 |
 | :----------- | :------: | ------------: |
-| Alignement Gauche | Centé | Alignement Droite |
+| Alignement Gauche | Centré | Alignement Droite |
 | bla | bla | bla |
+```
 
-<!-- ou bien, pour un résultat équivalent : -->
+ou bien, pour un résultat équivalent :
 
+```md
 Col 1 | Col2 | Col3
 :-- | :-: | --:
 Ough que c'est moche | svp | arrêtez
-
-<!-- Fin! -->
-
 ```
 
-Pour plus d'information :
- consultez [ici](http://daringfireball.net/projects/markdown/syntax) le post officiel de Jhon Gruber à propos de la syntaxe, 
- et [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) la superbe cheatsheet de Adam Pritchard.
+Pour plus d'information, consultez le post officiel de Jhon Gruber à propos de
+la syntaxe [ici](http://daringfireball.net/projects/markdown/syntax) et la
+superbe fiche pense-bête de Adam Pritchard [là](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
diff --git a/fr-fr/pyqt-fr.html.markdown b/fr-fr/pyqt-fr.html.markdown
new file mode 100644
index 00000000..6da9a380
--- /dev/null
+++ b/fr-fr/pyqt-fr.html.markdown
@@ -0,0 +1,85 @@
+---
+category: tool
+tool: PyQT
+filename: learnpyqt-fr.py
+contributors:
+    - ["Nathan Hughes", "https://github.com/sirsharpest"]
+translators:
+    - ["DevHugo", "http://twitter.com/devhugo"]
+lang: fr-fr
+---
+
+**Qt** est un framework très connu pour le développement de logiciel cross-platform qui peuvent être lancé sur différents systèmes avec de petit ou aucun changement dans le code, tout en ayant la puissance et la vitesse des applications natives. Bien que **Qt** ait été écrit à l'origine en *C++*.
+
+
+Ceci est une adaptation de l'intro C++ à QT par [Aleksey Kholovchuk](https://github.com/vortexxx192
+), certains exemples du code doivent avoir la même fonctionnalité,
+cette version ayant juste été faite en utilisant pyqt! 
+
+```python
+import sys
+from PyQt4 import QtGui
+	
+def window():
+	# Création de l'objet application 
+    app = QtGui.QApplication(sys.argv)
+	# Création d'un widget où notre label sera placé
+    w = QtGui.QWidget()
+	# Ajout d'un label au widget
+    b = QtGui.QLabel(w)
+	# Assignation de texte au label
+    b.setText("Hello World!")
+	# Assignation des tailles et des informations de placement
+    w.setGeometry(100, 100, 200, 50)
+    b.move(50, 20)
+	# Assignation d'un nom à notre fenêtre
+    w.setWindowTitle("PyQt")
+	# Affichage de la fenêtre
+    w.show()
+	# Exécution de l'application
+    sys.exit(app.exec_())
+
+if __name__ == '__main__':
+    window()
+
+```
+
+Pour obtenir certaines des fonctionnalités les plus avancées de **pyqt** nous devons commencer par chercher à construire des éléments supplémentaires.
+Ici nous voyons comment introduire une boîte de dialogue popup, utile pour demander une confirmation à un utilisateur ou fournir des informations.
+
+```Python 
+import sys
+from PyQt4.QtGui import *
+from PyQt4.QtCore import *
+
+
+def window():
+    app = QApplication(sys.argv)
+    w = QWidget()
+    # Creation d'un bouton attaché au widget w
+    b = QPushButton(w)
+    b.setText("Press me")
+    b.move(50, 50)
+    # Dire à b d'appeler cette fonction quand il est cliqué
+    # remarquez l'absence de "()" sur l'appel de la fonction
+    b.clicked.connect(showdialog)
+    w.setWindowTitle("PyQt Dialog")
+    w.show()
+    sys.exit(app.exec_())
+	
+# Cette fonction devrait créer une fenêtre de dialogue avec un bouton
+# qui attend d'être cliqué puis quitte le programme
+def showdialog():
+    d = QDialog()
+    b1 = QPushButton("ok", d)
+    b1.move(50, 50)
+    d.setWindowTitle("Dialog")
+    # Cette modalité dit au popup de bloquer le parent pendant qu'il est actif
+    d.setWindowModality(Qt.ApplicationModal)
+    # En cliquant je voudrais que tout le processus se termine
+    b1.clicked.connect(sys.exit)
+    d.exec_()
+
+if __name__ == '__main__':
+    window()
+```
diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
index d78291be..0ae410de 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -444,7 +444,7 @@ Human.grunt() #=> "*grunt*"
 
 # On peut importer des modules
 import math
-print math.sqrt(16) #=> 4
+print math.sqrt(16) #=> 4.0
 
 # Et récupérer des fonctions spécifiques d'un module
 from math import ceil, floor
diff --git a/fsharp.html.markdown b/fsharp.html.markdown
index bbf477ba..064a9fdd 100644
--- a/fsharp.html.markdown
+++ b/fsharp.html.markdown
@@ -14,7 +14,7 @@ The syntax of F# is different from C-style languages:
 * Curly braces are not used to delimit blocks of code. Instead, indentation is used (like Python).
 * Whitespace is used to separate parameters rather than commas.
 
-If you want to try out the code below, you can go to [tryfsharp.org](http://www.tryfsharp.org/Create) and paste it into an interactive REPL.
+If you want to try out the code below, you can go to [https://try.fsharp.org](https://try.fsharp.org) and paste it into an interactive REPL.
 
 ```csharp
 
@@ -34,7 +34,7 @@ let myFloat = 3.14
 let myString = "hello"           // note that no types needed
 
 // ------ Lists ------
-let twoToFive = [2; 3; 4; 5]        // Square brackets create a list with
+let twoToFive = [2; 3; 4; 5]     // Square brackets create a list with
                                  // semicolon delimiters.
 let oneToFive = 1 :: twoToFive   // :: creates list with new 1st element
 // The result is [1; 2; 3; 4; 5]
@@ -53,7 +53,8 @@ add 2 3                       // Now run the function.
 
 // to define a multiline function, just use indents. No semicolons needed.
 let evens list =
-   let isEven x = x % 2 = 0     // Define "isEven" as a sub function
+   let isEven x = x % 2 = 0   // Define "isEven" as a sub function. Note
+                              // that equality operator is single char "=".
    List.filter isEven list    // List.filter is a library function
                               // with two parameters: a boolean function
                               // and a list to work on
@@ -193,7 +194,7 @@ module ListExamples =
         | [] -> printfn "the list is empty"
         | [first] -> printfn "the list has one element %A " first
         | [first; second] -> printfn "list is %A and %A" first second
-        | _ -> printfn "the list has more than two elements"
+        | first :: _ -> printfn "the list has more than two elements, first element %A" first
 
     listMatcher [1; 2; 3; 4]
     listMatcher [1; 2]
@@ -306,7 +307,7 @@ module DataTypeExamples =
 
     // ------------------------------------
     // Union types (aka variants) have a set of choices
-    // Only case can be valid at a time.
+    // Only one case can be valid at a time.
     // ------------------------------------
 
     // Use "type" with bar/pipe to define a union type
diff --git a/git.html.markdown b/git.html.markdown
index 582f8863..aa96c90a 100644
--- a/git.html.markdown
+++ b/git.html.markdown
@@ -26,11 +26,11 @@ Version control is a system that records changes to a file(s), over time.
 
 ### Centralized Versioning vs. Distributed Versioning
 
-* Centralized version control focuses on synchronizing, tracking, and backing 
+* Centralized version control focuses on synchronizing, tracking, and backing
 up files.
-* Distributed version control focuses on sharing changes. Every change has a 
+* Distributed version control focuses on sharing changes. Every change has a
 unique id.
-* Distributed systems have no defined structure. You could easily have a SVN 
+* Distributed systems have no defined structure. You could easily have a SVN
 style, centralized system, with git.
 
 [Additional Information](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
@@ -57,7 +57,7 @@ A git repository is comprised of the .git directory & working tree.
 
 ### .git Directory (component of repository)
 
-The .git directory contains all the configurations, logs, branches, HEAD, and 
+The .git directory contains all the configurations, logs, branches, HEAD, and
 more.
 [Detailed List.](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
 
@@ -68,15 +68,15 @@ referred to as your working directory.
 
 ### Index (component of .git dir)
 
-The Index is the staging area in git. It's basically a layer that separates 
-your working tree from the Git repository. This gives developers more power 
+The Index is the staging area in git. It's basically a layer that separates
+your working tree from the Git repository. This gives developers more power
 over what gets sent to the Git repository.
 
 ### Commit
 
-A git commit is a snapshot of a set of changes, or manipulations to your 
-Working Tree. For example, if you added 5 files, and removed 2 others, these 
-changes will be contained in a commit (or snapshot). This commit can then be 
+A git commit is a snapshot of a set of changes, or manipulations to your
+Working Tree. For example, if you added 5 files, and removed 2 others, these
+changes will be contained in a commit (or snapshot). This commit can then be
 pushed to other repositories, or not!
 
 ### Branch
@@ -91,13 +91,13 @@ functionality to mark release points (v1.0, and so on)
 
 ### HEAD and head (component of .git dir)
 
-HEAD is a pointer that points to the current branch. A repository only has 1 
-*active* HEAD.  
-head is a pointer that points to any commit. A repository can have any number 
+HEAD is a pointer that points to the current branch. A repository only has 1
+*active* HEAD.
+head is a pointer that points to any commit. A repository can have any number
 of heads.
 
 ### Stages of Git
-* Modified - Changes have been made to a file but file has not been committed 
+* Modified - Changes have been made to a file but file has not been committed
 to Git Database yet
 * Staged - Marks a modified file to go into your next commit snapshot
 * Committed - Files have been committed to the Git Database
@@ -111,7 +111,7 @@ to Git Database yet
 
 ### init
 
-Create an empty Git repository. The Git repository's settings, stored 
+Create an empty Git repository. The Git repository's settings, stored
 information, and more is stored in a directory (a folder) named ".git".
 
 ```bash
@@ -179,7 +179,7 @@ $ git help status
 
 ### add
 
-To add files to the staging area/index. If you do not `git add` new files to 
+To add files to the staging area/index. If you do not `git add` new files to
 the staging area/index, they will not be included in commits!
 
 ```bash
@@ -201,7 +201,7 @@ working directory/repo.
 
 ### branch
 
-Manage your branches. You can view, edit, create, delete branches using this 
+Manage your branches. You can view, edit, create, delete branches using this
 command.
 
 ```bash
@@ -250,7 +250,7 @@ $ git push origin --tags
 
 ### checkout
 
-Updates all files in the working tree to match the version in the index, or 
+Updates all files in the working tree to match the version in the index, or
 specified tree.
 
 ```bash
@@ -269,7 +269,7 @@ $ git checkout -b newBranch
 ### clone
 
 Clones, or copies, an existing repository into a new directory. It also adds
-remote-tracking branches for each branch in the cloned repo, which allows you 
+remote-tracking branches for each branch in the cloned repo, which allows you
 to push to a remote branch.
 
 ```bash
@@ -285,7 +285,7 @@ $ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git -
 
 ### commit
 
-Stores the current contents of the index in a new "commit." This commit 
+Stores the current contents of the index in a new "commit." This commit
 contains the changes made and a message created by the user.
 
 ```bash
@@ -401,11 +401,11 @@ Pulls from a repository and merges it with another branch.
 $ git pull origin master
 
 # By default, git pull will update your current branch
-# by merging in new changes from its remote-tracking branch 
+# by merging in new changes from its remote-tracking branch
 $ git pull
 
 # Merge in changes from remote branch and rebase
-# branch commits onto your local repo, like: "git fetch <remote> <branch>, git 
+# branch commits onto your local repo, like: "git fetch <remote> <branch>, git
 # rebase <remote>/<branch>"
 $ git pull origin master --rebase
 ```
@@ -421,7 +421,7 @@ Push and merge changes from a branch to a remote & branch.
 $ git push origin master
 
 # By default, git push will push and merge changes from
-# the current branch to its remote-tracking branch 
+# the current branch to its remote-tracking branch
 $ git push
 
 # To link up current local branch with a remote branch, add -u flag:
@@ -432,7 +432,7 @@ $ git push
 
 ### stash
 
-Stashing takes the dirty state of your working directory and saves it on a 
+Stashing takes the dirty state of your working directory and saves it on a
 stack of unfinished changes that you can reapply at any time.
 
 Let's say you've been doing some work in your git repo, but you want to pull
@@ -464,7 +464,7 @@ nothing to commit, working directory clean
 ```
 
 You can see what "hunks" you've stashed so far using `git stash list`.
-Since the "hunks" are stored in a Last-In-First-Out stack, our most recent 
+Since the "hunks" are stored in a Last-In-First-Out stack, our most recent
 change will be at top.
 
 ```bash
@@ -495,7 +495,7 @@ Now you're ready to get back to work on your stuff!
 
 ### rebase (caution)
 
-Take all changes that were committed on one branch, and replay them onto 
+Take all changes that were committed on one branch, and replay them onto
 another branch.
 *Do not rebase commits that you have pushed to a public repo*.
 
@@ -510,7 +510,7 @@ $ git rebase master experimentBranch
 ### reset (caution)
 
 Reset the current HEAD to the specified state. This allows you to undo merges,
-pulls, commits, adds, and more. It's a great command but also dangerous if you 
+pulls, commits, adds, and more. It's a great command but also dangerous if you
 don't know what you are doing.
 
 ```bash
@@ -535,7 +535,7 @@ $ git reset --hard 31f2bb1
 Reflog will list most of the git commands you have done for a given time period,
 default 90 days.
 
-This give you the chance to reverse any git commands that have gone wrong 
+This give you the chance to reverse any git commands that have gone wrong
 (for instance, if a rebase has broken your application).
 
 You can do this:
@@ -558,8 +558,8 @@ ed8ddf2 HEAD@{4}: rebase -i (pick): pythonstatcomp spanish translation (#1748)
 
 ### revert
 
-Revert can be used to undo a commit. It should not be confused with reset which 
-restores the state of a project to a previous point. Revert will add a new 
+Revert can be used to undo a commit. It should not be confused with reset which
+restores the state of a project to a previous point. Revert will add a new
 commit which is the inverse of the specified commit, thus reverting it.
 
 ```bash
@@ -604,3 +604,5 @@ $ git rm /pather/to/the/file/HelloWorld.c
 * [Pro Git](http://www.git-scm.com/book/en/v2)
 
 * [An introduction to Git and GitHub for Beginners (Tutorial)](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners)
+
+* [The New Boston tutorial to Git covering basic commands and workflow](https://www.youtube.com/playlist?list=PL6gx4Cwl9DGAKWClAD_iKpNC0bGHxGhcx)
diff --git a/go.html.markdown b/go.html.markdown
index 47d9c234..ae99535b 100644
--- a/go.html.markdown
+++ b/go.html.markdown
@@ -15,15 +15,15 @@ contributors:
 ---
 
 Go was created out of the need to get work done. It's not the latest trend
-in computer science, but it is the newest fastest way to solve real-world
+in programming language theory, but it is a way to solve real-world
 problems.
 
-It has familiar concepts of imperative languages with static typing.
+It draws concepts from imperative languages with static typing.
 It's fast to compile and fast to execute, it adds easy-to-understand
-concurrency to leverage today's multi-core CPUs, and has features to
-help with large-scale programming.
+concurrency because multi-core CPUs are now common, and it's used successfully
+in large codebases (~100 million loc at Google, Inc.).
 
-Go comes with a great standard library and an enthusiastic community.
+Go comes with a good standard library and a sizeable community.
 
 ```go
 // Single line comment
@@ -48,7 +48,7 @@ import (
 // executable program. Love it or hate it, Go uses brace brackets.
 func main() {
 	// Println outputs a line to stdout.
-	// Qualify it with the package name, fmt.
+	// It comes from the package fmt.
 	fmt.Println("Hello world!")
 
 	// Call another function within this package.
@@ -277,7 +277,8 @@ func sentenceFactory(mystring string) func(before, after string) string {
 }
 
 func learnDefer() (ok bool) {
-	// Deferred statements are executed just before the function returns.
+	// A defer statement pushes a function call onto a list. The list of saved
+	// calls is executed AFTER the surrounding function returns.
 	defer fmt.Println("deferred statements execute in reverse (LIFO) order.")
 	defer fmt.Println("\nThis line is being printed first because")
 	// Defer is commonly used to close a file, so the function closing the
diff --git a/groovy.html.markdown b/groovy.html.markdown
index efbb2b32..89ca973a 100644
--- a/groovy.html.markdown
+++ b/groovy.html.markdown
@@ -181,6 +181,21 @@ class Foo {
 }
 
 /*
+  Methods with optional parameters
+*/
+
+// A mthod can have default values for parameters
+def say(msg = 'Hello', name = 'world') {
+    "$msg $name!"
+}
+
+// It can be called in 3 different ways
+assert 'Hello world!' == say()
+// Right most parameter with default value is eliminated first.
+assert 'Hi world!' == say('Hi')
+assert 'learn groovy' == say('learn', 'groovy')
+
+/*
   Logical Branching and Looping
 */
 
diff --git a/haskell.html.markdown b/haskell.html.markdown
index 266cf11b..90d47c27 100644
--- a/haskell.html.markdown
+++ b/haskell.html.markdown
@@ -124,6 +124,9 @@ last [1..5] -- 5
 fst ("haskell", 1) -- "haskell"
 snd ("haskell", 1) -- 1
 
+-- pair element accessing does not work on n-tuples (i.e. triple, quadruple, etc)
+snd ("snd", "can't touch this", "da na na na") -- error! see function below
+
 ----------------------------------------------------
 -- 3. Functions
 ----------------------------------------------------
@@ -159,8 +162,8 @@ fib 1 = 1
 fib 2 = 2
 fib x = fib (x - 1) + fib (x - 2)
 
--- Pattern matching on tuples:
-foo (x, y) = (x + 1, y + 2)
+-- Pattern matching on tuples
+sndOfTriple (_, y, _) = y -- use a wild card (_) to bypass naming unused value
 
 -- Pattern matching on lists. Here `x` is the first element
 -- in the list, and `xs` is the rest of the list. We can write
@@ -203,11 +206,11 @@ foo = (4*) . (10+)
 foo 5 -- 60
 
 -- fixing precedence
--- Haskell has an operator called `$`. This operator applies a function 
--- to a given parameter. In contrast to standard function application, which 
--- has highest possible priority of 10 and is left-associative, the `$` operator 
+-- Haskell has an operator called `$`. This operator applies a function
+-- to a given parameter. In contrast to standard function application, which
+-- has highest possible priority of 10 and is left-associative, the `$` operator
 -- has priority of 0 and is right-associative. Such a low priority means that
--- the expression on its right is applied as the parameter to the function on its left.
+-- the expression on its right is applied as a parameter to the function on its left.
 
 -- before
 even (fib 7) -- false
@@ -223,7 +226,7 @@ even . fib $ 7 -- false
 -- 5. Type signatures
 ----------------------------------------------------
 
--- Haskell has a very strong type system, and every valid expression has a type. 
+-- Haskell has a very strong type system, and every valid expression has a type.
 
 -- Some basic types:
 5 :: Integer
diff --git a/haxe.html.markdown b/haxe.html.markdown
index df2a1e78..a31728e1 100644
--- a/haxe.html.markdown
+++ b/haxe.html.markdown
@@ -7,17 +7,18 @@ contributors:
 ---
 
 Haxe is a web-oriented language that provides platform support for C++, C#,
-Swf/ActionScript, Javascript, Java, and Neko byte code (also written by the
-Haxe author).  Note that this guide is for Haxe version 3.  Some of the guide
-may be applicable to older versions, but it is recommended to use other
-references.
+Swf/ActionScript, Javascript, Java, PHP, Python, Lua, HashLink, and Neko byte code
+(the latter two being also written by the Haxe author). Note that this guide is for
+Haxe version 3.  Some of the guide may be applicable to older versions, but it is
+recommended to use other references.
 
 ```csharp
 /*
    Welcome to Learn Haxe 3 in 15 minutes.  http://www.haxe.org
    This is an executable tutorial.  You can compile and run it using the haxe
    compiler, while in the same directory as LearnHaxe.hx:
-   $> haxe -main LearnHaxe3 -x out
+   
+       $ haxe -main LearnHaxe3 --interp
 
    Look for the slash-star marks surrounding these paragraphs.  We are inside
    a "Multiline comment".  We can leave some notes here that will get ignored
@@ -26,16 +27,14 @@ references.
    Multiline comments are also used to generate javadoc-style documentation for
    haxedoc.  They will be used for haxedoc if they immediately precede a class,
    class function, or class variable.
-
  */
 
-// Double slashes like this will give a single-line comment
-
+// Double slashes like this will give a single-line comment.
 
 /*
    This is your first actual haxe code coming up, it's declaring an empty
-   package.  A package isn't necessary, but it's useful if you want to create a
-   namespace for your code (e.g. org.yourapp.ClassName).
+   package.  A package isn't necessary, but it's useful if you want to create
+   a namespace for your code (e.g. org.yourapp.ClassName).
 
    Omitting package declaration is the same as declaring an empty package.
  */
@@ -47,8 +46,9 @@ package; // empty package, no namespace.
    must be lower case while module names are capitalized. A module contain one
    or more types whose names are also capitalized.
 
-   E.g, the class "org.yourapp.Foo" should have the folder structure org/module/Foo.hx,
-   as accessible from the compiler's working directory or class path.
+   E.g, the class "org.yourapp.Foo" should have the folder structure
+   org/module/Foo.hx, as accessible from the compiler's working directory or
+   class path.
 
    If you import code from other files, it must be declared before the rest of
    the code.  Haxe provides a lot of common default classes to get you started:
@@ -64,34 +64,27 @@ import Lambda.array;
 // you can also use "*" to import all static fields
 import Math.*;
 
-/*
-   You can also import classes in a special way, enabling them to extend the
-   functionality of other classes like a "mixin".  More on 'using' later.
- */
+// You can also import classes in a special way, enabling them to extend the
+// functionality of other classes like a "mixin".  More on 'using' later.
 using StringTools;
 
-/*
-   Typedefs are like variables... for types.  They must be declared before any
-   code.  More on this later.
- */
+// Typedefs are like variables... for types.  They must be declared before any
+// code.  More on this later.
 typedef FooString = String;
 
 // Typedefs can also reference "structural" types, more on that later as well.
 typedef FooObject = { foo: String };
 
-/*
-   Here's the class definition.  It's the main class for the file, since it has
-   the same name (LearnHaxe3).
- */
-class LearnHaxe3{
+// Here's the class definition.  It's the main class for the file, since it has
+// the same name (LearnHaxe3).
+class LearnHaxe3 {
     /*
        If you want certain code to run automatically, you need to put it in
        a static main function, and specify the class in the compiler arguments.
        In this case, we've specified the "LearnHaxe3" class in the compiler
        arguments above.
      */
-    static function main(){
-
+    static function main() {
         /*
            Trace is the default method of printing haxe expressions to the
            screen.  Different targets will have different methods of
@@ -103,17 +96,13 @@ class LearnHaxe3{
          */
         trace("Hello World, with trace()!");
 
-        /*
-           Trace can handle any type of value or object.  It will try to print
-           a representation of the expression as best it can.  You can also
-           concatenate strings with the "+" operator:
-         */
-        trace( " Integer: " + 10 + " Float: " + 3.14 + " Boolean: " + true);
+        // Trace can handle any type of value or object.  It will try to print
+        // a representation of the expression as best it can.  You can also
+        // concatenate strings with the "+" operator:
+        trace("Integer: " + 10 + " Float: " + 3.14 + " Boolean: " + true);
 
-        /*
-           In Haxe, it's required to separate expressions in the same block with
-           semicolons.  But, you can put two expressions on one line:
-         */
+        // In Haxe, it's required to separate expressions in the same block with
+        // semicolons.  But, you can put two expressions on one line:
         trace('two expressions..'); trace('one line');
 
 
@@ -122,14 +111,11 @@ class LearnHaxe3{
         //////////////////////////////////////////////////////////////////
         trace("***Types & Variables***");
 
-        /*
-           You can save values and references to data structures using the
-           "var" keyword:
-         */
+        // You can save values and references to data structures using the
+        // "var" keyword:
         var an_integer:Int = 1;
         trace(an_integer + " is the value for an_integer");
 
-
         /*
            Haxe is statically typed, so "an_integer" is declared to have an
            "Int" type, and the rest of the expression assigns the value "1" to
@@ -150,46 +136,36 @@ class LearnHaxe3{
            Haxe uses platform precision for Int and Float sizes.  It also
            uses the platform behavior for overflow.
            (Other numeric types and behavior are possible using special
-           libraries)
-         */
-
-        /*
+           libraries.)
+           
            In addition to simple values like Integers, Floats, and Booleans,
            Haxe provides standard library implementations for common data
            structures like strings, arrays, lists, and maps:
          */
 
-        var a_string = "some" + 'string';  // strings can have double or single quotes
+        // Strings can have double or single quotes.
+        var a_string = "some" + 'string';
         trace(a_string + " is the value for a_string");
 
-        /*
-           Strings can be "interpolated" by inserting variables into specific
-           positions.  The string must be single quoted, and the variable must
-           be preceded with "$".  Expressions can be enclosed in ${...}.
-         */
+        // Strings can be "interpolated" by inserting variables into specific
+        // positions.  The string must be single quoted, and the variable must
+        // be preceded with "$".  Expressions can be enclosed in ${...}.
         var x = 1;
         var an_interpolated_string = 'the value of x is $x';
         var another_interpolated_string = 'the value of x + 1 is ${x + 1}';
 
-        /*
-           Strings are immutable, instance methods will return a copy of
-           parts or all of the string.
-           (See also the StringBuf class).
-         */
+        // Strings are immutable, instance methods will return a copy of
+        // parts or all of the string. (See also the StringBuf class).
         var a_sub_string = a_string.substr(0,4);
         trace(a_sub_string + " is the value for a_sub_string");
 
-        /*
-           Regexes are also supported, but there's not enough space to go into
-           much detail.
-         */
+        // Regexes are also supported, but there's not enough space here to go
+        // into much detail.
         var re = ~/foobar/;
         trace(re.match('foo') + " is the value for (~/foobar/.match('foo')))");
 
-        /*
-           Arrays are zero-indexed, dynamic, and mutable.  Missing values are
-           defined as null.
-         */
+        // Arrays are zero-indexed, dynamic, and mutable.  Missing values are
+        // defined as null.
         var a = new Array<String>(); // an array that contains Strings
         a[0] = 'foo';
         trace(a.length + " is the value for a.length");
@@ -197,20 +173,17 @@ class LearnHaxe3{
         trace(a.length + " is the value for a.length (after modification)");
         trace(a[3] + " is the value for a[3]"); //null
 
-        /*
-           Arrays are *generic*, so you can indicate which values they contain
-           with a type parameter:
-         */
+        // Arrays are *generic*, so you can indicate which values they contain
+        // with a type parameter:
         var a2 = new Array<Int>(); // an array of Ints
         var a3 = new Array<Array<String>>(); // an Array of Arrays (of Strings).
 
-        /*
-           Maps are simple key/value data structures.  The key and the value
-           can be of any type.
-         */
-        var m = new Map<String, Int>();  // The keys are strings, the values are Ints.
+        // Maps are simple key/value data structures.  The key and the value
+        // can be of any type.
+        // Here, the keys are strings, and the values are Ints:
+        var m = new Map<String, Int>();
         m.set('foo', 4);
-        // You can also use array notation;
+        // You can also use array notation:
         m['bar'] = 5;
         trace(m.exists('bar') + " is the value for m.exists('bar')");
         trace(m.get('bar') + " is the value for m.get('bar')");
@@ -219,19 +192,15 @@ class LearnHaxe3{
         var m2 =  ['foo' => 4, 'baz' => 6]; // Alternative map syntax
         trace(m2 + " is the value for m2");
 
-        /*
-           Remember, you can use type inference.  The Haxe compiler will
-           decide the type of the variable the first time you pass an
-           argument that sets a type parameter.
-         */
+        // Remember, you can use type inference.  The Haxe compiler will
+        // decide the type of the variable the first time you pass an
+        // argument that sets a type parameter.
         var m3 = new Map();
         m3.set(6, 'baz'); // m3 is now a Map<Int,String>
         trace(m3 + " is the value for m3");
 
-        /*
-           Haxe has some more common datastructures in the haxe.ds module, such as
-           List, Stack, and BalancedTree
-         */
+        // Haxe has some more common datastructures in the haxe.ds module, such
+        // as List, Stack, and BalancedTree.
 
 
         //////////////////////////////////////////////////////////////////
@@ -243,11 +212,11 @@ class LearnHaxe3{
         trace((4 + 3) + " is the value for (4 + 3)");
         trace((5 - 1) + " is the value for (5 - 1)");
         trace((2 * 4) + " is the value for (2 * 4)");
-        trace((8 / 3) + " is the value for (8 / 3) (division always produces Floats)");
+        // Division always produces Floats.
+        trace((8 / 3) + " is the value for (8 / 3) (a Float)");
         trace((12 % 4) + " is the value for (12 % 4)");
 
-
-        //basic comparison
+        // basic comparison
         trace((3 == 2) + " is the value for 3 == 2");
         trace((3 != 2) + " is the value for 3 != 2");
         trace((3 >  2) + " is the value for 3 > 2");
@@ -257,22 +226,23 @@ class LearnHaxe3{
 
         // standard bitwise operators
         /*
-        ~       Unary bitwise complement
-        <<      Signed left shift
-        >>      Signed right shift
-        >>>     Unsigned right shift
-        &       Bitwise AND
-        ^       Bitwise exclusive OR
-        |       Bitwise inclusive OR
+            ~       Unary bitwise complement
+            <<      Signed left shift
+            >>      Signed right shift
+            >>>     Unsigned right shift
+            &       Bitwise AND
+            ^       Bitwise exclusive OR
+            |       Bitwise inclusive OR
         */
 
-        //increments
+        // increments
         var i = 0;
         trace("Increments and decrements");
-        trace(i++); //i = 1. Post-Incrementation
-        trace(++i); //i = 2. Pre-Incrementation
-        trace(i--); //i = 1. Post-Decrementation
-        trace(--i); //i = 0. Pre-Decrementation
+        trace(i++); // i = 1. Post-Increment
+        trace(++i); // i = 2. Pre-Increment
+        trace(i--); // i = 1. Post-Decrement
+        trace(--i); // i = 0. Pre-Decrement
+
 
         //////////////////////////////////////////////////////////////////
         // Control Structures
@@ -281,21 +251,19 @@ class LearnHaxe3{
 
         // if statements
         var j = 10;
-        if (j == 10){
+        if (j == 10) {
             trace("this is printed");
-        } else if (j > 10){
+        } else if (j > 10) {
             trace("not greater than 10, so not printed");
         } else {
             trace("also not printed.");
         }
 
         // there is also a "ternary" if:
-        (j == 10) ?  trace("equals 10") : trace("not equals 10");
+        (j == 10) ? trace("equals 10") : trace("not equals 10");
 
-        /*
-           Finally, there is another form of control structures that operates
-           at compile time:  conditional compilation.
-         */
+        // Finally, there is another form of control structure that operates
+        // at compile time:  conditional compilation.
 #if neko
         trace('hello from neko');
 #elseif js
@@ -303,43 +271,40 @@ class LearnHaxe3{
 #else
         trace('hello from another platform!');
 #end
-        /*
-           The compiled code will change depending on the platform target.
-           Since we're compiling for neko (-x or -neko), we only get the neko
-           greeting.
-         */
+
+        // The compiled code will change depending on the platform target.
+        // Since we're compiling for neko (-x or -neko), we only get the neko
+        // greeting.
 
 
         trace("Looping and Iteration");
 
         // while loop
         var k = 0;
-        while(k < 100){
+        while (k < 100) {
             // trace(counter); // will print out numbers 0-99
             k++;
         }
 
         // do-while loop
         var  l = 0;
-        do{
+        do {
             trace("do statement always runs at least once");
         } while (l > 0);
 
         // for loop
-        /*
-           There is no c-style for loop in Haxe, because they are prone
-           to error, and not necessary.  Instead, Haxe has a much simpler
-           and safer version that uses Iterators (more on those later).
-         */
-        var m = [1,2,3];
-        for (val in m){
+        // There is no c-style for loop in Haxe, because they are prone
+        // to error, and not necessary.  Instead, Haxe has a much simpler
+        // and safer version that uses Iterators (more on those later).
+        var m = [1, 2, 3];
+        for (val in m) {
             trace(val + " is the value for val in the m array");
         }
 
         // Note that you can iterate on an index using a range
         // (more on ranges later as well)
         var n = ['foo', 'bar', 'baz'];
-        for (val in 0...n.length){
+        for (val in 0...n.length) {
             trace(val + " is the value for val (an index for n)");
         }
 
@@ -354,8 +319,11 @@ class LearnHaxe3{
         var modified_n = [for (val in n) val += '!'];
         trace(modified_n + " is the value for modified_n");
 
-        var filtered_and_modified_n = [for (val in n) if (val != "foo") val += "!"];
-        trace(filtered_and_modified_n + " is the value for filtered_and_modified_n");
+        var filtered_and_modified_n
+            = [for (val in n) if (val != "foo") val += "!"];
+        trace(filtered_and_modified_n
+                + " is the value for filtered_and_modified_n");
+
 
         //////////////////////////////////////////////////////////////////
         // Switch Statements (Value Type)
@@ -366,33 +334,32 @@ class LearnHaxe3{
            Switch statements in Haxe are very powerful.  In addition to working
            on basic values like strings and ints, they can also work on the
            generalized algebraic data types in enums (more on enums later).
-           Here's some basic value examples for now:
+           Here are some basic value examples for now:
          */
         var my_dog_name = "fido";
         var favorite_thing  = "";
-        switch(my_dog_name){
+        switch(my_dog_name) {
             case "fido" : favorite_thing = "bone";
             case "rex"  : favorite_thing = "shoe";
             case "spot" : favorite_thing = "tennis ball";
             default     : favorite_thing = "some unknown treat";
-            // case _   : favorite_thing = "some unknown treat"; // same as default
+            // same as default:
+            // case _   : favorite_thing = "some unknown treat";
         }
-        // The "_" case above is a "wildcard" value
-        // that will match anything.
+        // The "_" case above is a "wildcard" value that will match anything.
 
         trace("My dog's name is " + my_dog_name
                 + ", and his favorite thing is a: "
                 + favorite_thing);
 
+
         //////////////////////////////////////////////////////////////////
         // Expression Statements
         //////////////////////////////////////////////////////////////////
         trace("***EXPRESSION STATEMENTS***");
 
-        /*
-           Haxe control statements are very powerful because every statement
-           is also an expression, consider:
-        */
+        // Haxe control statements are very powerful because every statement
+        // is also an expression, consider:
 
         // if statements
         var k = if (true) 10 else 20;
@@ -410,6 +377,7 @@ class LearnHaxe3{
                 + ", and his other favorite thing is a: "
                 + other_favorite_thing);
 
+
         //////////////////////////////////////////////////////////////////
         // Converting Value Types
         //////////////////////////////////////////////////////////////////
@@ -418,14 +386,14 @@ class LearnHaxe3{
         // You can convert strings to ints fairly easily.
 
         // string to integer
-        Std.parseInt("0"); // returns 0
-        Std.parseFloat("0.4"); // returns 0.4;
+        Std.parseInt("0");     // returns 0
+        Std.parseFloat("0.4"); // returns 0.4
 
         // integer to string
-        Std.string(0); // returns "0";
+        Std.string(0); // returns "0"
         // concatenation with strings will auto-convert to string.
-        0 + "";  // returns "0";
-        true + ""; // returns "true";
+        0 + "";    // returns "0"
+        true + ""; // returns "true"
         // See documentation for parsing in Std for more details.
 
 
@@ -434,14 +402,13 @@ class LearnHaxe3{
         //////////////////////////////////////////////////////////////////
 
         /*
-
            As mentioned before, Haxe is a statically typed language.  All in
            all, static typing is a wonderful thing.  It enables
            precise autocompletions, and can be used to thoroughly check the
            correctness of a program.  Plus, the Haxe compiler is super fast.
 
-           *HOWEVER*, there are times when you just wish the compiler would let
-           something slide, and not throw a type error in a given case.
+           *HOWEVER*, there are times when you just wish the compiler would
+           let something slide, and not throw a type error in a given case.
 
            To do this, Haxe has two separate keywords.  The first is the
            "Dynamic" type:
@@ -456,11 +423,10 @@ class LearnHaxe3{
 
            The other more extreme option is the "untyped" keyword:
          */
-
-            untyped {
-                var x:Int = 'foo'; // this can't be right!
-                var y:String = 4; // madness!
-            }
+        untyped {
+            var x:Int = 'foo'; // This can't be right!
+            var y:String = 4;  // Madness!
+        }
 
         /*
            The untyped keyword operates on entire *blocks* of code, skipping
@@ -474,74 +440,66 @@ class LearnHaxe3{
            of the type models work should you resort to "Dynamic" or "untyped".
          */
 
+
         //////////////////////////////////////////////////////////////////
         // Basic Object Oriented Programming
         //////////////////////////////////////////////////////////////////
         trace("***BASIC OBJECT ORIENTED PROGRAMMING***");
 
-
-        /*
-           Create an instance of FooClass.  The classes for this are at the
-           end of the file.
-         */
+        // Create an instance of FooClass.  The classes for this are at the
+        // end of the file.
         var foo_instance = new FooClass(3);
 
         // read the public variable normally
-        trace(foo_instance.public_any + " is the value for foo_instance.public_any");
+        trace(foo_instance.public_any
+                + " is the value for foo_instance.public_any");
 
         // we can read this variable
-        trace(foo_instance.public_read + " is the value for foo_instance.public_read");
-        // but not write it
-        // foo_instance.public_read = 4; // this will throw an error if uncommented:
+        trace(foo_instance.public_read
+                + " is the value for foo_instance.public_read");
+        // but not write it; this will throw an error if uncommented:
+        // foo_instance.public_read = 4;
         // trace(foo_instance.public_write); // as will this.
 
-        // calls the toString method:
+        // Calls the toString method:
         trace(foo_instance + " is the value for foo_instance");
         // same thing:
-        trace(foo_instance.toString() + " is the value for foo_instance.toString()");
+        trace(foo_instance.toString()
+                + " is the value for foo_instance.toString()");
 
-
-        /*
-           The foo_instance has the "FooClass" type, while acceptBarInstance
-           has the BarClass type.  However, since FooClass extends BarClass, it
-           is accepted.
-         */
+        // The foo_instance has the "FooClass" type, while acceptBarInstance
+        // has the BarClass type.  However, since FooClass extends BarClass, it
+        // is accepted.
         BarClass.acceptBarInstance(foo_instance);
 
-        /*
-           The classes below have some more advanced examples, the "example()"
-           method will just run them here.
-         */
+        // The classes below have some more advanced examples, the "example()"
+        // method will just run them here.
         SimpleEnumTest.example();
         ComplexEnumTest.example();
         TypedefsAndStructuralTypes.example();
         UsingExample.example();
-
     }
-
 }
 
-/*
-   This is the "child class" of the main LearnHaxe3 Class
- */
-class FooClass extends BarClass implements BarInterface{
+// This is the "child class" of the main LearnHaxe3 Class.
+class FooClass extends BarClass implements BarInterface {
     public var public_any:Int; // public variables are accessible anywhere
     public var public_read (default, null): Int; // enable only public read
     public var public_write (null, default): Int; // or only public write
-    public var property (get, set): Int; // use this style to enable getters/setters
+    // Use this style to enable getters/setters:
+    public var property (get, set): Int;
 
     // private variables are not available outside the class.
     // see @:allow for ways around this.
     var _private:Int; // variables are private if they are not marked public
 
     // a public constructor
-    public function new(arg:Int){
+    public function new(arg:Int) {
         // call the constructor of the parent object, since we extended BarClass:
         super();
 
         this.public_any = 0;
         this._private = arg;
-
     }
 
     // getter for _private
@@ -555,47 +513,40 @@ class FooClass extends BarClass implements BarInterface{
         return val;
     }
 
-    // special function that is called whenever an instance is cast to a string.
-    public function toString(){
+    // Special function that is called whenever an instance is cast to a string.
+    public function toString() {
         return _private + " with toString() method!";
     }
 
     // this class needs to have this function defined, since it implements
     // the BarInterface interface.
-    public function baseFunction(x: Int) : String{
+    public function baseFunction(x: Int) : String {
         // convert the int to string automatically
         return x + " was passed into baseFunction!";
     }
 }
 
-/*
-    A simple class to extend
-*/
+// A simple class to extend.
 class BarClass {
     var base_variable:Int;
-    public function new(){
+    public function new() {
         base_variable = 4;
     }
-    public static function acceptBarInstance(b:BarClass){
-    }
+    public static function acceptBarInstance(b:BarClass) {}
 }
 
-/*
-    A simple interface to implement
-*/
-interface BarInterface{
+// A simple interface to implement
+interface BarInterface {
     public function baseFunction(x:Int):String;
 }
 
+
 //////////////////////////////////////////////////////////////////
 // Enums and Switch Statements
 //////////////////////////////////////////////////////////////////
 
-/*
-   Enums in Haxe are very powerful.  In their simplest form, enums
-   are a type with a limited number of states:
- */
-
+// Enums in Haxe are very powerful.  In their simplest form, enums
+// are a type with a limited number of states:
 enum SimpleEnum {
     Foo;
     Bar;
@@ -603,12 +554,12 @@ enum SimpleEnum {
 }
 
 //   Here's a class that uses it:
-
-class SimpleEnumTest{
-    public static function example(){
-        var e_explicit:SimpleEnum = SimpleEnum.Foo; // you can specify the "full" name
+class SimpleEnumTest {
+    public static function example() {
+        // You can specify the "full" name,
+        var e_explicit:SimpleEnum = SimpleEnum.Foo;
         var e = Foo; // but inference will work as well.
-        switch(e){
+        switch(e) {
             case Foo: trace("e was Foo");
             case Bar: trace("e was Bar");
             case Baz: trace("e was Baz"); // comment this line to throw an error.
@@ -621,18 +572,16 @@ class SimpleEnumTest{
 
            You can also specify a default for enum switches as well:
          */
-        switch(e){
+        switch(e) {
             case Foo: trace("e was Foo again");
             default : trace("default works here too");
         }
     }
 }
 
-/*
-    Enums go much further than simple states, we can also enumerate
-    *constructors*, but we'll need a more complex enum example
- */
-enum ComplexEnum{
+// Enums go much further than simple states, we can also enumerate
+// *constructors*, but we'll need a more complex enum example.
+enum ComplexEnum {
     IntEnum(i:Int);
     MultiEnum(i:Int, j:String, k:Float);
     SimpleEnumEnum(s:SimpleEnum);
@@ -641,14 +590,12 @@ enum ComplexEnum{
 // Note: The enum above can include *other* enums as well, including itself!
 // Note: This is what's called *Algebraic data type* in some other languages.
 
-class ComplexEnumTest{
-    public static function example(){
+class ComplexEnumTest {
+    public static function example() {
         var e1:ComplexEnum = IntEnum(4); // specifying the enum parameter
-        /*
-           Now we can switch on the enum, as well as extract any parameters
-           it might of had.
-         */
-        switch(e1){
+        // Now we can switch on the enum, as well as extract any parameters
+        // it might have had.
+        switch(e1) {
             case IntEnum(x) : trace('$x was the parameter passed to e1');
             default: trace("Shouldn't be printed");
         }
@@ -662,34 +609,28 @@ class ComplexEnumTest{
 
         // enums all the way down
         var e3 = ComplexEnumEnum(ComplexEnumEnum(MultiEnum(4, 'hi', 4.3)));
-        switch(e3){
-            // You can look for certain nested enums by specifying them explicitly:
+        switch(e3) {
+            // You can look for certain nested enums by specifying them
+            //  explicitly:
             case ComplexEnumEnum(ComplexEnumEnum(MultiEnum(i,j,k))) : {
                 trace('$i, $j, and $k were passed into this nested monster');
             }
             default: trace("Shouldn't be printed");
         }
-        /*
-           Check out "generalized algebraic data types" (GADT) for more details
-           on why these are so great.
-         */
+        // Check out "generalized algebraic data types" (GADT) for more details
+        // on why these are so great.
     }
 }
 
 class TypedefsAndStructuralTypes {
-    public static function example(){
-        /*
-           Here we're going to use typedef types, instead of base types.
-           At the top we've declared the type "FooString" to mean a "String" type.
-         */
+    public static function example() {
+        // Here we're going to use typedef types, instead of base types.
+        // At the top we've declared the type "FooString" to mean a "String" type.
         var t1:FooString = "some string";
 
-        /*
-           We can use typedefs for "structural types" as well.  These types are
-           defined by their field structure, not by class inheritance.  Here's
-           an anonymous object with a String field named "foo":
-         */
-
+        // We can use typedefs for "structural types" as well.  These types are
+        // defined by their field structure, not by class inheritance.  Here's
+        // an anonymous object with a String field named "foo":
         var anon_obj = { foo: 'hi' };
 
         /*
@@ -699,8 +640,7 @@ class TypedefsAndStructuralTypes {
            that structure, we can use it anywhere that a "FooObject" type is
            expected.
          */
-
-        var f = function(fo:FooObject){
+        var f = function(fo:FooObject) {
             trace('$fo was passed in to this function');
         }
         f(anon_obj); // call the FooObject signature function with anon_obj.
@@ -712,9 +652,7 @@ class TypedefsAndStructuralTypes {
                 ?optionalString: String,
                 requiredInt: Int
            }
-         */
 
-        /*
            Typedefs work well with conditional compilation.  For instance,
            we could have included this at the top of the file:
 
@@ -728,15 +666,14 @@ class TypedefsAndStructuralTypes {
         typedef Surface = java.awt.geom.GeneralPath;
 #end
 
-        That would give us a single "Surface" type to work with across
-        all of those platforms.
+           That would give us a single "Surface" type to work with across
+           all of those platforms.
         */
     }
 }
 
 class UsingExample {
     public static function example() {
-
         /*
            The "using" import keyword is a special type of class import that
            alters the behavior of any static methods in the class.
@@ -770,19 +707,18 @@ class UsingExample {
 ```
 
 We're still only scratching the surface here of what Haxe can do.  For a formal
-overview of all Haxe features, checkout the [online
-manual](http://haxe.org/manual), the [online API](http://api.haxe.org/), and
-"haxelib", the [haxe library repo] (http://lib.haxe.org/).
+overview of all Haxe features, see the [manual](https://haxe.org/manual) and
+the [API docs](https://api.haxe.org/). For a comprehensive directory of available
+third-party Haxe libraries, see [Haxelib](https://lib.haxe.org/).
 
 For more advanced topics, consider checking out:
 
-* [Abstract types](http://haxe.org/manual/abstracts)
-* [Macros](http://haxe.org/manual/macros), and [Compiler Macros](http://haxe.org/manual/macros_compiler)
-* [Tips and Tricks](http://haxe.org/manual/tips_and_tricks)
-
-
-Finally, please join us on [the mailing list](https://groups.google.com/forum/#!forum/haxelang), on IRC [#haxe on
-freenode](http://webchat.freenode.net/), or on
-[Google+](https://plus.google.com/communities/103302587329918132234).
+* [Abstract types](https://haxe.org/manual/types-abstract.html)
+* [Macros](https://haxe.org/manual/macro.html)
+* [Compiler Features](https://haxe.org/manual/cr-features.html)
 
 
+Finally, please join us on [the Haxe forum](https://community.haxe.org/),
+on IRC [#haxe on
+freenode](http://webchat.freenode.net/), or on the
+[Haxe Gitter chat](https://gitter.im/HaxeFoundation/haxe).
diff --git a/hre.csv b/hre.csv
new file mode 100644
index 00000000..eab43cc4
--- /dev/null
+++ b/hre.csv
@@ -0,0 +1 @@
+Ix,Dynasty,Name,Birth,Death,Coronation 1,Coronation 2,Ceased to be Emperor
N/A,Carolingian,Charles I,2 April 742,28 January 814,25 December 800,N/A,28 January 814
N/A,Carolingian,Louis I,778,20 June 840,11 September 813,5 October 816,20 June 840
N/A,Carolingian,Lothair I,795,29 September 855,5 April 823,N/A,29 September 855
N/A,Carolingian,Louis II,825,12 August 875,15 June 844,18 May 872,12 August 875
N/A,Carolingian,Charles II,13 June 823,6 October 877,29 December 875,N/A,6 October 877
N/A,Carolingian,Charles III,13 June 839,13 January 888,12 February 881,N/A,11 November 887
N/A,Widonid,Guy III,835,12 December 894,21 February 891,N/A,12 December 894
N/A,Widonid,Lambert I,880,15 October 898,30 April 892,N/A,15 October 898
N/A,Carolingian,Arnulph,850,8 December 899,22 February 896,N/A,8 December 899
N/A,Bosonid,Louis III,880,5 June 928,22 February 901,N/A,21 July 905
N/A,Unruoching,Berengar I,845,7 April 924,December 915,N/A,7 April 924
1,Ottonian,Otto I,23 November 912,7 May 973,2 February 962,N/A,7 May 973
2,Ottonian,Otto II,955,7 December 983,25 December 967,N/A,7 December 983
3,Ottonian,Otto III,980,23 January 1002,21 May 996,N/A,23 January 1002
4,Ottonian,Henry II,6 May 973,13 July 1024,14 February 1014,N/A,13 July 1024
5,Salian,Conrad II,990,4 June 1039,26 March 1027,N/A,4 June 1039
6,Salian,Henry III,29 October 1017,5 October 1056,25 December 1046,N/A,5 October 1056
7,Salian,Henry IV,11 November 1050,7 August 1106,31 March 1084,N/A,December 1105
8,Salian,Henry V,8 November 1086,23 May 1125,13 April 1111,N/A,23 May 1125
9,Supplinburg,Lothair III,9 June 1075,4 December 1137,4 June 1133,N/A,4 December 1137
10,Staufen,Frederick I,1122,10 June 1190,18 June 1155,N/A,10 June 1190
11,Staufen,Henry VI,November 1165,28 September 1197,14 April 1191,N/A,28 September 1197
12,Welf,Otto IV,1175,19 May 1218,4 October 1209,N/A,1215
13,Staufen,Frederick II,26 December 1194,13 December 1250,22 November 1220,N/A,13 December 1250
14,Luxembourg,Henry VII,1275,24 August 1313,29 June 1312,N/A,24 August 1313
15,Wittelsbach,Louis IV,1 April 1282,11 October 1347,17 January 1328,N/A,11 October 1347
16,Luxembourg,Charles IV,14 May 1316,29 November 1378,5 April 1355,N/A,29 November 1378
17,Luxembourg,Sigismund,14 February 1368,9 December 1437,31 May 1433,N/A,9 December 1437
18,Habsburg,Frederick III,21 September 1415,19 August 1493,19 March 1452,N/A,19 August 1493
19,Habsburg,Maximilian I,22 March 1459,12 January 1519,N/A,N/A,12 January 1519
20,Habsburg,Charles V,24 February 1500,21 September 1558,February 1530,N/A,16 January 1556
21,Habsburg,Ferdinand I,10 March 1503,25 July 1564,N/A,N/A,25 July 1564
22,Habsburg,Maximilian II,31 July 1527,12 October 1576,N/A,N/A,12 October 1576
23,Habsburg,Rudolph II,18 July 1552,20 January 1612,30 June 1575,N/A,20 January 1612
24,Habsburg,Matthias,24 February 1557,20 March 1619,23 January 1612,N/A,20 March 1619
25,Habsburg,Ferdinand II,9 July 1578,15 February 1637,10 March 1619,N/A,15 February 1637
26,Habsburg,Ferdinand III,13 July 1608,2 April 1657,18 November 1637,N/A,2 April 1657
27,Habsburg,Leopold I,9 June 1640,5 May 1705,6 March 1657,N/A,5 May 1705
28,Habsburg,Joseph I,26 July 1678,17 April 1711,1 May 1705,N/A,17 April 1711
29,Habsburg,Charles VI,1 October 1685,20 October 1740,22 December 1711,N/A,20 October 1740
30,Wittelsbach,Charles VII,6 August 1697,20 January 1745,12 February 1742,N/A,20 January 1745
31,Lorraine,Francis I,8 December 1708,18 August 1765,N/A,N/A,18 August 1765
32,Habsburg-Lorraine,Joseph II,13 March 1741,20 February 1790,19 August 1765,N/A,20 February 1790
33,Habsburg-Lorraine,Leopold II,5 May 1747,1 March 1792,N/A,N/A,1 March 1792
34,Habsburg-Lorraine,Francis II,12 February 1768,2 March 1835,4 March 1792,N/A,6 August 1806
\ No newline at end of file
diff --git a/html.html.markdown b/html.html.markdown
index 04b9f501..b8212776 100644
--- a/html.html.markdown
+++ b/html.html.markdown
@@ -5,27 +5,44 @@ contributors:
     - ["Christophe THOMAS", "https://github.com/WinChris"]
 translators:
     - ["Robert Steed", "https://github.com/robochat"]
+    - ["Dimitri Kokkonis", "https://github.com/kokkonisd"]
 ---
 
-HTML stands for HyperText Markup Language. 
+HTML stands for HyperText Markup Language.
+
 It is a language which allows us to write pages for the world wide web.
-It is a markup language, it enables us to write webpages using code to indicate how text and data should be displayed.
-In fact, html files are simple text files.
-What is this markup? It is a method of organising the page's data by surrounding it with opening tags and closing tags.
-This markup serves to give significance to the text that it encloses. 
-Like other computer languages, HTML has many versions. Here we will talk about HTML5.
+It is a markup language, it enables us to write webpages using code to indicate
+how text and data should be displayed.  In fact, html files are simple text
+files.
+
+What is this markup? It is a method of organising the page's data by
+surrounding it with opening tags and closing tags.  This markup serves to give
+significance to the text that it encloses.  Like other computer languages, HTML
+has many versions. Here we will talk about HTML5.
 
-**NOTE :**  You can test the different tags and elements as you progress through the tutorial on a site like [codepen](http://codepen.io/pen/) in order to see their effects, understand how they work and familiarise yourself with the language.
-This article is concerned principally with HTML syntax and some useful tips.
+**NOTE :**  You can test the different tags and elements as you progress through
+the tutorial on a site like [codepen](http://codepen.io/pen/) in order to see
+their effects, understand how they work and familiarise yourself with the
+language.  This article is concerned principally with HTML syntax and some
+useful tips.
 
 
 ```html
 <!-- Comments are enclosed like this line! -->
 
+<!--
+	Comments
+	can
+	span
+	multiple
+	lines!
+-->
+
 <!-- #################### The Tags #################### -->
-   
+
 <!-- Here is an example HTML file that we are going to analyse. -->
 
+
 <!doctype html>
 	<html>
 		<head>
@@ -33,7 +50,9 @@ This article is concerned principally with HTML syntax and some useful tips.
 		</head>
 		<body>
 			<h1>Hello, world!</h1>
-			<a href = "http://codepen.io/anon/pen/xwjLbZ">Come look at what this shows</a>
+			<a href="http://codepen.io/anon/pen/xwjLbZ">
+				Come look at what this shows
+			</a>
 			<p>This is a paragraph.</p>
 			<p>This is another paragraph.</p>
 			<ul>
@@ -44,7 +63,9 @@ This article is concerned principally with HTML syntax and some useful tips.
 		</body>
 	</html>
 
-<!-- An HTML file always starts by indicating to the browser that the page is HTML. -->
+<!--
+	An HTML file always starts by indicating to the browser that the page is HTML.
+-->
 <!doctype html>
 
 <!-- After this, it starts by opening an <html> tag. -->
@@ -58,10 +79,17 @@ This article is concerned principally with HTML syntax and some useful tips.
 <!-- Inside (between the opening and closing tags <html></html>), we find: -->
 
 <!-- A header defined by <head> (it must be closed with </head>). -->
-<!-- The header contains some description and additional information which are not displayed; this is metadata. -->
+<!--
+	The header contains some description and additional information which are not
+	displayed; this is metadata.
+-->
 
 <head>
-	<title>My Site</title><!-- The tag <title> indicates to the browser the title to show in browser window's title bar and tab name. -->
+	<!--
+		The tag <title> indicates to the browser the title to show in browser
+		window's title bar and tab name.
+	-->
+	<title>My Site</title>
 </head>
 
 <!-- After the <head> section, we find the tag - <body> -->
@@ -69,13 +97,28 @@ This article is concerned principally with HTML syntax and some useful tips.
 <!-- We must fill the body with the content to be displayed. -->
 
 <body>
-	<h1>Hello, world!</h1> <!-- The h1 tag creates a title. -->
-	<!-- There are also subtitles to <h1> from the most important (h2) to the most precise (h6). -->
-	<a href = "http://codepen.io/anon/pen/xwjLbZ">Come look at what this shows</a> <!-- a hyperlink to the url given by the attribute href="" -->
-	<p>This is a paragraph.</p> <!-- The tag <p> lets us include text in the html page. -->
+	<!-- The h1 tag creates a title. -->
+	<h1>Hello, world!</h1>
+	<!--
+		There are also subtitles to <h1> from the most important (h2) to the most
+		precise (h6).
+	-->
+
+	<!-- a hyperlink to the url given by the attribute href="" -->
+	<a href="http://codepen.io/anon/pen/xwjLbZ">
+		Come look at what this shows
+	</a>
+
+	<!-- The tag <p> lets us include text in the html page. -->
+	<p>This is a paragraph.</p>
 	<p>This is another paragraph.</p>
-	<ul> <!-- The tag <ul> creates a bullet list. -->
-	<!-- To have a numbered list instead we would use <ol> giving 1. for the first element, 2. for the second, etc. -->
+
+	<!-- The tag <ul> creates a bullet list. -->
+	<!--
+		To have a numbered list instead we would use <ol> giving 1. for the first
+		element, 2. for the second, etc.
+	-->
+	<ul>
 		<li>This is an item in a non-enumerated list (bullet list)</li>
 		<li>This is another item</li>
 		<li>And this is the last item on the list</li>
@@ -86,21 +129,33 @@ This article is concerned principally with HTML syntax and some useful tips.
 
 <!-- But it is possible to add many additional types of HTML tags. -->
 
-<!-- To insert an image. -->
-<img src="http://i.imgur.com/XWG0O.gif"/> <!-- The source of the image is indicated using the attribute src="" -->
-<!-- The source can be an URL or even path to a file on your computer. -->
+<!-- The <img /> tag is used to insert an image. -->
+<!--
+	The source of the image is indicated using the attribute src=""
+	The source can be an URL or even path to a file on your computer.
+-->
+<img src="http://i.imgur.com/XWG0O.gif"/>
 
 <!-- It is also possible to create a table. -->
 
-<table> <!-- We open a <table> element. -->
-	<tr> <!-- <tr> allows us to create a row. -->
-		<th>First Header</th> <!-- <th> allows us to give a title to a table column. -->
+<!-- We open a <table> element. -->
+<table>
+
+	<!-- <tr> allows us to create a row. -->
+	<tr>
+
+		<!-- <th> allows us to give a title to a table column. -->
+		<th>First Header</th>
 		<th>Second Header</th>
 	</tr>
+
 	<tr>
-		<td>first row, first column</td> <!-- <td> allows us to create a table cell. -->
+
+		<!-- <td> allows us to create a table cell. -->
+		<td>first row, first column</td>
 		<td>first row, second column</td>
 	</tr>
+
 	<tr>
 		<td>second row, first column</td>
 		<td>second row, second column</td>
@@ -111,9 +166,10 @@ This article is concerned principally with HTML syntax and some useful tips.
 
 ## Usage
 
-HTML is written in files ending with `.html` or `.htm`. The mime type is `text/html`.
-
-## To Learn More 
+HTML is written in files ending with `.html` or `.htm`. The mime type is
+`text/html`.
+**HTML is NOT a programming language**
+## To Learn More
 
 * [wikipedia](https://en.wikipedia.org/wiki/HTML)
 * [HTML tutorial](https://developer.mozilla.org/en-US/docs/Web/HTML)
diff --git a/hu-hu/python-hu.html.markdown b/hu-hu/python-hu.html.markdown
index 9b55f8e2..01f1c414 100644
--- a/hu-hu/python-hu.html.markdown
+++ b/hu-hu/python-hu.html.markdown
@@ -656,7 +656,7 @@ i.age  # => AttributeError hibát dob
 # Modulokat így lehet importálni
 import math
 
-print math.sqrt(16)  # => 4
+print math.sqrt(16)  # => 4.0
 
 # Lehetséges csak bizonyos függvényeket importálni egy modulból
 from math import ceil, floor
diff --git a/id-id/markdown.html.markdown b/id-id/markdown.html.markdown
index 06ad1092..1ff1963b 100644
--- a/id-id/markdown.html.markdown
+++ b/id-id/markdown.html.markdown
@@ -13,7 +13,7 @@ Markdown dibuat oleh John Gruber pada tahun 2004. Tujuannya untuk menjadi syntax
 Beri masukan sebanyak-banyaknya! / Jangan sungkan untuk melakukan fork dan pull request!
 
 
-```markdown
+```md
 <!-- Markdown adalah superset dari HTML, jadi setiap berkas HTML adalah markdown yang
 valid, ini berarti kita dapat menggunakan elemen HTML dalam markdown, seperti elemen
 komentar, dan ia tidak akan terpengaruh parser markdown. Namun, jika Anda membuat
diff --git a/it-it/asciidoc-it.html.markdown b/it-it/asciidoc-it.html.markdown
new file mode 100644
index 00000000..47a57349
--- /dev/null
+++ b/it-it/asciidoc-it.html.markdown
@@ -0,0 +1,135 @@
+---
+language: asciidoc
+contributors:
+    - ["Ryan Mavilia", "http://unoriginality.rocks/"]
+    - ["Abel Salgado Romero", "https://twitter.com/abelsromero"]
+translators:
+    - ["Ale46", "https://github.com/ale46"]
+lang: it-it
+filename: asciidoc-it.md
+---
+
+AsciiDoc è un linguaggio di markup simile a Markdown e può essere usato per qualsiasi cosa, dai libri ai blog. Creato nel 2002 da Stuart Rackman, questo linguaggio è semplice ma permette un buon numero di personalizzazioni.
+
+Intestazione Documento
+
+Le intestazioni sono opzionali e possono contenere linee vuote. Deve avere almeno una linea vuota rispetto al contenuto.
+
+Solo titolo
+
+```
+= Titolo documento
+
+Prima frase del documento.
+```
+
+Titolo ed Autore
+
+```
+= Titolo documento
+Primo Ultimo <first.last@learnxinyminutes.com>
+
+Inizio del documento
+```
+
+Autori multipli
+
+```
+= Titolo Documento
+John Doe <john@go.com>; Jane Doe<jane@yo.com>; Black Beard <beardy@pirate.com>
+
+Inizio di un documento con autori multipli.
+```
+
+Linea di revisione (richiede una linea autore)
+
+```
+= Titolo documento V1
+Potato Man <chip@crunchy.com>
+v1.0, 2016-01-13
+
+Questo articolo sulle patatine sarà divertente.
+```
+
+Paragrafi
+
+```
+Non hai bisogno di nulla di speciale per i paragrafi.
+
+Aggiungi una riga vuota tra i paragrafi per separarli.
+
+Per creare una riga vuota aggiungi un +
+e riceverai una interruzione di linea!
+```
+
+Formattazione Testo
+
+```
+_underscore crea corsivo_
+*asterischi per il grassetto*
+*_combinali per maggiore divertimento_*
+`usa i ticks per indicare il monospazio`
+`*spaziatura fissa in grassetto*`
+```
+
+Titoli di sezione
+
+```
+= Livello 0 (può essere utilizzato solo nell'intestazione del documento)
+
+== Livello 1 <h2>
+
+=== Livello 2 <h3>
+
+==== Livello 3 <h4>
+
+===== Livello 4 <h5>
+
+```
+
+Liste
+
+Per creare un elenco puntato, utilizzare gli asterischi.
+
+```
+* foo
+* bar
+* baz
+```
+
+Per creare un elenco numerato usa i periodi.
+
+```
+. item 1
+. item 2
+. item 3
+```
+
+È possibile nidificare elenchi aggiungendo asterischi o periodi aggiuntivi fino a cinque volte.
+
+```
+* foo 1
+** foo 2
+*** foo 3
+**** foo 4
+***** foo 5
+
+. foo 1
+.. foo 2
+... foo 3
+.... foo 4
+..... foo 5
+```
+
+## Ulteriori letture
+
+Esistono due strumenti per elaborare i documenti AsciiDoc:
+
+1. [AsciiDoc](http://asciidoc.org/): implementazione Python originale, disponibile nelle principali distribuzioni Linux. Stabile e attualmente in modalità di manutenzione.
+2. [Asciidoctor](http://asciidoctor.org/): implementazione alternativa di Ruby, utilizzabile anche da Java e JavaScript. In fase di sviluppo attivo, mira ad estendere la sintassi AsciiDoc con nuove funzionalità e formati di output.
+
+I seguenti collegamenti sono relativi all'implementazione di `Asciidoctor`:
+
+* [Markdown - AsciiDoc comparazione sintassi](http://asciidoctor.org/docs/user-manual/#comparison-by-example): confronto affiancato di elementi di Markdown e AsciiDoc comuni.
+* [Per iniziare](http://asciidoctor.org/docs/#get-started-with-asciidoctor): installazione e guide rapide per il rendering di documenti semplici.
+* [Asciidoctor Manuale Utente](http://asciidoctor.org/docs/user-manual/): manuale completo con riferimento alla sintassi, esempi, strumenti di rendering, tra gli altri.
diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown
index b4f9c50e..449aebfb 100644
--- a/it-it/c++-it.html.markdown
+++ b/it-it/c++-it.html.markdown
@@ -1130,7 +1130,6 @@ compl 4    // Effettua il NOT bit-a-bit
 ```
 Letture consigliate:
 
-Un riferimento aggiornato del linguaggio può essere trovato qui
-<http://cppreference.com/w/cpp>
-
-Risorse addizionali possono essere trovate qui <http://cplusplus.com>
+* Un riferimento aggiornato del linguaggio può essere trovato qui [CPP Reference](http://cppreference.com/w/cpp).
+* Risorse addizionali possono essere trovate qui [CPlusPlus](http://cplusplus.com).
+* Un tutorial che copre le basi del linguaggio e l'impostazione dell'ambiente di codifica è disponibile su [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb).
diff --git a/it-it/dynamic-programming-it.html.markdown b/it-it/dynamic-programming-it.html.markdown
new file mode 100644
index 00000000..9c7bd9b6
--- /dev/null
+++ b/it-it/dynamic-programming-it.html.markdown
@@ -0,0 +1,55 @@
+---
+category: Algorithms & Data Structures
+name: Dynamic Programming
+contributors:
+    - ["Akashdeep Goel", "http://github.com/akashdeepgoel"]
+translators:
+    - ["Ale46", "https://github.com/ale46"]
+lang: it-it
+---
+
+# Programmazione dinamica
+
+## Introduzione
+
+La programmazione dinamica è una tecnica potente utilizzata per risolvere una particolare classe di problemi, come vedremo. L'idea è molto semplice, se hai risolto un problema con l'input dato, salva il risultato come riferimento futuro, in modo da evitare di risolvere nuovamente lo stesso problema.
+
+Ricordate sempre!
+"Chi non ricorda il passato è condannato a ripeterlo"
+
+## Modi per risolvere questi problemi
+
+1. *Top-Down* : Inizia a risolvere il problema specifico suddividendolo. Se vedi che il problema è già stato risolto, rispondi semplicemente con la risposta già salvata. Se non è stato risolto, risolvilo e salva la risposta. Di solito è facile da pensare e molto intuitivo. Questo è indicato come Memoization.
+
+2. *Bottom-Up* : Analizza il problema e vedi l'ordine in cui i sotto-problemi sono risolti e inizia a risolvere dal sottoproblema banale, verso il problema dato. In questo processo, è garantito che i sottoproblemi vengono risolti prima di risolvere il problema. Si parla di programmazione dinamica.
+
+## Esempio di programmazione dinamica
+
+Il problema di "Longest Increasing Subsequence" consiste nel trovare la sottosequenza crescente più lunga di una determinata sequenza. Data una sequenza `S= {a1 , a2 , a3, a4, ............., an-1, an }` dobbiamo trovare il sottoinsieme più lungo tale che per tutti gli `j` e gli `i`,  `j<i` nel sotto-insieme `aj<ai`.
+Prima di tutto dobbiamo trovare il valore delle sottosequenze più lunghe (LSi) ad ogni indice i con l'ultimo elemento della sequenza che è ai. Quindi il più grande LSi sarebbe la sottosequenza più lunga nella sequenza data. Per iniziare LSi viene inizializzato ad 1, dato che ai è un element della sequenza (Ultimo elemento). Quindi per tutti gli `j` tale che `j<i` e `aj<ai`, troviamo il più grande LSj e lo aggiungiamo a LSi. Quindi l'algoritmo richiede un tempo di *O(n2)*.
+
+Pseudo-codice per trovare la lunghezza della sottosequenza crescente più lunga:
+Questa complessità degli algoritmi potrebbe essere ridotta usando una migliore struttura dei dati piuttosto che una matrice. La memorizzazione dell'array predecessore e della variabile come `largest_sequences_so_far` e il suo indice farebbero risparmiare molto tempo.
+
+Un concetto simile potrebbe essere applicato nel trovare il percorso più lungo nel grafico aciclico diretto.
+
+```python
+for i=0 to n-1
+    LS[i]=1
+    for j=0 to i-1
+        if (a[i] >  a[j] and LS[i]<LS[j])
+            LS[i] = LS[j]+1
+for i=0 to n-1
+    if (largest < LS[i])
+```
+
+### Alcuni famosi problemi DP
+
+- Floyd Warshall Algorithm - Tutorial e Codice sorgente in C del programma: [http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code]()
+- Integer Knapsack Problem - Tutorial e Codice sorgente in C del programma: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem]()
+- Longest Common Subsequence - Tutorial e Codice sorgente in C del programma: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence]()
+
+
+## Risorse online
+
+* [codechef](https://www.codechef.com/wiki/tutorial-dynamic-programming)
diff --git a/it-it/go-it.html.markdown b/it-it/go-it.html.markdown
index e49ccd79..797f6b0b 100644
--- a/it-it/go-it.html.markdown
+++ b/it-it/go-it.html.markdown
@@ -270,12 +270,13 @@ func fabbricaDiFrasi(miaStringa string) func(prima, dopo string) string {
 }
 
 func imparaDefer() (ok bool) {
-    // Le istruzioni dette "deferred" (rinviate) sono eseguite
-    // appena prima che la funzione abbia termine.
+	// La parola chiave "defer" inserisce una funzione in una lista.
+	// La lista contenente tutte le chiamate a funzione viene eseguita DOPO
+	// il return finale della funzione che le circonda.
 	defer fmt.Println("le istruzioni 'deferred' sono eseguite in ordine inverso (LIFO).")
 	defer fmt.Println("\nQuesta riga viene stampata per prima perché")
     // defer viene usato di solito per chiudere un file, così la funzione che
-    // chiude il file viene messa vicino a quella che lo apre.
+    // chiude il file, preceduta da "defer", viene messa vicino a quella che lo apre.
 	return true
 }
 
diff --git a/it-it/html-it.html.markdown b/it-it/html-it.html.markdown
index 471019a1..8f7391a2 100644
--- a/it-it/html-it.html.markdown
+++ b/it-it/html-it.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: html
-filename: learnhtml-it.html
+filename: learnhtml-it.txt
 contributors:
     - ["Christophe THOMAS", "https://github.com/WinChris"]
 translators:
@@ -112,7 +112,7 @@ Questo articolo riguarda principalmente la sintassi HTML ed alcuni suggerimenti
 
 ## Uso
 
-HTML è scritto in files che finiscono con `.html`.
+HTML è scritto in files che finiscono con `.html` o `.htm`. Il "MIME type" è `text/html`.
 
 ## Per saperne di più
 
diff --git a/it-it/java-it.html.markdown b/it-it/java-it.html.markdown
index 54602cff..1669816e 100644
--- a/it-it/java-it.html.markdown
+++ b/it-it/java-it.html.markdown
@@ -17,14 +17,14 @@ concorrente, basato su classi e adatto a svariati scopi.
 ```java
 // I commenti su singola linea incominciano con //
 /*
-I commenti su piu' linee invece sono cosi'
+I commenti su più linee invece sono così
 */
 /**
-I commenti per la documentazione JavaDoc si fanno cosi'.
+I commenti per la documentazione JavaDoc si fanno così.
 Vengono usati per descrivere una classe o alcuni suoi attributi.
 */
 
-// Per importare la classe ArrayList conenuta nel package java.util
+// Per importare la classe ArrayList contenuta nel package java.util
 import java.util.ArrayList;
 // Per importare tutte le classi contenute nel package java.security
 import java.security.*;
@@ -48,7 +48,7 @@ public class LearnJava {
         System.out.print("Ciao ");
         System.out.print("Mondo ");
 
-        // Per stampare del testo formattato, si puo' usare System.out.printf
+        // Per stampare del testo formattato, si può usare System.out.printf
         System.out.printf("pi greco = %.5f", Math.PI); // => pi greco = 3.14159
 
         ///////////////////////////////////////
@@ -60,7 +60,7 @@ public class LearnJava {
         */
         // Per dichiarare una variabile basta fare <tipoDato> <nomeVariabile>
         int fooInt;
-        // Per dichiarare piu' di una variabile dello lo stesso tipo si usa:
+        // Per dichiarare più di una variabile dello lo stesso tipo si usa:
         // <tipoDato> <nomeVariabile1>, <nomeVariabile2>, <nomeVariabile3>
         int fooInt1, fooInt2, fooInt3;
 
@@ -71,7 +71,7 @@ public class LearnJava {
         // Per inizializzare una variabile si usa
         // <tipoDato> <nomeVariabile> = <valore>
         int fooInt = 1;
-        // Per inizializzare piu' di una variabile dello lo stesso tipo
+        // Per inizializzare più di una variabile dello lo stesso tipo
         // si usa <tipoDato> <nomeVariabile1>, <nomeVariabile2>, <nomeVariabile3> = <valore>
         int fooInt1, fooInt2, fooInt3;
         fooInt1 = fooInt2 = fooInt3 = 1;
@@ -94,7 +94,7 @@ public class LearnJava {
         // Long - intero con segno a 64 bit (in complemento a 2)
         // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
         long fooLong = 100000L;
-        // L viene usato per indicare che il valore e' di tipo Long;
+        // L viene usato per indicare che il valore è di tipo Long;
         // altrimenti il valore viene considerato come intero.
 
         // Nota: Java non dispone di interi senza segno.
@@ -102,14 +102,14 @@ public class LearnJava {
         // Float - Numero in virgola mobile a 32 bit con precisione singola (IEEE 754)
         // 2^-149 <= float <= (2-2^-23) * 2^127
         float fooFloat = 234.5f;
-        // f o F indicano the la variabile e' di tipo float;
+        // f o F indicano the la variabile è di tipo float;
         // altrimenti il valore viene considerato come double.
 
         // Double - Numero in virgola mobile a 64 bit con precisione doppia (IEEE 754)
         // 2^-1074 <= x <= (2-2^-52) * 2^1023
         double fooDouble = 123.4;
 
-        // Boolean - Puo' assumere il valore vero (true) o falso (false)
+        // Boolean - Può assumere il valore vero (true) o falso (false)
         boolean fooBoolean = true;
         boolean barBoolean = false;
 
@@ -118,26 +118,26 @@ public class LearnJava {
 
         // Le variabili precedute da final possono essere inizializzate una volta sola,
         final int HOURS_I_WORK_PER_WEEK = 9001;
-        // pero' e' possibile dichiararle e poi inizializzarle in un secondo momento.
+        // però è possibile dichiararle e poi inizializzarle in un secondo momento.
         final double E;
         E = 2.71828;
 
 
         // BigInteger - Interi a precisione arbitraria
         //
-        // BigInteger e' un tipo di dato che permette ai programmatori di
-        // gestire interi piu' grandi di 64 bit. Internamente, le variabili
+        // BigInteger è un tipo di dato che permette ai programmatori di
+        // gestire interi più grandi di 64 bit. Internamente, le variabili
         // di tipo  BigInteger vengono memorizzate come un vettore di byte e 
         // vengono manipolate usando funzioni dentro la classe BigInteger.
         //
-        // Una variabile di tipo BigInteger puo' essere inizializzata usando
+        // Una variabile di tipo BigInteger può essere inizializzata usando
         // un array di byte oppure una stringa.
         
         BigInteger fooBigInteger = new BigDecimal(fooByteArray);
 
         // BigDecimal - Numero con segno, immutabile, a precisione arbitraria
         //
-        // Una variabile di tipo BigDecimal e' composta da due parti: un intero
+        // Una variabile di tipo BigDecimal è composta da due parti: un intero
         // a precisione arbitraria detto 'non scalato', e un intero a 32 bit
         // che rappresenta la 'scala', ovvero la potenza di 10 con cui
         // moltiplicare l'intero non scalato.
@@ -158,9 +158,9 @@ public class LearnJava {
         // Stringhe
         String fooString = "Questa e' la mia stringa!";
 
-        // \n e' un carattere di escape che rappresenta l'andare a capo
+        // \n è un carattere di escape che rappresenta l'andare a capo
         String barString = "Stampare su una nuova riga?\nNessun problema!";
-        // \t e' un carattere di escape che aggiunge un tab
+        // \t è un carattere di escape che aggiunge un tab
         String bazString = "Vuoi aggiungere un tab?\tNessun problema!";
         System.out.println(fooString);
         System.out.println(barString);
@@ -168,7 +168,7 @@ public class LearnJava {
 
         // Vettori
         // La dimensione di un array deve essere decisa in fase di
-        // istanziazione. Per dichiarare un array si puo' fare in due modi:
+        // istanziazione. Per dichiarare un array si può fare in due modi:
         // <tipoDato>[] <nomeVariabile> = new <tipoDato>[<dimensioneArray>];
         // <tipoDato> <nomeVariabile>[] = new <tipoDato>[<dimensioneArray>];
         int[] intArray = new int[10];
@@ -189,8 +189,8 @@ public class LearnJava {
         System.out.println("intArray @ 1: " + intArray[1]); // => 1
 
         // Ci sono altri tipo di dato interessanti.
-        // ArrayList - Simili ai vettori, pero' offrono altre funzionalita',
-        //             e la loro dimensione puo' essere modificata.
+        // ArrayList - Simili ai vettori, però offrono altre funzionalità,
+        //             e la loro dimensione può essere modificata.
         // LinkedList - Si tratta di una lista linkata doppia, e come tale
         //              implementa tutte le operazioni del caso.
         // Map - Un insieme di oggetti che fa corrispondere delle chiavi
@@ -207,7 +207,7 @@ public class LearnJava {
 
         int i1 = 1, i2 = 2; // Dichiarazone multipla in contemporanea
 
-        // L'aritmetica e' lineare.
+        // L'aritmetica è lineare.
         System.out.println("1+2 = " + (i1 + i2)); // => 3
         System.out.println("2-1 = " + (i2 - i1)); // => 1
         System.out.println("2*1 = " + (i2 * i1)); // => 2
@@ -253,7 +253,7 @@ public class LearnJava {
         ///////////////////////////////////////
         System.out.println("\n->Strutture di controllo");
 
-        // La dichiarazione dell'If e'' C-like.
+        // La dichiarazione dell'If è C-like.
         int j = 10;
         if (j == 10){
             System.out.println("Io vengo stampato");
@@ -328,18 +328,18 @@ public class LearnJava {
         System.out.println("Risultato del costrutto switch: " + stringaMese);
 
         // Condizioni brevi
-        // Si puo' usare l'operatore '?' per un rapido assegnamento
+        // Si può usare l'operatore '?' per un rapido assegnamento
         // o per operazioni logiche.
         // Si legge: 
-        // Se (condizione) e' vera, usa <primo valore>, altrimenti usa <secondo valore>
+        // Se (condizione) è vera, usa <primo valore>, altrimenti usa <secondo valore>
         int foo = 5;
         String bar = (foo < 10) ? "A" : "B";
         System.out.println("Se la condizione e' vera stampa A: "+bar); 
-        // Stampa A, perche' la condizione e' vera.
+        // Stampa A, perché la condizione è vera.
 
 
         /////////////////////////////////////////
-        // Convertire i tipi di tati e Typcasting
+        // Convertire i tipi di dati e Typecasting
         /////////////////////////////////////////
 
         // Convertire tipi di dati
@@ -397,16 +397,16 @@ class Bicicletta {
 
     // Variabili della bicicletta
     public int cadenza; 
-      // Public: Puo' essere richiamato da qualsiasi classe
+      // Public: Può essere richiamato da qualsiasi classe
     private int velocita; 
-      // Private: e'' accessibile solo dalla classe dove e'' stato inizializzato
+      // Private: è accessibile solo dalla classe dove è stato inizializzato
     protected int ingranaggi; 
-      // Protected: e'' visto sia dalla classe che dalle sottoclassi
+      // Protected: è visto sia dalla classe che dalle sottoclassi
     String nome; 
-      // default: e'' accessibile sono all'interno dello stesso package
+      // default: è accessibile sono all'interno dello stesso package
 
     // I costruttori vengono usati per creare variabili
-    // Questo e'' un costruttore
+    // Questo è un costruttore
     public Bicicletta() {
         ingranaggi = 1;
         cadenza = 50;
@@ -414,7 +414,7 @@ class Bicicletta {
         nome = "Bontrager";
     }
 
-    // Questo e'' un costruttore che richiede parametri
+    // Questo è un costruttore che richiede parametri
     public Bicicletta(int cadenza, int velocita, int ingranaggi, String nome) {
         this.ingranaggi = ingranaggi;
         this.cadenza = cadenza;
@@ -469,7 +469,7 @@ class Bicicletta {
     }
 } // Fine classe bicicletta
 
-// PennyFarthing e'' una sottoclasse della bicicletta
+// PennyFarthing è una sottoclasse della bicicletta
 class PennyFarthing extends Bicicletta {
     // (Sono quelle biciclette con un unica ruota enorme
     // Non hanno ingranaggi.)
@@ -481,7 +481,7 @@ class PennyFarthing extends Bicicletta {
 
     // Bisogna contrassegnre un medodo che si sta riscrivendo 
     // con una @annotazione
-    // Per saperne di piu' sulle annotazioni
+    // Per saperne di più sulle annotazioni
     // Vedi la guida: http://docs.oracle.com/javase/tutorial/java/annotations/
     @Override
     public void setIngranaggi(int ingranaggi) {
@@ -518,8 +518,8 @@ class Frutta implements Commestibile, Digestibile {
 	}
 }
 
-//In Java si puo' estendere solo una classe, ma si possono implementare 
-//piu' interfaccie, per esempio:
+//In Java si può estendere solo una classe, ma si possono implementare 
+//più interfaccie, per esempio:
 class ClasseEsempio extends AltraClasse implements PrimaInterfaccia, SecondaInterfaccia {
 	public void MetodoPrimaInterfaccia() {
 
diff --git a/it-it/javascript-it.html.markdown b/it-it/javascript-it.html.markdown
new file mode 100644
index 00000000..68bf6287
--- /dev/null
+++ b/it-it/javascript-it.html.markdown
@@ -0,0 +1,617 @@
+---
+language: javascript
+contributors:
+    - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+    - ["Ariel Krakowski", "http://www.learneroo.com"]
+translators:
+    - ["vinniec", "https://github.com/vinniec"]
+filename: javascript-it.js
+lang: it-it
+---
+
+JavaScript è stato creato da Netscape di Brendan Eich nel 1995. È stato originariamente pensato come un semplice linguaggio di scripting per i siti web, complementare all'uso di java per applicazioni più complesse ma la sua stretta integrazione con le pagine Web e il supporto integrato con esse ha causato il suo divenire più comune di Java per i frontend web.
+
+Tuttavia JavaScript non è semplicemente limitato ai web browser: Node.js è un progetto che fornisce una runtime standalone dell'engine JavaScript V8 per Google Chrome, sta diventando sempre più popolare.
+
+JavaScript ha una sintassi C-like, quindi se usate linguaggi come C o Java, molta della sintassi di base sarà già familiare. A dispetto di questo, e a dispetto del nome similare, il modello a oggetti di JavaScript è significativamente diverso da quello di Java.
+
+```js
+// I commenti a singola linea iniziano con due slash.
+/* I commenti multilinea cominciano con uno slash e un asterisco,
+   e terminano con un asterisco e uno slash */
+
+// Le istruzioni possono essere terminate con ;
+doStuff();
+
+// ... ma non devono esserci per forza, i punti e virgola vengono automaticamente inseriti
+// dove c'è un newline, ad eccezione di alcuni casi.
+doStuff()
+
+// Poiché questi casi possono causare risultati inaspettati, noi continueremo ad usare
+// i punti e virgola in questa guida.
+
+///////////////////////////////////
+// 1. Numeri, Stringe e Operatori
+
+// JavaScript ha un tipo numero (che è a 64-bit IEEE 754 double).
+// Double ha una mantissa di 52-bit che è abbastanza per memorizzare interi
+// fino a 9x10¹⁵ per essere precisi.
+3; // = 3
+1.5; // = 1.5
+
+// Alcuni lavori aritmetici di base come ci si può aspettare.
+1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004
+8 - 1; // = 7
+10 * 2; // = 20
+35 / 5; // = 7
+
+// inclusa la divisione con la virgola.
+5 / 2; // = 2.5
+
+// E il modulo.
+10 % 2; // = 0
+30 % 4; // = 2
+18.5 % 7; // = 4.5
+
+// Anche le operazioni binarie funzionano; quando effettuate una operazione binaria il vostro numero decimale
+// è convertito in un intero con segno *fino a* 32 bit..
+1 << 2; // = 4
+
+// Le precedenza è subordinata dalle parentesi.
+(1 + 3) * 2; // = 8
+
+// Ci sono tre valori speciali che non sono numeri reali:
+Infinity; // ad esempio il risultato di 1/0
+-Infinity; // ad esempio il risultato di -1/0
+NaN; // ad esempio il risultato di 0/0, sta per 'Not a Number'
+
+// Ci sono anche i tipi booleani.
+true;
+false;
+
+// Le stringe sono create con ' oppure ".
+'abc';
+"Hello, world";
+
+// La negazione usa il ! simbolo
+!true; // = false
+!false; // = true
+
+// L'uguaglianza è ===
+1 === 1; // = true
+2 === 1; // = false
+
+// L'inuguaglianza è !==
+1 !== 1; // = false
+2 !== 1; // = true
+
+// Altre comparazioni
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Le stringhe si concatenano con il +
+"Hello " + "world!"; // = "Hello world!"
+
+// ... che funziona con qualcosa in più delle semplici stringhe
+"1, 2, " + 3; // = "1, 2, 3"
+"Hello " + ["world", "!"]; // = "Hello world,!"
+
+// e sono comparate con < e >
+"a" < "b"; // = true
+
+// La comparazione con conversione implicita si fa con il doppio uguale...
+"5" == 5; // = true
+null == undefined; // = true
+
+// ...ammenoché non si usi ===
+"5" === 5; // = false
+null === undefined; // = false
+
+// ...che può provocare strani comportamenti...
+13 + !0; // 14
+"13" + !0; // '13true'
+
+// Si può accedere ai caratteri di una stringa con  `charAt`
+"This is a string".charAt(0);  // = 'T'
+
+// ...o usando le `substring` per ottenere una parte.
+"Hello world".substring(0, 5); // = "Hello"
+
+// `length` è una proprietà, quindi non usate le ().
+"Hello".length; // = 5
+
+// Ci sono anche `null` e `undefined`.
+null;      // usato per indicato deliberatamente un non-valore
+undefined; // usato per indicare un valore che attualmente non è presente (sebbene
+           // `undefined` sia un valore a sua stessa volta)
+
+// false, null, undefined, NaN, 0 e "" sono falsi; tutto il resto è vero.
+// Notare che 0 è falso e "0" è vero, nonostante 0 == "0".
+
+///////////////////////////////////
+// 2. Variabili, Array e Oggetti
+
+// Le variabili sono dichiarate con la parola chiave `var`. JavaScript è tipato
+// dinamicamente, quindi non serve specificare il tipo. L'assegnamento usa un carattere `=`
+// singolo.
+var someVar = 5;
+
+// Se si toglie la parola chiave var non si otterrà un errore...
+someOtherVar = 10;
+
+// ...ma la tua variabile sarà creata con visibilità globale e non
+// nel blocco dove la si è definita.
+
+// Le variabili dichiarate senza essere definite vengono impostate come undefined.
+var someThirdVar; // = undefined
+
+// Se si vuole dichiarare una coppia di variabili, lo si può fare usando una virgola
+// come separatore
+var someFourthVar = 2, someFifthVar = 4;
+
+// C'è una scorciatoia per effettuare operazioni matematiche sulle variabili:
+someVar += 5; // equivalente di someVar = someVar + 5; someVar vale 10 ora
+someVar *= 10; // ora someVar è 100
+
+// e un ulteriore scorciatoia per aggiungere o sottrarre 1
+someVar++; // ora someVar è 101
+someVar--; // di nuovo 100
+
+// Gli array sono liste ordinati di valori, di qualsiasi tipo.
+var myArray = ["Hello", 45, true];
+
+// Si può accedere ai loro membri usando la sintassi sottoscritta con le parentesi quadra.
+// Gli indici degli array iniziano a zero.
+myArray[1]; // = 45
+
+// Gli Array sono mutabili e di dimensione variabile.
+myArray.push("World");
+myArray.length; // = 4
+
+// Aggiungere/Modificare in un indice preciso
+myArray[3] = "Hello";
+
+// Aggiungere e rimovere un elemento dall'inizio o dalla fine di un array
+myArray.unshift(3); // Aggiungere come primo elemento
+someVar = myArray.shift(); // Rimuovere il primo elemento e restituirlo
+myArray.push(3); // Aggiungere come ultimo elemento
+someVar = myArray.pop(); // Rimuovere l'ultimo elemento e restituirlo
+
+// Unire tutti gli elementi di un array con un punto e virgola
+var myArray0 = [32,false,"js",12,56,90];
+myArray0.join(";") // = "32;false;js;12;56;90"
+
+// Ottenere un subarray di elementi dall'indice 1 (incluso) al 4 (escluso)
+myArray0.slice(1,4); // = [false,"js",12]
+
+// Rimuovere 4 elementi partendo dall'indice 2 e inserirci delle stringhe
+// "hi","wr" e "ld"; restituiscono i subarray rimossi
+myArray0.splice(2,4,"hi","wr","ld"); // = ["js",12,56,90]
+// myArray0 === [32,false,"hi","wr","ld"]
+
+// Gli oggetti di JavaScript sono equivalenti ai "dizionari" o "mappe" in altri
+// linguaggi: una collezione non ordinata di coppie di chiave-valore.
+var myObj = {key1: "Hello", key2: "World"};
+
+// Le chiavi sono stringhe, ma non è necessario quotarle se sono identificatori
+// JavaScript validi. I valori possono essere di ogni tipo.
+var myObj = {myKey: "myValue", "my other key": 4};
+
+// Gli attributi degli oggetti possono essere acceduti usando la sintassi "subscript",
+myObj["my other key"]; // = 4
+
+// ... o usando la notazione puntata fornendo una chiave che sia un identificatore valido.
+myObj.myKey; // = "myValue"
+
+// Gli oggetti sono mutabilil; i valori possono essere cambiati e nuove chiavi possono essere aggiunte.
+myObj.myThirdKey = true;
+
+// se si prova ad accedere ad un valore che non è stato ancora impostato, si otterrà undefined.
+myObj.myFourthKey; // = undefined
+
+///////////////////////////////////
+// 3. Strutture logiche e di controllo.
+
+// La struttura `if` funziona come ci si aspetta.
+var count = 1;
+if (count == 3){
+    // eseguito se count vale 3
+} else if (count == 4){
+    // eseguito se count vale 4
+} else {
+    // eseguito se count non è né 3 e né 4
+}
+
+// Così come il `while`.
+while (true){
+    // Un ciclo infinito!
+}
+
+// I cicli do-while sono come i cicli while ad eccezione che loro iterano almeno una volta.
+var input;
+do {
+    input = getInput();
+} while (!isValid(input));
+
+// Il ciclo `for` è lo stesso di C e di Java:
+// inizializzazione, condizione di proseguimento; iterazione.
+for (var i = 0; i < 5; i++){
+    // verrà eseguito 5 volte
+}
+
+// Uscire forzatamente da un un ciclo etichettato è simile a java:
+outer:
+for (var i = 0; i < 10; i++) {
+    for (var j = 0; j < 10; j++) {
+        if (i == 5 && j ==5) {
+            break outer;
+            // esce fuori dal ciclo outer invece che solo da quello più interno
+        }
+    }
+}
+
+// L'istruzione for/in permette l'iterazione sulle proprietà di un oggetto.
+var description = "";
+var person = {fname:"Paul", lname:"Ken", age:18};
+for (var x in person){
+    description += person[x] + " ";
+} // description = 'Paul Ken 18 '
+
+// L'istruzione for/of permette l'iterazione su oggetti iterabili (inclusi i built-in String,
+// Array, es. gli argomenti Array-like o gli oggetti NodeList, TypedArray, Map e Set,
+// e gli iterabili decisi dall'utente).
+var myPets = "";
+var pets = ["cat", "dog", "hamster", "hedgehog"];
+for (var pet of pets){
+    myPets += pet + " ";
+} // myPets = 'cat dog hamster hedgehog '
+
+// && è la congiunzione logica, || è la disgiunione logica
+if (house.size == "big" && house.colour == "blue"){
+    house.contains = "bear";
+}
+if (colour == "red" || colour == "blue"){
+    // i colori sono sia rossi che blu
+}
+
+// && e || "short circuit", utili per impostare i valori di default.
+var name = otherName || "default";
+
+// L'istruzione `switch` controlla l'uguaglianza con `===`.
+// Usare 'break' dopo ogni caso
+// oppure i casi dopo quello corretto verranno eseguiti comunque.
+grade = 'B';
+switch (grade) {
+  case 'A':
+    console.log("Great job");
+    break;
+  case 'B':
+    console.log("OK job");
+    break;
+  case 'C':
+    console.log("You can do better");
+    break;
+  default:
+    console.log("Oy vey");
+    break;
+}
+
+
+///////////////////////////////////
+// 4. Funzioni, Visibilità e Closure
+
+// Le funzioni di JavaScript sono dichiarate con la parolachiave `function`.
+function myFunction(thing){
+    return thing.toUpperCase();
+}
+myFunction("foo"); // = "FOO"
+
+// Nota che il valore da restituire deve iniziare nella stessa riga della
+// keyword `return`, altrimenti verrà sempre restituito `undefined` per via due to
+// dell'inserimento automatico dei punti e virgola. Fare attenzione a questo quando si usa lo stile Allman.
+function myFunction(){
+    return // <- punto e virgola automaticamente inserito qui
+    {thisIsAn: 'object literal'};
+}
+myFunction(); // = undefined
+
+// Le funzioni di JavaScript sono oggetti di prima classe, quindi possono essere riassegnate
+// a diversi nomi di variabili e passate ad altre funzioni come argomenti - per esempio,
+// mentre si fornisce un gestore di eventi:
+function myFunction(){
+    // questo codice sarà chiamato in 5 secondi
+}
+setTimeout(myFunction, 5000);
+// Nota: setTimeout non è parte del linguaggio JS, ma è fornito dai browser
+// e da Node.js.
+
+// Un altra funzione fornita dai browser è setInterval
+function myFunction(){
+    // questo codice verrà chiamato ogni 5 secondi
+}
+setInterval(myFunction, 5000);
+
+// Gli oggetti funzione non devono essere dichiarati con un nome - potete scrivere
+// la definizione di una funzione anonima direttamente come argomento di un'altra.
+setTimeout(function(){
+    // questo codice sarà chiamato in 5 secondi
+}, 5000);
+
+// In JavaScript le funzioni hanno una propria visibilità; le funzioni hanno
+// il loro scope ma gli altri blocchi no.
+if (true){
+    var i = 5;
+}
+i; // = 5 - non è undefined come ci si potrebbe aspettare in un linguaggio con una propria visibilità per blocco
+
+// Questo ha portato ad un pattern comune di "esecuzione immediata di funzioni
+// anonime", che previene alle variabili temporanee di finire nella
+// visibilità globale.
+(function(){
+    var temporary = 5;
+    // Noi possiamo accedere alla visibilità globale assegnando all' "oggetto globale", che
+    // in un browser web è sempre `windows`. L'oggetto globale potrebbe avere
+    // nomi differenti in ambienti diverso dal browser come Node.js.
+    window.permanent = 10;
+})();
+temporary; // solleva ReferenceError
+permanent; // = 10
+
+// Una delle più potenti caratteristiche di javascript sono le closure. Se una funzione è
+// definita dentro un'altra funzione, la funzione interna ha accesso a le variabili
+// della funzione esterna, anche dopo essere uscita dalla funzione esterna.
+function sayHelloInFiveSeconds(name){
+    var prompt = "Hello, " + name + "!";
+    // Le funzioni interne sono messe nella visibilità locale in modo predefinito, anche se vengono
+    // dichiarate con `var`.
+    function inner(){
+        alert(prompt);
+    }
+    setTimeout(inner, 5000);
+    // setTimeout è asincrono, quindi la funzione sayHelloInFiveSeconds
+    // esce immediatamente e setTimeout chiamera inner successivamente. Tuttavia,
+    // poiché inner è "chiuso prima" di sayHelloInFiveSeconds, inner ha ancora
+    // accesso alla variabile `prompt` quando viene finalmente richiamato.
+}
+sayHelloInFiveSeconds("Adam"); // aprirà un popup con "Hello, Adam!" in 5s
+
+///////////////////////////////////
+// 5. Di più sugli oggetti, costruttori e prototipi.
+
+// Gli oggetti possono contenere funzioni.
+var myObj = {
+    myFunc: function(){
+        return "Hello world!";
+    }
+};
+myObj.myFunc(); // = "Hello world!"
+
+// Quando una funzione contenuta in un oggetto viene chiamata, essa può accedere a questo oggetto
+// possono farlo usando la parola chiave `this`.
+myObj = {
+    myString: "Hello world!",
+    myFunc: function(){
+        return this.myString;
+    }
+};
+myObj.myFunc(); // = "Hello world!"
+
+// Questo ha a che fare con come la funzione è chiamata, non con dove
+// è definita. Quindi, la nostra funzione non funziona se non è chiamata
+// nel contesto dell'oggetto.
+var myFunc = myObj.myFunc;
+myFunc(); // = undefined
+
+// Al contrario, una funzione può essere assegnata ad un oggetto e poi accedere ad esso
+// attraverso `this`, anche se non è stata inserita durante la definizione.
+var myOtherFunc = function(){
+    return this.myString.toUpperCase();
+};
+myObj.myOtherFunc = myOtherFunc;
+myObj.myOtherFunc(); // = "HELLO WORLD!"
+
+// Possiamo anche specificare un contesto per una funzione da eseguire quando la invochiamo
+// usando `call` o `apply`.
+
+
+var anotherFunc = function(s){
+    return this.myString + s;
+};
+anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
+
+// La funzione `apply` è quasi identica, ma prende un array come lista
+// di argomenti.
+
+anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"
+
+// Questo è utile quanso si lavora con una funzione che accetta una sequenza di
+// argomenti e si vuole passare un array.
+
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN (uh-oh!)
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// Ma, `call` e `apply` sono solo temporanei. Quando vogliamo incollarli, possiamo
+// usare `bind`
+
+var boundFunc = anotherFunc.bind(myObj);
+boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
+
+// `bind` può essere anche usato per applicare parzialmente (curry) una funzione.
+
+var product = function(a, b){ return a * b; };
+var doubler = product.bind(this, 2);
+doubler(8); // = 16
+
+// Quando si chiama una funzione con la parola chiave `new`, un nuovo oggetto viene creato
+// e reso disponibile alla funzione attraverso la parola chiave `this`. Le funzioni progettate per essere
+// invocate in questo modo sono chiamate costruttrici.
+
+var MyConstructor = function(){
+    this.myNumber = 5;
+};
+myNewObj = new MyConstructor(); // = {myNumber: 5}
+myNewObj.myNumber; // = 5
+
+// Diversamente dalla molti degli altri linguaggi orientati agli oggetti, Javascript non ha
+// il concetto di 'istanze' create sull'impronta di una 'classe'; invece Javascript
+// combina l'instanziamento e l'ereditarietà in un singolo concetto: il 'prototipo'.
+
+// Ogni oggetto Javascript ha un 'prototipo'. Quando si cerca di accedere a una proprietà
+// su un oggetto che non la contiene, l'interprete
+// guarderà i suoi prototipi.
+
+// Alcune implementazioni di JS faranno accedere al propotipo di un oggetto con la proprietà
+// magica `__proto__`: Anche se questo è utile per spiegare i prototipi, non è
+// parte dello standard; capiremo più avanti come usare i prototipi in modo standard.
+var myObj = {
+    myString: "Hello world!"
+};
+var myPrototype = {
+    meaningOfLife: 42,
+    myFunc: function(){
+        return this.myString.toLowerCase();
+    }
+};
+
+myObj.__proto__ = myPrototype;
+myObj.meaningOfLife; // = 42
+
+// Questo funziona anche per le funzioni.
+myObj.myFunc(); // = "hello world!"
+
+// Ovviamente, se la proprietà non è nel prototipo, il prototipo
+// del prototipo viene ricercato, e così via.
+myPrototype.__proto__ = {
+    myBoolean: true
+};
+myObj.myBoolean; // = true
+
+// Non c'è nessuna copia coinvolta qui; ogni oggetto mantiene una referenza al suo
+// prototipo. Questo significa che possiamo modificare il prototipo e i nostri cambiamenti
+// si rifletteranno da ogni parte.
+myPrototype.meaningOfLife = 43;
+myObj.meaningOfLife; // = 43
+
+// L'istruzione for/in permette di iterare sulle proprietà di un oggetto,
+// risalendo la catena dei prototipi finché non trova un prototipo null.
+for (var x in myObj){
+    console.log(myObj[x]);
+}
+///stampa:
+// Hello world!
+// 43
+// [Function: myFunc]
+// true 
+
+// Per considerare solamente le proprietà inserite nell'oggetto stesso
+// e non i loro prototipi, usare il check `hasOwnProperty()`.
+for (var x in myObj){
+    if (myObj.hasOwnProperty(x)){
+        console.log(myObj[x]);
+    }
+}
+///stampa:
+// Hello world!
+
+// Abbiamo menzionato che `__proto__` non è standard, e non c'è nessun modo standard per
+// cambiare il prototipo di un oggetto esistente. Tuttavia, ci sono due strade per
+// creare un nuovo oggetto con un dato prototipo.
+
+// La prima è Object.create, che è una recente aggiunta a JS, e che quindi
+// non è disponibile ancora in tutte le implementazioni.
+var myObj = Object.create(myPrototype);
+myObj.meaningOfLife; // = 43
+
+// La seconda strada, che funziona ovunque, ha a che fare con i costruttori.
+// I costruttori hanno una proprietà chiamata prototype. Questo *non* è il prototipo del
+// costruttore della stessa funzione; invece è il prototipo del nuovo oggetto
+// che gli viene conferito alla creazione con quel costruttore e la parola chiave new.
+MyConstructor.prototype = {
+    myNumber: 5,
+    getMyNumber: function(){
+        return this.myNumber;
+    }
+};
+var myNewObj2 = new MyConstructor();
+myNewObj2.getMyNumber(); // = 5
+myNewObj2.myNumber = 6;
+myNewObj2.getMyNumber(); // = 6
+
+// I tipi built-in come stringhe e numeri hanno anche costruttori che creano
+// oggetti wrapper equivalenti.
+var myNumber = 12;
+var myNumberObj = new Number(12);
+myNumber == myNumberObj; // = true
+
+// Eccezione, loro non sono esattamente equivalenti.
+typeof myNumber; // = 'number'
+typeof myNumberObj; // = 'object'
+myNumber === myNumberObj; // = false
+if (0){
+    // Questo codice non verrà eseguito perchè 0 è falso.
+}
+if (new Number(0)){
+   // Questo codice verrà eseguito poiché i numeri wrappati sono oggetti e gli oggetti
+   // sono sempre veri.
+}
+
+// Tuttavia, gli oggetti wrapper e i regolari built-in condividono un prototipo, quindi
+// si possono aggiungere funzionalità ad una stringa, per esempio.
+String.prototype.firstCharacter = function(){
+    return this.charAt(0);
+};
+"abc".firstCharacter(); // = "a"
+
+// Questa caratteristica viene spesso usata nel "polyfilling", che implementa nuovi
+// aspetti in un vecchio sottoinsieme di JavaScript, in modo che si possano
+// usare in vecchi ambienti come browser non aggiornati.
+
+// Per esempio, abbiamo menzionato che Object.create non è disponibile in tutte le
+// implementazioni, ma possiamo ancora usarlo con questo polyfill:
+if (Object.create === undefined){ // non lo sovrascrive se esiste già
+    Object.create = function(proto){
+        // crea un costruttore temporaneo con il giusto prototipo
+        var Constructor = function(){};
+        Constructor.prototype = proto;
+        // quindi lo usa per creare un nuovo, propriamente-prototipato oggetto
+        return new Constructor();
+    };
+}
+```
+
+## Approfondimenti
+
+Il [Mozilla Developer Networ][1] fornisce una documentazione eccellente su come Javascript è utilizzato nei browsers. In più è un wiki, quindi si può imparare di più aiutando gli altri condividendo la propria conoscenza.
+
+MDN's [A re-introduction to JavaScript][2] copre molti dei concetti qui trattati in maggiore dettaglio. Questa guida ha deliberatamente coperto solamente il linguaggio JavaScript; se volete sapere di più su come usare JavaScript in una pagina web, iniziate leggendo il [Document Object Model][3].
+
+[Learn Javascript by Example and with Challenges][4] è una variante di questo referenziario con integrate delle sfide.
+
+[Javascript Garden][5] è una guida approfondita di tutte le parti controintuitive del linguaggio.
+
+[JavaScript: The Definitive Guide][6] è una guida classica e referenziario.
+
+[Eloqunt Javascript][8] di Marijn Haverbeke è un ottimo libro/ebook JS con terminale annesso
+
+[Javascript: The Right Way][10] è una guida dedicata all'introduzione dei nuovi sviluppatori a JavaScript e come aiuto agli sviluppatori esperti per imparare di più sulle best practice.
+
+[Javascript:info][11] è un moderno tutorial su javascript che copre le basi (linguaggio principale e lavorazione con un browser) come anche argomenti avanzati con spiegazioni concise.
+
+
+In aggiunta ai contributori di questo articolo, alcuni contenuti sono adattati dal Louie Dinh's Python tutorial su questo sito, e da [JS Tutorial][7] sul Mozilla Developer Network.
+
+
+[1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript
+[2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
+[3]: https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core
+[4]: http://www.learneroo.com/modules/64/nodes/350
+[5]: http://bonsaiden.github.io/JavaScript-Garden/
+[6]: http://www.amazon.com/gp/product/0596805527/
+[7]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
+[8]: http://eloquentjavascript.net/
+[10]: http://jstherightway.org/
+[11]: https://javascript.info/
diff --git a/it-it/jquery-it.html.markdown b/it-it/jquery-it.html.markdown
new file mode 100644
index 00000000..811c5c3a
--- /dev/null
+++ b/it-it/jquery-it.html.markdown
@@ -0,0 +1,131 @@
+---
+category: tool
+tool: jquery
+contributors:
+    - ["Sawyer Charles", "https://github.com/xssc"]
+filename: jquery-it.js
+translators:
+    - ["Ale46", "https://github.com/ale46"]
+lang: it-it
+---
+
+jQuery è una libreria JavaScript che ti aiuta a "fare di più, scrivendo meno". Rende molte attività comuni di JavaScript più facili da scrivere. jQuery è utilizzato da molte grandi aziende e sviluppatori in tutto il mondo. Rende AJAX, gestione degli eventi, manipolazione dei documenti e molto altro, più facile e veloce.
+
+Visto che jQuery è una libreria JavaScript dovresti prima [imparare JavaScript](https://learnxinyminutes.com/docs/javascript/)
+
+```js
+
+
+///////////////////////////////////
+// 1. Selettori
+
+// I selettori in jQuery vengono utilizzati per selezionare un elemento
+var page = $(window); // Seleziona l'intera finestra
+
+// I selettori possono anche essere selettori CSS
+var paragraph = $('p'); // Seleziona tutti gli elementi del paragrafo
+var table1 = $('#table1'); // Seleziona elemento con id 'table1'
+var squares = $('.square'); // Seleziona tutti gli elementi con la classe 'square'
+var square_p = $('p.square') // Seleziona i paragrafi con la classe 'square'
+
+
+///////////////////////////////////
+// 2. Eventi ed effetti
+// jQuery è molto bravo a gestire ciò che accade quando un evento viene attivato
+// Un evento molto comune è l'evento "pronto" sul documento
+// Puoi usare il metodo 'ready' per aspettare che l'elemento abbia finito di caricare
+$(document).ready(function(){
+  // Il codice non verrà eseguito fino a quando il documento non verrà caricato
+});
+// Puoi anche usare funzioni definite
+function onAction() {
+  // Questo viene eseguito quando l'evento viene attivato
+}
+$('#btn').click(onAction); // Invoca onAction al click
+
+// Alcuni altri eventi comuni sono:
+$('#btn').dblclick(onAction); // Doppio click
+$('#btn').hover(onAction); // Al passaggio del mouse
+$('#btn').focus(onAction); // Al focus
+$('#btn').blur(onAction); // Focus perso
+$('#btn').submit(onAction); // Al submit
+$('#btn').select(onAction); // Quando un elemento è selezionato
+$('#btn').keydown(onAction); // Quando un tasto è premuto (ma non rilasciato)
+$('#btn').keyup(onAction); // Quando viene rilasciato un tasto
+$('#btn').keypress(onAction); // Quando viene premuto un tasto
+$('#btn').mousemove(onAction); // Quando il mouse viene spostato
+$('#btn').mouseenter(onAction); // Il mouse entra nell'elemento
+$('#btn').mouseleave(onAction); // Il mouse lascia l'elemento
+
+
+// Questi possono anche innescare l'evento invece di gestirlo
+// semplicemente non passando alcun parametro
+$('#btn').dblclick(); // Innesca il doppio click sull'elemento
+
+// Puoi gestire più eventi mentre usi il selettore solo una volta
+$('#btn').on(
+  {dblclick: myFunction1} // Attivato con doppio clic
+  {blur: myFunction1} // Attivato al blur
+);
+
+// Puoi spostare e nascondere elementi con alcuni metodi di effetto
+$('.table').hide(); // Nascondi gli elementi
+
+// Nota: chiamare una funzione in questi metodi nasconderà comunque l'elemento
+$('.table').hide(function(){
+    // Elemento nascosto quindi funzione eseguita
+});
+
+// È possibile memorizzare selettori in variabili
+var tables = $('.table');
+
+// Alcuni metodi di manipolazione dei documenti di base sono:
+tables.hide(); // Nascondi elementi
+tables.show(); // Mostra elementi
+tables.toggle(); // Cambia lo stato nascondi/mostra
+tables.fadeOut(); // Fades out
+tables.fadeIn(); // Fades in
+tables.fadeToggle(); // Fades in o out
+tables.fadeTo(0.5); // Dissolve in opacità (tra 0 e 1)
+tables.slideUp(); // Scorre verso l'alto
+tables.slideDown(); // Scorre verso il basso
+tables.slideToggle(); // Scorre su o giù
+
+// Tutti i precedenti prendono una velocità (millisecondi) e la funzione di callback
+tables.hide(1000, myFunction); // nasconde l'animazione per 1 secondo quindi esegue la funzione
+
+// fadeTo ha un'opacità richiesta come secondo parametro
+tables.fadeTo(2000, 0.1, myFunction); // esegue in 2 sec. il fade sino ad una opacità di 0.1 opacity e poi la funzione
+
+// Puoi ottenere un effetti più avanzati con il metodo animate
+tables.animate({margin-top:"+=50", height: "100px"}, 500, myFunction);
+// Il metodo animate accetta un oggetto di css e valori con cui terminare,
+// parametri opzionali per affinare l'animazione,
+// e naturalmente la funzione di callback
+
+///////////////////////////////////
+// 3. Manipolazione
+
+// Questi sono simili agli effetti ma possono fare di più
+$('div').addClass('taming-slim-20'); // Aggiunge la classe taming-slim-20 a tutti i div 
+
+// Metodi di manipolazione comuni
+$('p').append('Hello world'); // Aggiunge alla fine dell'elemento
+$('p').attr('class'); // Ottiene l'attributo
+$('p').attr('class', 'content'); // Imposta l'attributo
+$('p').hasClass('taming-slim-20'); // Restituisce vero se ha la classe
+$('p').height(); // Ottiene l'altezza dell'elemento o imposta l'altezza
+
+
+// Per molti metodi di manipolazione, ottenere informazioni su un elemento
+// restituirà SOLO il primo elemento corrispondente
+$('p').height(); // Ottiene solo la prima altezza del tag 'p'
+
+// È possibile utilizzare each per scorrere tutti gli elementi
+var heights = [];
+$('p').each(function() {
+  heights.push($(this).height()); // Aggiunge tutte le altezze del tag 'p' all'array
+});
+
+
+```
diff --git a/it-it/logtalk-it.html.markdown b/it-it/logtalk-it.html.markdown
index 7f1e9eeb..5cc53e6f 100644
--- a/it-it/logtalk-it.html.markdown
+++ b/it-it/logtalk-it.html.markdown
@@ -43,7 +43,7 @@ Un oggetto incapsula le dichiarazioni e le definizioni dei predicati. Gli oggett
 :- end_object.
 ```
 
-# Compilazione dei file sorgenti
+# Compilazione e il caricamento dei file sorgenti
 
 Supponendo che il codice di cui sopra per l'oggetto `list` venga salvato in un file` list.lgt`, esso può essere compilato e caricato utilizzando il predicato predefiniti `logtalk_load/1` o la sua abbreviazione `{}/1`, con il percorso del file come argomento (l'estensione può essere omessa):
 
@@ -52,6 +52,9 @@ Supponendo che il codice di cui sopra per l'oggetto `list` venga salvato in un f
 yes
 ```
 
+In generale, le entità potrebbero avere dipendenze sulle entità definite in altri file di origine (ad esempio le entità di biblioteca). Per caricare un file e tutte le sue dipendenze, la soluzione consigliata consiste nel definire un file _loader_ che carica tutti i file necessari per un'applicazione. Un file loader è semplicemente un file di origine, in genere denominato `loader.lgt`, che effettua chiamate ai predicati built-in `logtalk_load/1-2`, di solito
+da una direttiva `initialization/1` per la portabilità e conformità agli standard. Caricatore file vengono forniti per tutte le librerie, strumenti ed esempi. 
+
 # Inviare un messaggio ad un oggetto
 
 L'operatore infisso `::/2` è usato per inviare messaggi ad un oggetto. Analogamente al Prolog, è possibile fare backtracking per le soluzioni alternative:
diff --git a/it-it/markdown.html.markdown b/it-it/markdown.html.markdown
index 44801747..b0a123f1 100644
--- a/it-it/markdown.html.markdown
+++ b/it-it/markdown.html.markdown
@@ -28,7 +28,7 @@ Markdown varia nelle sue implementazioni da un parser all'altro. Questa guida ce
 ## Elementi HTML
 Markdown è un superset di HTML, quindi ogni file HTML è a sua volta un file Markdown valido.
 
-```markdown
+```md
 <!-- Questo significa che possiamo usare elementi di HTML in Markdown, come per esempio i commenti,
 e questi non saranno modificati dal parser di Markdown. State attenti però, 
 se inserite un elemento HTML nel vostro file Markdown, non potrete usare la sua sintassi 
@@ -39,7 +39,7 @@ all'interno del contenuto dell'elemento. -->
 
 Potete creare gli elementi HTML da `<h1>` a `<h6>` facilmente, basta che inseriate un egual numero di caratteri cancelletto (#) prima del testo che volete all'interno dell'elemento
 
-```markdown
+```md
 # Questo è un <h1>
 ## Questo è un <h2>
 ### Questo è un <h3>
@@ -49,7 +49,7 @@ Potete creare gli elementi HTML da `<h1>` a `<h6>` facilmente, basta che inseria
 ```
 Markdown inoltre fornisce due alternative per indicare gli elementi h1 e h2
 
-```markdown
+```md
 Questo è un h1
 ==============
 
@@ -60,7 +60,7 @@ Questo è un h2
 ## Stili di testo semplici
 Il testo può essere stilizzato in corsivo o grassetto usando markdown
 
-```markdown
+```md
 *Questo testo è in corsivo.*
 _Come pure questo._
 
@@ -74,12 +74,12 @@ __Come pure questo.__
 
 In Github Flavored Markdown, che è utilizzato per renderizzare i file markdown su Github, è presente anche lo stile barrato:
 
-```markdown
+```md
 ~~Questo testo è barrato.~~
 ```
 ## Paragrafi
 
-```markdown
+```md
 I paragrafi sono una o più linee di testo adiacenti separate da una o più righe vuote.
 
 Questo è un paragrafo. Sto scrivendo in un paragrafo, non è divertente?
@@ -93,7 +93,7 @@ Qui siamo nel paragrafo 3!
 
 Se volete inserire l'elemento HTML `<br />`, potete terminare la linea con due o più spazi e poi iniziare un nuovo paragrafo.
 
-```markdown
+```md
 Questa frase finisce con due spazi (evidenziatemi per vederli).  
 
 C'è un <br /> sopra di me!
@@ -101,7 +101,7 @@ C'è un <br /> sopra di me!
 
 Le citazioni sono semplici da inserire, basta usare il carattere >.
 
-```markdown
+```md
 > Questa è una citazione. Potete
 > mandare a capo manualmente le linee e inserire un `>` prima di ognuna, oppure potete usare una sola linea e lasciare che vada a capo automaticamente.
 > Non c'è alcuna differenza, basta che iniziate ogni riga con `>`.
@@ -115,7 +115,7 @@ Le citazioni sono semplici da inserire, basta usare il carattere >.
 ## Liste
 Le liste non ordinate possono essere inserite usando gli asterischi, il simbolo più o dei trattini
 
-```markdown
+```md
 * Oggetto
 * Oggetto
 * Altro oggetto
@@ -135,7 +135,7 @@ oppure
 
 Le liste ordinate invece, sono inserite con un numero seguito da un punto.
 
-```markdown
+```md
 1. Primo oggetto
 2. Secondo oggetto
 3. Terzo oggetto
@@ -143,7 +143,7 @@ Le liste ordinate invece, sono inserite con un numero seguito da un punto.
 
 Non dovete nemmeno mettere i numeri nell'ordine giusto, markdown li visualizzerà comunque nell'ordine corretto, anche se potrebbe non essere una buona idea.
 
-```markdown
+```md
 1. Primo oggetto
 1. Secondo oggetto
 1. Terzo oggetto
@@ -152,7 +152,7 @@ Non dovete nemmeno mettere i numeri nell'ordine giusto, markdown li visualizzer�
 
 Potete inserire anche sotto liste
 
-```markdown
+```md
 1. Primo oggetto
 2. Secondo oggetto
 3. Terzo oggetto
@@ -163,7 +163,7 @@ Potete inserire anche sotto liste
 
 Sono presenti anche le task list. In questo modo è possibile creare checkbox in HTML.
 
-```markdown
+```md
 I box senza la 'x' sono checkbox HTML ancora da completare.
 - [ ] Primo task da completare.
 - [ ] Secondo task che deve essere completato.
@@ -174,14 +174,14 @@ Il box subito sotto è una checkbox HTML spuntata.
 
 Potete inserire un estratto di codice (che utilizza l'elemento `<code>`) indentando una linea con quattro spazi oppure con un carattere tab.
 
-```markdown
+```md
     Questa è una linea di codice
     Come questa
 ```
 
 Potete inoltre inserire un altro tab (o altri quattro spazi) per indentare il vostro codice
 
-```markdown
+```md
     my_array.each do |item|
         puts item
     end
@@ -189,7 +189,7 @@ Potete inoltre inserire un altro tab (o altri quattro spazi) per indentare il vo
 
 Codice inline può essere inserito usando il carattere backtick `
 
-```markdown
+```md
 Giovanni non sapeva neppure a cosa servisse la funzione `go_to()`!
 ```
 
@@ -205,7 +205,7 @@ Se usate questa sintassi, il testo non richiederà di essere indentato, inoltre
 ## Linea orizzontale
 Le linee orizzontali (`<hr/>`) sono inserite facilmente usanto tre o più asterischi o trattini, con o senza spazi. 
 
-```markdown
+```md
 ***
 ---
 - - -
@@ -215,24 +215,24 @@ Le linee orizzontali (`<hr/>`) sono inserite facilmente usanto tre o più asteri
 ## Links
 Una delle funzionalità migliori di markdown è la facilità con cui si possono inserire i link. Mettete il testo da visualizzare fra parentesi quadre [] seguite dall'url messo fra parentesi tonde ()
 
-```markdown
+```md
 [Cliccami!](http://test.com/)
 ```
 
 Potete inoltre aggiungere al link un titolo mettendolo fra doppi apici dopo il link
 
-```markdown
+```md
 [Cliccami!](http://test.com/ "Link a Test.com")
 ```
 
 La sintassi funziona anche con i path relativi.
 
-```markdown
+```md
 [Vai a musica](/music/).
 ```
 
 Markdown supporta inoltre anche la possibilità di aggiungere i link facendo riferimento ad altri punti del testo.
-```markdown
+```md
 [Apri questo link][link1] per più informazioni!
 [Guarda anche questo link][foobar] se ti va.
 
@@ -242,7 +242,7 @@ Markdown supporta inoltre anche la possibilità di aggiungere i link facendo rif
 l titolo può anche essere inserito in apici singoli o in parentesi, oppure omesso interamente. Il riferimento può essere inserito in un punto qualsiasi del vostro documento e l'identificativo del riferimento può essere lungo a piacere a patto che sia univoco.
 
 Esiste anche un "identificativo implicito" che vi permette di usare il testo del link come id.
-```markdown
+```md
 [Questo][] è un link.
 
 [Questo]: http://thisisalink.com/
@@ -252,13 +252,13 @@ Ma non è comunemente usato.
 ## Immagini
 Le immagini sono inserite come i link ma con un punto esclamativo inserito prima delle parentesi quadre!
 
-```markdown
+```md
 ![Qeusto è il testo alternativo per l'immagine](http://imgur.com/myimage.jpg "Il titolo opzionale")
 ```
 
 E la modalità a riferimento funziona esattamente come ci si aspetta
 
-```markdown
+```md
 ![Questo è il testo alternativo.][myimage]
 
 [myimage]: relative/urls/cool/image.jpg "Se vi serve un titolo, lo mettete qui"
@@ -266,25 +266,25 @@ E la modalità a riferimento funziona esattamente come ci si aspetta
 ## Miscellanea 
 ### Auto link
 
-```markdown
+```md
 <http://testwebsite.com/> è equivalente ad
 [http://testwebsite.com/](http://testwebsite.com/)
 ```
 ### Auto link per le email
 
-```markdown
+```md
 <foo@bar.com>
 ```
 ### Caratteri di escaping
 
-```markdown
+```md
 Voglio inserire *questo testo circondato da asterischi* ma non voglio che venga renderizzato in corsivo, quindi lo inserirò così: \*questo testo è circondato da asterischi\*.
 ```
 
 ### Combinazioni di tasti
 In Github Flavored Markdown, potete utilizzare il tag `<kbd>` per raffigurare i tasti della tastiera.
 
-```markdown
+```md
 Il tuo computer è crashato? Prova a premere
 <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Canc</kbd>
 ```
@@ -292,7 +292,7 @@ Il tuo computer è crashato? Prova a premere
 ### Tabelle
 Le tabelle sono disponibili solo in Github Flavored Markdown e sono leggeremente complesse, ma se proprio volete inserirle fate come segue:
 
-```markdown
+```md
 | Col1                 | Col2     | Col3               |
 | :------------------- | :------: | -----------------: |
 | Allineato a sinistra | Centrato | Allineato a destra |
@@ -300,7 +300,7 @@ Le tabelle sono disponibili solo in Github Flavored Markdown e sono leggeremente
 ```
 oppure, per lo stesso risultato
 
-```markdown
+```md
 Col 1 | Col2 | Col3
 :-- | :-: | --:
 È una cosa orrenda | fatela | finire in fretta
diff --git a/it-it/matlab-it.html.markdown b/it-it/matlab-it.html.markdown
index 8d6d4385..38be8848 100644
--- a/it-it/matlab-it.html.markdown
+++ b/it-it/matlab-it.html.markdown
@@ -199,8 +199,7 @@ size(A) % ans = 3 3
 A(1, :) =[] % Rimuove la prima riga della matrice
 A(:, 1) =[] % Rimuove la prima colonna della matrice
 
-transpose(A) % Traspone la matrice, equivale a:
-A one
+transpose(A) % Traspone la matrice, equivale a: A.'
 ctranspose(A) % Trasposizione hermitiana della matrice
 % (ovvero il complesso coniugato di ogni elemento della matrice trasposta)
 
diff --git a/it-it/pcre-it.html.markdown b/it-it/pcre-it.html.markdown
new file mode 100644
index 00000000..704392ef
--- /dev/null
+++ b/it-it/pcre-it.html.markdown
@@ -0,0 +1,85 @@
+---
+language: PCRE
+filename: pcre-it.txt
+contributors:
+    - ["Sachin Divekar", "http://github.com/ssd532"]
+translators:
+    - ["Christian Grasso", "https://grasso.io"]
+lang: it-it
+---
+
+Un'espressione regolare (regex o regexp in breve) è una speciale stringa
+utilizzata per definire un pattern, ad esempio per cercare una sequenza di
+caratteri; ad esempio, `/^[a-z]+:/` può essere usato per estrarre `http:`
+dall'URL `http://github.com/`.
+
+PCRE (Perl Compatible Regular Expressions) è una libreria per i regex in C.
+La sintassi utilizzata per le espressioni è molto simile a quella di Perl, da
+cui il nome. Si tratta di una delle sintassi più diffuse per la scrittura di
+regex.
+
+Esistono due tipi di metacaratteri (caratteri con una funzione speciale):
+
+* Caratteri riconosciuti ovunque tranne che nelle parentesi quadre
+
+```
+  \      carattere di escape
+  ^      cerca all'inizio della stringa (o della riga, in modalità multiline)
+  $      cerca alla fine della stringa (o della riga, in modalità multiline)
+  .      qualsiasi carattere eccetto le newline
+  [      inizio classe di caratteri
+  |      separatore condizioni alternative
+  (      inizio subpattern
+  )      fine subpattern
+  ?      quantificatore "0 o 1"
+  *      quantificatore "0 o più"
+  +      quantificatore "1 o più"
+  {      inizio quantificatore numerico
+```
+
+* Caratteri riconosciuti nelle parentesi quadre
+
+```
+  \      carattere di escape
+  ^      nega la classe se è il primo carattere
+  -      indica una serie di caratteri
+  [      classe caratteri POSIX (se seguita dalla sintassi POSIX)
+  ]      termina la classe caratteri
+```
+
+PCRE fornisce inoltre delle classi di caratteri predefinite:
+
+```
+  \d     cifra decimale
+  \D     NON cifra decimale
+  \h     spazio vuoto orizzontale
+  \H     NON spazio vuoto orizzontale
+  \s     spazio
+  \S     NON spazio
+  \v     spazio vuoto verticale
+  \V     NON spazio vuoto verticale
+  \w     parola
+  \W     "NON parola"
+```
+
+## Esempi
+
+Utilizzeremo la seguente stringa per i nostri test:
+
+```
+66.249.64.13 - - [18/Sep/2004:11:07:48 +1000] "GET /robots.txt HTTP/1.0" 200 468 "-" "Googlebot/2.1"
+```
+
+Si tratta di una riga di log del web server Apache.
+
+| Regex | Risultato          | Commento |
+| :---- | :-------------- | :------ |
+| `GET`   | GET | Cerca esattamente la stringa "GET" (case sensitive) |
+| `\d+.\d+.\d+.\d+` | 66.249.64.13 | `\d+` identifica uno o più (quantificatore `+`) numeri [0-9], `\.` identifica il carattere `.` |
+| `(\d+\.){3}\d+` | 66.249.64.13 | `(\d+\.){3}` cerca il gruppo (`\d+\.`) esattamente 3 volte. |
+| `\[.+\]` | [18/Sep/2004:11:07:48 +1000] | `.+` identifica qualsiasi carattere, eccetto le newline; `.` indica un carattere qualsiasi |
+| `^\S+` | 66.249.64.13 | `^` cerca all'inizio della stringa, `\S+` identifica la prima stringa di caratteri diversi dallo spazio |
+| `\+[0-9]+` | +1000 | `\+` identifica il carattere `+`. `[0-9]` indica una cifra da 0 a 9. L'espressione è equivalente a `\+\d+` |
+
+## Altre risorse
+[Regex101](https://regex101.com/) - tester per le espressioni regolari
diff --git a/it-it/pyqt-it.html.markdown b/it-it/pyqt-it.html.markdown
new file mode 100644
index 00000000..7238dd7b
--- /dev/null
+++ b/it-it/pyqt-it.html.markdown
@@ -0,0 +1,85 @@
+---
+category: tool
+tool: PyQT
+filename: learnpyqt-it.py
+contributors:
+    - ["Nathan Hughes", "https://github.com/sirsharpest"]
+translators:
+    - ["Ale46", "https://github.com/ale46"]
+lang: it-it
+---
+
+**Qt** è un framework ampiamente conosciuto per lo sviluppo di software multipiattaforma che può essere eseguito su varie piattaforme software e hardware con modifiche minime o nulle nel codice, pur avendo la potenza e la velocità delle applicazioni native. Sebbene **Qt** sia stato originariamente scritto in *C++*.
+
+
+Questo è un adattamento sull'introduzione di C ++ a QT di [Aleksey Kholovchuk] (https://github.com/vortexxx192
+), alcuni degli esempi di codice dovrebbero avere la stessa funzionalità
+che avrebbero se fossero fatte usando pyqt! 
+
+```python
+import sys
+from PyQt4 import QtGui
+	
+def window():
+	# Crea un oggetto applicazione
+    app = QtGui.QApplication(sys.argv)
+	# Crea un widget in cui verrà inserita la nostra etichetta
+    w = QtGui.QWidget()
+	# Aggiungi un'etichetta al widget
+    b = QtGui.QLabel(w)
+	# Imposta del testo per l'etichetta
+    b.setText("Ciao Mondo!")
+	# Fornisce informazioni su dimensioni e posizionamento
+    w.setGeometry(100, 100, 200, 50)
+    b.move(50, 20)
+	# Dai alla nostra finestra un bel titolo
+    w.setWindowTitle("PyQt")
+	# Visualizza tutto
+    w.show()
+	# Esegui ciò che abbiamo chiesto, una volta che tutto è stato configurato
+    sys.exit(app.exec_())
+
+if __name__ == '__main__':
+    window()
+
+```
+
+Per ottenere alcune delle funzionalità più avanzate in **pyqt**, dobbiamo iniziare a cercare di creare elementi aggiuntivi.
+Qui mostriamo come creare una finestra popup di dialogo, utile per chiedere all'utente di confermare una decisione o fornire informazioni
+
+```Python 
+import sys
+from PyQt4.QtGui import *
+from PyQt4.QtCore import *
+
+
+def window():
+    app = QApplication(sys.argv)
+    w = QWidget()
+    # Crea un pulsante e allegalo al widget w
+    b = QPushButton(w)
+    b.setText("Premimi")
+    b.move(50, 50)
+    # Indica a b di chiamare questa funzione quando si fa clic
+    # notare la mancanza di "()" sulla chiamata di funzione
+    b.clicked.connect(showdialog)
+    w.setWindowTitle("PyQt Dialog")
+    w.show()
+    sys.exit(app.exec_())
+	
+# Questa funzione dovrebbe creare una finestra di dialogo con un pulsante
+# che aspetta di essere cliccato e quindi esce dal programma
+def showdialog():
+    d = QDialog()
+    b1 = QPushButton("ok", d)
+    b1.move(50, 50)
+    d.setWindowTitle("Dialog")
+    # Questa modalità dice al popup di bloccare il genitore, mentre è attivo
+    d.setWindowModality(Qt.ApplicationModal)
+    # Al click vorrei che l'intero processo finisse
+    b1.clicked.connect(sys.exit)
+    d.exec_()
+
+if __name__ == '__main__':
+    window()
+```
diff --git a/it-it/python-it.html.markdown b/it-it/python-it.html.markdown
index e81d1676..794e7a70 100644
--- a/it-it/python-it.html.markdown
+++ b/it-it/python-it.html.markdown
@@ -640,7 +640,7 @@ i.age  # => Emette un AttributeError
 
 # Puoi importare moduli
 import math
-print math.sqrt(16)  # => 4
+print math.sqrt(16)  # => 4.0
 
 # Puoi ottenere specifiche funzione da un modulo
 from math import ceil, floor
diff --git a/it-it/python3-it.html.markdown b/it-it/python3-it.html.markdown
index 06ef9a5e..04f78cff 100644
--- a/it-it/python3-it.html.markdown
+++ b/it-it/python3-it.html.markdown
@@ -400,8 +400,8 @@ else:                  # Anche else è opzionale
     print("some_var è  10.")
 
 """
-I cicli for iterano sulle liste, cioé ripetono un codice per ogni elemento 
-# di una lista.
+I cicli for iterano sulle liste, cioè ripetono un codice per ogni elemento 
+di una lista.
 Il seguente codice scriverà:
     cane è un mammifero
     gatto è un mammifero
@@ -409,7 +409,7 @@ Il seguente codice scriverà:
 """
 for animale in ["cane", "gatto", "topo"]:
     # Puoi usare format() per interpolare le stringhe formattate.
-    print("{} is a mammal".format(animal))
+    print("{} è un mammifero".format(animale))
 
 """
 "range(numero)" restituisce una lista di numeri da zero al numero dato
diff --git a/it-it/qt-it.html.markdown b/it-it/qt-it.html.markdown
new file mode 100644
index 00000000..d7469f67
--- /dev/null
+++ b/it-it/qt-it.html.markdown
@@ -0,0 +1,161 @@
+---
+category: tool
+tool: Qt Framework
+language: c++
+filename: learnqt-it.cpp
+contributors:
+    - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
+translators:
+    - ["Ale46", "https://gihub.com/ale46"]
+lang: it-it
+---
+
+**Qt** è un framework ampiamente conosciuto per lo sviluppo di software multipiattaforma che può essere eseguito su varie piattaforme software e hardware con modifiche minime o nulle nel codice, pur avendo la potenza e la velocità delle applicazioni native. Sebbene **Qt** sia stato originariamente scritto in *C++*, ci sono diversi porting in altri linguaggi: *[PyQt](https://learnxinyminutes.com/docs/pyqt/)*, *QtRuby*, *PHP-Qt*, etc.
+
+**Qt** è ottimo per la creazione di applicazioni con interfaccia utente grafica (GUI). Questo tutorial descrive come farlo in *C++*.
+
+```c++
+/*
+ * Iniziamo classicamente
+ */
+
+// tutte le intestazioni dal framework Qt iniziano con la lettera maiuscola 'Q'
+#include <QApplication>
+#include <QLineEdit>
+
+int main(int argc, char *argv[]) {
+	  // crea un oggetto per gestire le risorse a livello di applicazione
+    QApplication app(argc, argv);
+
+    // crea un widget di campo di testo e lo mostra sullo schermo
+    QLineEdit lineEdit("Hello world!");
+    lineEdit.show();
+
+    // avvia il ciclo degli eventi dell'applicazione
+    return app.exec();
+}
+```
+
+La parte relativa alla GUI di **Qt** riguarda esclusivamente *widget* e le loro *connessioni*.
+
+[LEGGI DI PIÙ SUI WIDGET](http://doc.qt.io/qt-5/qtwidgets-index.html)
+
+```c++
+/*
+ * Creiamo un'etichetta e un pulsante.
+ * Un'etichetta dovrebbe apparire quando si preme un pulsante.
+ * 
+ * Il codice Qt parla da solo.
+ */
+ 
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QLabel>
+
+int main(int argc, char *argv[]) {
+    QApplication app(argc, argv);
+
+    QDialog dialogWindow;
+    dialogWindow.show();
+    
+    // add vertical layout 
+    QVBoxLayout layout;
+    dialogWindow.setLayout(&layout);  
+
+    QLabel textLabel("Grazie per aver premuto quel pulsante");
+    layout.addWidget(&textLabel);
+    textLabel.hide();
+
+    QPushButton button("Premimi");
+    layout.addWidget(&button);
+    
+    // mostra l'etichetta nascosta quando viene premuto il pulsante
+    QObject::connect(&button, &QPushButton::pressed,
+                     &textLabel, &QLabel::show);
+
+    return app.exec();
+}
+```
+
+Si noti la parte relativa a *QObject::connect*. Questo metodo viene utilizzato per connettere *SEGNALI* di un oggetto agli *SLOTS* di un altro.
+
+**I SEGNALI** vengono emessi quando certe cose accadono agli oggetti, come il segnale *premuto* che viene emesso quando l'utente preme sull'oggetto QPushButton.
+
+**Gli slot** sono *azioni* che potrebbero essere eseguite in risposta ai segnali ricevuti.
+
+[LEGGI DI PIÙ SU SLOT E SEGNALI](http://doc.qt.io/qt-5/signalsandslots.html)
+
+
+Successivamente, impariamo che non possiamo solo usare i widget standard, ma estendere il loro comportamento usando l'ereditarietà. Creiamo un pulsante e contiamo quante volte è stato premuto. A tale scopo definiamo la nostra classe *CounterLabel*. Deve essere dichiarato in un file separato a causa dell'architettura Qt specifica.
+
+```c++
+// counterlabel.hpp
+
+#ifndef COUNTERLABEL
+#define COUNTERLABEL
+
+#include <QLabel>
+
+class CounterLabel : public QLabel {
+    Q_OBJECT  // Macro definite da Qt che devono essere presenti in ogni widget personalizzato
+    
+public:
+    CounterLabel() : counter(0) {
+        setText("Il contatore non è stato ancora aumentato");  // metodo di QLabel
+    }
+
+public slots:
+    // azione che verrà chiamata in risposta alla pressione del pulsante
+    void increaseCounter() {
+        setText(QString("Valore contatore: %1").arg(QString::number(++counter)));
+    }
+
+private:
+    int counter;
+};
+
+#endif // COUNTERLABEL
+```
+
+```c++
+// main.cpp
+// Quasi uguale all'esempio precedente
+
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QString>
+#include "counterlabel.hpp"
+
+int main(int argc, char *argv[]) {
+    QApplication app(argc, argv);
+
+    QDialog dialogWindow;
+    dialogWindow.show();
+
+    QVBoxLayout layout;
+    dialogWindow.setLayout(&layout);
+
+    CounterLabel counterLabel;
+    layout.addWidget(&counterLabel);
+
+    QPushButton button("Premimi ancora una volta");
+    layout.addWidget(&button);
+    QObject::connect(&button, &QPushButton::pressed,
+                     &counterLabel, &CounterLabel::increaseCounter);
+
+    return app.exec();
+}
+```
+
+Questo è tutto! Ovviamente, il framework Qt è molto più grande della parte che è stata trattata in questo tutorial, quindi preparatevi a leggere e fare pratica.
+
+## Ulteriori letture
+
+- [Qt 4.8 tutorials](http://doc.qt.io/qt-4.8/tutorials.html)
+- [Qt 5 tutorials](http://doc.qt.io/qt-5/qtexamplesandtutorials.html)
+
+Buona fortuna e buon divertimento!
diff --git a/it-it/ruby-it.html.markdown b/it-it/ruby-it.html.markdown
new file mode 100644
index 00000000..295bf28a
--- /dev/null
+++ b/it-it/ruby-it.html.markdown
@@ -0,0 +1,653 @@
+---
+language: ruby
+filename: learnruby-it.rb
+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"]
+  - ["Ariel Krakowski", "http://www.learneroo.com"]
+  - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+  - ["Levi Bostian", "https://github.com/levibostian"]
+  - ["Rahil Momin", "https://github.com/iamrahil"]
+  - ["Gabriel Halley", "https://github.com/ghalley"]
+  - ["Persa Zula", "http://persazula.com"]
+  - ["Jake Faris", "https://github.com/farisj"]
+  - ["Corey Ward", "https://github.com/coreyward"]
+translators:
+  - ["abonte", "https://github.com/abonte"]
+lang: it-it   
+---
+
+```ruby
+# Questo è un commento
+
+# In Ruby, (quasi) tutto è un oggetto.
+# Questo include i numeri...
+3.class #=> Integer
+
+# ...stringhe...
+"Hello".class #=> String
+
+# ...e anche i metodi!
+"Hello".method(:class).class #=> Method
+
+# Qualche operazione aritmetica di base
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+2 ** 5 #=> 32
+5 % 3 #=> 2
+
+# Bitwise operators
+3 & 5 #=> 1
+3 | 5 #=> 7
+3 ^ 5 #=> 6
+
+# L'aritmetica è solo zucchero sintattico
+# per chiamare il metodo di un oggetto
+1.+(3) #=> 4
+10.* 5 #=> 50
+100.methods.include?(:/) #=> true
+
+# I valori speciali sono oggetti
+nil # equivalente a null in altri linguaggi
+true # vero
+false # falso
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Uguaglianza
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Disuguaglianza
+1 != 1 #=> false
+2 != 1 #=> true
+
+# nil è l'unico valore, oltre a false, che è considerato 'falso'
+!!nil   #=> false
+!!false #=> false
+!!0     #=> true
+!!""    #=> true
+
+# Altri confronti
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Operatori di confronto combinati (ritorna '1' quando il primo argomento è più
+# grande, '-1' quando il secondo argomento è più grande, altrimenti '0')
+1 <=> 10 #=> -1
+10 <=> 1 #=> 1
+1 <=> 1 #=> 0
+
+# Operatori logici
+true && false #=> false
+true || false #=> true
+
+# Ci sono versioni alternative degli operatori logici con meno precedenza.
+# Sono usati come costrutti per il controllo di flusso per concatenare
+# insieme statement finché uno di essi ritorna true o false.
+
+# `do_something_else` chiamato solo se `do_something` ha successo.
+do_something() and do_something_else()
+# `log_error` è chiamato solo se `do_something` fallisce.
+do_something() or log_error()
+
+# Interpolazione di stringhe
+
+placeholder = 'usare l\'interpolazione di stringhe'
+"Per #{placeholder} si usano stringhe con i doppi apici"
+#=> "Per usare l'interpolazione di stringhe si usano stringhe con i doppi apici"
+
+# E' possibile combinare le stringhe usando `+`, ma non con gli altri tipi
+'hello ' + 'world'  #=> "hello world"
+'hello ' + 3 #=> TypeError: can't convert Fixnum into String
+'hello ' + 3.to_s #=> "hello 3"
+"hello #{3}" #=> "hello 3"
+
+# ...oppure combinare stringhe e operatori
+'ciao ' * 3 #=> "ciao ciao ciao "
+
+# ...oppure aggiungere alla stringa
+'ciao' << ' mondo' #=> "ciao mondo"
+
+# Per stampare a schermo e andare a capo
+puts "Sto stampando!"
+#=> Sto stampando!
+#=> nil
+
+# Per stampare a schermo senza andare a capo
+print "Sto stampando!"
+#=> Sto stampando! => nil
+
+# Variabili
+x = 25 #=> 25
+x #=> 25
+
+# Notare che l'assegnamento ritorna il valore assegnato.
+# Questo significa che è possibile effettuare assegnamenti multipli:
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# Per convenzione si usa lo snake_case per i nomi delle variabili
+snake_case = true
+
+# Usare nomi delle variabili descrittivi
+path_to_project_root = '/buon/nome/'
+m = '/nome/scadente/'
+
+# I simboli sono immutabili, costanti riusabili rappresentati internamente da
+# un valore intero. Sono spesso usati al posto delle stringhe per comunicare
+# specifici e significativi valori.
+
+:pendente.class #=> Symbol
+
+stato = :pendente
+
+stato == :pendente #=> true
+
+stato == 'pendente' #=> false
+
+stato == :approvato #=> false
+
+# Le stringhe possono essere convertite in simboli e viceversa:
+status.to_s #=> "pendente"
+"argon".to_sym #=> :argon
+
+# Arrays
+
+# Questo è un array
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Gli array possono contenere diversi tipi di elementi
+[1, 'hello', false] #=> [1, "hello", false]
+
+# Gli array possono essere indicizzati
+# Dall'inizio...
+array[0] #=> 1
+array.first #=> 1
+array[12] #=> nil
+
+
+# ...o dalla fine...
+array[-1] #=> 5
+array.last #=> 5
+
+# With a start index and length
+# ...o con un indice di inzio e la lunghezza...
+array[2, 3] #=> [3, 4, 5]
+
+# ...oppure con un intervallo.
+array[1..3] #=> [2, 3, 4]
+
+# Invertire l'ordine degli elementi di un array
+a = [1,2,3]
+a.reverse! #=> [3,2,1]
+
+# Come per l'aritmetica,  l'accesso tramite [var]
+# è solo zucchero sintattico
+# per chiamare il metodo '[]'' di un oggetto
+array.[] 0 #=> 1
+array.[] 12 #=> nil
+
+# Si può aggiungere un elemento all'array così
+array << 6 #=> [1, 2, 3, 4, 5, 6]
+# oppure così
+array.push(6) #=> [1, 2, 3, 4, 5, 6]
+
+# Controllare se un elemento esiste in un array
+array.include?(1) #=> true
+
+# Hash è un dizionario con coppie di chiave e valore
+# Un hash è denotato da parentesi graffe:
+hash = { 'colore' => 'verde', 'numero' => 5 }
+
+hash.keys #=> ['colore', 'numero']
+
+# E' possibile accedere all'hash tramite chiave:
+hash['colore'] #=> 'verde'
+hash['numero'] #=> 5
+
+# Accedere all'hash con una chiave che non esiste ritorna nil:
+hash['nothing here'] #=> nil
+
+# Quando si usano simboli come chiavi di un hash, si possono utilizzare
+# queste sintassi:
+
+hash = { :defcon => 3, :action => true }
+hash.keys #=> [:defcon, :action]
+# oppure
+hash = { defcon: 3, action: true }
+hash.keys #=> [:defcon, :action]
+
+# Controllare l'esistenza di una chiave o di un valore in un hash
+new_hash.key?(:defcon) #=> true
+new_hash.value?(3) #=> true
+
+# Suggerimento: sia gli array che gli hash sono enumerabili!
+# Entrambi possiedono metodi utili come each, map, count e altri.
+
+# Strutture di controllo
+
+#Condizionali
+if true
+  'if statement'
+elsif false
+  'else if, opzionale'
+else
+  'else, opzionale'
+end
+
+#Cicli
+# In Ruby, i tradizionali cicli `for` non sono molto comuni. Questi semplici
+# cicli, invece, sono implementati con un enumerable, usando `each`:
+(1..5).each do |contatore|
+  puts "iterazione #{contatore}"
+end
+
+# Esso è equivalente a questo ciclo, il quale è inusuale da vedere in Ruby:
+for contatore in 1..5
+  puts "iterazione #{contatore}"
+end
+
+# Il costrutto `do |variable| ... end` è chiamato 'blocco'. I blocchi
+# sono simili alle lambda, funzioni anonime o closure che si trovano in altri
+# linguaggi di programmazione. Essi possono essere passati come oggetti,
+# chiamati o allegati come metodi.
+# 
+# Il metodo 'each' di un intervallo (range) esegue il blocco una volta
+# per ogni elemento dell'intervallo.
+# Al blocco è passato un contatore come parametro.
+
+# E' possibile inglobare il blocco fra le parentesi graffe
+(1..5).each { |contatore| puts "iterazione #{contatore}" }
+
+# Il contenuto delle strutture dati può essere iterato usando "each".
+array.each do |elemento|
+  puts "#{elemento} è parte dell'array"
+end
+hash.each do |chiave, valore|
+  puts "#{chiave} è #{valore}"
+end
+
+# If you still need an index you can use 'each_with_index' and define an index
+# variable
+# Se comunque si vuole un indice, si può usare "each_with_index" e definire
+# una variabile che contiene l'indice
+array.each_with_index do |elemento, indice|
+  puts "#{elemento} è il numero #{index} nell'array"
+end
+
+contatore = 1
+while contatore <= 5 do
+  puts "iterazione #{contatore}"
+  contatore += 1
+end
+#=> iterazione 1
+#=> iterazione 2
+#=> iterazione 3
+#=> iterazione 4
+#=> iterazione 5
+
+# Esistono in Ruby ulteriori funzioni per fare i cicli,
+# come per esempio 'map', 'reduce', 'inject' e altri.
+# Nel caso di 'map', esso prende l'array sul quale si sta iterando, esegue
+# le istruzioni definite nel blocco, e ritorna un array completamente nuovo.
+array = [1,2,3,4,5]
+doubled = array.map do |elemento|
+  elemento * 2
+end
+puts doubled
+#=> [2,4,6,8,10]
+puts array
+#=> [1,2,3,4,5]
+
+# Costrutto "case"
+grade = 'B'
+
+case grade
+when 'A'
+  puts 'Way to go kiddo'
+when 'B'
+  puts 'Better luck next time'
+when 'C'
+  puts 'You can do better'
+when 'D'
+  puts 'Scraping through'
+when 'F'
+  puts 'You failed!'
+else
+  puts 'Alternative grading system, eh?'
+end
+#=> "Better luck next time"
+
+# 'case' può usare anche gli intervalli
+grade = 82
+case grade
+when 90..100
+  puts 'Hooray!'
+when 80...90
+  puts 'OK job'
+else
+  puts 'You failed!'
+end
+#=> "OK job"
+
+# Gestione delle eccezioni
+begin
+  # codice che può sollevare un eccezione
+  raise NoMemoryError, 'Esaurita la memoria.'
+rescue NoMemoryError => exception_variable
+  puts 'NoMemoryError è stato sollevato.', exception_variable
+rescue RuntimeError => other_exception_variable
+  puts 'RuntimeError è stato sollvato.'
+else
+  puts 'Questo viene eseguito se nessuna eccezione è stata sollevata.'
+ensure
+  puts 'Questo codice viene sempre eseguito a prescindere.'
+end
+
+# Metodi
+
+def double(x)
+  x * 2
+end
+
+# Metodi (e blocchi) ritornano implicitamente il valore dell'ultima istruzione
+double(2) #=> 4
+
+# Le parentesi sono opzionali dove l'interpolazione è inequivocabile
+double 3 #=> 6
+
+double double 3 #=> 12
+
+def sum(x, y)
+  x + y
+end
+
+# Gli argomenit dei metodi sono separati dalla virgola
+sum 3, 4 #=> 7
+
+sum sum(3, 4), 5 #=> 12
+
+# yield
+# Tutti i metodi hanno un implicito e opzionale parametro del blocco.
+# Esso può essere chiamato con la parola chiave 'yield'.
+
+def surround
+  puts '{'
+  yield
+  puts '}'
+end
+
+surround { puts 'hello world' }
+
+# {
+# hello world
+# }
+
+# I blocchi possono essere convertiti in 'proc', il quale racchiude il blocco
+# e gli permette di essere passato ad un altro metodo, legato ad uno scope
+# differente o modificato. Questo è molto comune nella lista parametri del
+# metodo, dove è frequente vedere il parametro '&block' in coda. Esso accetta
+# il blocco, se ne è stato passato uno, e lo converte in un 'Proc'.
+# Qui la denominazione è una convenzione; funzionerebbe anche con '&ananas'.
+def guests(&block)
+  block.class #=> Proc
+  block.call(4)
+end
+
+# Il metodo 'call' del Proc è simile allo 'yield' quando è presente un blocco.
+# Gli argomenti passati a 'call' sono inoltrati al blocco come argomenti:
+
+guests { |n| "You have #{n} guests." }
+# => "You have 4 guests."
+
+# L'operatore splat ("*") converte una lista di argomenti in un array
+def guests(*array)
+  array.each { |guest| puts guest }
+end
+
+# Destrutturazione
+
+# Ruby destruttura automaticamente gli array in assegnamento
+# a variabili multiple:
+a, b, c = [1, 2, 3]
+a #=> 1
+b #=> 2
+c #=> 3
+
+# In alcuni casi si usa l'operatore splat ("*") per destrutturare
+# un array in una lista.
+classifica_concorrenti = ["John", "Sally", "Dingus", "Moe", "Marcy"]
+
+def migliore(primo, secondo, terzo)
+  puts "I vincitori sono #{primo}, #{secondo}, e #{terzo}."
+end
+
+migliore *classifica_concorrenti.first(3)
+#=> I vincitori sono John, Sally, e Dingus.
+
+# The splat operator can also be used in parameters:
+def migliore(primo, secondo, terzo, *altri)
+  puts "I vincitori sono #{primo}, #{secondo}, e #{terzo}."
+  puts "C'erano altri #{altri.count} partecipanti."
+end
+
+migliore *classifica_concorrenti 
+#=> I vincitori sono John, Sally, e Dingus.
+#=> C'erano altri 2 partecipanti.
+
+# Per convenzione, tutti i metodi che ritornano un booleano terminano
+# con un punto interrogativo
+5.even? #=> false
+5.odd? #=> true
+
+# Per convenzione, se il nome di un metodo termina con un punto esclamativo,
+# esso esegue qualcosa di distruttivo. Molti metodi hanno una versione con '!'
+# per effettuare una modifiche, e una versione senza '!' che ritorna
+# una versione modificata.
+nome_azienda = "Dunder Mifflin"
+nome_azienda.upcase #=> "DUNDER MIFFLIN"
+nome_azienda #=> "Dunder Mifflin"
+# Questa volta modifichiamo nome_azienda
+nome_azienda.upcase! #=> "DUNDER MIFFLIN"
+nome_azienda #=> "DUNDER MIFFLIN"
+
+# Classi
+
+# Definire una classe con la parola chiave class
+class Umano
+
+  # Una variabile di classe. E' condivisa da tutte le istance di questa classe.
+  @@specie = 'H. sapiens'
+
+  # Inizializzatore di base
+  def initialize(nome, eta = 0)
+    # Assegna il valore dell'argomento alla variabile dell'istanza "nome"
+    @nome = nome
+    # Se l'età non è fornita, verrà assegnato il valore di default indicato
+    # nella lista degli argomenti
+    @eta = eta
+  end
+
+  # Metodo setter di base
+  def nome=(nome)
+    @nome = nome
+  end
+
+  # Metodo getter di base
+  def nome
+    @nome
+  end
+
+  # Le funzionalità di cui sopra posso essere incapsulate usando
+  # il metodo attr_accessor come segue
+  attr_accessor :nome
+
+  # Getter/setter possono anche essere creati individualmente
+  attr_reader :nome
+  attr_writer :nome
+
+  # Un metodo della classe usa 'self' per distinguersi dai metodi dell'istanza.
+  # Può essere richimato solo dalla classe, non dall'istanza.
+  def self.say(msg)
+    puts msg
+  end
+
+  def specie
+    @@specie
+  end
+end
+
+
+# Instanziare una classe
+jim = Umano.new('Jim Halpert')
+
+dwight = Umano.new('Dwight K. Schrute')
+
+# Chiamiamo qualche metodo
+jim.specie #=> "H. sapiens"
+jim.nome #=> "Jim Halpert"
+jim.nome = "Jim Halpert II" #=> "Jim Halpert II"
+jim.nome #=> "Jim Halpert II"
+dwight.specie #=> "H. sapiens"
+dwight.nome #=> "Dwight K. Schrute"
+
+# Chiamare un metodo della classe
+Umano.say('Ciao') #=> "Ciao"
+
+# La visibilità della variabile (variable's scope) è determinata dal modo
+# in cui le viene assegnato il nome.
+# Variabili che iniziano con $ hanno uno scope globale
+$var = "Sono una variabile globale"
+defined? $var #=> "global-variable"
+
+# Variabili che inziano con @ hanno a livello dell'istanza
+@var = "Sono una variabile dell'istanza"
+defined? @var #=> "instance-variable"
+
+# Variabili che iniziano con @@ hanno una visibilità a livello della classe
+@@var = "Sono una variabile della classe"
+defined? @@var #=> "class variable"
+
+# Variabili che iniziano con una lettera maiuscola sono costanti
+Var = "Sono una costante"
+defined? Var #=> "constant"
+
+# Anche una classe è un oggetto in ruby. Quindi la classe può avere
+# una variabile dell'istanza. Le variabili della classe sono condivise
+# fra la classe e tutti i suoi discendenti.
+
+# Classe base
+class Umano
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+# Classe derivata
+class Lavoratore < Umano
+end
+
+Umano.foo #=> 0
+Lavoratore.foo #=> 0
+
+Umano.foo = 2 #=> 2
+Lavoratore.foo #=> 2
+
+# La variabile dell'istanza della classe non è condivisa dai discendenti.
+
+class Umano
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(value)
+    @bar = value
+  end
+end
+
+class Dottore < Umano
+end
+
+Umano.bar #=> 0
+Dottore.bar #=> nil
+
+module EsempioModulo
+  def foo
+    'foo'
+  end
+end
+
+# Includere moduli vincola i suoi metodi all'istanza della classe.
+# Estendere moduli vincola i suoi metodi alla classe stessa.
+class Persona
+  include EsempioModulo
+end
+
+class Libro
+  extend EsempioModulo
+end
+
+Persona.foo     #=> NoMethodError: undefined method `foo' for Person:Class
+Persona.new.foo #=> 'foo'
+Libro.foo       #=> 'foo'
+Libro.new.foo   #=> NoMethodError: undefined method `foo'
+
+# Callbacks sono eseguiti quand si include o estende un modulo
+module ConcernExample
+  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 Something
+  include ConcernExample
+end
+
+Something.bar     #=> 'bar'
+Something.qux     #=> NoMethodError: undefined method `qux'
+Something.new.bar #=> NoMethodError: undefined method `bar'
+Something.new.qux #=> 'qux'
+```
+
+## Ulteriori risorse
+
+- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - Una variante di questa guida con esercizi nel browser.
+- [An Interactive Tutorial for Ruby](https://rubymonk.com/) - Imparare Ruby attraverso una serie di tutorial interattivi.
+- [Official Documentation](http://ruby-doc.org/core)
+- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
+- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Una passata [edizione libera](http://ruby-doc.com/docs/ProgrammingRuby/) è disponibile online.
+- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
+- [Try Ruby](http://tryruby.org) - Imparare le basi del linguaggio di programmazion Ruby, interattivamente nel browser.
diff --git a/it-it/rust-it.html.markdown b/it-it/rust-it.html.markdown
index 6b379f93..e4b7c33f 100644
--- a/it-it/rust-it.html.markdown
+++ b/it-it/rust-it.html.markdown
@@ -130,14 +130,14 @@ fn main() {
     /////////////
 
     // Strutture
-    struct Point {
+    struct Punto {
         x: i32,
         y: i32,
     }
 
     let origine: Punto = Punto { x: 0, y: 0 };
 
-    // Ana struct con campi senza nome, chiamata ‘tuple struct’
+    // Una struct con campi senza nome, chiamata ‘tuple struct’
     struct Punto2(i32, i32);
 
     let origine2 = Punto2(0, 0);
diff --git a/it-it/toml-it.html.markdown b/it-it/toml-it.html.markdown
new file mode 100644
index 00000000..99082048
--- /dev/null
+++ b/it-it/toml-it.html.markdown
@@ -0,0 +1,276 @@
+---

+language: toml

+filename: learntoml-it.toml

+contributors:

+  - ["Alois de Gouvello", "https://github.com/aloisdg"]

+translators:

+  - ["Christian Grasso", "https://grasso.io"]

+lang: it-it

+---

+

+TOML è l'acronimo di _Tom's Obvious, Minimal Language_. È un linguaggio per la

+serializzazione di dati, progettato per i file di configurazione.

+

+È un'alternativa a linguaggi come YAML e JSON, che punta ad essere più leggibile

+per le persone. Allo stesso tempo, TOML può essere utilizzato in modo abbastanza

+semplice nella maggior parte dei linguaggi di programmazione, in quanto è

+progettato per essere tradotto senza ambiguità in una hash table.

+

+Tieni presente che TOML è ancora in fase di sviluppo, e la sua specifica non è

+ancora stabile. Questo documento utilizza TOML 0.4.0.

+

+```toml

+# I commenti in TOML sono fatti così.

+

+################

+# TIPI SCALARI #

+################

+

+# Il nostro oggetto root (corrispondente all'intero documento) sarà una mappa,

+# anche chiamata dizionario, hash o oggetto in altri linguaggi.

+

+# La key, il simbolo di uguale e il valore devono trovarsi sulla stessa riga,

+# eccetto per alcuni tipi di valori.

+key = "value"

+stringa = "ciao"

+numero = 42

+float = 3.14

+boolean = true

+data = 1979-05-27T07:32:00-08:00

+notazScientifica = 1e+12

+"puoi utilizzare le virgolette per la key" = true # Puoi usare " oppure '

+"la key può contenere" = "lettere, numeri, underscore e trattini"

+

+############

+# Stringhe #

+############

+

+# Le stringhe possono contenere solo caratteri UTF-8 validi.

+# Possiamo effettuare l'escape dei caratteri, e alcuni hanno delle sequenze

+# di escape compatte. Ad esempio, \t corrisponde al TAB.

+stringaSemplice = "Racchiusa tra virgolette. \"Usa il backslash per l'escape\"."

+

+stringaMultiriga = """

+Racchiusa da tre virgolette doppie all'inizio e

+alla fine - consente di andare a capo."""

+

+stringaLiteral = 'Virgolette singole. Non consente di effettuare escape.'

+

+stringaMultirigaLiteral = '''

+Racchiusa da tre virgolette singole all'inizio e

+alla fine - consente di andare a capo.

+Anche in questo caso non si può fare escape.

+Il primo ritorno a capo viene eliminato.

+   Tutti gli altri spazi aggiuntivi

+   vengono mantenuti.

+'''

+

+# Per i dati binari è consigliabile utilizzare Base64 e

+# gestirli manualmente dall'applicazione.

+

+##########

+# Interi #

+##########

+

+## Gli interi possono avere o meno un segno (+, -).

+## Non si possono inserire zero superflui all'inizio.

+## Non è possibile inoltre utilizzare valori numerici

+## non rappresentabili con una sequenza di cifre.

+int1 = +42

+int2 = 0

+int3 = -21

+

+## Puoi utilizzare gli underscore per migliorare la leggibilità.

+## Fai attenzione a non inserirne due di seguito.

+int4 = 5_349_221

+int5 = 1_2_3_4_5     # VALIDO, ma da evitare

+

+#########

+# Float #

+#########

+

+# I float permettono di rappresentare numeri decimali.

+flt1 = 3.1415

+flt2 = -5e6

+flt3 = 6.626E-34

+

+###########

+# Boolean #

+###########

+

+# I valori boolean (true/false) devono essere scritti in minuscolo.

+bool1 = true

+bool2 = false

+

+############

+# Data/ora #

+############

+

+data1 = 1979-05-27T07:32:00Z # Specifica RFC 3339/ISO 8601 (UTC)

+data2 = 1979-05-26T15:32:00+08:00 # RFC 3339/ISO 8601 con offset

+

+######################

+# TIPI DI COLLECTION #

+######################

+

+#########

+# Array #

+#########

+

+array1 = [ 1, 2, 3 ]

+array2 = [ "Le", "virgole", "sono", "delimitatori" ]

+array3 = [ "Non", "unire", "tipi", "diversi" ]

+array4 = [ "tutte", 'le stringhe', """hanno lo stesso""", '''tipo''' ]

+array5 = [

+  "Gli spazi vuoti", "sono", "ignorati"

+]

+

+###########

+# Tabelle #

+###########

+

+# Le tabelle (o hash table o dizionari) sono collection di coppie key/value.

+# Iniziano con un nome tra parentesi quadre su una linea separata. 

+# Le tabelle vuote (senza alcun valore) sono valide.

+[tabella]

+

+# Tutti i valori che si trovano sotto il nome della tabella

+# appartengono alla tabella stessa (finchè non ne viene creata un'altra).

+# L'ordine di questi valori non è garantito.

+[tabella-1]

+key1 = "una stringa"

+key2 = 123

+

+[tabella-2]

+key1 = "un'altra stringa"

+key2 = 456

+

+# Utilizzando i punti è possibile creare delle sottotabelle.

+# Ogni parte suddivisa dai punti segue le regole delle key per il nome.

+[tabella-3."sotto.tabella"]

+key1 = "prova"

+

+# Ecco l'equivalente JSON della tabella precedente:

+# { "tabella-3": { "sotto.tabella": { "key1": "prova" } } }

+

+# Gli spazi non vengono considerati, ma è consigliabile

+# evitare di usare spazi superflui.

+[a.b.c]            # consigliato

+[ d.e.f ]          # identico a [d.e.f]

+

+# Non c'è bisogno di creare le tabelle superiori per creare una sottotabella.

+# [x] queste

+# [x.y] non

+# [x.y.z] servono

+[x.y.z.w] # per creare questa tabella

+

+# Se non è stata già creata prima, puoi anche creare

+# una tabella superiore più avanti.

+[a.b]

+c = 1

+

+[a]

+d = 2

+

+# Non puoi definire una key o una tabella più di una volta.

+

+# ERRORE

+[a]

+b = 1

+

+[a]

+c = 2

+

+# ERRORE

+[a]

+b = 1

+

+[a.b]

+c = 2

+

+# I nomi delle tabelle non possono essere vuoti.

+[]     # NON VALIDO

+[a.]   # NON VALIDO

+[a..b] # NON VALIDO

+[.b]   # NON VALIDO

+[.]    # NON VALIDO

+

+##################

+# Tabelle inline #

+##################

+

+tabelleInline = { racchiuseData = "{ e }", rigaSingola = true }

+punto = { x = 1, y = 2 }

+

+####################

+# Array di tabelle #

+####################

+

+# Un array di tabelle può essere creato utilizzando due parentesi quadre.

+# Tutte le tabelle con questo nome saranno elementi dell'array.

+# Gli elementi vengono inseriti nell'ordine in cui si trovano.

+

+[[prodotti]]

+nome = "array di tabelle"

+sku = 738594937

+tabelleVuoteValide = true

+

+[[prodotti]]

+

+[[prodotti]]

+nome = "un altro item"

+sku = 284758393

+colore = "grigio"

+

+# Puoi anche creare array di tabelle nested. Le sottotabelle con doppie

+# parentesi quadre apparterranno alla tabella più vicina sopra di esse.

+

+[[frutta]]

+  nome = "mela"

+

+  [frutto.geometria]

+    forma = "sferica"

+    nota = "Sono una proprietà del frutto"

+

+  [[frutto.colore]]

+    nome = "rosso"

+    nota = "Sono un oggetto di un array dentro mela"

+

+  [[frutto.colore]]

+    nome = "verde"

+    nota = "Sono nello stesso array di rosso"

+

+[[frutta]]

+  nome = "banana"

+

+  [[frutto.colore]]

+    nome = "giallo"

+    nota = "Anche io sono un oggetto di un array, ma dentro banana"

+```

+

+Ecco l'equivalente JSON dell'ultima tabella:

+

+```json

+{

+  "frutta": [

+    {

+      "nome": "mela",

+      "geometria": { "forma": "sferica", "nota": "..."},

+      "colore": [

+        { "nome": "rosso", "nota": "..." },

+        { "nome": "verde", "nota": "..." }

+      ]

+    },

+    {

+      "nome": "banana",

+      "colore": [

+        { "nome": "giallo", "nota": "..." }

+      ]

+    }

+  ]

+}

+```

+

+### Altre risorse

+

++ [Repository ufficiale di TOML](https://github.com/toml-lang/toml)

diff --git a/it-it/typescript-it.html.markdown b/it-it/typescript-it.html.markdown
new file mode 100644
index 00000000..b78705c5
--- /dev/null
+++ b/it-it/typescript-it.html.markdown
@@ -0,0 +1,227 @@
+---
+language: TypeScript
+contributors:
+    - ["Philippe Vlérick", "https://github.com/pvlerick"]
+translators:
+    - ["Christian Grasso", "https://grasso.io"]
+filename: learntypescript-it.ts
+lang: it-it
+---
+
+TypeScript è un linguaggio basato su JavaScript che punta a rendere il codice
+più scalabile introducendo concetti quali le classi, i moduli, le interface,
+e i generics.
+Poichè TypeScript è un superset di JavaScript, è possibile sfruttare le sue
+funzionalità anche in progetti esistenti: il codice JavaScript valido è anche
+valido in TypeScript. Il compilatore di TypeScript genera codice JavaScript.
+
+Questo articolo si concentrerà solo sulle funzionalità aggiuntive di TypeScript.
+
+Per testare il compilatore, puoi utilizzare il
+[Playground](http://www.typescriptlang.org/Playground), dove potrai scrivere
+codice TypeScript e visualizzare l'output in JavaScript.
+
+```ts
+// TypeScript ha tre tipi di base
+let completato: boolean = false;
+let righe: number = 42;
+let nome: string = "Andrea";
+
+// Il tipo può essere omesso se è presente un assegnamento a scalari/literal
+let completato = false;
+let righe = 42;
+let nome = "Andrea";
+
+// Il tipo "any" indica che la variabile può essere di qualsiasi tipo
+let qualsiasi: any = 4;
+qualsiasi = "oppure una stringa";
+qualsiasi = false; // o magari un boolean
+
+// Usa la keyword "const" per le costanti
+const numeroViteGatti = 9;
+numeroViteGatti = 1; // Errore
+
+// Per gli array, puoi usare l'apposito tipo o la versione con i generics
+let lista: number[] = [1, 2, 3];
+let lista: Array<number> = [1, 2, 3];
+
+// Per le enumerazioni:
+enum Colore { Rosso, Verde, Blu };
+let c: Colore = Colore.Verde;
+
+// Infine, "void" viene utilizzato per le funzioni che non restituiscono valori
+function avviso(): void {
+  alert("Sono un piccolo avviso fastidioso!");
+}
+
+// Le funzioni supportano la sintassi "a freccia" (lambda) e supportano la type
+// inference, cioè per scalari/literal non c'è bisogno di specificare il tipo
+
+// Tutte le seguenti funzioni sono equivalenti, e il compilatore genererà
+// lo stesso codice JavaScript per ognuna di esse
+let f1 = function (i: number): number { return i * i; }
+// Type inference
+let f2 = function (i: number) { return i * i; }
+// Sintassi lambda
+let f3 = (i: number): number => { return i * i; }
+// Sintassi lambda + type inference
+let f4 = (i: number) => { return i * i; }
+// Sintassi lambda + type inference + sintassi abbreviata (senza return)
+let f5 = (i: number) => i * i;
+
+// Le interfacce sono strutturali, e qualunque oggetto con le stesse proprietà
+// di un'interfaccia è compatibile con essa
+interface Persona {
+  nome: string;
+  // Proprietà opzionale, indicata con "?"
+  anni?: number;
+  // Funzioni
+  saluta(): void;
+}
+
+// Oggetto che implementa l'interfaccia Persona
+// È una Persona valida poichè implementa tutta le proprietà non opzionali
+let p: Persona = { nome: "Bobby", saluta: () => { } };
+// Naturalmente può avere anche le proprietà opzionali:
+let pValida: Persona = { nome: "Bobby", anni: 42, saluta: () => { } };
+// Questa invece NON è una Persona, poichè il tipo di "anni" è sbagliato
+let pNonValida: Persona = { nome: "Bobby", anni: true };
+
+// Le interfacce possono anche descrivere una funzione
+interface SearchFunc {
+  (source: string, subString: string): boolean;
+}
+// I nomi dei parametri non sono rilevanti: vengono controllati solo i tipi
+let ricerca: SearchFunc;
+ricerca = function (src: string, sub: string) {
+  return src.search(sub) != -1;
+}
+
+// Classi - i membri sono pubblici di default
+class Punto {
+  // Proprietà
+  x: number;
+
+  // Costruttore - in questo caso la keyword "public" può generare in automatico
+  // il codice per l'inizializzazione di una variabile.
+  // In questo esempio, verrà creata la variabile y in modo identico alla x, ma
+  // con meno codice. Sono supportati anche i valori di default.
+  constructor(x: number, public y: number = 0) {
+    this.x = x;
+  }
+
+  // Funzioni
+  dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+  // Membri statici
+  static origine = new Point(0, 0);
+}
+
+// Le classi possono anche implementare esplicitamente delle interfacce.
+// Il compilatore restituirà un errore nel caso in cui manchino delle proprietà. 
+class PersonaDiRiferimento implements Persona {
+    nome: string
+    saluta() {}
+}
+
+let p1 = new Punto(10, 20);
+let p2 = new Punto(25); // y = 0
+
+// Inheritance
+class Punto3D extends Punto {
+  constructor(x: number, y: number, public z: number = 0) {
+    super(x, y); // La chiamata esplicita a super è obbligatoria
+  }
+
+  // Sovrascrittura
+  dist() {
+    let d = super.dist();
+    return Math.sqrt(d * d + this.z * this.z);
+  }
+}
+
+// Moduli - "." può essere usato come separatore per i sottomoduli
+module Geometria {
+  export class Quadrato {
+    constructor(public lato: number = 0) { }
+
+    area() {
+      return Math.pow(this.lato, 2);
+    }
+  }
+}
+
+let s1 = new Geometria.Quadrato(5);
+
+// Alias locale per un modulo
+import G = Geometria;
+
+let s2 = new G.Quadrato(10);
+
+// Generics
+// Classi
+class Tuple<T1, T2> {
+  constructor(public item1: T1, public item2: T2) {
+  }
+}
+
+// Interfacce
+interface Pair<T> {
+  item1: T;
+  item2: T;
+}
+
+// E funzioni
+let pairToTuple = function <T>(p: Pair<T>) {
+  return new Tuple(p.item1, p.item2);
+};
+
+let tuple = pairToTuple({ item1: "hello", item2: "world" });
+
+// Interpolazione con le template string (definite con i backtick)
+let nome = 'Tyrone';
+let saluto = `Ciao ${name}, come stai?`
+// Possono anche estendersi su più righe
+let multiriga = `Questo è un esempio
+di stringa multiriga.`;
+
+// La keyword "readonly" rende un membro di sola lettura
+interface Persona {
+  readonly nome: string;
+  readonly anni: number;
+}
+
+var p1: Persona = { nome: "Tyrone", anni: 42 };
+p1.anni = 25; // Errore, p1.anni è readonly
+
+var p2 = { nome: "John", anni: 60 };
+var p3: Person = p2; // Ok, abbiamo creato una versione readonly di p2
+p3.anni = 35; // Errore, p3.anni è readonly
+p2.anni = 45; // Compila, ma cambia anche p3.anni per via dell'aliasing!
+
+class Macchina {
+  readonly marca: string;
+  readonly modello: string;
+  readonly anno = 2018;
+
+  constructor() {
+    // Possiamo anche assegnare nel constructor
+    this.marca = "Marca sconosciuta";
+    this.modello = "Modello sconosciuto";
+  }
+}
+
+let numeri: Array<number> = [0, 1, 2, 3, 4];
+let altriNumeri: ReadonlyArray<number> = numbers;
+altriNumeri[5] = 5; // Errore, gli elementi sono readonly
+altriNumeri.push(5); // Errore, il metodo push non esiste (modifica l'array)
+altriNumeri.length = 3; // Errore, length è readonly
+numeri = altriNumeri; // Errore, i metodi di modifica non esistono
+```
+
+## Altre risorse
+ * [Sito ufficiale di TypeScript](http://www.typescriptlang.org/)
+ * [Specifica di TypeScript](https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md)
+ * [Anders Hejlsberg - Introducing TypeScript su Channel 9](http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [TypeScript su GitHub](https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed - definizioni per le librerie](http://definitelytyped.org/)
diff --git a/ja-jp/asciidoc.html.markdown b/ja-jp/asciidoc.html.markdown
new file mode 100644
index 00000000..7347589a
--- /dev/null
+++ b/ja-jp/asciidoc.html.markdown
@@ -0,0 +1,135 @@
+---
+language: asciidoc
+contributors:
+    - ["Ryan Mavilia", "http://unoriginality.rocks/"]
+    - ["Abel Salgado Romero", "https://twitter.com/abelsromero"]
+translators:
+    - ["Ryota Kayanuma", "https://github.com/PicoSushi"]
+filename: asciidoc-ja.md
+lang: ja-jp
+---
+
+AsciiDocはMarkdownに似たマークアップ言語で、書籍の執筆からブログを書くことまでなんでも使うことができます。2002年、Stuart RackhamによりAsciiDocは作成され、シンプルでありつつも沢山のカスタマイズを可能にしています。
+
+文書のヘッダー
+
+ヘッダーはオプションで、空行を含むことはできません。本文から1行以上の改行を開ける必要があります。
+
+タイトルのみの例
+
+```
+= 文章タイトル
+
+文書の最初の行
+```
+
+タイトルと著者
+
+```
+= 文書タイトル
+文書 太郎 <first.last@learnxinyminutes.com>
+
+文書の開始
+```
+
+複数の著者
+
+```
+= 文書タイトル
+John Doe <john@go.com>; Jane Doe<jane@yo.com>; Black Beard <beardy@pirate.com>
+
+複数の著者による文書の始まり。
+```
+
+版(著者の行を必要とします)
+
+```
+= 第一版のタイトル
+芋男 <chip@crunchy.com>
+v1.0, 2016-01-13
+
+このポテトについての文書は面白いです。
+```
+
+段落
+
+```
+段落は特別なことは不要です。
+
+空行を段落の間に入れることで、段落を分けることができます。
+
+折り返しをしたい場合、+
+を書くことで折り返せます!
+```
+
+文書の整形
+
+```
+_アンダースコアで斜体になります。_
+*アスタリスクで太字になります。*
+*_組み合わせると楽しい_*
+`バッククォートで固定幅になります。`
+`*太字の固定幅*`
+```
+
+節タイトル
+
+```
+= Level 0 (文書のヘッダーにのみ使用してください)
+
+== Level 1 <h2>
+
+=== Level 2 <h3>
+
+==== Level 3 <h4>
+
+===== Level 4 <h5>
+
+```
+
+リスト
+
+箇条書きリストを作るには、アスタリスクを使用してください。
+
+```
+* foo
+* bar
+* baz
+```
+
+番号付きリストを作るには、ピリオドを使用してください。
+
+```
+. item 1
+. item 2
+. item 3
+```
+
+リストはアスタリスクやピリオドを追加することで5段階まで入れ子にできます。
+
+```
+* foo 1
+** foo 2
+*** foo 3
+**** foo 4
+***** foo 5
+
+. foo 1
+.. foo 2
+... foo 3
+.... foo 4
+..... foo 5
+```
+
+## 補足資料
+
+AsciiDocの文書を処理するツールは2種類あります。
+
+1. [AsciiDoc](http://asciidoc.org/): オリジナルのPython実装で、Linuxで利用可能です。現在は開発されておらず、メンテナンスのみの状態です。
+2. [Asciidoctor](http://asciidoctor.org/): Rubyによる別実装で、JavaやJavascriptでも利用可能です。AsciiDocに新しい機能や出力形式を追加するため、現在活発に開発されています。
+
+以下のリンクは `AsciiDoctor` 実装関連のものです。
+
+* [Markdown - AsciiDoc syntax comparison](http://asciidoctor.org/docs/user-manual/#comparison-by-example): Common MarkdownとAsciidocの要素を並べて比較しています。
+* [Getting started](http://asciidoctor.org/docs/#get-started-with-asciidoctor): インストールから簡潔な文書を作るための簡単なガイドです。
+* [Asciidoctor User Manual](http://asciidoctor.org/docs/user-manual/): 文法のリファレンス、例、描画ツール、その他を含む完全なドキュメントです。
diff --git a/ja-jp/python3-jp.html.markdown b/ja-jp/python3-jp.html.markdown
index 3b1a0d73..b9731411 100644
--- a/ja-jp/python3-jp.html.markdown
+++ b/ja-jp/python3-jp.html.markdown
@@ -6,13 +6,16 @@ contributors:
     - ["Andre Polykanine", "https://github.com/Oire"]
     - ["Zachary Ferguson", "http://github.com/zfergus2"]
     - ["evuez", "http://github.com/evuez"]
+    - ["Rommel Martinez", "https://ebzzry.io"]
+    - ["Roberto Fernandez Diaz", "https://github.com/robertofd1995"]
 translators:
     - ["kakakaya", "https://github.com/kakakaya"]
+    - ["Ryota Kayanuma", "https://github.com/PicoSushi"]
 filename: learnpython3-jp.py
 lang: ja-jp
 ---
 
-90年代の初め、Guido Van RossumによってPythonは作成されました。現在となっては、最も有名な言語の1つです。
+90年代の初め、Guido van RossumによってPythonは作成されました。現在となっては、最も有名な言語の1つです。
 私は構文の明快さによって、Pythonと恋に落ちました。
 以下は基本的に実行可能な疑似コードです。
 
@@ -21,12 +24,11 @@ lang: ja-jp
 Note: この記事はPython 3に内容を絞っています。もし古いPython 2.7を学習したいなら、 [こちら](http://learnxinyminutes.com/docs/python/) をご確認下さい。
 
 ```python
-
 # 1行のコメントは番号記号(#)から始まります。
 
 """ 複数行の文字は、"を3つ繋げることで
     書くことができます。
-    また、これはコメントとしてもよく使われます。
+    また、これはドキュメントとしてもよく使われます。
 """
 
 ####################################################
@@ -44,8 +46,8 @@ Note: この記事はPython 3に内容を絞っています。もし古いPython
 
 # 整数除算の結果は、正負に関わらず小数の切り捨てが行われます。
 5 // 3                          # => 1
-5.0 // 3.0                      # => 1.0 # 浮動小数点でも同様に動作します。
 -5 // 3                         # => -2
+5.0 // 3.0                      # => 1.0 # 浮動小数点でも同様に動作します。
 -5.0 // 3.0                     # => -2.0
 
 # 除算の結果は常に浮動小数点になります。
@@ -55,7 +57,7 @@ Note: この記事はPython 3に内容を絞っています。もし古いPython
 7 % 3                           # => 1
 
 # 冪乗 (x**y, x の y 乗)
-2**4                            # => 16
+2**3                            # => 8
 
 # 括弧により、計算の順番を優先させられます。
 (1 + 3) * 2                     # => 8
@@ -69,16 +71,28 @@ not True                        # => False
 not False                       # => True
 
 # ブール演算
-# 注意: "and" と "or" は小文字です
+# 注意: "and" と "or" は小文字です。
 True and False                  # => False
 False or True                   # => True
 
-# 整数でブール演算をするときのメモ
-0 and 2                         # => 0
--5 or 0                         # => -5
+# TrueとFalseは実際には1と0になるキーワードです。
+True + True                     # => 2
+True * 8                        # => 8
+False - 5                       # => -5
+
+# 比較演算子はTrueとFalseを数値として扱います。
 0 == False                      # => True
-2 == True                       # => False
 1 == True                       # => True
+2 == True                       # => False
+-5 != True                      # => True
+
+# bool論理演算子を整数に対して使うことで整数を真偽値に変換して評価できますが、キャストされていない値が
+# bool(int)とビット演算子(& や |)を混同しないようにうにしましょう。
+bool(0)                         # => False
+bool(4)                         # => True
+bool(-6)                        # => True
+0 and 2                         # => 0
+-5 or 0                         # => -5
 
 # 値が等しいか確認するには ==
 1 == 1                          # => True
@@ -94,7 +108,11 @@ False or True                   # => True
 2 <= 2                          # => True
 2 >= 2                          # => True
 
-# 比較は連結させられます!
+# 値がある範囲の中にあるか調べる方法
+1 < 2 and 2 < 3                # => True
+2 < 3 and 3 < 2                # => False
+
+# 連結させるともっと見やすくなります。
 1 < 2 < 3                       # => True
 2 < 3 < 2                       # => False
 
@@ -115,7 +133,7 @@ b == a               # => True, a と b が参照するオブジェクトの値�
 
 # 文字列も加算をすることができます!でも、あまり行わないように。
 "Hello " + "world!"             # => "Hello world!"
-# '+' を使わなくても連結はできます。
+# '+' を使わなくても文字列リテラル(変数ではないもの)の連結ができます。
 "Hello " "world!"               # => "Hello world!"
 
 # 文字列は文字のリストであるかのように扱うことができます。
@@ -138,6 +156,12 @@ len("This is a string")         # => 16
 # 旧式のフォーマット方法を使うこともできます。
 "%s can be %s the %s way" % ("Strings", "interpolated", "old")  # => "Strings can be interpolated the old way"
 
+# Python3.6以上では、f-stringsやフォーマット文字列を使ってフォーマットすることもできます。
+name = "Reiko"
+f"She said her name is {name}."  # => "She said her name is Reiko"
+
+# 基本的に、任意のPythonの文を中括弧に書くことができ、それは評価されて出力されます。
+f"{name} is {len(name)} characters long."
 
 # None はオブジェクトです(大文字からです!)
 None                            # => None
@@ -170,7 +194,7 @@ print("Hello, World", end="!")  # => Hello, World!
 input_string_var = input("Enter some data: ")  # 入力を文字列として返します
 # Note: Python の初期のバージョンでは、 input() は raw_input() という名前で存在します。
 
-# 変数に代入する前に宣言する必要はありません。
+# Pythonでは変数の宣言は存在せず、代入のみです。
 # 慣例的に、小文字でアンダースコア区切り ( lower_case_with_underscores ) の変数が使われます。
 some_var = 5
 some_var                        # => 5
@@ -207,10 +231,11 @@ li[-1]                          # => 3
 li[4]                           # IndexError が発生します
 
 # スライス構文により範囲を参照できます。
+# 開始部分のインデックスに対応する部分は含まれますが、終了部分のインデックスに対応する部分は含まれません。
 li[1:3]                         # => [2, 4]
-# 先端を取り除く
+# 先端を取り除いたリスト
 li[2:]                          # => [4, 3]
-# 末尾を取り除く
+# 末尾を取り除いたリスト
 li[:3]                          # => [1, 2, 4]
 # 1つ飛ばしで選択する
 li[::2]                         # =>[1, 4]
@@ -272,7 +297,7 @@ a, b, c = (1, 2, 3)             # a, b, c にはそれぞれ 1, 2, 3 が代入�
 # 拡張記法もあります。
 a, *b, c = (1, 2, 3, 4)         # a は 1 、 b は [2, 3] 、c は4 になります。
 # 括弧を作成しなくてもデフォルトでタプルが作成されます。
-d, e, f = 4, 5, 6
+d, e, f = 4, 5, 6               # 4、5、6がそれぞれd、 e、 fに代入されます。
 # 2つの変数を交換するのがどれほど簡単か見てみましょう。
 e, d = d, e                     # d は 5 、 e は e になります。
 
@@ -293,14 +318,17 @@ filled_dict["one"]              # => 1
 
 # "keys()"により、全てのキーを反復可能な形式で取り出せます。
 # これをリストにするために、"list()"で囲んでいます。これについては後程解説します。
-# Note: 辞書のキーの順番は考慮されていません。実行した結果がこれと異なる場合があります。
-list(filled_dict.keys())        # => ["three", "two", "one"]
+# Note: Python3.7未満では、辞書のキーの順番は考慮されていません。実行した結果がこれと異なる場合があります。
+#       しかし、Python3.7以降ではキーの挿入順を保つようになりました。
+list(filled_dict.keys())        # => ["three", "two", "one"] in Python <3.7
+list(filled_dict.keys())        # => ["one", "two", "three"] in Python 3.7+
+
 
 # "values()"により、全ての値を反復可能な形式で取り出せます。
 # 前と同じように、これをリストにするために、"list()"で囲んでいます。
 # Note: 辞書の値の順番は考慮されていません。実行した結果がこれと異なる場合があります。
-list(filled_dict.values())      # => [3, 2, 1]
-
+list(filled_dict.values())      # => [3, 2, 1]  in Python <3.7
+list(filled_dict.values())      # => [1, 2, 3] in Python 3.7+
 
 # "in" により、辞書のキーが存在するか確認できます。
 "one" in filled_dict            # => True
@@ -322,7 +350,7 @@ filled_dict.setdefault("five", 6)  # filled_dict["five"] は 5 のままです�
 
 # 辞書にマップを追加する
 filled_dict.update({"four": 4})  # => {"one": 1, "two": 2, "three": 3, "four": 4}
-# filled_dict["four"] = 4        # 辞書に追加する別の方法
+filled_dict["four"] = 4        # 辞書に追加する別の方法
 
 # del により辞書からキーを削除できます。
 del filled_dict["one"]          # "one" キーを辞書から削除します。
@@ -341,11 +369,11 @@ some_set = {1, 1, 2, 2, 3, 4}   # some_set is now {1, 2, 3, 4}
 invalid_set = {[1], 1}         # => list はハッシュ化できないので、 TypeError が送出されます。
 valid_set = {(1,), 1}
 
-# 新しい値を集合にセットできます。
-filled_set = some_set
-
 # 集合に新しい要素を追加できます。
+filled_set = some_set
 filled_set.add(5)               # filled_set は {1, 2, 3, 4, 5} になりました。
+# 集合は重複した要素を持ちません。
+filled_set.add(5)               # 以前の{1, 2, 3, 4, 5}のままです。
 
 # & により、集合同士の共通部分が得られます。
 other_set = {3, 4, 5, 6}
@@ -378,7 +406,8 @@ filled_set | other_set          # => {1, 2, 3, 4, 5, 6}
 # まずは変数を作りましょう。
 some_var = 5
 
-# これはif文です。インデントがPythonでは特徴的ですね!
+# これはif文です。Pythonではインデントが特徴的ですね!
+# 規約ではタブではなく4つのスペースでインデントすることが推奨されています。
 # 以下の例では"some_var is smaller than 10"と出力されます。
 if some_var > 10:
     print("some_var is totally bigger than 10.")
@@ -541,9 +570,9 @@ all_the_args(1, 2, a=3, b=4) prints:
 # * を使ってタプルを展開したり、 ** を使って辞書を展開できます。
 args = (1, 2, 3, 4)
 kwargs = {"a": 3, "b": 4}
-all_the_args(*args)             # foo(1, 2, 3, 4) に対応します。
-all_the_args(**kwargs)          # foo(a=3, b=4) に対応します。
-all_the_args(*args, **kwargs)   # foo(1, 2, 3, 4, a=3, b=4) に対応します。
+all_the_args(*args)             # all_the_args(1, 2, 3, 4) と等しいです。
+all_the_args(**kwargs)          # all_the_args(a=3, b=4) と等しいです。
+all_the_args(*args, **kwargs)   # all_the_args(1, 2, 3, 4, a=3, b=4) と等しいです。
 
 
 # タプルで複数の値を返す
@@ -646,7 +675,7 @@ dir(math)
 # 6. クラス
 ####################################################
 
-# クラスを作成するために、"class"という演算子を使います。
+# クラスを作成するために、class文を使います。
 class Human:
 
     # クラスの属性です。このクラスの全てのインスタンスで共有されます。
@@ -656,14 +685,14 @@ class Human:
     # 2つのアンダースコアがオブジェクトや属性の前後についているとき、これらはPythonによって利用され、
     # ユーザーの名前空間には存在しないということに注意してください。
     # __init__ や __str__ 、 __repr__ のようなメソッド(やオブジェクト、属性)は、
-    # magic methods (または dunder methods)と呼ばれます。
-    # このような名前を自分で発明しないほうがよいでしょう。
+    # special methods (または dunder methods)と呼ばれます。
+    # 同じような名前を自分で発明しないほうがよいでしょう。
     def __init__(self, name):
         # 引数をインスタンスのname属性に設定します。
         self.name = name
 
         # プロパティの初期化
-        self.age = 0
+        self._age = 0
 
     # インスタンスメソッド。全てのメソッドは"self"を最初の引数に取ります。
     def say(self, msg):
@@ -686,6 +715,7 @@ class Human:
 
     # プロパティはgetterのようなものです。
     # age() メソッドを同名の読取専用属性に変換します。
+    # Pythonではわざわざgetterやsetterを書く必要はありません。
     @property
     def age(self):
         return self._age
@@ -720,24 +750,117 @@ if __name__ == '__main__':
     j.say(j.get_species())      # => "Joel: H. neanderthalensis"
 
     # スタティックメソッドを呼んでみましょう。
-    print(Human.grunt())            # => "*grunt*"
-    print(i.grunt())                # => "*grunt*"
+    print(Human.grunt())        # => "*grunt*"
+
+    # スタティックメソッドはインスタンスから呼ぶことはできません。
+    # なぜならば、 i.grunt() は自動的に"self" ( i オブジェクト ) を引数として渡してしまうからです。
+    print(i.grunt())  # => TypeError: grunt() takes 0 positional arguments but 1 was given
 
     # インスタンスのプロパティを更新してみましょう。
     i.age = 42
     # プロパティを取得してみましょう。
-    i.say(i.age)                    # => 42
-    j.say(j.age)                    # => 0
+    i.say(i.age)                # => "Ian: 42"
+    j.say(j.age)                # => "Joel: 0"
     # プロパティを削除してみましょう。
     del i.age
     # i.age                         # => AttributeError が発生します。
 
 
 ####################################################
-# 6.1 多重継承
+# 6.1 継承
+####################################################
+# 継承を行うことで、親クラスからメソッドと変数を継承する新しい子クラスを定義できます。
+
+# 上記で定義されたHumanクラスを親クラス(基底クラス)として使い、Superheroという子クラスを定義します。
+# これは"species"、"name"や"age"といった変数や、"sing"や"grunt"のようなメソッドをHumanから継承しますが、
+# Superhero独自のプロパティを持つこともできます。
+
+# ファイルを分割してモジュール化の利点を活用するために、上記のHumanクラスを独自のファイル、ここでは human.py に記述ましょう。
+
+# 別のファイルから関数をインポートするには次の形式を利用してください:
+# from "拡張子なしのファイル名" import "関数やクラス"
+
+from human import Human
+
+
+# 親クラスを子クラスのパラメータとして指定します
+class Superhero(Human):
+
+    # もし子クラスが親クラスの全ての定義を変更なしで継承する場合、"pass"キーワードのみを書くだけで良いです。
+    # しかし、今回は親クラスとは異なる子クラスを作成するので、今回は以下の通りコメントアウトしています。
+    # pass
+
+    # 子クラスは親クラスの属性を上書きできます。
+    species = 'Superhuman'
+
+    # 子クラスは親クラスのコンストラクタを引数含めて自動的に継承しますが、
+    # 追加の引数や定義を行ってコンストラクタのようなメソッドを上書きすることもできます。
+    # このコンストラクタは"name"引数を"Human"クラスから継承し、"superpower"と"movie"という引数を追加します。
+    def __init__(self, name, movie=False,
+                 superpowers=["super strength", "bulletproofing"]):
+
+        # 追加のクラス属性を作成する
+        self.fictional = True
+        self.movie = movie
+        # デフォルト値は共有されるので、可変のデフォルト値には注意してください。
+        self.superpowers = superpowers
+
+        # "super"関数を使うと子クラスに上書きされた親クラスのメソッド(今回は "__init__")にアクセスできます。
+        # これで、親クラスのコンストラクタを呼んでいます。
+        super().__init__(name)
+
+    # singメソッドを上書きし、
+    def sing(self):
+        return 'Dun, dun, DUN!'
+
+    # 追加のインスタンスメソッドを作成します。
+    def boast(self):
+        for power in self.superpowers:
+            print("I wield the power of {pow}!".format(pow=power))
+
+
+if __name__ == '__main__':
+    sup = Superhero(name="Tick")
+
+    # インスタンスの型を調べる
+    if isinstance(sup, Human):
+        print('I am human')
+    if type(sup) is Superhero:
+        print('I am a superhero')
+
+    # getattr()とsuper()で使われるメソッドの解決順序を調べてみます。
+    # この属性は動的であり、変更可能です。
+    print(Superhero.__mro__)    # => (<class '__main__.Superhero'>,
+                                # => <class 'human.Human'>, <class 'object'>)
+
+    # 親のメソッドを呼びだすものの、独自のクラス属性を参照します。
+    print(sup.get_species())    # => Superhuman
+
+    # 上書きされたメソッドを呼ぶ
+    print(sup.sing())           # => Dun, dun, DUN!
+
+    # Humanのメソッドを呼ぶ
+    sup.say('Spoon')            # => Tick: Spoon
+
+    # Superhero限定のメソッドを呼ぶ
+    sup.boast()                 # => I wield the power of super strength!
+                                # => I wield the power of bulletproofing!
+
+    # 継承されたクラス属性
+    sup.age = 31
+    print(sup.age)              # => 31
+
+    # Superhero限定の属性
+    print('Am I Oscar eligible? ' + str(sup.movie))
+
+
+
+####################################################
+# 6.2 多重継承
 ####################################################
 
 # 別のクラスを定義します。
+# bat.py
 class Bat:
 
     species = 'Baty'
@@ -759,31 +882,22 @@ if __name__ == '__main__':
     print(b.say('hello'))
     print(b.fly)
 
-# ファイル単位のモジュール化を利用するために、上記のクラスを別々のファイルに配置することができます。
-# ここでは、human.pyとbat.pyを作成してみましょう。
-
-# 他のファイルから関数をインポートするために、次のような形式を利用してください。
-# from "拡張子無しのファイル名" import "関数またはクラス"
-
 # superhero.py
-from human import Human
+from superhero import Superhero
 from bat import Bat
 
-
-# BatmanはHumanとBatの両方を継承します。
-class Batman(Human, Bat):
-
-    # Batmanは species のクラス属性に独自の値を持ちます。
-    species = 'Superhero'
+# BatmanをSuperheroとBatの両方を継承した子クラスとして定義します。
+class Batman(Superhero, Bat):
 
     def __init__(self, *args, **kwargs):
         # 通常、属性を継承するにはsuper()を呼び出します。
-        #     super(Batman, self).__init__(*args, **kwargs)
+        # super(Batman, self).__init__(*args, **kwargs)
         # しかし、ここでは多重継承を行っているので、 super() はMRO(メソッド解決順序)の次の基本クラスにのみ動作します。
         # なので、全ての祖先に対して明示的に __init__ を呼ぶことにします。
         # *args と **kwargs を使うことで、それぞれの継承元が
         # たまねぎの皮を剥がすごとく、引数を用いることができます。
-        Human.__init__(self, 'anonymous', *args, **kwargs)
+        Superhero.__init__(self, 'anonymous', movie=True,
+                           superpowers=['Wealthy'], *args, **kwargs)
         Bat.__init__(self, *args, can_fly=False, **kwargs)
         # 名前の属性の値を上書きします。
         self.name = 'Sad Affleck'
@@ -795,22 +909,18 @@ class Batman(Human, Bat):
 if __name__ == '__main__':
     sup = Batman()
 
-    # インスタンスの型を調べてみましょう。
-    if isinstance(sup, Human):
-        print('I am human')
-    if isinstance(sup, Bat):
-        print('I am bat')
-    if type(sup) is Batman:
-        print('I am Batman')
-
     # getattr() や super() の両方で使われるMROを取得します。
     # この属性は動的であり、更新が可能です。
-    print(Batman.__mro__)  # => (<class '__main__.Batman'>, <class 'human.Human'>, <class 'bat.Bat'>, <class 'object'>)
+    print(Batman.__mro__)       # => (<class '__main__.Batman'>,
+                                # => <class 'superhero.Superhero'>,
+                                # => <class 'human.Human'>,
+                                # => <class 'bat.Bat'>, <class 'object'>)
+
 
     # 親メソッドを呼び出しますが、独自のクラス属性を参照します。
-    print(sup.get_species())    # => Superhero
+    print(sup.get_species())    # => Superhuman
 
-    # オーバーロードされたメソッドを呼び出します。
+    # 上書きされたメソッドを呼び出します。
     print(sup.sing())           # => nan nan nan nan nan batman!
 
     # 継承順により、Humanから継承されたメソッドを呼び出します。
@@ -821,10 +931,10 @@ if __name__ == '__main__':
 
     # 継承されたクラス属性
     sup.age = 100
-    print(sup.age)
+    print(sup.age)              # => 100
 
     # デフォルト値が上書きされて、2番目の先祖から継承された属性
-    print('Can I fly? ' + str(sup.fly))
+    print('Can I fly? ' + str(sup.fly))  # => Can I fly? False
 
 
 ####################################################
diff --git a/java.html.markdown b/java.html.markdown
index ab2be4a2..ca0b04c2 100644
--- a/java.html.markdown
+++ b/java.html.markdown
@@ -11,6 +11,7 @@ contributors:
     - ["Michael Dähnert", "https://github.com/JaXt0r"]
     - ["Rob Rose", "https://github.com/RobRoseKnows"]
     - ["Sean Nam", "https://github.com/seannam"]
+    - ["Shawn M. Hanes", "https://github.com/smhanes15"]
 filename: LearnJava.java
 ---
 
@@ -858,6 +859,108 @@ public class EnumTest {
 // The enum body can include methods and other fields.
 // You can see more at https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
 
+// Getting Started with Lambda Expressions
+//
+// New to Java version 8 are lambda expressions. Lambdas are more commonly found
+// in functional programming languages, which means they are methods which can
+// be created without belonging to a class, passed around as if it were itself
+// an object, and executed on demand.
+//
+// Final note, lambdas must implement a functional interface. A functional
+// interface is one which has only a single abstract method declared. It can
+// have any number of default methods. Lambda expressions can be used as an
+// instance of that functional interface. Any interface meeting the requirements
+// is treated as a functional interface. You can read more about interfaces
+// above.
+//
+import java.util.Map;
+import java.util.HashMap;
+import java.util.function.*;
+import java.security.SecureRandom;
+
+public class Lambdas {
+    public static void main(String[] args) {
+        // Lambda declaration syntax:
+	// <zero or more parameters> -> <expression body or statement block>
+
+        // We will use this hashmap in our examples below.
+        Map<String, String> planets = new HashMap<>();
+            planets.put("Mercury", "87.969");
+            planets.put("Venus", "224.7");
+            planets.put("Earth", "365.2564");
+            planets.put("Mars", "687");
+            planets.put("Jupiter", "4,332.59");
+            planets.put("Saturn", "10,759");
+            planets.put("Uranus", "30,688.5");
+            planets.put("Neptune", "60,182");
+
+        // Lambda with zero parameters using the Supplier functional interface
+        // from java.util.function.Supplier. The actual lambda expression is
+        // what comes after numPlanets =.
+        Supplier<String> numPlanets = () -> Integer.toString(planets.size());
+        System.out.format("Number of Planets: %s\n\n", numPlanets.get());
+
+        // Lambda with one parameter and using the Consumer functional interface
+        // from java.util.function.Consumer. This is because planets is a Map,
+        // which implements both Collection and Iterable. The forEach used here,
+        // found in Iterable, applies the lambda expression to each member of
+        // the Collection. The default implementation of forEach behaves as if:
+        /*
+            for (T t : this)
+                action.accept(t);
+        */
+
+        // The actual lambda expression is the parameter passed to forEach.
+        planets.keySet().forEach((p) -> System.out.format("%s\n", p));
+
+        // If you are only passing a single argument, then the above can also be
+        // written as (note absent parentheses around p):
+        planets.keySet().forEach(p -> System.out.format("%s\n", p));
+
+        // Tracing the above, we see that planets is a HashMap, keySet() returns
+        // a Set of its keys, forEach applies each element as the lambda 
+        // expression of: (parameter p) -> System.out.format("%s\n", p). Each
+        // time, the element is said to be "consumed" and the statement(s)
+        // referred to in the lambda body is applied. Remember the lambda body
+        // is what comes after the ->.
+
+        // The above without use of lambdas would look more traditionally like:
+        for (String planet : planets.keySet()) {
+            System.out.format("%s\n", planet);
+        }
+
+        // This example differs from the above in that a different forEach
+        // implementation is used: the forEach found in the HashMap class
+        // implementing the Map interface. This forEach accepts a BiConsumer,
+        // which generically speaking is a fancy way of saying it handles
+        // the Set of each Key -> Value pairs. This default implementation
+        // behaves as if:
+        /*
+            for (Map.Entry<K, V> entry : map.entrySet())
+                action.accept(entry.getKey(), entry.getValue());
+        */
+
+        // The actual lambda expression is the parameter passed to forEach.
+        String orbits = "%s orbits the Sun in %s Earth days.\n";
+        planets.forEach((K, V) -> System.out.format(orbits, K, V));
+
+        // The above without use of lambdas would look more traditionally like:
+        for (String planet : planets.keySet()) {
+            System.out.format(orbits, planet, planets.get(planet));
+        }
+
+        // Or, if following more closely the specification provided by the
+        // default implementation:
+        for (Map.Entry<String, String> planet : planets.entrySet()) {
+            System.out.format(orbits, planet.getKey(), planet.getValue());
+        }
+
+        // These examples cover only the very basic use of lambdas. It might not
+        // seem like much or even very useful, but remember that a lambda can be
+        // created as an object that can later be passed as parameters to other
+        // methods.
+    }
+}
 ```
 
 ## Further Reading
diff --git a/javascript.html.markdown b/javascript.html.markdown
index e7066291..c466c09b 100644
--- a/javascript.html.markdown
+++ b/javascript.html.markdown
@@ -266,6 +266,15 @@ for (var x in person){
     description += person[x] + " ";
 } // description = 'Paul Ken 18 '
 
+// The for/of statement allows iteration over iterable objects (including the built-in String, 
+// Array, e.g. the Array-like arguments or NodeList objects, TypedArray, Map and Set, 
+// and user-defined iterables).
+var myPets = "";
+var pets = ["cat", "dog", "hamster", "hedgehog"];
+for (var pet of pets){
+    myPets += pet + " ";
+} // myPets = 'cat dog hamster hedgehog '
+
 // && is logical and, || is logical or
 if (house.size == "big" && house.colour == "blue"){
     house.contains = "bear";
@@ -501,6 +510,7 @@ for (var x in myObj){
 // Hello world!
 // 43
 // [Function: myFunc]
+// true
 
 // To only consider properties attached to the object itself
 // and not its prototypes, use the `hasOwnProperty()` check.
@@ -600,10 +610,6 @@ of the language.
 [Eloquent Javascript][8] by Marijn Haverbeke is an excellent JS book/ebook with
 attached terminal
 
-[Eloquent Javascript - The Annotated Version][9] by Gordon Zhu is also a great
-derivative of Eloquent Javascript with extra explanations and clarifications for
-some of the more complicated examples.
-
 [Javascript: The Right Way][10] is a guide intended to introduce new developers
 to JavaScript and help experienced developers learn more about its best practices.
 
@@ -624,6 +630,5 @@ Mozilla Developer Network.
 [6]: http://www.amazon.com/gp/product/0596805527/
 [7]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
 [8]: http://eloquentjavascript.net/
-[9]: http://watchandcode.com/courses/eloquent-javascript-the-annotated-version
 [10]: http://jstherightway.org/
 [11]: https://javascript.info/
diff --git a/jquery.html.markdown b/jquery.html.markdown
index 9326c74b..a1673c10 100644
--- a/jquery.html.markdown
+++ b/jquery.html.markdown
@@ -104,7 +104,7 @@ tables.animate({margin-top:"+=50", height: "100px"}, 500, myFunction);
 // 3. Manipulation
 
 // These are similar to effects but can do more
-$('div').addClass('taming-slim-20'); // Adds class taming-slim-20 to all div 
+$('div').addClass('taming-slim-20'); // Adds class taming-slim-20 to all div
 
 // Common manipulation methods
 $('p').append('Hello world'); // Adds to end of element
@@ -126,3 +126,7 @@ $('p').each(function() {
 
 
 ```
+
+## Further Reading
+
+* [Codecademy - jQuery](https://www.codecademy.com/learn/learn-jquery) A good introduction to jQuery in a "learn by doing it" format.
diff --git a/json.html.markdown b/json.html.markdown
index cd42d42d..3ec7a3af 100644
--- a/json.html.markdown
+++ b/json.html.markdown
@@ -6,6 +6,7 @@ contributors:
   - ["Marco Scannadinari", "https://github.com/marcoms"]
   - ["himanshu", "https://github.com/himanshu81494"]
   - ["Michael Neth", "https://github.com/infernocloud"]
+  - ["Athanasios Emmanouilidis", "https://github.com/athanasiosem"]
 ---
 
 JSON is an extremely simple data-interchange format. As [json.org](http://json.org) says, it is easy for humans to read and write and for machines to parse and generate.
@@ -14,7 +15,6 @@ A piece of JSON must represent either:
 
 * A collection of name/value pairs (`{ }`). In various languages, this is realized as an object, record, struct, dictionary, hash table, keyed list, or associative array.
 * An ordered list of values (`[ ]`). In various languages, this is realized as an array, vector, list, or sequence.
- an array/list/sequence (`[ ]`) or a dictionary/object/associated array (`{ }`).
 
 JSON in its purest form has no actual comments, but most parsers will accept C-style (`//`, `/* */`) comments. Some parsers also tolerate a trailing comma (i.e. a comma after the last element of an array or the after the last property of an object), but they should be avoided for better compatibility.
 
@@ -81,3 +81,5 @@ Supported data types:
 ## Further Reading
 
 * [JSON.org](http://json.org) All of JSON beautifully explained using flowchart-like graphics.
+
+* [JSON Tutorial](https://www.youtube.com/watch?v=wI1CWzNtE-M) A concise introduction to JSON.
diff --git a/julia.html.markdown b/julia.html.markdown
index 9e28452f..5e9ef1b8 100644
--- a/julia.html.markdown
+++ b/julia.html.markdown
@@ -2,17 +2,18 @@
 language: Julia
 contributors:
     - ["Leah Hanson", "http://leahhanson.us"]
-    - ["Pranit Bauva", "http://github.com/pranitbauva1997"]
+    - ["Pranit Bauva", "https://github.com/pranitbauva1997"]
+    - ["Daniel YC Lin", "https://github.com/dlintw"]
 filename: learnjulia.jl
 ---
 
 Julia is a new homoiconic functional language focused on technical computing.
-While having the full power of homoiconic macros, first-class functions, and low-level control, Julia is as easy to learn and use as Python.
+While having the full power of homoiconic macros, first-class functions,
+and low-level control, Julia is as easy to learn and use as Python.
 
-This is based on Julia 0.4.
-
-```ruby
+This is based on Julia 1.0.0
 
+```julia
 # Single line comments start with a hash (pound) symbol.
 #= Multiline comments can be written
    by putting '#=' before the text  and '=#'
@@ -26,38 +27,45 @@ This is based on Julia 0.4.
 # Everything in Julia is an expression.
 
 # There are several basic types of numbers.
-3 # => 3 (Int64)
-3.2 # => 3.2 (Float64)
-2 + 1im # => 2 + 1im (Complex{Int64})
-2//3 # => 2//3 (Rational{Int64})
+typeof(3)       # => Int64
+typeof(3.2)     # => Float64
+typeof(2 + 1im) # => Complex{Int64}
+typeof(2 // 3)  # => Rational{Int64}
 
 # All of the normal infix operators are available.
-1 + 1 # => 2
-8 - 1 # => 7
-10 * 2 # => 20
-35 / 5 # => 7.0
-5 / 2 # => 2.5 # dividing an Int by an Int always results in a Float
-div(5, 2) # => 2 # for a truncated result, use div
-5 \ 35 # => 7.0
-2 ^ 2 # => 4 # power, not bitwise xor
-12 % 10 # => 2
+1 + 1      # => 2
+8 - 1      # => 7
+10 * 2     # => 20
+35 / 5     # => 7.0
+10 / 2     # => 5.0  # dividing integers always results in a Float64
+div(5, 2)  # => 2    # for a truncated result, use div
+5 \ 35     # => 7.0
+2^2        # => 4    # power, not bitwise xor
+12 % 10    # => 2
 
 # Enforce precedence with parentheses
-(1 + 3) * 2 # => 8
+(1 + 3) * 2  # => 8
+
+# Julia (unlike Python for instance) has integer under/overflow
+10^19      # => -8446744073709551616
+# use bigint or floating point to avoid this
+big(10)^19 # => 10000000000000000000
+1e19       # => 1.0e19
+10.0^19    # => 1.0e19
 
 # Bitwise Operators
-~2 # => -3   # bitwise not
-3 & 5 # => 1 # bitwise and
-2 | 4 # => 6 # bitwise or
-2 $ 4 # => 6 # bitwise xor
-2 >>> 1 # => 1 # logical shift right
-2 >> 1  # => 1 # arithmetic shift right
-2 << 1  # => 4 # logical/arithmetic shift left
-
-# You can use the bits function to see the binary representation of a number.
-bits(12345)
+~2         # => -3 # bitwise not
+3 & 5      # => 1  # bitwise and
+2 | 4      # => 6  # bitwise or
+xor(2, 4)  # => 6  # bitwise xor
+2 >>> 1    # => 1  # logical shift right
+2 >> 1     # => 1  # arithmetic shift right
+2 << 1     # => 4  # logical/arithmetic shift left
+
+# Use the bitstring function to see the binary representation of a number.
+bitstring(12345)
 # => "0000000000000000000000000000000000000000000000000011000000111001"
-bits(12345.0)
+bitstring(12345.0)
 # => "0100000011001000000111001000000000000000000000000000000000000000"
 
 # Boolean values are primitives
@@ -65,70 +73,71 @@ true
 false
 
 # Boolean operators
-!true # => false
-!false # => true
-1 == 1 # => true
-2 == 1 # => false
-1 != 1 # => false
-2 != 1 # => true
-1 < 10 # => true
-1 > 10 # => false
-2 <= 2 # => true
-2 >= 2 # => true
+!true   # => false
+!false  # => true
+1 == 1  # => true
+2 == 1  # => false
+1 != 1  # => false
+2 != 1  # => true
+1 < 10  # => true
+1 > 10  # => false
+2 <= 2  # => true
+2 >= 2  # => true
 # Comparisons can be chained
-1 < 2 < 3 # => true
-2 < 3 < 2 # => false
+1 < 2 < 3  # => true
+2 < 3 < 2  # => false
 
 # Strings are created with "
 "This is a string."
 
-# Julia has several types of strings, including ASCIIString and UTF8String.
-# More on this in the Types section.
-
 # Character literals are written with '
 'a'
 
-# Some strings can be indexed like an array of characters
-"This is a string"[1] # => 'T' # Julia indexes from 1
-# However, this is will not work well for UTF8 strings,
-# so iterating over strings is recommended (map, for loops, etc).
+# Strings are UTF8 encoded. Only if they contain only ASCII characters can
+# they be safely indexed.
+ascii("This is a string")[1]  
+# => 'T': ASCII/Unicode U+0054 (category Lu: Letter, uppercase)
+# Julia indexes from 1
+# Otherwise, iterating over strings is recommended (map, for loops, etc).
+
+# String can be compared lexicographically
+"good" > "bye" # => true
+"good" == "good" # => true
+"1 + 2 = 3" == "1 + 2 = $(1 + 2)" # => true
 
 # $ can be used for string interpolation:
 "2 + 2 = $(2 + 2)" # => "2 + 2 = 4"
 # You can put any Julia expression inside the parentheses.
 
-# Another way to format strings is the printf macro.
-@printf "%d is less than %f" 4.5 5.3 # 4.5 is less than 5.300000
-
 # Printing is easy
-println("I'm Julia. Nice to meet you!")
+println("I'm Julia. Nice to meet you!") # => I'm Julia. Nice to meet you!
+
+# Another way to format strings is the printf macro from the stdlib Printf.
+using Printf
+@printf "%d is less than %f\n" 4.5 5.3  # => 5 is less than 5.300000
 
-# String can be compared lexicographically
-"good" > "bye" # => true
-"good" == "good" # => true
-"1 + 2 = 3" == "1 + 2 = $(1+2)" # => true
 
 ####################################################
 ## 2. Variables and Collections
 ####################################################
 
 # You don't declare variables before assigning to them.
-some_var = 5 # => 5
-some_var # => 5
+someVar = 5  # => 5
+someVar  # => 5
 
 # Accessing a previously unassigned variable is an error
 try
-    some_other_var # => ERROR: some_other_var not defined
+    someOtherVar  # => ERROR: UndefVarError: someOtherVar not defined
 catch e
     println(e)
 end
 
 # Variable names start with a letter or underscore.
 # After that, you can use letters, digits, underscores, and exclamation points.
-SomeOtherVar123! = 6 # => 6
+SomeOtherVar123! = 6  # => 6
 
 # You can also use certain unicode characters
-☃ = 8 # => 8
+☃ = 8  # => 8
 # These are especially handy for mathematical notation
 2 * π # => 6.283185307179586
 
@@ -147,250 +156,282 @@ SomeOtherVar123! = 6 # => 6
 #   functions are sometimes called mutating functions or in-place functions.
 
 # Arrays store a sequence of values indexed by integers 1 through n:
-a = Int64[] # => 0-element Int64 Array
+a = Int64[] # => 0-element Array{Int64,1}
 
 # 1-dimensional array literals can be written with comma-separated values.
-b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6]
-b = [4; 5; 6] # => 3-element Int64 Array: [4, 5, 6]
-b[1] # => 4
-b[end] # => 6
+b = [4, 5, 6] # => 3-element Array{Int64,1}: [4, 5, 6]
+b = [4; 5; 6] # => 3-element Array{Int64,1}: [4, 5, 6]
+b[1]    # => 4
+b[end]  # => 6
 
 # 2-dimensional arrays use space-separated values and semicolon-separated rows.
-matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4]
+matrix = [1 2; 3 4] # => 2×2 Array{Int64,2}: [1 2; 3 4]
 
-# Arrays of a particular Type
-b = Int8[4, 5, 6] # => 3-element Int8 Array: [4, 5, 6]
+# Arrays of a particular type
+b = Int8[4, 5, 6] # => 3-element Array{Int8,1}: [4, 5, 6]
 
 # Add stuff to the end of a list with push! and append!
-push!(a,1)     # => [1]
-push!(a,2)     # => [1,2]
-push!(a,4)     # => [1,2,4]
-push!(a,3)     # => [1,2,4,3]
-append!(a,b) # => [1,2,4,3,4,5,6]
+# By convention, the exclamation mark '!'' is appended to names of functions
+# that modify their arguments
+push!(a, 1)    # => [1]
+push!(a, 2)    # => [1,2]
+push!(a, 4)    # => [1,2,4]
+push!(a, 3)    # => [1,2,4,3]
+append!(a, b)  # => [1,2,4,3,4,5,6]
 
 # Remove from the end with pop
-pop!(b)        # => 6 and b is now [4,5]
+pop!(b)  # => 6
+b # => [4,5]
 
 # Let's put it back
-push!(b,6)   # b is now [4,5,6] again.
+push!(b, 6)  # => [4,5,6]
+b # => [4,5,6]
 
-a[1] # => 1 # remember that Julia indexes from 1, not 0!
+a[1]  # => 1  # remember that Julia indexes from 1, not 0!
 
 # end is a shorthand for the last index. It can be used in any
 # indexing expression
-a[end] # => 6
+a[end]  # => 6
 
-# we also have shift and unshift
-shift!(a) # => 1 and a is now [2,4,3,4,5,6]
-unshift!(a,7) # => [7,2,4,3,4,5,6]
+# we also have popfirst! and pushfirst!
+popfirst!(a)  # => 1 
+a # => [2,4,3,4,5,6]
+pushfirst!(a, 7)  # => [7,2,4,3,4,5,6]
+a # => [7,2,4,3,4,5,6]
 
 # Function names that end in exclamations points indicate that they modify
 # their argument.
-arr = [5,4,6] # => 3-element Int64 Array: [5,4,6]
-sort(arr) # => [4,5,6]; arr is still [5,4,6]
-sort!(arr) # => [4,5,6]; arr is now [4,5,6]
+arr = [5,4,6]  # => 3-element Array{Int64,1}: [5,4,6]
+sort(arr)   # => [4,5,6]
+arr         # => [5,4,6]
+sort!(arr)  # => [4,5,6]
+arr         # => [4,5,6]
 
 # Looking out of bounds is a BoundsError
 try
-    a[0] # => ERROR: BoundsError() in getindex at array.jl:270
-    a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270
+    a[0] 
+    # => ERROR: BoundsError: attempt to access 7-element Array{Int64,1} at 
+    # index [0]
+    # => Stacktrace:
+    # =>  [1] getindex(::Array{Int64,1}, ::Int64) at .\array.jl:731
+    # =>  [2] top-level scope at none:0
+    # =>  [3] ...
+    # => in expression starting at ...\LearnJulia.jl:180
+    a[end + 1] 
+    # => ERROR: BoundsError: attempt to access 7-element Array{Int64,1} at 
+    # index [8]
+    # => Stacktrace:
+    # =>  [1] getindex(::Array{Int64,1}, ::Int64) at .\array.jl:731
+    # =>  [2] top-level scope at none:0
+    # =>  [3] ...
+    # => in expression starting at ...\LearnJulia.jl:188
 catch e
     println(e)
 end
 
 # Errors list the line and file they came from, even if it's in the standard
-# library. If you built Julia from source, you can look in the folder base
-# inside the julia folder to find these files.
+# library. You can look in the folder share/julia inside the julia folder to
+# find these files.
 
 # You can initialize arrays from ranges
-a = [1:5;] # => 5-element Int64 Array: [1,2,3,4,5]
+a = [1:5;]  # => 5-element Array{Int64,1}: [1,2,3,4,5]
+a2 = [1:5]  # => 1-element Array{UnitRange{Int64},1}: [1:5]
 
 # You can look at ranges with slice syntax.
-a[1:3] # => [1, 2, 3]
-a[2:end] # => [2, 3, 4, 5]
+a[1:3]  # => [1, 2, 3]
+a[2:end]  # => [2, 3, 4, 5]
 
 # Remove elements from an array by index with splice!
 arr = [3,4,5]
-splice!(arr,2) # => 4 ; arr is now [3,5]
+splice!(arr, 2) # => 4 
+arr # => [3,5]
 
 # Concatenate lists with append!
 b = [1,2,3]
-append!(a,b) # Now a is [1, 2, 3, 4, 5, 1, 2, 3]
+append!(a, b) # => [1, 2, 3, 4, 5, 1, 2, 3]
+a # => [1, 2, 3, 4, 5, 1, 2, 3]
 
 # Check for existence in a list with in
-in(1, a) # => true
+in(1, a)  # => true
 
 # Examine the length with length
-length(a) # => 8
+length(a)  # => 8
 
 # Tuples are immutable.
-tup = (1, 2, 3) # => (1,2,3) # an (Int64,Int64,Int64) tuple.
+tup = (1, 2, 3)  # => (1,2,3)
+typeof(tup) # => Tuple{Int64,Int64,Int64}
 tup[1] # => 1
-try:
-    tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64)
+try
+    tup[1] = 3  
+    # => ERROR: MethodError: no method matching 
+    # setindex!(::Tuple{Int64,Int64,Int64}, ::Int64, ::Int64)
 catch e
     println(e)
 end
 
-# Many list functions also work on tuples
+# Many array functions also work on tuples
 length(tup) # => 3
-tup[1:2] # => (1,2)
-in(2, tup) # => true
+tup[1:2]    # => (1,2)
+in(2, tup)  # => true
 
 # You can unpack tuples into variables
-a, b, c = (1, 2, 3) # => (1,2,3)  # a is now 1, b is now 2 and c is now 3
+a, b, c = (1, 2, 3)  # => (1,2,3)  
+a # => 1
+b # => 2
+c # => 3
 
 # Tuples are created even if you leave out the parentheses
-d, e, f = 4, 5, 6 # => (4,5,6)
+d, e, f = 4, 5, 6  # => (4,5,6)
+d # => 4
+e # => 5
+f # => 6
 
 # A 1-element tuple is distinct from the value it contains
 (1,) == 1 # => false
-(1) == 1 # => true
+(1) == 1  # => true
 
 # Look how easy it is to swap two values
-e, d = d, e  # => (5,4) # d is now 5 and e is now 4
-
+e, d = d, e  # => (5,4) 
+d # => 5
+e # => 4
 
 # Dictionaries store mappings
-empty_dict = Dict() # => Dict{Any,Any}()
+emptyDict = Dict()  # => Dict{Any,Any} with 0 entries
 
 # You can create a dictionary using a literal
-filled_dict = Dict("one"=> 1, "two"=> 2, "three"=> 3)
-# => Dict{ASCIIString,Int64}
+filledDict = Dict("one" => 1, "two" => 2, "three" => 3)
+# => Dict{String,Int64} with 3 entries:
+# =>  "two" => 2, "one" => 1, "three" => 3
 
 # Look up values with []
-filled_dict["one"] # => 1
+filledDict["one"]  # => 1
 
 # Get all keys
-keys(filled_dict)
-# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+keys(filledDict)
+# => Base.KeySet for a Dict{String,Int64} with 3 entries. Keys:
+# =>  "two", "one", "three"
 # Note - dictionary keys are not sorted or in the order you inserted them.
 
 # Get all values
-values(filled_dict)
-# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+values(filledDict)
+# => Base.ValueIterator for a Dict{String,Int64} with 3 entries. Values: 
+# =>  2, 1, 3
 # Note - Same as above regarding key ordering.
 
 # Check for existence of keys in a dictionary with in, haskey
-in(("one" => 1), filled_dict) # => true
-in(("two" => 3), filled_dict) # => false
-haskey(filled_dict, "one") # => true
-haskey(filled_dict, 1) # => false
+in(("one" => 1), filledDict)  # => true
+in(("two" => 3), filledDict)  # => false
+haskey(filledDict, "one")     # => true
+haskey(filledDict, 1)         # => false
 
 # Trying to look up a non-existent key will raise an error
 try
-    filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489
+    filledDict["four"]  # => ERROR: KeyError: key "four" not found
 catch e
     println(e)
 end
 
 # Use the get method to avoid that error by providing a default value
-# get(dictionary,key,default_value)
-get(filled_dict,"one",4) # => 1
-get(filled_dict,"four",4) # => 4
+# get(dictionary, key, defaultValue)
+get(filledDict, "one", 4)   # => 1
+get(filledDict, "four", 4)  # => 4
 
 # Use Sets to represent collections of unordered, unique values
-empty_set = Set() # => Set{Any}()
+emptySet = Set()  # => Set(Any[])
 # Initialize a set with values
-filled_set = Set([1,2,2,3,4]) # => Set{Int64}(1,2,3,4)
+filledSet = Set([1, 2, 2, 3, 4])  # => Set([4, 2, 3, 1])
 
 # Add more values to a set
-push!(filled_set,5) # => Set{Int64}(5,4,2,3,1)
+push!(filledSet, 5)  # => Set([4, 2, 3, 5, 1])
 
 # Check if the values are in the set
-in(2, filled_set) # => true
-in(10, filled_set) # => false
+in(2, filledSet)   # => true
+in(10, filledSet)  # => false
 
 # There are functions for set intersection, union, and difference.
-other_set = Set([3, 4, 5, 6]) # => Set{Int64}(6,4,5,3)
-intersect(filled_set, other_set) # => Set{Int64}(3,4,5)
-union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6)
-setdiff(Set([1,2,3,4]),Set([2,3,5])) # => Set{Int64}(1,4)
-
+otherSet = Set([3, 4, 5, 6])         # => Set([4, 3, 5, 6])
+intersect(filledSet, otherSet)      # => Set([4, 3, 5])
+union(filledSet, otherSet)          # => Set([4, 2, 3, 5, 6, 1])
+setdiff(Set([1,2,3,4]), Set([2,3,5])) # => Set([4, 1])
 
 ####################################################
 ## 3. Control Flow
 ####################################################
 
 # Let's make a variable
-some_var = 5
+someVar = 5
 
 # Here is an if statement. Indentation is not meaningful in Julia.
-if some_var > 10
-    println("some_var is totally bigger than 10.")
-elseif some_var < 10    # This elseif clause is optional.
-    println("some_var is smaller than 10.")
+if someVar > 10
+    println("someVar is totally bigger than 10.")
+elseif someVar < 10    # This elseif clause is optional.
+    println("someVar is smaller than 10.")
 else                    # The else clause is optional too.
-    println("some_var is indeed 10.")
+    println("someVar is indeed 10.")
 end
 # => prints "some var is smaller than 10"
 
-
 # For loops iterate over iterables.
 # Iterable types include Range, Array, Set, Dict, and AbstractString.
-for animal=["dog", "cat", "mouse"]
+for animal = ["dog", "cat", "mouse"]
     println("$animal is a mammal")
     # You can use $ to interpolate variables or expression into strings
 end
-# prints:
-#    dog is a mammal
-#    cat is a mammal
-#    mouse is a mammal
+# => dog is a mammal
+# => cat is a mammal
+# => mouse is a mammal
 
 # You can use 'in' instead of '='.
 for animal in ["dog", "cat", "mouse"]
     println("$animal is a mammal")
 end
-# prints:
-#    dog is a mammal
-#    cat is a mammal
-#    mouse is a mammal
+# => dog is a mammal
+# => cat is a mammal
+# => mouse is a mammal
 
-for a in Dict("dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal")
-    println("$(a[1]) is a $(a[2])")
+for pair in Dict("dog" => "mammal", "cat" => "mammal", "mouse" => "mammal")
+    from, to = pair
+    println("$from is a $to")
 end
-# prints:
-#    dog is a mammal
-#    cat is a mammal
-#    mouse is a mammal
+# => mouse is a mammal
+# => cat is a mammal
+# => dog is a mammal
 
-for (k,v) in Dict("dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal")
+for (k, v) in Dict("dog" => "mammal", "cat" => "mammal", "mouse" => "mammal")
     println("$k is a $v")
 end
-# prints:
-#    dog is a mammal
-#    cat is a mammal
-#    mouse is a mammal
+# => mouse is a mammal
+# => cat is a mammal
+# => dog is a mammal
 
 # While loops loop while a condition is true
-x = 0
-while x < 4
-    println(x)
-    x += 1  # Shorthand for x = x + 1
+let x = 0
+    while x < 4
+        println(x)
+        x += 1  # Shorthand for x = x + 1
+    end
 end
-# prints:
-#   0
-#   1
-#   2
-#   3
+# => 0
+# => 1
+# => 2
+# => 3
 
 # Handle exceptions with a try/catch block
 try
-   error("help")
+    error("help")
 catch e
-   println("caught it $e")
+    println("caught it $e")
 end
 # => caught it ErrorException("help")
 
-
 ####################################################
 ## 4. Functions
 ####################################################
 
 # The keyword 'function' creates new functions
-#function name(arglist)
-#  body...
-#end
+# function name(arglist)
+#   body...
+# end
 function add(x, y)
     println("x is $x and y is $y")
 
@@ -398,15 +439,17 @@ function add(x, y)
     x + y
 end
 
-add(5, 6) # => 11 after printing out "x is 5 and y is 6"
+add(5, 6)
+# => x is 5 and y is 6
+# => 11
 
 # Compact assignment of functions
-f_add(x, y) = x + y # => "f (generic function with 1 method)"
-f_add(3, 4) # => 7
+f_add(x, y) = x + y  # => f_add (generic function with 1 method)
+f_add(3, 4)  # => 7
 
 # Function can also return multiple values as tuple
-f(x, y) = x + y, x - y
-f(3, 4) # => (7, -1)
+fn(x, y) = x + y, x - y # => fn (generic function with 1 method)
+fn(3, 4)  # => (7, -1)
 
 # You can define functions that take a variable number of
 # positional arguments
@@ -416,54 +459,56 @@ function varargs(args...)
 end
 # => varargs (generic function with 1 method)
 
-varargs(1,2,3) # => (1,2,3)
+varargs(1, 2, 3)  # => (1,2,3)
 
 # The ... is called a splat.
 # We just used it in a function definition.
 # It can also be used in a function call,
 # where it will splat an Array or Tuple's contents into the argument list.
-add([5,6]...) # this is equivalent to add(5,6)
+add([5,6]...)  # this is equivalent to add(5,6)
 
-x = (5,6)     # => (5,6)
-add(x...)     # this is equivalent to add(5,6)
+x = (5, 6)  # => (5,6)
+add(x...)  # this is equivalent to add(5,6)
 
 
 # You can define functions with optional positional arguments
-function defaults(a,b,x=5,y=6)
+function defaults(a, b, x=5, y=6)
     return "$a $b and $x $y"
 end
+# => defaults (generic function with 3 methods)
 
-defaults('h','g') # => "h g and 5 6"
-defaults('h','g','j') # => "h g and j 6"
-defaults('h','g','j','k') # => "h g and j k"
+defaults('h', 'g')  # => "h g and 5 6"
+defaults('h', 'g', 'j')  # => "h g and j 6"
+defaults('h', 'g', 'j', 'k')  # => "h g and j k"
 try
-    defaults('h') # => ERROR: no method defaults(Char,)
-    defaults() # => ERROR: no methods defaults()
+    defaults('h')  # => ERROR: MethodError: no method matching defaults(::Char)
+    defaults()  # => ERROR: MethodError: no method matching defaults()
 catch e
     println(e)
 end
 
 # You can define functions that take keyword arguments
-function keyword_args(;k1=4,name2="hello") # note the ;
-    return Dict("k1"=>k1,"name2"=>name2)
+function keyword_args(;k1=4, name2="hello")  # note the ;
+    return Dict("k1" => k1, "name2" => name2)
 end
+# => keyword_args (generic function with 1 method)
 
-keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4]
-keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"]
-keyword_args() # => ["name2"=>"hello","k1"=>4]
+keyword_args(name2="ness")  # => ["name2"=>"ness", "k1"=>4]
+keyword_args(k1="mine")     # => ["name2"=>"hello", "k1"=>"mine"]
+keyword_args()              # => ["name2"=>"hello", "k1"=>4]
 
 # You can combine all kinds of arguments in the same function
-function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo")
-    println("normal arg: $normal_arg")
-    println("optional arg: $optional_positional_arg")
-    println("keyword arg: $keyword_arg")
+function all_the_args(normalArg, optionalPositionalArg=2; keywordArg="foo")
+    println("normal arg: $normalArg")
+    println("optional arg: $optionalPositionalArg")
+    println("keyword arg: $keywordArg")
 end
+# => all_the_args (generic function with 2 methods)
 
-all_the_args(1, 3, keyword_arg=4)
-# prints:
-#   normal arg: 1
-#   optional arg: 3
-#   keyword arg: 4
+all_the_args(1, 3, keywordArg=4)
+# => normal arg: 1
+# => optional arg: 3
+# => keyword arg: 4
 
 # Julia has first class functions
 function create_adder(x)
@@ -472,14 +517,16 @@ function create_adder(x)
     end
     return adder
 end
+# => create_adder (generic function with 1 method)
 
 # This is "stabby lambda syntax" for creating anonymous functions
-(x -> x > 2)(3) # => true
+(x -> x > 2)(3)  # => true
 
 # This function is identical to create_adder implementation above.
 function create_adder(x)
     y -> x + y
 end
+# => create_adder (generic function with 1 method)
 
 # You can also name the internal function, if you want
 function create_adder(x)
@@ -488,18 +535,21 @@ function create_adder(x)
     end
     adder
 end
+# => create_adder (generic function with 1 method)
 
-add_10 = create_adder(10)
+add_10 = create_adder(10) # => (::getfield(Main, Symbol("#adder#11")){Int64}) 
+                          # (generic function with 1 method)
 add_10(3) # => 13
 
 
 # There are built-in higher order functions
-map(add_10, [1,2,3]) # => [11, 12, 13]
-filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
+map(add_10, [1,2,3])  # => [11, 12, 13]
+filter(x -> x > 5, [3, 4, 5, 6, 7])  # => [6, 7]
 
-# We can use list comprehensions for nicer maps
-[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13]
-[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
+# We can use list comprehensions
+[add_10(i) for i = [1, 2, 3]]   # => [11, 12, 13]
+[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. Types
@@ -508,11 +558,11 @@ filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
 # Julia has a type system.
 # Every value has a type; variables do not have types themselves.
 # You can use the `typeof` function to get the type of a value.
-typeof(5) # => Int64
+typeof(5)  # => Int64
 
 # Types are first-class values
-typeof(Int64) # => DataType
-typeof(DataType) # => DataType
+typeof(Int64)     # => DataType
+typeof(DataType)  # => DataType
 # DataType is the type that represents types, including itself.
 
 # Types are used for documentation, optimizations, and dispatch.
@@ -520,80 +570,76 @@ typeof(DataType) # => DataType
 
 # Users can define types
 # They are like records or structs in other languages.
-# New types are defined using the `type` keyword.
+# New types are defined using the `struct` keyword.
 
-# type Name
+# struct Name
 #   field::OptionalType
 #   ...
 # end
-type Tiger
-  taillength::Float64
-  coatcolor # not including a type annotation is the same as `::Any`
+struct Tiger
+    taillength::Float64
+    coatcolor  # not including a type annotation is the same as `::Any`
 end
 
 # The default constructor's arguments are the properties
 # of the type, in the order they are listed in the definition
-tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange")
+tigger = Tiger(3.5, "orange")  # => Tiger(3.5,"orange")
 
 # The type doubles as the constructor function for values of that type
-sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire")
+sherekhan = typeof(tigger)(5.6, "fire")  # => Tiger(5.6,"fire")
 
 # These struct-style types are called concrete types
 # They can be instantiated, but cannot have subtypes.
 # The other kind of types is abstract types.
 
 # abstract Name
-abstract Cat # just a name and point in the type hierarchy
+abstract type Cat end  # just a name and point in the type hierarchy
 
 # Abstract types cannot be instantiated, but can have subtypes.
 # For example, Number is an abstract type
-subtypes(Number) # => 2-element Array{Any,1}:
-                 #     Complex{T<:Real}
-                 #     Real
-subtypes(Cat) # => 0-element Array{Any,1}
+subtypes(Number)  # => 2-element Array{Any,1}:
+                  # =>  Complex
+                  # =>  Real
+subtypes(Cat)  # => 0-element Array{Any,1}
 
 # AbstractString, as the name implies, is also an abstract type
-subtypes(AbstractString)    # 8-element Array{Any,1}:
-                            #  Base.SubstitutionString{T<:AbstractString}
-                            #  DirectIndexString
-                            #  RepString
-                            #  RevString{T<:AbstractString}
-                            #  RopeString
-                            #  SubString{T<:AbstractString}
-                            #  UTF16String
-                            #  UTF8String
-
-# Every type has a super type; use the `super` function to get it.
+subtypes(AbstractString)  # => 4-element Array{Any,1}:
+                          # =>  String
+                          # =>  SubString
+                          # =>  SubstitutionString
+                          # =>  Test.GenericString
+
+# Every type has a super type; use the `supertype` function to get it.
 typeof(5) # => Int64
-super(Int64) # => Signed
-super(Signed) # => Integer
-super(Integer) # => Real
-super(Real) # => Number
-super(Number) # => Any
-super(super(Signed)) # => Real
-super(Any) # => Any
+supertype(Int64)    # => Signed
+supertype(Signed)   # => Integer
+supertype(Integer)  # => Real
+supertype(Real)     # => Number
+supertype(Number)   # => Any
+supertype(supertype(Signed))  # => Real
+supertype(Any)      # => Any
 # All of these type, except for Int64, are abstract.
-typeof("fire") # => ASCIIString
-super(ASCIIString) # => DirectIndexString
-super(DirectIndexString) # => AbstractString
-# Likewise here with ASCIIString
+typeof("fire")      # => String
+supertype(String)   # => AbstractString
+# Likewise here with String
+supertype(SubString)  # => AbstractString
 
 # <: is the subtyping operator
-type Lion <: Cat # Lion is a subtype of Cat
-  mane_color
-  roar::AbstractString
+struct Lion <: Cat  # Lion is a subtype of Cat
+    maneColor
+    roar::AbstractString
 end
 
 # You can define more constructors for your type
 # Just define a function of the same name as the type
 # and call an existing constructor to get a value of the correct type
-Lion(roar::AbstractString) = Lion("green",roar)
+Lion(roar::AbstractString) = Lion("green", roar)
 # This is an outer constructor because it's outside the type definition
 
-type Panther <: Cat # Panther is also a subtype of Cat
-  eye_color
-  Panther() = new("green")
-  # Panthers will only have this constructor, and no default constructor.
+struct Panther <: Cat  # Panther is also a subtype of Cat
+    eyeColor
+    Panther() = new("green")
+    # Panthers will only have this constructor, and no default constructor.
 end
 # Using inner constructors, like Panther does, gives you control
 # over how values of the type can be created.
@@ -611,35 +657,36 @@ end
 
 # Definitions for Lion, Panther, Tiger
 function meow(animal::Lion)
-  animal.roar # access type properties using dot notation
+    animal.roar  # access type properties using dot notation
 end
 
 function meow(animal::Panther)
-  "grrr"
+    "grrr"
 end
 
 function meow(animal::Tiger)
-  "rawwwr"
+    "rawwwr"
 end
 
 # Testing the meow function
-meow(tigger) # => "rawwr"
-meow(Lion("brown","ROAAR")) # => "ROAAR"
+meow(tigger)  # => "rawwwr"
+meow(Lion("brown", "ROAAR"))  # => "ROAAR"
 meow(Panther()) # => "grrr"
 
 # Review the local type hierarchy
-issubtype(Tiger,Cat) # => false
-issubtype(Lion,Cat) # => true
-issubtype(Panther,Cat) # => true
+Tiger   <: Cat  # => false
+Lion    <: Cat  # => true
+Panther <: Cat  # => true
 
 # Defining a function that takes Cats
 function pet_cat(cat::Cat)
-  println("The cat says $(meow(cat))")
+    println("The cat says $(meow(cat))")
 end
+# => pet_cat (generic function with 1 method)
 
-pet_cat(Lion("42")) # => prints "The cat says 42"
+pet_cat(Lion("42")) # => The cat says 42
 try
-    pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,)
+    pet_cat(tigger) # => ERROR: MethodError: no method matching pet_cat(::Tiger)
 catch e
     println(e)
 end
@@ -649,130 +696,179 @@ end
 # In Julia, all of the argument types contribute to selecting the best method.
 
 # Let's define a function with more arguments, so we can see the difference
-function fight(t::Tiger,c::Cat)
-  println("The $(t.coatcolor) tiger wins!")
+function fight(t::Tiger, c::Cat)
+    println("The $(t.coatcolor) tiger wins!")
 end
 # => fight (generic function with 1 method)
 
-fight(tigger,Panther()) # => prints The orange tiger wins!
-fight(tigger,Lion("ROAR")) # => prints The orange tiger wins!
+fight(tigger, Panther())  # => The orange tiger wins!
+fight(tigger, Lion("ROAR")) # => The orange tiger wins!
 
 # Let's change the behavior when the Cat is specifically a Lion
-fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!")
+fight(t::Tiger, l::Lion) = println("The $(l.maneColor)-maned lion wins!")
 # => fight (generic function with 2 methods)
 
-fight(tigger,Panther()) # => prints The orange tiger wins!
-fight(tigger,Lion("ROAR")) # => prints The green-maned lion wins!
+fight(tigger, Panther())  # => The orange tiger wins!
+fight(tigger, Lion("ROAR")) # => The green-maned lion wins!
 
 # We don't need a Tiger in order to fight
-fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))")
+fight(l::Lion, c::Cat) = println("The victorious cat says $(meow(c))")
 # => fight (generic function with 3 methods)
 
-fight(Lion("balooga!"),Panther()) # => prints The victorious cat says grrr
+fight(Lion("balooga!"), Panther())  # => The victorious cat says grrr
 try
-  fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion)
-catch
+    fight(Panther(), Lion("RAWR"))  
+    # => ERROR: MethodError: no method matching fight(::Panther, ::Lion)
+    # => Closest candidates are:
+    # =>   fight(::Tiger, ::Lion) at ...
+    # =>   fight(::Tiger, ::Cat) at ...
+    # =>   fight(::Lion, ::Cat) at ...
+    # => ...
+catch e
+    println(e)
 end
 
 # Also let the cat go first
-fight(c::Cat,l::Lion) = println("The cat beats the Lion")
-# => Warning: New definition
-#    fight(Cat,Lion) at none:1
-# is ambiguous with
-#    fight(Lion,Cat) at none:2.
-# Make sure
-#    fight(Lion,Lion)
-# is defined first.
-#fight (generic function with 4 methods)
+fight(c::Cat, l::Lion) = println("The cat beats the Lion")
+# => fight (generic function with 4 methods)
 
 # This warning is because it's unclear which fight will be called in:
-fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The victorious cat says rarrr
+try
+    fight(Lion("RAR"), Lion("brown", "rarrr"))
+    # => ERROR: MethodError: fight(::Lion, ::Lion) is ambiguous. Candidates:
+    # =>   fight(c::Cat, l::Lion) in Main at ...
+    # =>   fight(l::Lion, c::Cat) in Main at ...
+    # => Possible fix, define
+    # =>   fight(::Lion, ::Lion)
+    # => ...
+catch e
+    println(e)
+end
 # The result may be different in other versions of Julia
 
-fight(l::Lion,l2::Lion) = println("The lions come to a tie")
-fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The lions come to a tie
+fight(l::Lion, l2::Lion) = println("The lions come to a tie") 
+# => fight (generic function with 5 methods)
+fight(Lion("RAR"), Lion("brown", "rarrr"))  # => The lions come to a tie
 
 
 # Under the hood
 # You can take a look at the llvm  and the assembly code generated.
 
-square_area(l) = l * l      # square_area (generic function with 1 method)
+square_area(l) = l * l  # square_area (generic function with 1 method)
 
-square_area(5) #25
+square_area(5)  # => 25
 
 # What happens when we feed square_area an integer?
-code_native(square_area, (Int32,))
-	#	    .section    __TEXT,__text,regular,pure_instructions
-	#	Filename: none
-	#	Source line: 1              # Prologue
-	#	    push    RBP
-	#	    mov RBP, RSP
-	#	Source line: 1
-	#	    movsxd  RAX, EDI        # Fetch l from memory?
-	#	    imul    RAX, RAX        # Square l and store the result in RAX
-	#	    pop RBP                 # Restore old base pointer
-	#	    ret                     # Result will still be in RAX
-
-code_native(square_area, (Float32,))
-	#	    .section    __TEXT,__text,regular,pure_instructions
-	#	Filename: none
-	#	Source line: 1
-	#	    push    RBP
-	#	    mov RBP, RSP
-	#	Source line: 1
-	#	    vmulss  XMM0, XMM0, XMM0  # Scalar single precision multiply (AVX)
-	#	    pop RBP
-	#	    ret
-
-code_native(square_area, (Float64,))
-	#	    .section    __TEXT,__text,regular,pure_instructions
-	#	Filename: none
-	#	Source line: 1
-	#	    push    RBP
-	#	    mov RBP, RSP
-	#	Source line: 1
-	#	    vmulsd  XMM0, XMM0, XMM0 # Scalar double precision multiply (AVX)
-	#	    pop RBP
-	#	    ret
-	#
+code_native(square_area, (Int32,), syntax = :intel)
+	#         .text
+	# ; Function square_area {
+	# ; Location: REPL[116]:1       # Prologue
+	#         push    rbp
+	#         mov     rbp, rsp
+	# ; Function *; {
+	# ; Location: int.jl:54
+	#         imul    ecx, ecx      # Square l and store the result in ECX
+	# ;}
+	#         mov     eax, ecx
+	#         pop     rbp           # Restore old base pointer
+	#         ret                   # Result will still be in EAX
+	#         nop     dword ptr [rax + rax]
+	# ;}
+
+code_native(square_area, (Float32,), syntax = :intel)
+    #         .text
+    # ; Function square_area {
+    # ; Location: REPL[116]:1
+    #         push    rbp
+    #         mov     rbp, rsp
+    # ; Function *; {
+    # ; Location: float.jl:398
+    #         vmulss  xmm0, xmm0, xmm0  # Scalar single precision multiply (AVX)
+    # ;}
+    #         pop     rbp
+    #         ret
+    #         nop     word ptr [rax + rax]
+    # ;}
+
+code_native(square_area, (Float64,), syntax = :intel)
+    #         .text
+    # ; Function square_area {
+    # ; Location: REPL[116]:1
+    #         push    rbp
+    #         mov     rbp, rsp
+    # ; Function *; {
+    # ; Location: float.jl:399
+    #         vmulsd  xmm0, xmm0, xmm0  # Scalar double precision multiply (AVX)
+    # ;}
+    #         pop     rbp
+    #         ret
+    #         nop     word ptr [rax + rax]
+    # ;}
+
 # Note that julia will use floating point instructions if any of the
 # arguments are floats.
 # Let's calculate the area of a circle
 circle_area(r) = pi * r * r     # circle_area (generic function with 1 method)
-circle_area(5)                  # 78.53981633974483
-
-code_native(circle_area, (Int32,))
-	#	    .section    __TEXT,__text,regular,pure_instructions
-	#	Filename: none
-	#	Source line: 1
-	#	    push    RBP
-	#	    mov RBP, RSP
-	#	Source line: 1
-	#	    vcvtsi2sd   XMM0, XMM0, EDI          # Load integer (r) from memory
-	#	    movabs  RAX, 4593140240              # Load pi
-	#	    vmulsd  XMM1, XMM0, QWORD PTR [RAX]  # pi * r
-	#	    vmulsd  XMM0, XMM0, XMM1             # (pi * r) * r
-	#	    pop RBP
-	#	    ret
-	#
-
-code_native(circle_area, (Float64,))
-	#	    .section    __TEXT,__text,regular,pure_instructions
-	#	Filename: none
-	#	Source line: 1
-	#	    push    RBP
-	#	    mov RBP, RSP
-	#	    movabs  RAX, 4593140496
-	#	Source line: 1
-	#	    vmulsd  XMM1, XMM0, QWORD PTR [RAX]
-	#	    vmulsd  XMM0, XMM1, XMM0
-	#	    pop RBP
-	#	    ret
-	#
+circle_area(5)  # 78.53981633974483
+
+code_native(circle_area, (Int32,), syntax = :intel)
+    #         .text
+    # ; Function circle_area {
+    # ; Location: REPL[121]:1
+    #         push    rbp
+    #         mov     rbp, rsp
+    # ; Function *; {
+    # ; Location: operators.jl:502
+    # ; Function *; {
+    # ; Location: promotion.jl:314
+    # ; Function promote; {
+    # ; Location: promotion.jl:284
+    # ; Function _promote; {
+    # ; Location: promotion.jl:261
+    # ; Function convert; {
+    # ; Location: number.jl:7
+    # ; Function Type; {
+    # ; Location: float.jl:60
+    #         vcvtsi2sd       xmm0, xmm0, ecx     # Load integer (r) from memory
+    #         movabs  rax, 497710928              # Load pi
+    # ;}}}}}
+    # ; Function *; {
+    # ; Location: float.jl:399
+    #         vmulsd  xmm1, xmm0, qword ptr [rax] # pi * r
+    #         vmulsd  xmm0, xmm1, xmm0            # (pi * r) * r
+    # ;}}
+    #         pop     rbp
+    #         ret
+    #         nop     dword ptr [rax]
+    # ;}
+
+code_native(circle_area, (Float64,), syntax = :intel)
+    #         .text
+    # ; Function circle_area {
+    # ; Location: REPL[121]:1
+    #         push    rbp
+    #         mov     rbp, rsp
+    #         movabs  rax, 497711048
+    # ; Function *; {
+    # ; Location: operators.jl:502
+    # ; Function *; {
+    # ; Location: promotion.jl:314
+    # ; Function *; {
+    # ; Location: float.jl:399
+    #         vmulsd  xmm1, xmm0, qword ptr [rax]
+    # ;}}}
+    # ; Function *; {
+    # ; Location: float.jl:399
+    #         vmulsd  xmm0, xmm1, xmm0
+    # ;}
+    #         pop     rbp
+    #         ret
+    #         nop     dword ptr [rax + rax]
+    # ;}
 ```
 
 ## Further Reading
 
-You can get a lot more detail from [The Julia Manual](http://docs.julialang.org/en/latest/#Manual-1)
+You can get a lot more detail from the [Julia Documentation](https://docs.julialang.org/)
 
 The best place to get help with Julia is the (very friendly) [Discourse forum](https://discourse.julialang.org/).
diff --git a/kdb+.html.markdown b/kdb+.html.markdown
index 097f177b..027b6571 100644
--- a/kdb+.html.markdown
+++ b/kdb+.html.markdown
@@ -689,14 +689,14 @@ first each (1 2 3;4 5 6;7 8 9)
 
 / each-left (\:) and each-right (/:) modify a two-argument function
 / to treat one of the arguments and individual variables instead of a list
-1 2 3 +\: 1 2 3
-/ => 2 3 4
-/ => 3 4 5
-/ => 4 5 6
-1 2 3 +/: 1 2 3
-/ => 2 3 4
-/ => 3 4 5
-/ => 4 5 6
+1 2 3 +\: 11 22 33
+/ => 12 23 34
+/ => 13 24 35
+/ => 14 25 36
+1 2 3 +/: 11 22 33
+/ => 12 13 14
+/ => 23 24 25
+/ => 34 35 36
 
 / The true alternatives to loops in q are the adverbs scan (\) and over (/)
 / their behaviour differs based on the number of arguments the function they
diff --git a/ko-kr/markdown-kr.html.markdown b/ko-kr/markdown-kr.html.markdown
index bfa2a877..397e9f30 100644
--- a/ko-kr/markdown-kr.html.markdown
+++ b/ko-kr/markdown-kr.html.markdown
@@ -25,7 +25,7 @@ lang: ko-kr
 
 ## HTML 요소
 HTML은 마크다운의 수퍼셋입니다. 모든 HTML 파일은 유효한 마크다운이라는 것입니다.
-```markdown
+```md
 <!--따라서 주석과 같은 HTML 요소들을 마크다운에 사용할 수 있으며, 마크다운 파서에 영향을
 받지 않을 것입니다. 하지만 마크다운 파일에서 HTML 요소를 만든다면 그 요소의 안에서는
 마크다운 문법을 사용할 수 없습니다.-->
@@ -34,7 +34,7 @@ HTML은 마크다운의 수퍼셋입니다. 모든 HTML 파일은 유효한 마�
 
 텍스트 앞에 붙이는 우물 정 기호(#)의 갯수에 따라 `<h1>`부터 `<h6>`까지의 HTML 요소를
 손쉽게 작성할 수 있습니다.
-```markdown
+```md
 # <h1>입니다.
 ## <h2>입니다.
 ### <h3>입니다.
@@ -43,7 +43,7 @@ HTML은 마크다운의 수퍼셋입니다. 모든 HTML 파일은 유효한 마�
 ###### <h6>입니다.
 ```
 또한 h1과 h2를 나타내는 다른 방법이 있습니다.
-```markdown
+```md
 h1입니다.
 =============
 
@@ -53,7 +53,7 @@ h2입니다.
 ## 간단한 텍스트 꾸미기
 
 마크다운으로 쉽게 텍스트를 기울이거나 굵게 할 수 있습니다.
-```markdown
+```md
 *기울인 텍스트입니다.*
 _이 텍스트도 같습니다._
 
@@ -65,14 +65,14 @@ __이 텍스트도 같습니다.__
 *__이것도 같습니다.__*
 ```
 깃헙 전용 마크다운에는 취소선도 있습니다.
-```markdown
+```md
 ~~이 텍스트에는 취소선이 그려집니다.~~
 ```
 ## 문단
 
 문단은 하나 이상의 빈 줄로 구분되는, 한 줄 이상의 인접한 텍스트입니다.
 
-```markdown
+```md
 문단입니다. 문단에 글을 쓰다니 재밌지 않나요?
 
 이제 두 번째 문단입니다.
@@ -83,7 +83,7 @@ __이 텍스트도 같습니다.__
 HTML `<br />` 태그를 삽입하고 싶으시다면, 두 개 이상의 띄어쓰기로 문단을 끝내고
 새 문단을 시작할 수 있습니다.
 
-```markdown
+```md
 띄어쓰기 두 개로 끝나는 문단 (마우스로 긁어 보세요).  
 
 이 위에는 `<br />` 태그가 있습니다.
@@ -91,7 +91,7 @@ HTML `<br />` 태그를 삽입하고 싶으시다면, 두 개 이상의 띄어�
 
 인용문은 > 문자로 쉽게 쓸 수 있습니다.
 
-```markdown
+```md
 > 인용문입니다. 수동으로 개행하고서
 > 줄마다 `>`를 칠 수도 있고 줄을 길게 쓴 다음에 저절로 개행되게 내버려 둘 수도 있습니다.
 > `>`로 시작하기만 한다면 차이가 없습니다.
@@ -103,7 +103,7 @@ HTML `<br />` 태그를 삽입하고 싶으시다면, 두 개 이상의 띄어�
 
 ## 목록
 순서가 없는 목록은 별표, 더하기, 하이픈을 이용해 만들 수 있습니다.
-```markdown
+```md
 * 이거
 * 저거
 * 그거
@@ -111,7 +111,7 @@ HTML `<br />` 태그를 삽입하고 싶으시다면, 두 개 이상의 띄어�
 
 또는
 
-```markdown
+```md
 + 이거
 + 저거
 + 그거
@@ -119,7 +119,7 @@ HTML `<br />` 태그를 삽입하고 싶으시다면, 두 개 이상의 띄어�
 
 또는
 
-```markdown
+```md
 - 이거
 - 저거
 - 그거
@@ -127,7 +127,7 @@ HTML `<br />` 태그를 삽입하고 싶으시다면, 두 개 이상의 띄어�
 
 순서가 있는 목록은 숫자와 마침표입니다.
 
-```markdown
+```md
 1. 하나
 2. 둘
 3. 셋
@@ -135,7 +135,7 @@ HTML `<br />` 태그를 삽입하고 싶으시다면, 두 개 이상의 띄어�
 
 숫자를 정확히 붙이지 않더라도 제대로 된 순서로 보여주겠지만, 좋은 생각은 아닙니다.
 
-```markdown
+```md
 1. 하나
 1. 둘
 1. 셋
@@ -144,7 +144,7 @@ HTML `<br />` 태그를 삽입하고 싶으시다면, 두 개 이상의 띄어�
 
 목록 안에 목록이 올 수도 있습니다.
 
-```markdown
+```md
 1. 하나
 2. 둘
 3. 셋
@@ -155,7 +155,7 @@ HTML `<br />` 태그를 삽입하고 싶으시다면, 두 개 이상의 띄어�
 
 심지어 할 일 목록도 있습니다. HTML 체크박스가 만들어집니다.
 
-```markdown
+```md
 x가 없는 박스들은 체크되지 않은 HTML 체크박스입니다.
 - [ ] 첫 번째 할 일
 - [ ] 두 번째 할 일
@@ -168,13 +168,13 @@ x가 없는 박스들은 체크되지 않은 HTML 체크박스입니다.
 띄어쓰기 네 개 혹은 탭 한 개로 줄을 들여씀으로서 (`<code> 요소를 사용하여`) 코드를
 나타낼 수 있습니다.
 
-```markdown
+```md
     puts "Hello, world!"
 ```
 
 탭을 더 치거나 띄어쓰기를 네 번 더 함으로써 코드를 들여쓸 수 있습니다.
 
-```markdown
+```md
     my_array.each do |item|
         puts item
     end
@@ -182,7 +182,7 @@ x가 없는 박스들은 체크되지 않은 HTML 체크박스입니다.
 
 인라인 코드는 백틱 문자를 이용하여 나타냅니다. `
 
-```markdown
+```md
 철수는 `go_to()` 함수가 뭘 했는지도 몰랐어!
 ```
 
@@ -202,7 +202,7 @@ end
 
 수평선(`<hr/>`)은 셋 이상의 별표나 하이픈을 이용해 쉽게 나타낼 수 있습니다.
 띄어쓰기가 포함될 수 있습니다.
-```markdown
+```md
 ***
 ---
 - - -
@@ -213,19 +213,19 @@ end
 마크다운의 장점 중 하나는 링크를 만들기 쉽다는 것입니다. 대괄호 안에 나타낼 텍스트를 쓰고
 괄호 안에 URL을 쓰면 됩니다.
 
-```markdown
+```md
 [클릭](http://test.com/)
 ```
 
 괄호 안에 따옴표를 이용해 링크에 제목을 달 수도 있습니다.
 
-```markdown
+```md
 [클릭](http://test.com/ "test.com으로 가기")
 ```
 
 상대 경로도 유효합니다.
 
-```markdown
+```md
 [music으로 가기](/music/).
 ```
 
@@ -251,7 +251,7 @@ end
 ## 이미지
 이미지는 링크와 같지만 앞에 느낌표가 붙습니다.
 
-```markdown
+```md
 ![이미지의 alt 속성](http://imgur.com/myimage.jpg "제목")
 ```
 
@@ -264,18 +264,18 @@ end
 ## 기타
 ### 자동 링크
 
-```markdown
+```md
 <http://testwebsite.com/>와
 [http://testwebsite.com/](http://testwebsite.com/)는 동일합니다.
 ```
 
 ### 이메일 자동 링크
-```markdown
+```md
 <foo@bar.com>
 ```
 ### 탈출 문자
 
-```markdown
+```md
 *별표 사이에 이 텍스트*를 치고 싶지만 기울이고 싶지는 않다면
 이렇게 하시면 됩니다. \*별표 사이에 이 텍스트\*.
 ```
@@ -284,7 +284,7 @@ end
 
 깃헙 전용 마크다운에서는 `<kbd>` 태그를 이용해 키보드 키를 나타낼 수 있습니다.
 
-```markdown
+```md
 컴퓨터가 멈췄다면 눌러보세요.
 <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
 ```
@@ -292,14 +292,14 @@ end
 ### 표
 
 표는 깃헙 전용 마크다운에서만 쓸 수 있고 다소 복잡하지만, 정말 쓰고 싶으시다면
-```markdown
+```md
 | 1열      | 2열        | 3열       |
 | :--------| :-------: | --------: |
 | 왼쪽 정렬 | 가운데 정렬 | 오른쪽 정렬 |
 | 머시기    | 머시기     | 머시기     |
 ```
 혹은
-```markdown
+```md
 1열 | 2열 | 3열
 :-- | :-: | --:
 으악 너무 못생겼어 | 그만 | 둬
diff --git a/ko-kr/python-kr.html.markdown b/ko-kr/python-kr.html.markdown
index ed377a99..0145754d 100644
--- a/ko-kr/python-kr.html.markdown
+++ b/ko-kr/python-kr.html.markdown
@@ -441,7 +441,7 @@ Human.grunt() #=> "*grunt*"
 
 # 다음과 같이 모듈을 임포트할 수 있습니다.
 import math
-print math.sqrt(16) #=> 4
+print math.sqrt(16) #=> 4.0
 
 # 모듈의 특정 함수를 호출할 수 있습니다.
 from math import ceil, floor
diff --git a/kotlin.html.markdown b/kotlin.html.markdown
index 0c787d7e..5bbf6847 100644
--- a/kotlin.html.markdown
+++ b/kotlin.html.markdown
@@ -20,7 +20,9 @@ package com.learnxinyminutes.kotlin
 
 /*
 The entry point to a Kotlin program is a function named "main".
-The function is passed an array containing any command line arguments.
+The function is passed an array containing any command-line arguments.
+Since Kotlin 1.3 the "main" function can also be defined without
+any parameters.
 */
 fun main(args: Array<String>) {
     /*
@@ -65,7 +67,7 @@ fun helloWorld(val name : String) {
     A template expression starts with a dollar sign ($).
     */
     val fooTemplateString = "$fooString has ${fooString.length} characters"
-    println(fooTemplateString) // => My String Is Here! has 18 characters 
+    println(fooTemplateString) // => My String Is Here! has 18 characters
 
     /*
     For a variable to hold null it must be explicitly specified as nullable.
@@ -107,7 +109,7 @@ fun helloWorld(val name : String) {
 
     /*
     When a function consists of a single expression then the curly brackets can
-    be omitted. The body is specified after a = symbol.
+    be omitted. The body is specified after the = symbol.
     */
     fun odd(x: Int): Boolean = x % 2 == 1
     println(odd(6)) // => false
@@ -175,12 +177,12 @@ fun helloWorld(val name : String) {
     // Objects can be destructured into multiple variables.
     val (a, b, c) = fooCopy
     println("$a $b $c") // => 1 100 4
-    
+
     // destructuring in "for" loop
     for ((a, b, c) in listOf(fooData)) {
         println("$a $b $c") // => 1 100 4
     }
-    
+
     val mapData = mapOf("a" to 1, "b" to 2)
     // Map.Entry is destructurable as well
     for ((key, value) in mapData) {
@@ -304,7 +306,7 @@ fun helloWorld(val name : String) {
     println(result)
 
     /*
-    We can check if an object is a particular type by using the "is" operator.
+    We can check if an object is of a particular type by using the "is" operator.
     If an object passes a type check then it can be used as that type without
     explicitly casting it.
     */
@@ -344,15 +346,25 @@ fun helloWorld(val name : String) {
         return this.filter {it != c}
     }
     println("Hello, world!".remove('l')) // => Heo, word!
-
-    println(EnumExample.A) // => A
-    println(ObjectExample.hello()) // => hello
 }
 
 // Enum classes are similar to Java enum types.
 enum class EnumExample {
-    A, B, C
+    A, B, C // Enum constants are separated with commas.
 }
+fun printEnum() = println(EnumExample.A) // => A
+
+// Since each enum is an instance of the enum class, they can be initialized as:
+enum class EnumExample(val value: Int) {
+    A(value = 1),
+    B(value = 2),
+    C(value = 3)
+}
+fun printProperty() = println(EnumExample.A.value) // => 1
+
+// Every enum has properties to obtain its name and ordinal(position) in the enum class declaration:
+fun printName() = println(EnumExample.A.name) // => A
+fun printPosition() = println(EnumExample.A.ordinal) // => 0
 
 /*
 The "object" keyword can be used to create singleton objects.
@@ -363,17 +375,80 @@ object ObjectExample {
     fun hello(): String {
         return "hello"
     }
+
+    override fun toString(): String {
+        return "Hello, it's me, ${ObjectExample::class.simpleName}"
+    }
 }
 
-fun useObject() {
-    ObjectExample.hello()
-    val someRef: Any = ObjectExample // we use objects name just as is
+
+fun useSingletonObject() {
+    println(ObjectExample.hello()) // => hello
+    // In Kotlin, "Any" is the root of the class hierarchy, just like "Object" is in Java
+    val someRef: Any = ObjectExample
+    println(someRef) // => Hello, it's me, ObjectExample
 }
 
+
+/* The not-null assertion operator (!!) converts any value to a non-null type and
+throws an exception if the value is null.
+*/
+var b: String? = "abc"
+val l = b!!.length
+
+data class Counter(var value: Int) {
+    // overload Counter += Int
+    operator fun plusAssign(increment: Int) {
+        this.value += increment
+    }
+
+    // overload Counter++ and ++Counter
+    operator fun inc() = Counter(value + 1)
+
+    // overload Counter + Counter
+    operator fun plus(other: Counter) = Counter(this.value + other.value)
+
+    // overload Counter * Counter
+    operator fun times(other: Counter) = Counter(this.value * other.value)
+
+    // overload Counter * Int
+    operator fun times(value: Int) = Counter(this.value * value)
+
+    // overload Counter in Counter
+    operator fun contains(other: Counter) = other.value == this.value
+
+    // overload Counter[Int] = Int
+    operator fun set(index: Int, value: Int) {
+        this.value = index + value
+    }
+
+    // overload Counter instance invocation
+    operator fun invoke() = println("The value of the counter is $value")
+
+}
+/* You can also overload operators through an extension methods */
+// overload -Counter
+operator fun Counter.unaryMinus() = Counter(-this.value)
+
+fun operatorOverloadingDemo() {
+    var counter1 = Counter(0)
+    var counter2 = Counter(5)
+    counter1 += 7
+    println(counter1) // => Counter(value=7)
+    println(counter1 + counter2) // => Counter(value=12)
+    println(counter1 * counter2) // => Counter(value=35)
+    println(counter2 * 2) // => Counter(value=10)
+    println(counter1 in Counter(5)) // => false
+    println(counter1 in Counter(7)) // => true
+    counter1[26] = 10
+    println(counter1) // => Counter(value=36)
+    counter1() // => The value of the counter is 36
+    println(-counter2) // => Counter(value=-5)
+}
 ```
 
 ### Further Reading
 
 * [Kotlin tutorials](https://kotlinlang.org/docs/tutorials/)
-* [Try Kotlin in your browser](http://try.kotlinlang.org/)
+* [Try Kotlin in your browser](https://play.kotlinlang.org/)
 * [A list of Kotlin resources](http://kotlin.link/)
diff --git a/lambda-calculus.html.markdown b/lambda-calculus.html.markdown
index 6103c015..53a7a7cd 100644
--- a/lambda-calculus.html.markdown
+++ b/lambda-calculus.html.markdown
@@ -3,6 +3,7 @@ category: Algorithms & Data Structures
 name: Lambda Calculus
 contributors:
     - ["Max Sun", "http://github.com/maxsun"]
+    - ["Yan Hui Hang", "http://github.com/yanhh0"]
 ---
 
 # Lambda Calculus
@@ -54,7 +55,7 @@ Although lambda calculus traditionally supports only single parameter
 functions, we can create multi-parameter functions using a technique called 
 [currying](https://en.wikipedia.org/wiki/Currying).
 
-- `(λx.λy.λz.xyz)` is equivalent to `f(x, y, z) = x(y(z))`
+- `(λx.λy.λz.xyz)` is equivalent to `f(x, y, z) = ((x y) z)`
 
 Sometimes `λxy.<body>` is used interchangeably with: `λx.λy.<body>`
 
@@ -84,9 +85,9 @@ Using `IF`, we can define the basic boolean logic operators:
 
 `a OR b` is equivalent to: `λab.IF a T b`
 
-`a NOT b` is equivalent to: `λa.IF a F T`
+`NOT a` is equivalent to: `λa.IF a F T`
 
-*Note: `IF a b c` is essentially saying: `IF(a(b(c)))`*
+*Note: `IF a b c` is essentially saying: `IF((a b) c)`*
 
 ## Numbers:
 
@@ -110,12 +111,109 @@ we use the successor function `S(n) = n + 1` which is:
 
 Using successor, we can define add:
 
-`ADD = λab.(a S)n`
+`ADD = λab.(a S)b`
 
 **Challenge:** try defining your own multiplication function!
 
+## Get even smaller: SKI, SK and Iota
+
+### SKI Combinator Calculus
+
+Let S, K, I be the following functions:
+
+`I x = x`
+
+`K x y =  x`
+
+`S x y z = x z (y z)`
+
+We can convert an expression in the lambda calculus to an expression
+in the SKI combinator calculus:
+
+1. `λx.x = I`
+2. `λx.c = Kc`
+3. `λx.(y z) = S (λx.y) (λx.z)`
+
+Take the church number 2 for example:
+
+`2 = λf.λx.f(f x)`
+
+For the inner part `λx.f(f x)`:
+
+```
+  λx.f(f x)
+= S (λx.f) (λx.(f x))          (case 3)
+= S (K f)  (S (λx.f) (λx.x))   (case 2, 3)
+= S (K f)  (S (K f) I)         (case 2, 1)
+```
+
+So:
+
+```
+  2
+= λf.λx.f(f x)
+= λf.(S (K f) (S (K f) I))
+= λf.((S (K f)) (S (K f) I))
+= S (λf.(S (K f))) (λf.(S (K f) I)) (case 3)
+```
+
+For the first argument `λf.(S (K f))`:
+
+```
+  λf.(S (K f))
+= S (λf.S) (λf.(K f))       (case 3)
+= S (K S) (S (λf.K) (λf.f)) (case 2, 3)
+= S (K S) (S (K K) I)       (case 2, 3)
+```
+
+For the second argument `λf.(S (K f) I)`:
+
+```
+  λf.(S (K f) I)
+= λf.((S (K f)) I)
+= S (λf.(S (K f))) (λf.I)             (case 3)
+= S (S (λf.S) (λf.(K f))) (K I)       (case 2, 3)
+= S (S (K S) (S (λf.K) (λf.f))) (K I) (case 1, 3)
+= S (S (K S) (S (K K) I)) (K I)       (case 1, 2)
+```
+
+Merging them up:
+
+```
+  2
+= S (λf.(S (K f))) (λf.(S (K f) I))
+= S (S (K S) (S (K K) I)) (S (S (K S) (S (K K) I)) (K I))
+```
+
+Expanding this, we would end up with the same expression for the
+church number 2 again.
+
+### SK Combinator Calculus
+
+The SKI combinator calculus can still be reduced further. We can
+remove the I combinator by noting that `I = SKK`. We can substitute
+all `I`'s with `SKK`.
+
+### Iota Combinator
+
+The SK combinator calculus is still not minimal. Defining:
+
+```
+ι = λf.((f S) K)
+```
+
+We have:
+
+```
+I = ιι
+K = ι(ιI) = ι(ι(ιι))
+S = ι(K) = ι(ι(ι(ιι)))
+```
+
 ## For more advanced reading:
 
 1. [A Tutorial Introduction to the Lambda Calculus](http://www.inf.fu-berlin.de/lehre/WS03/alpi/lambda.pdf)
 2. [Cornell CS 312 Recitation 26: The Lambda Calculus](http://www.cs.cornell.edu/courses/cs3110/2008fa/recitations/rec26.html)
-3. [Wikipedia - Lambda Calculus](https://en.wikipedia.org/wiki/Lambda_calculus)
\ No newline at end of file
+3. [Wikipedia - Lambda Calculus](https://en.wikipedia.org/wiki/Lambda_calculus)
+4. [Wikipedia - SKI combinator calculus](https://en.wikipedia.org/wiki/SKI_combinator_calculus)
+5. [Wikipedia - Iota and Jot](https://en.wikipedia.org/wiki/Iota_and_Jot)
diff --git a/latex.html.markdown b/latex.html.markdown
index c9b1d8fb..c980f5e5 100644
--- a/latex.html.markdown
+++ b/latex.html.markdown
@@ -6,6 +6,7 @@ contributors:
     - ["Sricharan Chiruvolu", "http://sricharan.xyz"]
     - ["Ramanan Balakrishnan", "https://github.com/ramananbalakrishnan"]
     - ["Svetlana Golubeva", "https://attillax.github.io/"]
+    - ["Oliver Kopp", "http://orcid.org/0000-0001-6962-4290"]
 filename: learn-latex.tex
 ---
 
@@ -26,8 +27,8 @@ filename: learn-latex.tex
 
 % Next we define the packages the document uses.
 % If you want to include graphics, colored text, or
-% source code from another language file into your document, 
-% you need to enhance the capabilities of LaTeX. This is done by adding packages. 
+% source code from another language file into your document,
+% you need to enhance the capabilities of LaTeX. This is done by adding packages.
 % I'm going to include the float and caption packages for figures
 % and hyperref package for hyperlinks
 \usepackage{caption}
@@ -38,18 +39,18 @@ filename: learn-latex.tex
 \author{Chaitanya Krishna Ande, Colton Kohnke, Sricharan Chiruvolu \& \\
 Svetlana Golubeva}
 \date{\today}
-\title{Learn \LaTeX \hspace{1pt} in Y Minutes!}
+\title{Learn \LaTeX{} in Y Minutes!}
 
 % Now we're ready to begin the document
 % Everything before this line is called "The Preamble"
-\begin{document} 
-% if we set the author, date, title fields, we can have LaTeX 
+\begin{document}
+% if we set the author, date, title fields, we can have LaTeX
 % create a title page for us.
 \maketitle
 
 % If we have sections, we can create table of contents. We have to compile our
 % document twice to make it appear in right order.
-% It is a good practice to separate the table of contents form the body of the 
+% It is a good practice to separate the table of contents form the body of the
 % document. To do so we use \newpage command
 \newpage
 \tableofcontents
@@ -58,14 +59,14 @@ Svetlana Golubeva}
 
 % Most research papers have abstract, you can use the predefined commands for this.
 % This should appear in its logical order, therefore, after the top matter,
-% but before the main sections of the body. 
+% but before the main sections of the body.
 % This command is available in the document classes article and report.
 \begin{abstract}
- \LaTeX \hspace{1pt} documentation written as \LaTeX! How novel and totally not
+ \LaTeX{} documentation written as \LaTeX! How novel and totally not
  my idea!
 \end{abstract}
 
-% Section commands are intuitive. 
+% Section commands are intuitive.
 % All the titles of the sections are added automatically to the table of contents.
 \section{Introduction}
 Hello, my name is Colton and together we're going to explore \LaTeX!
@@ -74,23 +75,28 @@ Hello, my name is Colton and together we're going to explore \LaTeX!
 This is the text for another section. I think it needs a subsection.
 
 \subsection{This is a subsection} % Subsections are also intuitive.
-I think we need another one
+I think we need another one.
 
 \subsubsection{Pythagoras}
 Much better now.
 \label{subsec:pythagoras}
 
 % By using the asterisk we can suppress LaTeX's inbuilt numbering.
-% This works for other LaTeX commands as well. 
-\section*{This is an unnumbered section} 
+% This works for other LaTeX commands as well.
+\section*{This is an unnumbered section}
 However not all sections have to be numbered!
 
 \section{Some Text notes}
 %\section{Spacing} % Need to add more information about space intervals
-\LaTeX \hspace{1pt} is generally pretty good about placing text where it should
-go. If 
-a line \\ needs \\ to \\ break \\ you add \textbackslash\textbackslash 
-\hspace{1pt} to the source code. \\ 
+\LaTeX{} is generally pretty good about placing text where it should
+go. If
+a line \\ needs \\ to \\ break \\ you add \textbackslash\textbackslash{}
+to the source code.
+
+Separate paragraphs by empty lines.
+
+You need to add a backslash after abbreviations (if not followed by a comma), because otherwise the spacing after the dot is too large:
+E.g., i.e., etc.\ are are such abbreviations.
 
 \section{Lists}
 Lists are one of the easiest things to create in \LaTeX! I need to go shopping
@@ -109,18 +115,18 @@ tomorrow, so let's make a grocery list.
 
 \section{Math}
 
-One of the primary uses for \LaTeX \hspace{1pt} is to produce academic articles
-or technical papers. Usually in the realm of math and science. As such, 
-we need to be able to add special symbols to our paper! \\
+One of the primary uses for \LaTeX{} is to produce academic articles
+or technical papers. Usually in the realm of math and science. As such,
+we need to be able to add special symbols to our paper!
 
 Math has many symbols, far beyond what you can find on a keyboard;
-Set and relation symbols, arrows, operators, and Greek letters to name a few.\\
+Set and relation symbols, arrows, operators, and Greek letters to name a few.
 
 Sets and relations play a vital role in many mathematical research papers.
-Here's how you state all x that belong to X, $\forall$ x $\in$ X. \\
-% Notice how I needed to add $ signs before and after the symbols. This is 
-% because when writing, we are in text-mode. 
-% However, the math symbols only exist in math-mode. 
+Here's how you state all x that belong to X, $\forall$ x $\in$ X.
+% Notice how I needed to add $ signs before and after the symbols. This is
+% because when writing, we are in text-mode.
+% However, the math symbols only exist in math-mode.
 % We can enter math-mode from text mode with the $ signs.
 % The opposite also holds true. Variable can also be rendered in math-mode.
 % We can also enter math mode with \[\]
@@ -128,16 +134,16 @@ Here's how you state all x that belong to X, $\forall$ x $\in$ X. \\
 \[a^2 + b^2 = c^2 \]
 
 My favorite Greek letter is $\xi$. I also like $\beta$, $\gamma$ and $\sigma$.
-I haven't found a Greek letter yet that \LaTeX \hspace{1pt} doesn't know
-about! \\
+I haven't found a Greek letter yet that \LaTeX{} doesn't know
+about!
 
-Operators are essential parts of a mathematical document: 
-trigonometric functions ($\sin$, $\cos$, $\tan$), 
-logarithms and exponentials ($\log$, $\exp$), 
-limits ($\lim$), etc. 
-have per-defined LaTeX commands. 
-Let's write an equation to see how it's done: 
-$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$ \\
+Operators are essential parts of a mathematical document:
+trigonometric functions ($\sin$, $\cos$, $\tan$),
+logarithms and exponentials ($\log$, $\exp$),
+limits ($\lim$), etc.\ 
+have per-defined LaTeX commands.
+Let's write an equation to see how it's done:
+$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$
 
 Fractions (Numerator-denominators) can be written in these forms:
 
@@ -146,7 +152,7 @@ $$ ^{10}/_{7} $$
 
 % Relatively complex fractions can be written as
 % \frac{numerator}{denominator}
-$$ \frac{n!}{k!(n - k)!} $$ \\
+$$ \frac{n!}{k!(n - k)!} $$
 
 We can also insert equations in an ``equation environment''.
 
@@ -156,31 +162,31 @@ We can also insert equations in an ``equation environment''.
     \label{eq:pythagoras} % for referencing
 \end{equation} % all \begin statements must have an end statement
 
-We can then reference our new equation! 
+We can then reference our new equation!
 Eqn.~\ref{eq:pythagoras} is also known as the Pythagoras Theorem which is also
-the subject of Sec.~\ref{subsec:pythagoras}. A lot of things can be labeled: 
+the subject of Sec.~\ref{subsec:pythagoras}. A lot of things can be labeled:
 figures, equations, sections, etc.
 
 Summations and Integrals are written with sum and int commands:
 
 % Some LaTeX compilers will complain if there are blank lines
 % In an equation environment.
-\begin{equation} 
+\begin{equation}
   \sum_{i=0}^{5} f_{i}
-\end{equation} 
-\begin{equation} 
+\end{equation}
+\begin{equation}
   \int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x
-\end{equation} 
+\end{equation}
 
 \section{Figures}
 
-Let's insert a Figure. Figure placement can get a little tricky. 
+Let's insert a figure. Figure placement can get a little tricky.
 I definitely have to lookup the placement options each time.
 
-\begin{figure}[H] % H here denoted the placement option. 
+\begin{figure}[H] % H here denoted the placement option.
     \centering % centers the figure on the page
     % Inserts a figure scaled to 0.8 the width of the page.
-    %\includegraphics[width=0.8\linewidth]{right-triangle.png} 
+    %\includegraphics[width=0.8\linewidth]{right-triangle.png}
     % Commented out for compilation purposes. Please use your imagination.
     \caption{Right triangle with sides $a$, $b$, $c$}
     \label{fig:right-triangle}
@@ -193,7 +199,7 @@ We can also insert Tables in the same way as figures.
   \caption{Caption for the Table.}
   % the {} arguments below describe how each row of the table is drawn.
   % Again, I have to look these up. Each. And. Every. Time.
-  \begin{tabular}{c|cc} 
+  \begin{tabular}{c|cc}
     Number &  Last Name & First Name \\ % Column rows are separated by &
     \hline % a horizontal line
     1 & Biggus & Dickus \\
@@ -201,37 +207,38 @@ We can also insert Tables in the same way as figures.
   \end{tabular}
 \end{table}
 
-\section{Getting \LaTeX \hspace{1pt} to not compile something (i.e. Source Code)}
-Let's say we want to include some code into our \LaTeX \hspace{1pt} document,
-we would then need \LaTeX \hspace{1pt} to not try and interpret that text and
-instead just print it to the document. We do this with a verbatim 
-environment. 
+\section{Getting \LaTeX{} to not compile something (i.e.\ Source Code)}
+Let's say we want to include some code into our \LaTeX{} document,
+we would then need \LaTeX{} to not try and interpret that text and
+instead just print it to the document. We do this with a verbatim
+environment.
 
 % There are other packages that exist (i.e. minty, lstlisting, etc.)
 % but verbatim is the bare-bones basic one.
-\begin{verbatim} 
+\begin{verbatim}
   print("Hello World!")
-  a%b; % look! We can use % signs in verbatim. 
+  a%b; % look! We can use % signs in verbatim.
   random = 4; #decided by fair random dice roll
 \end{verbatim}
 
-\section{Compiling} 
+\section{Compiling}
+
+By now you're probably wondering how to compile this fabulous document
+and look at the glorious glory that is a \LaTeX{} pdf.
+(yes, this document actually does compile).
 
-By now you're probably wondering how to compile this fabulous document 
-and look at the glorious glory that is a \LaTeX \hspace{1pt} pdf.
-(yes, this document actually does compile). \\
-Getting to the final document using \LaTeX \hspace{1pt} consists of the following 
+Getting to the final document using \LaTeX{} consists of the following
 steps:
   \begin{enumerate}
     \item Write the document in plain text (the ``source code'').
-    \item Compile source code to produce a pdf. 
+    \item Compile source code to produce a pdf.
      The compilation step looks like this (in Linux): \\
-     \begin{verbatim} 
+     \begin{verbatim}
         > pdflatex learn-latex.tex
      \end{verbatim}
   \end{enumerate}
 
-A number of \LaTeX \hspace{1pt}editors combine both Step 1 and Step 2 in the 
+A number of \LaTeX{} editors combine both Step 1 and Step 2 in the
 same piece of software. So, you get to see Step 1, but not Step 2 completely.
 Step 2 is still happening behind the scenes\footnote{In cases, where you use
 references (like Eqn.~\ref{eq:pythagoras}), you may need to run Step 2
@@ -245,17 +252,17 @@ format you defined in Step 1.
 \section{Hyperlinks}
 We can also insert hyperlinks in our document. To do so we need to include the
 package hyperref into preamble with the command:
-\begin{verbatim} 
+\begin{verbatim}
     \usepackage{hyperref}
 \end{verbatim}
 
 There exists two main types of links: visible URL \\
-\url{https://learnxinyminutes.com/docs/latex/}, or  
+\url{https://learnxinyminutes.com/docs/latex/}, or
 \href{https://learnxinyminutes.com/docs/latex/}{shadowed by text}
-% You can not add extra-spaces or special symbols into shadowing text since it 
+% You can not add extra-spaces or special symbols into shadowing text since it
 % will cause mistakes during the compilation
 
-This package also produces list of thumbnails in the output pdf document and 
+This package also produces list of thumbnails in the output pdf document and
 active links in the table of contents.
 
 \section{End}
@@ -267,9 +274,8 @@ That's all for now!
 \begin{thebibliography}{1}
   % similar to other lists, the \bibitem command can be used to list items
   % each entry can then be cited directly in the body of the text
-  \bibitem{latexwiki} The amazing \LaTeX \hspace{1pt} wikibook: {\em 
-https://en.wikibooks.org/wiki/LaTeX}
-  \bibitem{latextutorial} An actual tutorial: {\em http://www.latex-tutorial.com}
+  \bibitem{latexwiki} The amazing \LaTeX{} wikibook: \emph{https://en.wikibooks.org/wiki/LaTeX}
+  \bibitem{latextutorial} An actual tutorial: \emph{http://www.latex-tutorial.com}
 \end{thebibliography}
 
 % end the document
@@ -280,3 +286,4 @@ https://en.wikibooks.org/wiki/LaTeX}
 
 * The amazing LaTeX wikibook: [https://en.wikibooks.org/wiki/LaTeX](https://en.wikibooks.org/wiki/LaTeX)
 * An actual tutorial: [http://www.latex-tutorial.com/](http://www.latex-tutorial.com/)
+* A quick guide for learning LaTeX: [Learn LaTeX in 30 minutes](https://www.overleaf.com/learn/latex/Learn_LaTeX_in_30_minutes)
diff --git a/ldpl.html.markdown b/ldpl.html.markdown
new file mode 100644
index 00000000..cc95f5fb
--- /dev/null
+++ b/ldpl.html.markdown
@@ -0,0 +1,183 @@
+---
+language: LDPL
+filename: learnLDPL.ldpl
+contributors:
+    - ["Martín del Río", "https://github.com/lartu"]
+---
+
+**LDPL** is a powerful, C++ transpiled, open-source programming language designed
+from the ground up to be excessively expressive, readable, fast and easy to learn.
+It mimics plain English, in the likeness of older programming languages like COBOL,
+with the desire that it can be understood by anybody. It's very portable and runs on a
+plethora of different architectures and operating systems and it even supports UTF-8
+out of the box.
+
+[Read more here.](https://github.com/lartu/ldpl)
+
+```coffeescript
+# This is a single line comment in LDPL.
+# LDPL doesn't have multi-line comments.
+
+# LDPL is a case-insensitive language: dIsPlaY and DISPLAY are the same
+# statement, and foo and FOO name the same variable.
+
+# An LDPL source file is divided in two sections, the DATA section and
+# the PROCEDURE section.
+
+DATA:
+# Within the DATA section, variables are declared.
+
+myNumber is number          # Defines a real number.
+myString is text            # Defines a string.
+myList is number list       # Defines a list of numbers.
+myMap  is number map        # Defines a map of numbers.
+
+# LDPL understands four data types: two scalar types (NUMBER, TEXT)
+# and two container types (LISTs and MAPs).
+# LISTs can be TEXT LISTs or NUMBER LISTs, while MAPs can be
+# TEXT MAPs and NUMBER MAPs. You can also chain many containers
+# to create larger data types:
+textListList is text list list
+myMulticontainer is number list list map 
+# Defines a map of lists of lists of numbers.
+
+PROCEDURE:
+# Within the PROCEDURE section, your code is written.
+
+store -19.2 in myNumber         # Use the STORE statement to assign values
+store "Hi there" in myString    # to variables.
+push 890 to myList # Use PUSH - TO to append values to lists.
+push 100 to myList
+push 500 to myList
+store 45 in myMap:"someIndex" # Use the : operator to index containers.
+
+push list to textListList # Push an empty list into a list of lists.
+push "LDPL is nice!" to textListList:0 #Push text to the pushed list.
+
+display "Hello World!" # Use the DISPLAY statement to print values.
+# The display statement can receive multiple values separated by spaces.
+display crlf "How are you today?" myNumber myString crlf
+# CRLF is the standard line break value in LDPL.
+display textListList:0:0 " Isn't it?" crlf
+
+# IF statements in LDPL are extremely verbose:
+if myNumber is equal to -19.2 and myList:0 is less than 900 then
+    display "Yes!" crlf
+else if myMap:"someIndex" is not equal to 45 then
+    display "This is an else if!" crlf
+else
+    display "Else!" crlf
+end if
+# Valid LDPL comparisson operators are
+# - IS EQUAL TO
+# - IS NOT EQUAL TO
+# - IS LESS THAN
+# - IS GREATER THAN
+# - IS LESS THAN OR EQUAL TO
+# - IS GREATER THAN OR EQUAL TO
+if "Hi there!" is not equal to "Bye bye!" then
+    display "Yep, those weren't equal." crlf
+end if
+# LDPL normally doesn't understand inline expressions, so you
+# cannot do stuff like:
+# if myNumber - 9 * 2 is equal to 10 then
+# LDPL will set your computer on fire and burst your screen if you do so.
+
+# WHILE loops follow the same rules
+store 0 in myNumber
+while myNumber is less than 10 do
+    display "Loop number " myNumber "..." crlf
+    in myNumber solve myNumber + 1 # You can do math like this.
+repeat
+# You can use 'break' and 'continue' inside loops just like any other language.
+
+# LDPL also has FOR loops and FOR EACH loops
+for myNumber from 0 to 100 step 2 do
+    display myNumber crlf
+repeat
+
+for each myNumber in myList do
+    display myNumber
+repeat
+
+display "Enter your name: "
+accept myString # Use ACCEPT to let the user input values.
+display "Hi there, " myString crlf
+display "How old are you?: "
+accept myNumber
+if myNumber is greater than 200 then
+    display "Woah, you are so old!" crlf
+end if
+
+wait 1000 milliseconds # Pause the program for a whole second.
+
+# Let's do some math
+store 1.2 in myNumber
+in myNumber solve myNumber * (10 / 7.2) # Operators are separated by spaces.
+floor myNumber
+display myNumber crlf
+get random in myNumber # get a random number between 0 and 1 
+                       # and store it in myNumber
+
+# Functions in LDPL are called sub-procedures. Sub-procedures, like source
+# files, are divided in sections. The sections found in sub-procedures are
+# the PARAMETERS section, the LOCAL DATA section and the PROCEDURE section.
+# All sections except the PROCEDURE section can be skipped if they aren't
+# used. If no PARAMTERS nor LOCAL DATA sections are used, the PROCEDURE
+# keyword may be omited.
+sub myFunction
+    parameters:
+        a is number # LDPL is pass by reference
+        b is number
+        result is number # Thus you can return values through a parameter.
+    local data:
+        c is number
+    procedure:
+        get random in c
+        in result solve a + b * c
+end sub
+
+sub sayHello
+    display "Hi there!" crlf
+    return
+    display "This won't be displayed :("
+end sub
+
+call myFunction with 1 2 myNumber
+display myNumber crlf
+call sayHello
+call sayBye # sub-procedures may be called before they are declared
+
+sub sayBye
+    display "Bye!"
+end sub
+
+# One of the greatest features of LDPL is the ability to create your
+# own statements.
+
+create statement "say hi" executing sayHello
+say hi
+
+create statement "random add $ and $ in $" executing myFunction
+random add 1 and 2 in myNumber
+display myNumber crlf
+
+exit
+```
+
+## Topics Not Covered
+
+ * [Command line arguments](https://docs.ldpl-lang.org/variables-in-ldpl/command-line-arguments)
+ * [Error variables](https://docs.ldpl-lang.org/variables-in-ldpl/errorcode-and-errortext)
+ * [Import other files](https://docs.ldpl-lang.org/structure-of-ldpl-source-code/importing-other-sources)
+ * [Identifier naming schemes](https://docs.ldpl-lang.org/naming-rules)
+ * [Text Statements](https://docs.ldpl-lang.org/text-statements/join-and-in)
+ * [List Statements](https://docs.ldpl-lang.org/list-statements/push-to)
+ * [Map Statements](https://docs.ldpl-lang.org/vector-statements/clear)
+ * [File loading / writing](https://docs.ldpl-lang.org/i-o-statements/load-file-in)
+ * [Executing commands](https://docs.ldpl-lang.org/i-o-statements/execute)
+ * [Extending LDPL with C++](https://docs.ldpl-lang.org/extensions/c++-extensions)
+
+## Further Reading
+
+ * [LDPL Docs](https://docs.ldpl-lang.org)
diff --git a/linker.html.markdown b/linker.html.markdown
new file mode 100644
index 00000000..ebe6233d
--- /dev/null
+++ b/linker.html.markdown
@@ -0,0 +1,9 @@
+---
+category: tool
+tool: linker
+contributors:
+    - ["Alexander Kovalchuk", "https://github.com/Zamuhrishka"]
+---
+
+This article is available in [Russian](http://localhost:4567/docs/ru-ru/linker-ru/).
+
diff --git a/logtalk.html.markdown b/logtalk.html.markdown
index 5a52bd3c..ce907ee3 100644
--- a/logtalk.html.markdown
+++ b/logtalk.html.markdown
@@ -40,7 +40,7 @@ An object encapsulates predicate declarations and definitions. Objects can be cr
 :- end_object.
 ```
 
-# Compiling source files
+# Compiling and loading source files
 
 Assuming that the code above for the `list` object is saved in a `list.lgt` file, it can be compiled and loaded using the `logtalk_load/1` built-in predicate or its abbreviation, `{}/1`, with the file path as argument (the extension can be omitted):
 
@@ -49,6 +49,11 @@ Assuming that the code above for the `list` object is saved in a `list.lgt` file
 yes
 ```
 
+In general, entities may have dependencies on entities defined in other source files (e.g. library entities). To load a file and all its dependencies, the advised solution is to define a 
+_loader_ file that loads all the necessary files for an application. A loader file is simply a source file, typically named `loader.lgt`, that makes calls to the `logtalk_load/1-2`
+built-in predicates, usually from an `initialization/1` directive for portability and
+standards compliance. Loader files are provided for all libraries, tools, and examples.
+
 # Sending a message to an object
 
 The `::/2` infix operator is used to send a message to an object. As in Prolog, we can backtrack for alternative solutions:
diff --git a/lsf/lambda-calculus-lsf.html.markdown b/lsf/lambda-calculus-lsf.html.markdown
new file mode 100644
index 00000000..88bb638f
--- /dev/null
+++ b/lsf/lambda-calculus-lsf.html.markdown
@@ -0,0 +1,91 @@
+---
+category: Algorithms & Data Structures
+name: Lambda Calculus
+contributors:
+    - ["Max Sun", "http://github.com/maxsun"]
+translators:
+    - ["Victore Leve", "https://github.com/AcProIL"]
+lang: lsf
+---
+
+# Calculo λ
+
+Calculo lambda, creato principto per Alonzo Church, es lingua de programmatura
+computatro maximo parvo. Quamquam non habe numero, serie de charactere vel ullo
+typo de data non functionale, id pote repraesenta omne machina de Turing.
+
+Tres elemento compone calculo lambda: **quantitate variabile** (q.v.),
+**functione** et **applicatione**.
+
+| Elemento             | Syntaxe                           | Exemplo   |
+|----------------------|-----------------------------------|-----------|
+| Quantitate variabile | `<nomine>`                        | `x`       |
+| Functione            | `λ<parametro>.<corpore>`          | `λx.x`    |
+| Applicatione         | `<functione><q.v. aut functione>` | `(λx.x)a` |
+
+Functione fundamentale es identitate: `λx.x` cum argumento primo `x` et cum
+corpore secundo `x`. In mathematica, nos scribe `id: x↦x`.
+
+## Quantitate variabile libero et ligato
+
+* In functione praecedente, `x` es q.v. ligato nam id es et in copore et
+  argumento.
+* In `λx.y`, `y` es q.v. libero nam non es declarato ante.
+
+## Valutatione
+
+Valutatione es facto per reductione beta (reductione β) que es essentialiter 
+substitutione lexicale.
+
+Dum valutatione de formula `(λx.x)a`, nos substitue omne evento de `x` in
+corpore de functione pro `a`.
+
+* `(λx.x)a` vale `a`
+* `(λx.y)a` vale `y`
+
+Pote etiam crea functione de ordine supero: `(λx.(λy.x))a` vale `λy.a`.
+
+Etsi calculo lambda solo tracta functione de uno parametro, nos pote crea
+functione cum plure argumento utente methodo de Curry: `λx.(λy.(λz.xyz))`
+es scriptura informatica de formula mathematico `f: x, y, z ↦ x(y(z)))`.
+
+Ergo, interdum, nos ute `λxy.<corpore>` pro `λx.λy.<corpore>`.
+
+## Arithmetica
+
+### Logica de Boole
+
+Es nec numero nec booleano in calculo lambda.
+
+* «vero» es `v = λx.λy.x`
+* «falso» es `f = λx.λy.y`
+
+Primo, nos pote defini functione «si t tunc a alio b» per `si = λtab.tab`.
+Si `t` es vero, valutatione da `(λxy.x) a b` id es `a`. Similiter si `t` es
+falso, nos obtine `b`.
+
+Secundo, nos pote defini operatore de logica:
+
+* «a et b» es `et = λa.λb.si a b f`
+* «a vel b» es `vel = λa.λb.si a t b`
+* «non a» es `non = λa.si a f t`
+
+### Numeros
+
+Nos pone:
+
+* `0 = λf.λx.x` (`0: f↦id`)
+* `1 = λf.λx.f x` (`1: f↦f`)
+* `2 = λf.λx.f(f x)` (`2: f↦f⚬f`)
+
+Cum mente generale, successore de numero `n` es `S n = λf.λx.f((n f) x)`
+(`n+1: f↦f⚬fⁿ`). Id es **`n` est functione que da `fⁿ` ex functione `f`**.
+
+Postremo additione es `λab.(a S)b`
+
+## Ut progrede
+
+### In lingua anglo
+
+1. [A Tutorial Introduction to the Lambda Calculus](http://www.inf.fu-berlin.de/lehre/WS03/alpi/lambda.pdf) per Raúl Roja
+2. [The Lambda Calculus](http://www.cs.cornell.edu/courses/cs3110/2008fa/recitations/rec26.html), CS 312 Recitation 26
diff --git a/lsf/latex-lsf.html.markdown b/lsf/latex-lsf.html.markdown
new file mode 100644
index 00000000..18c2e62b
--- /dev/null
+++ b/lsf/latex-lsf.html.markdown
@@ -0,0 +1,146 @@
+---
+language: latex
+lang: lsf
+contributors:
+    - ["Chaitanya Krishna Ande", "http://icymist.github.io"]
+    - ["Colton Kohnke", "http://github.com/voltnor"]
+    - ["Sricharan Chiruvolu", "http://sricharan.xyz"]
+translators:
+    - ["Victore Leve", "https://github.com/AcProIL"]
+filename: learn-latex-lsf.tex
+---
+
+```tex
+% Solo existe commentario monolinea, illo incipe cum charactere %
+
+% LaTeX non es sicut MS Word aut OpenOffice: que scribe non es que obtine.
+% Primo, scribe imperio (que semper incipe cum \) et secundo programma crea
+% lima.
+
+% Nos defini typo de document (id es articulo aut libro aut libello etc.).
+% Optione muta quomodo programma age, per exemplo altore de littera.
+\documentclass[12pt]{article}
+
+% Deinde nos lista paccettos que nos vol ute. Es classe de imperio que alio
+% utatore e scribe. Pote muta funda, geometria de pagina, etc. vel adde
+% functionnalitate.
+\usepackage{euler}
+\usepackage{graphicx}
+
+% Ultimo statione ante scribe documento es metadata id es titulo, auctore et
+% tempore. Charactere ~ es spatio que non pote es secato.
+\title{Disce LaTeX in~Y Minutos!}
+\author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu}
+\date{\today}
+
+% Principio de documento
+\begin{document}
+    \maketitle % Nos vol adfige metadata.
+
+    % Saepe nos adde breviario us describe texto.
+    \begin{abstract}
+        Hic es exmplo de documento sibre cum lingua de LaTeX.
+    \end{abstract}
+
+    % \section crea sectione cum titulo dato sicut sperato
+    \section{Introductione}
+
+    Traductione de hic cursu es importante.
+
+    \subsection{Methodo}
+    Iste parte non es utile.
+
+    \subsubsection{Methodo peculiare}
+    % \label da nomine ad parte ut post ute imperio de referentia \ref.
+    \label{subsec:metpec}
+
+    % Cum asteritco nos indice que nos non vol numero ante titulo de sectione.
+    \section*{Me non aestima numero…}
+
+    …sed de Peano aut de Church.
+
+    \section{Listas}
+   
+    Que me debe scribe:
+    
+    \begin{enumerate} % `enumerate` designa lista cum numeros contra `itemize`.
+        \item articulo,
+        \item libro,
+        \item cursu.
+    \end{enumerate}
+
+    \section{Mathematica}
+
+    Methematicas ute multo programma LaTeX ut communica suo decooperito.
+    Illo necessita symbolo multo instar de logica vel sagitta vel littera cum
+    accento.
+
+    % Fornula es in linea si nos scribe inter \( et \) (aut duo $) sed magno si
+    % nos ute \[ et \].
+    \(\forall n\in N_0\) % pro omne n in classe N₀
+    \[^{3}/_{4} = \frac{3}{4} < 1\] % ¾ < 1
+    
+    Alphabeta graeco contine littera $\alpha$.
+
+    % Ut scribe equatione cum numero et nomine, existe circumiecto `equation`.
+    \begin{equation}
+        c^2 = a^2 + b^2
+        \label{eq:pythagoras}
+    \end{equation}
+
+    \begin{equation}
+        % Summa ab 1 ad n de numeros dimidio de n(n+1)
+        \sum_{i=1}^n i = \frac{n(n+1)}{2}
+    \end{equation}
+
+    \section{Figura}
+
+    % Nos adde imagine `right-triangle.png` cum latitudo de quinque centimetro,
+    % horizontaliter in centro et cum capite «Triangulo recto».
+    \begin{figure}
+        \centering
+        \includegraphics[width=5cm]{right-triangle.png}
+        \caption{Triangulo recto}
+        \label{fig:right-triangle}
+    \end{figure}
+
+    \subsection{Tabula}
+
+    \begin{table}
+    \caption{Título para la tabla.}
+        % Argumento de `tabular` es lineamente de columna.
+        % c: centro, l: sinistra, r: destra, | linea verticale
+        \begin{tabular}{c|cc}
+            Numero & B & C \\
+            \hline % linea horizontale
+            1 & et & aut \\
+            2 & atque & vel
+        \end{tabular}
+    \end{table}
+
+    \section{Stylo}
+
+    Texto pote es \textbf{crasso} et \textit{italico}!
+
+    \section{Texto puro}
+
+    % Circumiecto `verbatim` ignora imperio, nos saepe ute id pro monstra
+    % programma.
+    \begin{verbatim}
+from math import tau, e
+print(e ** tau)
+    \end{verbatim}
+
+    \section{Et plus!}
+    LaTeX habe facultate crea bibliographia, paritura, scaccarip… cum paccetto
+    dedicato.
+\end{document}
+```
+
+Imperio ut conge documento es `pdflatex documento` in terminale.
+
+## Ut progrede
+
+### In lingua anglo
+
+* [LaTeX tutorial](http://www.latex-tutorial.com/) per Claudio Vellage
diff --git a/lua.html.markdown b/lua.html.markdown
index 1e2d4366..0a7c4f00 100644
--- a/lua.html.markdown
+++ b/lua.html.markdown
@@ -12,13 +12,15 @@ filename: learnlua.lua
      Adding two ['s and ]'s makes it a
      multi-line comment.
 --]]
---------------------------------------------------------------------------------
+
+----------------------------------------------------
 -- 1. Variables and flow control.
---------------------------------------------------------------------------------
+----------------------------------------------------
 
 num = 42  -- All numbers are doubles.
--- Don't freak out, 64-bit doubles have 52 bits for storing exact int
--- values; machine precision is not a problem for ints that need < 52 bits.
+-- Don't freak out, 64-bit doubles have 52 bits for
+-- storing exact int values; machine precision is
+-- not a problem for ints that need < 52 bits.
 
 s = 'walternate'  -- Immutable strings like Python.
 t = "double-quotes are also fine"
@@ -58,8 +60,8 @@ aBoolValue = false
 -- Only nil and false are falsy; 0 and '' are true!
 if not aBoolValue then print('twas false') end
 
--- 'or' and 'and' are short-circuited. This is similar to the a?b:c operator
--- in C/js:
+-- 'or' and 'and' are short-circuited.
+-- This is similar to the a?b:c operator in C/js:
 ans = aBoolValue and 'yes' or 'no'  --> 'no'
 
 karlSum = 0
@@ -79,19 +81,20 @@ repeat
   num = num - 1
 until num == 0
 
---------------------------------------------------------------------------------
+
+----------------------------------------------------
 -- 2. Functions.
---------------------------------------------------------------------------------
+----------------------------------------------------
 
 function fib(n)
-  if n < 2 then return n end
+  if n < 2 then return 1 end
   return fib(n - 2) + fib(n - 1)
 end
 
 -- Closures and anonymous functions are ok:
 function adder(x)
-  -- The returned function is created when adder is called, and remembers the
-  -- value of x:
+  -- The returned function is created when adder is
+  -- called, and remembers the value of x:
   return function (y) return x + y end
 end
 a1 = adder(9)
@@ -99,9 +102,10 @@ a2 = adder(36)
 print(a1(16))  --> 25
 print(a2(64))  --> 100
 
--- Returns, func calls, and assignments all work with lists that may be
--- mismatched in length. Unmatched receivers are nil; unmatched senders are
--- discarded.
+-- Returns, func calls, and assignments all work
+-- with lists that may be mismatched in length.
+-- Unmatched receivers are nil;
+-- unmatched senders are discarded.
 
 x, y, z = 1, 2, 3, 4
 -- Now x = 1, y = 2, z = 3, and 4 is thrown away.
@@ -114,15 +118,13 @@ end
 x, y = bar('zaphod')  --> prints "zaphod  nil nil"
 -- Now x = 4, y = 8, values 15..42 are discarded.
 
--- Functions are first-class, may be local/global. These are the same:
+-- Functions are first-class, may be local/global.
+-- These are the same:
 function f(x) return x * x end
 f = function (x) return x * x end
 
 -- And so are these:
 local function g(x) return math.sin(x) end
-local g = function(x) return math.sin(x) end
--- Equivalent to local function g(x)..., except referring to g in the function
--- body won't work as expected.
 local g; g  = function (x) return math.sin(x) end
 -- the 'local g' decl makes g-self-references ok.
 
@@ -131,16 +133,15 @@ local g; g  = function (x) return math.sin(x) end
 -- Calls with one string param don't need parens:
 print 'hello'  -- Works fine.
 
--- Calls with one table param don't need parens either (more on tables below):
-print {} -- Works fine too.
 
---------------------------------------------------------------------------------
+----------------------------------------------------
 -- 3. Tables.
---------------------------------------------------------------------------------
+----------------------------------------------------
 
--- Tables = Lua's only compound data structure; they are associative arrays.
--- Similar to php arrays or js objects, they are hash-lookup dicts that can
--- also be used as lists.
+-- Tables = Lua's only compound data structure;
+--          they are associative arrays.
+-- Similar to php arrays or js objects, they are
+-- hash-lookup dicts that can also be used as lists.
 
 -- Using tables as dictionaries / maps:
 
@@ -156,13 +157,14 @@ t.key2 = nil   -- Removes key2 from the table.
 u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'}
 print(u[6.28])  -- prints "tau"
 
--- Key matching is basically by value for numbers and strings, but by identity
--- for tables.
+-- Key matching is basically by value for numbers
+-- and strings, but by identity for tables.
 a = u['@!#']  -- Now a = 'qbert'.
 b = u[{}]     -- We might expect 1729, but it's nil:
--- b = nil since the lookup fails. It fails because the key we used is not the
--- same object as the one used to store the original value. So strings &
--- numbers are more portable keys.
+-- b = nil since the lookup fails. It fails
+-- because the key we used is not the same object
+-- as the one used to store the original value. So
+-- strings & numbers are more portable keys.
 
 -- A one-table-param function call needs no parens:
 function h(x) print(x.key1) end
@@ -182,15 +184,16 @@ v = {'value1', 'value2', 1.21, 'gigawatts'}
 for i = 1, #v do  -- #v is the size of v for lists.
   print(v[i])  -- Indices start at 1 !! SO CRAZY!
 end
--- A 'list' is not a real type. v is just a table with consecutive integer
--- keys, treated as a list.
+-- A 'list' is not a real type. v is just a table
+-- with consecutive integer keys, treated as a list.
 
---------------------------------------------------------------------------------
+----------------------------------------------------
 -- 3.1 Metatables and metamethods.
---------------------------------------------------------------------------------
+----------------------------------------------------
 
--- A table can have a metatable that gives the table operator-overloadish
--- behaviour. Later we'll see how metatables support js-prototype behaviour.
+-- A table can have a metatable that gives the table
+-- operator-overloadish behavior. Later we'll see
+-- how metatables support js-prototypey behavior.
 
 f1 = {a = 1, b = 2}  -- Represents the fraction a/b.
 f2 = {a = 2, b = 3}
@@ -200,7 +203,7 @@ f2 = {a = 2, b = 3}
 
 metafraction = {}
 function metafraction.__add(f1, f2)
-  local sum = {}
+  sum = {}
   sum.b = f1.b * f2.b
   sum.a = f1.a * f2.b + f2.a * f1.b
   return sum
@@ -211,9 +214,10 @@ setmetatable(f2, metafraction)
 
 s = f1 + f2  -- call __add(f1, f2) on f1's metatable
 
--- f1, f2 have no key for their metatable, unlike prototypes in js, so you must
--- retrieve it as in getmetatable(f1). The metatable is a normal table with
--- keys that Lua knows about, like __add.
+-- f1, f2 have no key for their metatable, unlike
+-- prototypes in js, so you must retrieve it as in
+-- getmetatable(f1). The metatable is a normal table
+-- with keys that Lua knows about, like __add.
 
 -- But the next line fails since s has no metatable:
 -- t = s + s
@@ -225,12 +229,11 @@ myFavs = {food = 'pizza'}
 setmetatable(myFavs, {__index = defaultFavs})
 eatenBy = myFavs.animal  -- works! thanks, metatable
 
---------------------------------------------------------------------------------
--- Direct table lookups that fail will retry using the metatable's __index
--- value, and this recurses.
+-- Direct table lookups that fail will retry using
+-- the metatable's __index value, and this recurses.
 
--- An __index value can also be a function(tbl, key) for more customized
--- lookups.
+-- An __index value can also be a function(tbl, key)
+-- for more customized lookups.
 
 -- Values of __index,add, .. are called metamethods.
 -- Full list. Here a is a table with the metamethod.
@@ -251,19 +254,19 @@ eatenBy = myFavs.animal  -- works! thanks, metatable
 -- __newindex(a, b, c)             for a.b = c
 -- __call(a, ...)                  for a(...)
 
---------------------------------------------------------------------------------
+----------------------------------------------------
 -- 3.2 Class-like tables and inheritance.
---------------------------------------------------------------------------------
+----------------------------------------------------
 
--- Classes aren't built in; there are different ways to make them using
--- tables and metatables.
+-- Classes aren't built in; there are different ways
+-- to make them using tables and metatables.
 
 -- Explanation for this example is below it.
 
 Dog = {}                                   -- 1.
 
 function Dog:new()                         -- 2.
-  local newObj = {sound = 'woof'}          -- 3.
+  newObj = {sound = 'woof'}                -- 3.
   self.__index = self                      -- 4.
   return setmetatable(newObj, self)        -- 5.
 end
@@ -276,59 +279,62 @@ mrDog = Dog:new()                          -- 7.
 mrDog:makeSound()  -- 'I say woof'         -- 8.
 
 -- 1. Dog acts like a class; it's really a table.
--- 2. "function tablename:fn(...)" is the same as
---    "function tablename.fn(self, ...)", The : just adds a first arg called
---    self. Read 7 & 8 below for how self gets its value.
+-- 2. function tablename:fn(...) is the same as
+--    function tablename.fn(self, ...)
+--    The : just adds a first arg called self.
+--    Read 7 & 8 below for how self gets its value.
 -- 3. newObj will be an instance of class Dog.
--- 4. "self" is the class being instantiated. Often self = Dog, but inheritance
---    can change it. newObj gets self's functions when we set both newObj's
---    metatable and self's __index to self.
+-- 4. self = the class being instantiated. Often
+--    self = Dog, but inheritance can change it.
+--    newObj gets self's functions when we set both
+--    newObj's metatable and self's __index to self.
 -- 5. Reminder: setmetatable returns its first arg.
--- 6. The : works as in 2, but this time we expect self to be an instance
---    instead of a class.
+-- 6. The : works as in 2, but this time we expect
+--    self to be an instance instead of a class.
 -- 7. Same as Dog.new(Dog), so self = Dog in new().
 -- 8. Same as mrDog.makeSound(mrDog); self = mrDog.
 
---------------------------------------------------------------------------------
+----------------------------------------------------
 
 -- Inheritance example:
 
 LoudDog = Dog:new()                           -- 1.
 
 function LoudDog:makeSound()
-  local s = self.sound .. ' '                 -- 2.
+  s = self.sound .. ' '                       -- 2.
   print(s .. s .. s)
 end
 
 seymour = LoudDog:new()                       -- 3.
 seymour:makeSound()  -- 'woof woof woof'      -- 4.
 
---------------------------------------------------------------------------------
 -- 1. LoudDog gets Dog's methods and variables.
 -- 2. self has a 'sound' key from new(), see 3.
--- 3. Same as "LoudDog.new(LoudDog)", and converted to "Dog.new(LoudDog)" as
---    LoudDog has no 'new' key, but does have "__index = Dog" on its metatable.
---    Result: seymour's metatable is LoudDog, and "LoudDog.__index = Dog". So
---    seymour.key will equal seymour.key, LoudDog.key, Dog.key, whichever
+-- 3. Same as LoudDog.new(LoudDog), and converted to
+--    Dog.new(LoudDog) as LoudDog has no 'new' key,
+--    but does have __index = Dog on its metatable.
+--    Result: seymour's metatable is LoudDog, and
+--    LoudDog.__index = LoudDog. So seymour.key will
+--    = seymour.key, LoudDog.key, Dog.key, whichever
 --    table is the first with the given key.
--- 4. The 'makeSound' key is found in LoudDog; this is the same as
---    "LoudDog.makeSound(seymour)".
+-- 4. The 'makeSound' key is found in LoudDog; this
+--    is the same as LoudDog.makeSound(seymour).
 
 -- If needed, a subclass's new() is like the base's:
 function LoudDog:new()
-  local newObj = {}
+  newObj = {}
   -- set up newObj
   self.__index = self
   return setmetatable(newObj, self)
 end
 
---------------------------------------------------------------------------------
+----------------------------------------------------
 -- 4. Modules.
---------------------------------------------------------------------------------
+----------------------------------------------------
 
 
---[[ I'm commenting out this section so the rest of this script remains
---   runnable.
+--[[ I'm commenting out this section so the rest of
+--   this script remains runnable.
 ```
 
 ```lua
@@ -354,8 +360,8 @@ local mod = require('mod')  -- Run the file mod.lua.
 local mod = (function ()
   <contents of mod.lua>
 end)()
--- It's like mod.lua is a function body, so that locals inside mod.lua are
--- invisible outside it.
+-- It's like mod.lua is a function body, so that
+-- locals inside mod.lua are invisible outside it.
 
 -- This works because mod here = M in mod.lua:
 mod.sayHello()  -- Says hello to Hrunkner.
@@ -363,19 +369,19 @@ mod.sayHello()  -- Says hello to Hrunkner.
 -- This is wrong; sayMyName only exists in mod.lua:
 mod.sayMyName()  -- error
 
--- require's return values are cached so a file is run at most once, even when
--- require'd many times.
+-- require's return values are cached so a file is
+-- run at most once, even when require'd many times.
 
 -- Suppose mod2.lua contains "print('Hi!')".
 local a = require('mod2')  -- Prints Hi!
 local b = require('mod2')  -- Doesn't print; a=b.
 
 -- dofile is like require without caching:
-dofile('mod2')  --> Hi!
-dofile('mod2')  --> Hi! (runs again, unlike require)
+dofile('mod2.lua')  --> Hi!
+dofile('mod2.lua')  --> Hi! (runs it again)
 
 -- loadfile loads a lua file but doesn't run it yet.
-f = loadfile('mod2')  -- Calling f() runs mod2.lua.
+f = loadfile('mod2.lua')  -- Call f() to run it.
 
 -- loadstring is loadfile for strings.
 g = loadstring('print(343)')  -- Returns a function.
diff --git a/m.html.markdown b/m.html.markdown
new file mode 100644
index 00000000..96828ae5
--- /dev/null
+++ b/m.html.markdown
@@ -0,0 +1,370 @@
+--- 
+language: M (MUMPS)
+contributors: 
+    - ["Fred Turkington", "http://z3ugma.github.io"] 
+filename: LEARNM.m 
+---
+
+M, or MUMPS (Massachusetts General Hospital Utility Multi-Programming System) is
+a procedural language with a built-in NoSQL database. Or, it’s a database with
+an integrated language optimized for accessing and manipulating that database.
+A key feature of M is that accessing local variables in memory and persistent
+storage use the same basic syntax, so there's no separate query
+language to remember. This makes it fast to program with, especially for
+beginners. M's syntax was designed to be concise in an era where
+computer memory was expensive and limited. This concise style means that a lot
+more fits on one screen without scrolling.
+
+The M database is a hierarchical key-value store designed for high-throughput
+transaction processing. The database is organized into tree structures called
+"globals", which are sparse data structures with parallels to modern formats
+like JSON.
+
+Originally designed in 1966 for the healthcare applications, M continues to be
+used widely by healthcare systems and financial institutions for high-throughput
+real-time applications. 
+
+### Example
+
+Here's an example M program to calculate the Fibonacci series:
+
+```
+fib ; compute the first few Fibonacci terms
+    new i,a,b,sum
+    set (a,b)=1 ; Initial conditions
+    for i=1:1 do  quit:sum>1000
+    . set sum=a+b
+    . write !,sum
+    . set a=b,b=sum
+```
+
+### Comments
+
+```
+;   Comments start with a semicolon (;)
+```
+### Data Types
+
+M has two data types:
+
+```
+;   Numbers - no commas, leading and trailing 0 removed.
+;       Scientific notation with 'E'.
+;       Floats with IEEE 754 double-precision values (15 digits of precision)
+;       Examples: 20, 1e3 (stored as 1000), 0500.20 (stored as 500.2)
+;   Strings - Characters enclosed in double quotes.
+;       "" is the null string. Use "" within a string for "
+;       Examples: "hello", "Scrooge said, ""Bah, Humbug!"""
+```
+### Commands
+
+Commands are case insensitive, and have a shortened abbreviation, often the first letter. Commands have zero or more arguments,depending on the command. M is whitespace-aware. Spaces are treated as a delimiter between commands and arguments. Each command is separated from its arguments by 1 space. Commands with zero arguments are followed by 2 spaces.
+
+#### W(rite)
+
+Print data to the current device.
+
+``` 
+WRITE !,"hello world" 
+```
+
+! is syntax for a new line. Multiple statements can be provided as additional arguments:
+
+```
+w !,"foo bar"," ","baz" 
+```
+
+#### R(ead)
+
+Retrieve input from the user
+
+```
+READ var
+r !,"Wherefore art thou Romeo? ",why
+```
+Multiple arguments can be passed to a read command. Constants are outputted. Variables are retrieved from the user. The terminal waits for the user to enter the first variable before displaying the second prompt.
+
+```
+r !,"Better one, or two? ",lorem," Better two, or three? ",ipsum
+```
+
+#### S(et)
+
+Assign a value to a variable
+
+```
+SET name="Benjamin Franklin"
+s centi=0.01,micro=10E-6
+w !,centi,!,micro
+
+;.01
+;.00001
+```
+#### K(ill)
+
+Remove a variable from memory or remove a database entry from disk.
+
+```
+KILL centi
+k micro
+```
+### Globals and Arrays
+
+In addition to local variables, M has persistent variables stored to disk called _globals_. Global names must start with a __caret__ (__^__). Globals are the built-in database of M.
+
+Any variable can be an array with the assignment of a _subscript_. Arrays are sparse and do not have a predefined size. Arrays should be visualized like trees, where subscripts are branches and assigned values are leaves. Not all nodes in an array need to have a value. 
+
+```
+s ^cars=20
+s ^cars("Tesla",1,"Name")="Model 3"
+s ^cars("Tesla",2,"Name")="Model X"
+s ^cars("Tesla",2,"Doors")=5
+
+w !,^cars 
+; 20
+w !,^cars("Tesla")
+; null value - there's no value assigned to this node but it has children
+w !,^cars("Tesla",1,"Name")
+; Model 3
+```
+
+Arrays are automatically sorted in order. Take advantage of the built-in sorting by setting your value of interest as the last child subscript of an array rather than its value.
+
+```
+; A log of temperatures by date and time
+s ^TEMPS("11/12","0600",32)=""
+s ^TEMPS("11/12","1030",48)=""
+s ^TEMPS("11/12","1400",49)=""
+s ^TEMPS("11/12","1700",43)=""
+```
+### Operators
+```jinja
+; Assignment:       =
+; Unary:            +   Convert a string value into a numeric value.
+; Arthmetic:
+;                   +   addition
+­;                   -   subtraction
+;                   *   multiplication
+;                   /   floating-point division
+;                   \   integer division
+;                   #   modulo
+;                   **  exponentiation
+; Logical:  
+;                   &   and
+;                   !   or
+;                   '   not
+; Comparison:
+;                   =   equal 
+;                   '=  not equal
+;                   >   greater than
+;                   <   less than
+;                   '>  not greater / less than or equal to
+;                   '<  not less / greater than or equal to
+; String operators:
+;                   _   concatenate
+;                   [   contains ­          a contains b 
+;                   ]]  sorts after  ­      a comes after b
+;                   '[  does not contain
+;                   ']] does not sort after
+```
+
+#### Order of operations
+
+Operations in M are _strictly_ evaluated left to right. No operator has precedence over any other.
+You should use parentheses to group expressions.
+
+```
+w 5+3*20
+;160
+;You probably wanted 65
+w 5+(3*20) 
+```
+
+### Flow Control, Blocks, & Code Structure
+
+A single M file is called a _routine_. Within a given routine, you can break your code up into smaller chunks with _tags_. The tag starts in column 1 and the commands pertaining to that tag are indented.
+
+A tag can accept parameters and return a value, this is a function. A function is called with '$$':
+
+```
+; Execute the 'tag' function, which has two parameters, and write the result.
+w !,$$tag^routine(a,b) 
+```
+
+M has an execution stack. When all levels of the stack have returned, the program ends. Levels are added to the stack with _do_ commands and removed with _quit_ commands.
+
+#### D(o)
+
+With an argument: execute a block of code & add a level to the stack. 
+
+```
+d ^routine    ;run a routine from the begining. 
+;             ;routines are identified by a caret.
+d tag         ;run a tag in the current routine
+d tag^routine ;run a tag in different routine
+```
+
+Argumentless do: used to create blocks of code. The block is indented with a period for each level of the block:
+
+```
+set a=1
+if a=1 do  
+. write !,a
+. read b
+. if b > 10 d
+. . w !, b 
+w "hello"
+```
+
+#### Q(uit)
+Stop executing this block and return to the previous stack level.
+Quit can return a value.
+
+#### N(ew)
+Clear a given variable's value _for just this stack level_. Useful for preventing side effects.
+
+Putting all this together, we can create a full example of an M routine:
+
+```
+; RECTANGLE - a routine to deal with rectangle math
+    q ; quit if a specific tag is not called
+
+main 
+    n length,width ; New length and width so any previous value doesn't persist
+    w !,"Welcome to RECTANGLE. Enter the dimensions of your rectangle."
+    r !,"Length? ",length,!,"Width? ",width
+    d area(length,width)            ;Do a tag
+    s per=$$perimeter(length,width) ;Get the value of a function
+    w !,"Perimeter: ",per
+    q
+
+area(length,width)  ; This is a tag that accepts parameters. 
+                    ; It's not a function since it quits with no value.
+    w !, "Area: ",length*width
+    q ; Quit: return to the previous level of the stack.
+
+perimeter(length,width)
+    q 2*(length+width) ; Quits with a value; thus a function
+```
+
+### Conditionals, Looping and $Order()
+
+F(or) loops can follow a few different patterns:
+
+```jinja
+;Finite loop with counter
+;f var=start:increment:stop
+
+f i=0:5:25 w i," " ;0 5 10 15 20 25 
+
+; Infinite loop with counter
+; The counter will keep incrementing forever. Use a conditional with Quit to get out of the loop.
+;f var=start:increment 
+
+f j=1:1 w j," " i j>1E3 q ; Print 1-1000 separated by a space
+
+;Argumentless for - infinite loop. Use a conditional with Quit.
+;   Also read as "forever" - f or for followed by two spaces.
+s var=""
+f  s var=var_"%" w !,var i var="%%%%%%%%%%" q  
+; %
+; %%
+; %%%
+; %%%%
+; %%%%%
+; %%%%%%
+; %%%%%%%
+; %%%%%%%%
+; %%%%%%%%%
+; %%%%%%%%%%
+
+```
+
+#### I(f), E(lse), Postconditionals
+
+M has an if/else construct for conditional evaluation, but any command can be conditionally executed without an extra if statement using a _postconditional_. This is a condition that occurs immediately after the command, separated with a colon (:).
+
+```jinja
+; Conditional using traditional if/else
+r "Enter a number: ",num
+i num>100 w !,"huge"
+e i num>10 w !,"big"
+e w !,"small"
+
+; Postconditionals are especially useful in a for loop.
+; This is the dominant for loop construct:
+;   a 'for' statement
+;   that tests for a 'quit' condition with a postconditional
+;   then 'do'es an indented block for each iteration
+
+s var=""
+f  s var=var_"%" q:var="%%%%%%%%%%" d  ;Read as "Quit if var equals "%%%%%%%%%%"
+. w !,var
+
+;Bonus points - the $L(ength) built-in function makes this even terser
+
+s var=""
+f  s var=var_"%" q:$L(var)>10  d  ;
+. w !,var
+
+```
+#### Array Looping - $Order
+As we saw in the previous example, M has built-in functions called with a single $, compared to user-defined functions called with $$. These functions have shortened abbreviations, like commands.
+One of the most useful is __$Order()__ / $O(). When given an array subscript, $O returns the next subscript in that array. When it reaches the last subscript, it returns "".
+
+```jinja
+;Let's call back to our ^TEMPS global from earlier:
+; A log of temperatures by date and time
+s ^TEMPS("11/12","0600",32)=""
+s ^TEMPS("11/12","0600",48)=""
+s ^TEMPS("11/12","1400",49)=""
+s ^TEMPS("11/12","1700",43)=""
+; Some more
+s ^TEMPS("11/16","0300",27)=""
+s ^TEMPS("11/16","1130",32)=""
+s ^TEMPS("11/16","1300",47)=""
+
+;Here's a loop to print out all the dates we have temperatures for:
+n date,time ; Initialize these variables with ""
+
+; This line reads: forever; set date as the next date in ^TEMPS.
+; If date was set to "", it means we're at the end, so quit.
+; Do the block below
+f  s date=$ORDER(^TEMPS(date)) q:date="" d
+. w !,date
+
+; Add in times too:
+f  s date=$ORDER(^TEMPS(date)) q:date=""  d
+. w !,"Date: ",date
+. f  s time=$O(^TEMPS(date,time)) q:time=""  d
+. . w !,"Time: ",time
+
+; Build an index that sorts first by temperature - 
+; what dates and times had a given temperature?
+n date,time,temp
+f  s date=$ORDER(^TEMPS(date)) q:date=""  d
+. f  s time=$O(^TEMPS(date,time)) q:time=""  d
+. . f  s temp=$O(^TEMPS(date,time,temp)) q:temp=""  d
+. . . s ^TEMPINDEX(temp,date,time)=""
+
+;This will produce a global like
+^TEMPINDEX(27,"11/16","0300")
+^TEMPINDEX(32,"11/12","0600")
+^TEMPINDEX(32,"11/16","1130")
+```
+
+## Further Reading
+
+There's lots more to learn about M. A great short tutorial comes from the University of Northern Iowa and  Professor Kevin O'Kane's [Introduction to the MUMPS Language][1] presentation.
+
+To install an M interpreter / database on your computer, try a [YottaDB Docker image][2]. 
+
+YottaDB and its precursor, GT.M, have thorough documentation on all the language features including database transactions, locking, and replication:
+
+* [YottaDB Programmer's Guide][3]
+* [GT.M Programmer's Guide][4]
+
+[1]: https://www.cs.uni.edu/~okane/source/MUMPS-MDH/MumpsTutorial.pdf 
+[2]: https://yottadb.com/product/get-started/
+[3]: https://docs.yottadb.com/ProgrammersGuide/langfeat.html
+[4]: http://tinco.pair.com/bhaskar/gtm/doc/books/pg/UNIX_manual/index.html
diff --git a/make.html.markdown b/make.html.markdown
index 45d020e9..eecc96bf 100644
--- a/make.html.markdown
+++ b/make.html.markdown
@@ -1,5 +1,6 @@
 ---

-language: make

+category: tool

+tool: make

 contributors:

     - ["Robert Steed", "https://github.com/robochat"]

     - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]

diff --git a/markdown.html.markdown b/markdown.html.markdown
index ece2567c..cf4286e2 100644
--- a/markdown.html.markdown
+++ b/markdown.html.markdown
@@ -197,7 +197,7 @@ inside your code
     end
 ```
 
-Inline code can be created using the backtick character `
+Inline code can be created using the backtick character `` ` ``
 
 ```md
 John didn't even know what the `go_to()` function did!
diff --git a/matlab.html.markdown b/matlab.html.markdown
index b88b1c03..5790bcc6 100644
--- a/matlab.html.markdown
+++ b/matlab.html.markdown
@@ -221,11 +221,11 @@ A(1, :) =[] % Delete the first row of the matrix
 A(:, 1) =[] % Delete the first column of the matrix
 
 transpose(A) % Transpose the matrix, which is the same as:
-A one
-ctranspose(A) % Hermitian transpose the matrix
-% (the transpose, followed by taking complex conjugate of each element)
-A' % Concise version of complex transpose
 A.' % Concise version of transpose (without taking complex conjugate)
+ctranspose(A) % Hermitian transpose the matrix, which is the same as:
+A'  % Concise version of complex transpose
+    % (the transpose, followed by taking complex conjugate of each element)
+
 
 
 
diff --git a/mercurial.html.markdown b/mercurial.html.markdown
new file mode 100644
index 00000000..98658f83
--- /dev/null
+++ b/mercurial.html.markdown
@@ -0,0 +1,355 @@
+---
+category: tool
+tool: Mercurial
+contributors:
+  - ["Will L. Fife", "http://github.com/sarlalian"]
+filename: LearnMercurial.txt
+---
+
+Mercurial is a free, distributed source control management tool. It offers
+you the power to efficiently handle projects of any size while using an
+intuitive interface. It is easy to use and hard to break, making it ideal for
+anyone working with versioned files.
+
+## Versioning Concepts
+
+### What is version control?
+
+Version control is a system that keeps track fo changes to a set of file(s)
+and/or directorie(s) over time.
+
+### Why use Mercurial?
+
+* Distributed Architecture - Traditionally version control systems such as CVS
+and Subversion are a client server architecture with a central server to
+store the revsion history of a project. Mercurial however is a truly
+distributed architecture, giving each devloper a full local copy of the
+entire development history. It works independently of a central server.
+* Fast - Traditionally version control systems such as CVS and Subversion are a
+client server architecture with a central server to store the revsion history
+of a project. Mercurial however is a truly distributed architecture, giving
+each devloper a full local copy of the entire development history. It works
+independently of a central server.
+* Platform Independent - Mercurial was written to be highly platform
+independent. Much of Mercurial is written in Python, with small performance
+critical parts written in portable C. Binary releases are available for all
+major platforms.
+* Extensible - The functionality of Mercurial can be increased with extensions,
+either by activating the official ones which are shipped with Mercurial or
+downloading some [from the wiki](https://www.mercurial-scm.org/wiki/UsingExtensions) or by [writing your own](https://www.mercurial-scm.org/wiki/WritingExtensions). Extensions are written in
+Python and can change the workings of the basic commands, add new commands and
+access all the core functions of Mercurial.
+* Easy to use - The Mercurial command set is consistent with what subversion
+users would expect, so they are likely to feel right at home. Most dangerous
+actions are part of extensions that need to be enabled to be used.
+* Open Source - Mercurial is free software licensed under the terms of the [GNU
+General Public License Version 2](http://www.gnu.org/licenses/gpl-2.0.txt) or
+any later version.
+
+## Terminology
+
+| Term | Definition |
+| ------------- | ---------------------------------- |
+| Repository | A repository is a collection of revisions |
+| hgrc | A configuration file which stores the defaults for a repository. |
+| revision | A committed changeset: has a REV number |
+| changeset | Set of changes saved as diffs |
+| diff | Changes between file(s) |
+| tag | A named named revision |
+| parent(s) | Immediate ancestor(s) of a revison |
+| branch | A child of a revision |
+| head | A head is a changeset with no child changesets |
+| merge | The process of merging two HEADS |
+| tip | The latest revision in any branch |
+| patch | All of the diffs between two revisions |
+| bundle | Patch with permis­sions and rename support |
+
+## Commands
+
+### init
+
+Create a new repository in the given directory, the settings and stored
+information are in a directory named `.hg`.
+
+```bash
+$ hg init
+```
+
+### help
+
+Will give you access to a very detailed description of each command.
+
+```bash 
+# Quickly check what commands are available
+$ hg help
+
+# Get help on a specific command
+# hg help <command>
+$ hg help add
+$ hg help commit
+$ hg help init
+```
+
+### status
+
+Show the differences between what is on disk and what is committed to the current
+branch or tag.
+
+```bash
+# Will display the status of files
+$ hg status
+
+# Get help on the status subcommand
+$ hg help status
+```
+
+### add
+
+Will add the specified files to the repository on the next commit.
+
+```bash
+# Add a file in the current directory
+$ hg add filename.rb
+
+# Add a file in a sub directory
+$ hg add foo/bar/filename.rb
+
+# Add files by pattern
+$ hg add *.rb
+```
+
+### branch
+
+Set or show the current branch name.
+
+*Branch names are permanent and global. Use 'hg bookmark' to create a
+light-weight bookmark instead. See 'hg help glossary' for more information
+about named branches and bookmarks.*
+
+```bash
+# With no argument it shows the current branch name
+$ hg branch
+
+# With a name argument it will change the current branch.
+$ hg branch new_branch
+marked working directory as branch new_branch
+(branches are permanent and global, did you want a bookmark?)
+```
+
+### tag
+
+Add one or more tags for the current or given revision.
+
+Tags are used to name particular revisions of the repository and are very
+useful to compare different revisions, to go back to significant earlier
+versions or to mark branch points as releases, etc. Changing an existing tag
+is normally disallowed; use -f/--force to override.
+
+```bash
+# List tags
+$ hg tags
+tip                                2:efc8222cd1fb
+v1.0                               0:37e9b57123b3
+
+# Create a new tag on the current revision
+$ hg tag v1.1
+
+# Create a tag on a specific revision
+$ hg tag -r efc8222cd1fb v1.1.1
+```
+
+### clone
+
+Create a copy of an existing repository in a new directory.
+
+If no destination directory name is specified, it defaults to the basename of
+the source.
+
+```bash
+# Clone a remote repo to a local directory
+$ hg clone https://some-mercurial-server.example.com/reponame
+
+# Clone a local repo to a remote server
+$ hg clone . ssh://username@some-mercurial-server.example.com/newrepo
+
+# Clone a local repo to a local repo
+$ hg clone . /tmp/some_backup_dir
+```
+
+### commit / ci
+
+Commit changes to the given files into the repository. 
+
+```bash
+# Commit with a message
+$ hg commit -m 'This is a commit message'
+
+# Commit all added / removed files in the currrent tree
+$ hg commit -A 'Adding and removing all existing files in the tree'
+
+# amend the parent of the working directory with a new commit that contains the
+# changes in the parent in addition to those currently reported by 'hg status',
+$ hg commit --amend -m "Correct message"
+```
+
+### diff
+
+Show differences between revisions for the specified files using the unified
+diff format.
+
+```bash
+# Show the diff between the current directory and a previous revision
+$ hg diff -r 10
+
+# Show the diff between two previous revisions
+$ hg diff -r 30 -r 20
+```
+
+### grep
+
+Search revision history for a pattern in specified files.
+
+```bash
+# Search files for a specific phrase
+$ hg grep "TODO:"
+```
+
+### log / history
+
+Show revision history of entire repository or files. If no revision range is
+specified, the default is "tip:0" unless --follow is set, in which case the
+working directory parent is used as the starting revision.
+
+```bash
+# Show the history of the entire repository
+$ hg log
+
+# Show the history of a single file
+$ hg log myfile.rb
+
+# Show the revision changes as an ASCII art DAG with the most recent changeset
+# at the top.
+$ hg log -G
+```
+
+### merge
+
+Merge another revision into working directory.
+
+```bash
+# Merge changesets to local repository
+$ hg merge
+
+# Merge from a named branch or revision into the current local branch
+$ hg merge branchname_or_revision
+
+# After successful merge, commit the changes
+hg commit
+```
+
+### move / mv / rename
+
+Rename files; equivalent of copy + remove. Mark dest as copies of sources;
+mark sources for deletion. If dest is a directory, copies are put in that
+directory. If dest is a file, there can only be one source.
+
+```bash
+# Rename a single file
+$ hg mv foo.txt bar.txt
+
+# Rename a directory
+$ hg mv some_directory new_directory
+```
+
+### pull
+
+Pull changes from a remote repository to a local one.
+
+```bash
+# List remote paths
+$ hg paths
+remote1 = http://path/to/remote1
+remote2 = http://path/to/remote2
+
+# Pull from remote 1
+$ hg pull remote1
+
+# Pull from remote 2
+$ hg pull remote2
+```
+
+### push
+
+Push changesets from the local repository to the specified destination.
+
+```bash
+# List remote paths
+$ hg paths
+remote1 = http://path/to/remote1
+remote2 = http://path/to/remote2
+
+# Pull from remote 1
+$ hg push remote1
+
+# Pull from remote 2
+$ hg push remote2
+```
+
+### rebase
+
+Move changeset (and descendants) to a different branch.
+
+Rebase uses repeated merging to graft changesets from one part of history
+(the source) onto another (the destination). This can be useful for
+linearizing *local* changes relative to a master development tree.
+
+* Draft the commits back to the source revision.
+* -s is the source, ie. what you are rebasing.
+* -d is the destination, which is where you are sending it.
+
+```bash
+# Put the commits into draft status
+# This will draft all subsequent commits on the relevant branch
+$ hg phase --draft --force -r 1206
+
+# Rebase from from revision 102 over revision 208
+$ hg rebase -s 102 -d 208
+```
+
+### revert
+
+Restore files to their checkout state. With no revision specified, revert the
+specified files or directories to the contents they had in the parent of the
+working directory. This restores the contents of files to an unmodified state
+and unschedules adds, removes, copies, and renames. If the working directory
+has two parents, you must explicitly specify a revision.
+
+```bash
+# Reset a specific file to its checked out state
+$ hg revert oops_i_did_it_again.txt
+
+# Revert a specific file to its checked out state without leaving a .orig file
+# around
+$ hg revert -C oops_i_did_it_again.txt
+
+# Revert all changes
+$ hg revert -a
+```
+
+### rm / remove
+
+Remove the specified files on the next commit.
+
+```bash
+# Remove a spcific file
+$ hg remove go_away.txt
+
+# Remove a group of files by pattern
+$ hg remove *.txt
+```
+
+## Further information
+
+* [Learning Mercurial in Workflows](https://www.mercurial-scm.org/guide)
+* [Mercurial Quick Start](https://www.mercurial-scm.org/wiki/QuickStart)
+* [Mercurial: The Definitive Guide by Bryan O'Sullivan](http://hgbook.red-bean.com/)
diff --git a/mercury.html.markdown b/mercury.html.markdown
new file mode 100644
index 00000000..f749bac4
--- /dev/null
+++ b/mercury.html.markdown
@@ -0,0 +1,263 @@
+---
+language: mercury
+contributors:
+    - ["Julian Fondren", "https://mercury-in.space/"]
+---
+
+Mercury is a strict, pure functional/logic programming language, with
+influences from Prolog, ML, and Haskell.
+
+```prolog
+% Percent sign starts a one-line comment.
+
+    % foo(Bar, Baz)
+    %
+    % Documentation comments are indented before what they describe.
+:- pred foo(bar::in, baz::out) is det.
+
+% All toplevel syntax elements end with a '.' -- a full stop.
+
+% Mercury terminology comes from predicate logic. Very roughly:
+
+% | Mercury               | C                            |
+% |                       |                              |
+% | Goal                  | statement                    |
+% | expression            | expression                   |
+% | predicate rule        | void function                |
+% | function rule         | function                     |
+% | head (of a rule)      | function name and parameters |
+% | body (of a rule)      | function body                |
+% | fact                  | (rule without a body)        |
+% | pred/func declaration | function signature           |
+% | A, B  (conjunction)   | A && B                       |
+% | A ; B (disjunction)   | if (A) {} else if (B) {}     |
+
+% some facts:
+man(socrates).  % "it is a fact that Socrates is a man"
+man(plato).
+man(aristotle).
+
+% a rule:
+mortal(X) :- man(X).  % "It is a rule that X is a mortal if X is a man."
+%            ^^^^^^-- the body of the rule
+%         ^^-- an arrow <--, pointing to the head from the body
+%^^^^^^^^-- the head of the rule
+% this is also a single clause that defines the rule.
+
+% that X is capitalized is how you know it's a variable.
+% that socrates is uncapitalized is how you know it's a term.
+
+% it's an error for 'socrates' to be undefined. It must have a type:
+
+% declarations begin with ':-'
+:- type people
+    --->    socrates
+    ;       plato
+    ;       aristotle
+    ;       hermes.
+    %<--first tab stop (using 4-space tabs)
+            %<--third tab stop (first after --->)
+
+:- pred man(people).  % rules and facts also require types
+
+% a rule's modes tell you how it can be used.
+:- mode man(in) is semidet.  % man(plato) succeeds. man(hermes) fails.
+:- mode man(out) is multi.   % man(X) binds X to one of socrates ; plato ; aristotle
+
+% a semidet predicate is like a test. It doesn't return a value, but
+% it can succeed or fail, triggering backtracking or the other side of
+% a disjunction or conditional.
+
+% 'is semidet' provides the determinism of a mode. Other determinisms:
+% | Can fail? | 0 solutions | 1       | more than 1 |
+% |           |             |         |             |
+% | no        | erroneous   | det     | multi       |
+% | yes       | failure     | semidet | nondet      |
+
+:- pred mortal(people::in) is semidet.  % type/mode in one declaration
+
+% this rule's body consists of two conjunctions: A, B, C
+% this rule is true if A, B, and C are all true.
+% if age(P) returns 16, it fails.
+% if alive(P) fails, it fails.
+:- type voter(people::in) is semidet.
+voter(P) :-
+    alive(P),
+    registered(P, locale(P)),
+    age(P) >= 18.  % age/1 is a function; int.>= is a function used as an operator
+
+% "a P is a voter if it is alive, is registered in P's locale, and if
+% P's age is 18 or older."
+
+% the >= used here is provided by the 'int' module, which isn't
+% imported by default. Mercury has a very small 'Prelude' (the
+% 'builtin' module). You even need to import the 'list' module if
+% you're going to use list literals.
+```
+
+Complete runnable example. File in 'types.m'; compile with 'mmc --make types'.
+
+```prolog
+:- module types.
+:- interface.
+:- import_module io.  % required for io.io types in...
+% main/2 is usually 'det'. threading and exceptions require 'cc_multi'
+:- pred main(io::di, io::uo) is cc_multi.  % program entry point
+:- implementation.
+:- import_module int, float, string, list, bool, map, exception.
+
+% enum.
+:- type days
+    --->    sunday
+    ;       monday
+    ;       tuesday
+    ;       wednesday
+    ;       thursday
+    ;       friday
+    ;       saturday.
+
+% discriminated union, like datatype in ML.
+:- type payment_method
+    --->    cash(int)
+    ;       credit_card(
+                name :: string,         % named fields
+                cc_number :: string,
+                cvv :: int,
+                expiration :: string
+            )
+    ;       crypto(coin_type, wallet, amount).
+
+:- type coin_type
+    --->    etherium
+    ;       monero.  % "other coins are available"
+
+% type aliases.
+:- type wallet == string.
+:- type amount == int.
+
+% !IO is the pair of io.io arguments
+% pass it to anything doing I/O, in order to perform I/O.
+% many otherwise-impure functions can 'attach to the I/O state' by taking !IO
+main(!IO) :-
+    Ints = [
+        3,
+        1 + 1,
+        8 - 1,
+        10 * 2,
+        35 / 5,
+        5 / 2,      % truncating division
+        int.div(5, 2),  % floored division
+        div(5, 2),  % (module is unambiguous due to types)
+        5 `div` 2,  % (any binary function can be an operator with ``)
+        7 `mod` 3,  % modulo of floored division
+        7 `rem` 3,  % remainder of truncating division
+        2 `pow` 4,  % 2 to the 4th power
+        (1 + 3) * 2,    % parens have their usual meaning
+
+        2 >> 3,     % bitwise right shift
+        128 << 3,   % bitwise left shift
+        \ 0,        % bitwise complement
+        5 /\ 1,     % bitwise and
+        5 \/ 1,     % bitwise or
+        5 `xor` 3,  % bitwise xor
+
+        max_int,
+        min_int,
+
+        5 `min` 3,  % ( if 5 > 3 then 3 else 5 )
+        5 `max` 3
+    ],
+    Bools = [
+        yes,
+        no
+        % bools are much less important in Mercury because control flow goes by
+        % semidet goals instead of boolean expressions.
+    ],
+    Strings = [
+        "this is a string",
+        "strings can have "" embedded doublequotes via doubling",
+        "strings support \u4F60\u597D the usual escapes\n",
+        % no implicit concatenation of strings: "concat:" "together"
+        "but you can " ++ " use the string.++ operator",
+
+        % second param is a list(string.poly_type)
+        % s/1 is a function that takes a string and returns a poly_type
+        % i/1 takes an int. f/1 takes a float. c/1 takes a char.
+        string.format("Hello, %d'th %s\n", [i(45), s("World")])
+    ],
+
+    % start with purely functional types like 'map' and 'list'!
+    % arrays and hash tables are available too, but using them
+    % requires knowing a lot more about Mercury
+    get_map1(Map1),
+    get_map2(Map2),
+
+    % list.foldl has *many* variations
+    % this one calls io.print_line(X, !IO) for each X of the list
+    foldl(io.print_line, Ints, !IO),
+    foldl(io.print_line, Bools, !IO),
+    foldl(io.print_line, Strings, !IO),
+    io.print_line(Map1, !IO),
+    % ( if Cond then ThenGoal else ElseGoal )
+    % I/O not allowed in Cond: I/O isn't allowed to fail!
+    ( if Map2^elem(42) = Elem then
+        io.print_line(Elem, !IO)
+    else % always required
+        true  % do nothing, successfully (vs. 'fail')
+    ),
+
+    % exception handling:
+    ( try [io(!IO)] ( % io/1 param required or no I/O allowed here
+        io.print_line(received(cash(1234)), !IO),
+        io.print_line(received(crypto(monero, "invalid", 123)), !IO)
+    ) then
+        io.write_string("all payments accepted\n", !IO) % never reached
+    catch "monero not yet supported" -> % extremely specific catch!
+        io.write_string("monero payment failed\n", !IO)
+    ).
+
+:- pred get_map1(map(string, int)::out) is det.
+get_map1(!:Map) :-  % !:Map in the head is the final (free, unbound) Map
+    !:Map = init,   % !:Map in the body is the next Map
+    det_insert("hello", 1, !Map),  % pair of Map vars
+    det_insert("world", 2, !Map),
+
+    % debug print of current (bound) Map
+    % other [Params] can make it optional per runtime or compiletime flags
+    trace [io(!IO)] (io.print_line(!.Map, !IO)),
+
+    det_insert_from_corresponding_lists(K, V, !Map),
+    % this code is reordered so that K and V and defined prior to their use
+    K = ["more", "words", "here"],
+    V = [3, 4, 5].
+
+:- pred get_map2(map(int, bool)::out) is det.
+get_map2(Map) :-
+    det_insert(42, yes, map.init, Map).
+
+:- func received(payment_method) = string.
+received(cash(N)) = string.format("received %d dollars", [i(N)]).
+received(credit_card(_, _, _, _)) = "received credit card".  % _ is throwaway
+received(crypto(Type, _Wallet, Amount)) = S :-  % _Wallet is named throwaway
+    ( % case/switch structure
+        Type = etherium,
+        S = string.format("receiving %d ETH", [i(Amount)])
+    ;
+        Type = monero,
+        throw("monero not yet supported")  % exception with string as payload
+    ).
+```
+
+## That was quick! Want more?
+
+### More Tutorials
+
+* [Mercury Tutorial](https://mercurylang.org/documentation/papers/book.pdf) (pdf link) - a more traditional tutorial with a more relaxed pace
+* [Mercury Crash Course](https://mercury-in.space/crash.html) - a dense example-driven tutorial with Q&A format
+* [Github Wiki Tutorial](https://github.com/Mercury-Language/mercury/wiki/Tutorial)
+* [Getting Started with Mercury](https://bluishcoder.co.nz/2019/06/23/getting-started-with-mercury.html) - installation and your first steps
+  
+### Documentation
+
+* Language manual, user's guide, and library reference are all at
+  [mercurylang.org](https://mercurylang.org/documentation/documentation.html)
diff --git a/mips.html.markdown b/mips.html.markdown
index 1133f769..4134d3fa 100644
--- a/mips.html.markdown
+++ b/mips.html.markdown
@@ -12,7 +12,7 @@ gateways and routers.
 
 [Read More](https://en.wikipedia.org/wiki/MIPS_architecture)
 
-```assembly
+```asm
 # Comments are denoted with a '#'
 
 # Everything that occurs after a '#' will be ignored by the assembler's lexer.
diff --git a/montilang.html.markdown b/montilang.html.markdown
new file mode 100644
index 00000000..cceb7aa1
--- /dev/null
+++ b/montilang.html.markdown
@@ -0,0 +1,233 @@
+---
+language: "montilang"
+filename: montilang.ml
+contributors:
+  - ["Leo Whitehead", "https://github.com/lduck11007"]
+---
+
+MontiLang is a Stack-Oriented concatenative imperative programming language. Its syntax
+is roughly based off of forth with similar style for doing arithmetic in [reverse polish notation.](https://en.wikipedia.org/wiki/Reverse_Polish_notation)
+
+A good way to start with MontiLang is to read the documentation and examples at [montilang.ml](http://montilang.ml),
+then download MontiLang or build from source code with the instructions provided.
+
+```
+/# Monti Reference sheet #/
+/#
+Comments are multiline
+Nested comments are not supported 
+#/
+/# Whitespace is all arbitrary, indentation is optional #/
+/# All programming in Monti is done by manipulating the parameter stack 
+arithmetic and stack operations in MontiLang are similar to FORTH
+https://en.wikipedia.org/wiki/Forth_(programming_language)
+#/
+
+/# in Monti, everything is either a string or a number. Operations treat all numbers
+similarly to floats, but anything without a remainder is treated as type int #/
+
+/# numbers and strings are added to the stack from left to right #/
+
+/# Arithmetic works by manipulating data on the stack #/
+
+5 3 + PRINT . /# 8 #/
+
+/#  5 and 3 are pushed onto the stack
+    '+' replaces top 2 items on stack with sum of top 2 items
+    'PRINT' prints out the top item on the stack
+    '.' pops the top item from the stack. 
+    #/
+
+6 7 * PRINT . /# 42 #/
+1360 23 - PRINT . /# 1337 #/
+12 12 / PRINT . /# 1 #/
+13 2 % PRINT . /# 1 #/
+
+37 NEG PRINT . /# -37 #/
+-12 ABS PRINT . /# 12 #/
+52 23 MAX PRINT . /# 52 #/
+52 23 MIN PRINT . /# 23 #/
+
+/# 'PSTACK' command prints the entire stack, 'CLEAR' clears the entire stack #/
+
+3 6 8 PSTACK CLEAR /# [3, 6, 8] #/
+
+/# Monti comes with some tools for stack manipulation #/
+
+2 DUP PSTACK CLEAR /# [2, 2] - Duplicate the top item on the stack#/
+2 6 SWAP PSTACK CLEAR /# [6, 2] - Swap top 2 items on stack #/
+1 2 3 ROT PSTACK CLEAR /# [2, 3, 1] - Rotate top 3 items on stack #/
+2 3 NIP PSTACK CLEAR /# [3] - delete second item from the top of the stack #/
+4 5 6 TRIM PSTACK CLEAR /# [5, 6] - Deletes first item on stack #/
+/# variables are assigned with the syntax 'VAR [name]'#/
+/# When assigned, the variable will take the value of the top item of the stack #/
+
+6 VAR six . /# assigns var 'six' to be equal to 6 #/
+3 6 + VAR a . /# assigns var 'a' to be equal to 9 #/
+
+/# the length of the stack can be calculated with the statement 'STKLEN' #/
+1 2 3 4 STKLEN PRINT CLEAR /# 4 #/
+
+/# strings are defined with | | #/
+
+|Hello World!| VAR world . /# sets variable 'world' equal to string 'Hello world! #/ 
+
+/# variables can be called by typing its name. when called, the value of the variable is pushed
+to the top of the stack #/
+world PRINT .
+
+/# with the OUT statement, the top item on the stack can be printed without a newline #/
+
+|world!| |Hello, | OUT SWAP PRINT CLEAR
+
+/# Data types can be converted between strings and integers with the commands 'TOINT' and 'TOSTR'#/
+|5| TOINT PSTACK . /# [5] #/
+45 TOSTR PSTACK . /# ['45'] #/
+
+/# User input is taken with INPUT and pushed to the stack. If the top item of the stack is a string, 
+the string is used as an input prompt #/
+
+|What is your name? | INPUT NIP 
+|Hello, | OUT SWAP PRINT CLEAR
+
+
+/# FOR loops have the syntax 'FOR [condition] [commands] ENDFOR' At the moment, [condition] can
+only have the value of an integer. Either by using an integer, or a variable call to an integer.
+[commands] will be interpereted the amount of time specified in [condition] #/
+/# E.G: this prints out 1 to 10 #/
+
+1 VAR a .
+FOR 10
+    a PRINT 1 + VAR a
+ENDFOR
+
+/# the syntax for while loops are similar. A number is evaluated as true if it is larger than
+0. a string is true if its length > 0. Infinite loops can be used by using literals.
+#/
+10 var loop .
+WHILE loop
+    loop print 
+    1 - var loop
+ENDWHILE
+/#
+this loop would count down from 10.
+
+IF statements are pretty much the same, but only are executed once.
+#/
+IF loop
+ loop PRINT .
+ENDIF
+
+/# This would only print 'loop' if it is larger than 0 #/
+
+/# If you would want to use the top item on the stack as loop parameters, this can be done with the ':' character #/
+
+/# eg, if you wanted to print 'hello' 7 times, instead of using #/
+
+FOR 7
+    |hello| PRINT .
+ENDFOR
+
+/# this could be used #/
+7
+FOR : 
+    |hello| PRINT .
+ENDFOR
+
+/# Equality and inequality statements use the top 2 items on the stack as parameters, and replace the top two items with the output #/
+/# If it is true, the top 2 items are replaced with '1'. If false, with '0'. #/
+
+7 3 > PRINT . /# 1 #/
+2 10 > PRINT . /# 0 #/
+5 9 <= PRINT . /# 1 #/
+5 5 == PRINT . /# 1 #/
+5 7 == PRINT . /# 0 #/
+3 8 != PRINT . /# 1 #/
+
+/# User defined commands have the syntax of 'DEF [name] [commands] ENDDEF'. #/
+/# eg, if you wanted to define a function with the name of 'printseven' to print '7' 10 times, this could be used #/
+
+DEF printseven
+    FOR 10
+       7 PRINT .
+    ENDFOR
+ENDDEF
+
+/# to run the defined statement, simply type it and it will be run by the interpereter #/
+
+printseven
+
+/# Montilang supports AND, OR and NOT statements #/
+
+1 0 AND PRINT . /# 0 #/
+1 1 AND PRINT . /# 1 #/
+1 0 OR PRINT . /# 1 #/
+0 0 OR PRINT . /# 0 #/
+1 NOT PRINT . /# 0 #/
+0 NOT PRINT . /# 1 #/
+
+/# Preprocessor statements are made inbetween '&' characters #/
+/# currently, preprocessor statements can be used to make c++-style constants #/
+
+&DEFINE LOOPSTR 20&
+/# must have & on either side with no spaces, 'DEFINE' is case sensative. #/
+/# All statements are scanned and replaced before the program is run, regardless of where the statements are placed #/
+
+FOR LOOPSTR 7 PRINT . ENDFOR /# Prints '7' 20 times. At run, 'LOOPSTR' in source code is replaced with '20' #/ 
+
+/# Multiple files can be used with the &INCLUDE <filename>& Command that operates similar to c++, where the file specified is tokenized,
+   and the &INCLUDE statement is replaced with the file #/
+   
+/# E.G, you can have a program be run through several files. If you had the file 'name.mt' with the following data:
+
+[name.mt]
+|Hello, | OUT . name PRINT .
+
+a program that asks for your name and then prints it out can be defined as such: #/
+
+|What is your name? | INPUT VAR name . &INCLUDE name.mt&
+
+/# ARRAYS: #/
+
+/# arrays are defined with the statement 'ARR'
+When called, everything currently in the stack is put into one
+array and all items on the stack are replaced with the new array. #/
+
+2 3 4 ARR PSTACK . /# [[2, 3, 4]] #/
+
+/# the statement 'LEN' adds the length of the last item on the stack to the stack.
+This can be used on arrays, as well as strings. #/
+
+3 4 5 ARR LEN PRINT . /# 3 #/
+
+/# values can be appended to an array with the statement 'APPEND' #/
+
+1 2 3 ARR 5 APPEND . PRINT . /# [1, 2, 3, 5] #/
+
+/# an array at the top of the stack can be wiped with the statement 'WIPE' #/
+3 4 5 ARR WIPE PRINT . /# [] #/
+
+/# The last item of an array can be removed with the statement 'DROP' #/
+
+3 4 5 ARR DROP PRINT . /# [3, 4]
+/# arrays, like other datatypes can be stored in variables #/
+5 6 7 ARR VAR list .
+list PRINT . /# [5, 6, 7] #/
+
+/# Values at specific indexes can be changed with the statement 'INSERT <index>' #/
+4 5 6 ARR 
+97 INSERT 1 . PRINT /# 4, 97, 6 #/
+
+/# Values at specific indexes can be deleted with the statement 'DEL <index>' #/
+1 2 3 ARR
+DEL 1 PRINT . /# [1, 3] #/
+
+/# items at certain indexes of an array can be gotten with the statement 'GET <index>' #/
+
+1 2 3 ARR GET 2 PSTACK /# [[1, 2, 3], 3] #/
+```
+
+## Extra information
+
+- [MontiLang.ml](http://montilang.ml/)
+- [Github Page](https://github.com/lduck11007/MontiLang)
diff --git a/moonscript.html.markdown b/moonscript.html.markdown
new file mode 100644
index 00000000..941578e7
--- /dev/null
+++ b/moonscript.html.markdown
@@ -0,0 +1,570 @@
+---
+language: moonscript
+contributors:
+  - ["RyanSquared", "https://ryansquared.github.io/"]
+  - ["Job van der Zwan", "https://github.com/JobLeonard"]
+filename: moonscript.moon
+---
+
+MoonScript is a dynamic scripting language that compiles into Lua. It gives
+you the power of one of the fastest scripting languages combined with a
+rich set of features.
+
+See [the MoonScript website](https://moonscript.org/) to see official guides on installation for all platforms.
+
+```moon
+-- Two dashes start a comment. Comments can go until the end of the line.
+-- MoonScript transpiled to Lua does not keep comments.
+
+-- As a note, MoonScript does not use 'do', 'then', or 'end' like Lua would and
+-- instead uses an indented syntax, much like Python.
+
+--------------------------------------------------
+-- 1. Assignment
+--------------------------------------------------
+
+hello = "world"
+a, b, c = 1, 2, 3
+hello = 123 -- Overwrites `hello` from above.
+
+x = 0
+x += 10 -- x = x + 10
+
+s = "hello "
+s ..= "world" -- s = s .. "world"
+
+b = false
+b and= true or false -- b = b and (true or false)
+
+--------------------------------------------------
+-- 2. Literals and Operators
+--------------------------------------------------
+
+-- Literals work almost exactly as they would in Lua. Strings can be broken in
+-- the middle of a line without requiring a \.
+
+some_string = "exa
+mple" -- local some_string = "exa\nmple"
+
+-- Strings can also have interpolated values, or values that are evaluated and
+-- then placed inside of a string.
+
+some_string = "This is an #{some_string}" -- Becomes 'This is an exa\nmple'
+
+--------------------------------------------------
+-- 2.1. Function Literals
+--------------------------------------------------
+
+-- Functions are written using arrows:
+
+my_function = -> -- compiles to `function() end`
+my_function() -- calls an empty function
+
+-- Functions can be called without using parenthesis. Parentheses may still be
+-- used to have priority over other functions.
+
+func_a = -> print "Hello World!"
+func_b = ->
+	value = 100
+	print "The value: #{value}"
+
+-- If a function needs no parameters, it can be called with either `()` or `!`.
+
+func_a!
+func_b()
+
+-- Functions can use arguments by preceding the arrow with a list of argument
+-- names bound by parentheses.
+
+sum = (x, y)-> x + y -- The last expression is returned from the function.
+print sum(5, 10)
+
+-- Lua has an idiom of sending the first argument to a function as the object,
+-- like a 'self' object. Using a fat arrow (=>) instead of a skinny arrow (->)
+-- automatically creates a `self` variable. `@x` is a shorthand for `self.x`.
+
+func = (num)=> @value + num
+
+-- Default arguments can also be used with function literals:
+
+a_function = (name = "something", height=100)->
+	print "Hello, I am #{name}.\nMy height is #{height}."
+
+-- Because default arguments are calculated in the body of the function when
+-- transpiled to Lua, you can reference previous arguments.
+
+some_args = (x = 100, y = x + 1000)-> print(x + y)
+
+--------------------------------------------------
+-- Considerations
+--------------------------------------------------
+
+-- The minus sign plays two roles, a unary negation operator and a binary
+-- subtraction operator. It is recommended to always use spaces between binary
+-- operators to avoid the possible collision.
+
+a = x - 10 --  a = x - 10
+b = x-10 -- b = x - 10
+c = x -y -- c = x(-y)
+d = x- z -- d = x - z
+
+-- When there is no space between a variable and string literal, the function
+-- call takes priority over following expressions:
+
+x = func"hello" + 100 -- func("hello") + 100
+y = func "hello" + 100 -- func("hello" + 100)
+
+-- Arguments to a function can span across multiple lines as long as the
+-- arguments are indented. The indentation can be nested as well.
+
+my_func 5, -- called as my_func(5, 8, another_func(6, 7, 9, 1, 2), 5, 4)
+	8, another_func 6, 7, -- called as
+		9, 1, 2,		  -- another_func(6, 7, 9, 1, 2)
+	5, 4
+
+-- If a function is used at the start of a block, the indentation can be
+-- different than the level of indentation used in a block:
+
+if func 1, 2, 3, -- called as func(1, 2, 3, "hello", "world")
+		"hello",
+		"world"
+	print "hello"
+
+--------------------------------------------------
+-- 3. Tables
+--------------------------------------------------
+
+-- Tables are defined by curly braces, like Lua:
+
+some_values = {1, 2, 3, 4}
+
+-- Tables can use newlines instead of commas.
+
+some_other_values = {
+	5, 6
+	7, 8
+}
+
+-- Assignment is done with `:` instead of `=`:
+
+profile = {
+	name: "Bill"
+	age: 200
+	"favorite food": "rice"
+}
+
+-- Curly braces can be left off for `key: value` tables.
+
+y = type: "dog", legs: 4, tails: 1
+
+profile =
+	height: "4 feet",
+	shoe_size: 13,
+	favorite_foods: -- nested table
+		foo: "ice cream", 
+		bar: "donuts"
+
+my_function dance: "Tango", partner: "none" -- :( forever alone
+
+-- Tables constructed from variables can use the same name as the variables
+-- by using `:` as a prefix operator.
+
+hair = "golden"
+height = 200
+person = {:hair, :height}
+
+-- Like in Lua, keys can be non-string or non-numeric values by using `[]`.
+
+t =
+	[1 + 2]: "hello"
+	"hello world": true -- Can use string literals without `[]`.
+
+--------------------------------------------------
+-- 3.1. Table Comprehensions
+--------------------------------------------------
+
+-- List Comprehensions
+
+-- Creates a copy of a list but with all items doubled. Using a star before a
+-- variable name or table can be used to iterate through the table's values.
+
+items = {1, 2, 3, 4}
+doubled = [item * 2 for item in *items]
+-- Uses `when` to determine if a value should be included.
+
+slice = [item for item in *items when i > 1 and i < 3]
+
+-- `for` clauses inside of list comprehensions can be chained.
+
+x_coords = {4, 5, 6, 7}
+y_coords = {9, 2, 3}
+
+points = [{x,y} for x in *x_coords for y in *y_coords]
+
+-- Numeric for loops can also be used in comprehensions:
+
+evens = [i for i=1, 100 when i % 2 == 0]
+
+-- Table Comprehensions are very similar but use `{` and `}` and take two
+-- values for each iteration.
+
+thing = color: "red", name: "thing", width: 123
+thing_copy = {k, v for k, v in pairs thing}
+
+-- Tables can be "flattened" from key-value pairs in an array by using `unpack`
+-- to return both values, using the first as the key and the second as the
+-- value.
+
+tuples = {{"hello", "world"}, {"foo", "bar"}}
+table = {unpack tuple for tuple in *tuples}
+
+-- Slicing can be done to iterate over only a certain section of an array. It
+-- uses the `*` notation for iterating but appends `[start, end, step]`.
+
+-- The next example also shows that this syntax can be used in a `for` loop as
+-- well as any comprehensions.
+
+for item in *points[1, 10, 2]
+	print unpack item
+
+-- Any undesired values can be left off. The second comma is not required if
+-- the step is not included.
+
+words = {"these", "are", "some", "words"}
+for word in *words[,3] 
+	print word
+
+--------------------------------------------------
+-- 4. Control Structures
+--------------------------------------------------
+
+have_coins = false
+if have_coins
+	print "Got coins"
+else
+	print "No coins"
+
+-- Use `then` for single-line `if`
+if have_coins then "Got coins" else "No coins"
+
+-- `unless` is the opposite of `if`
+unless os.date("%A") == "Monday"
+	print "It is not Monday!"
+
+-- `if` and `unless` can be used as expressions
+is_tall = (name)-> if name == "Rob" then true else false
+message = "I am #{if is_tall "Rob" then "very tall" else "not so tall"}"
+print message -- "I am very tall"
+
+-- `if`, `elseif`, and `unless` can evaluate assignment as well as expressions.
+if x = possibly_nil! -- sets `x` to `possibly_nil()` and evaluates `x`
+	print x
+
+-- Conditionals can be used after a statement as well as before. This is
+-- called a "line decorator".
+
+is_monday = os.date("%A") == "Monday"
+print("It IS Monday!") if isMonday
+print("It is not Monday..") unless isMonday
+--print("It IS Monday!" if isMonday) -- Not a statement, does not work
+
+--------------------------------------------------
+-- 4.1 Loops
+--------------------------------------------------
+
+for i = 1, 10
+	print i
+
+for i = 10, 1, -1 do print i -- Use `do` for single-line loops.
+
+i = 0
+while i < 10
+	continue if i % 2 == 0 -- Continue statement; skip the rest of the loop.
+	print i
+
+-- Loops can be used as a line decorator, just like conditionals
+print "item: #{item}" for item in *items
+
+-- Using loops as an expression generates an array table. The last statement
+-- in the block is coerced into an expression and added to the table.
+my_numbers = for i = 1, 6 do i -- {1, 2, 3, 4, 5, 6}
+
+-- use `continue` to filter out values
+odds = for i in *my_numbers
+	continue if i % 2 == 0 -- acts opposite to `when` in comprehensions!
+	i -- Only added to return table if odd
+
+-- A `for` loop returns `nil` when it is the last statement of a function
+-- Use an explicit `return` to generate a table.
+print_squared = (t) -> for x in *t do x*x -- returns `nil`
+squared = (t) -> return for x in *t do x*x -- returns new table of squares
+
+-- The following does the same as `(t) -> [i for i in *t when i % 2 == 0]`
+-- But list comprehension generates better code and is more readable!
+
+filter_odds = (t) -> 
+	return for x in *t
+		if x % 2 == 0 then x else continue
+evens = filter_odds(my_numbers) -- {2, 4, 6}
+
+--------------------------------------------------
+-- 4.2 Switch Statements
+--------------------------------------------------
+
+-- Switch statements are a shorthand way of writing multiple `if` statements
+-- checking against the same value. The value is only evaluated once.
+
+name = "Dan"
+
+switch name
+	when "Dave"
+		print "You are Dave."
+	when "Dan"
+		print "You are not Dave, but Dan."
+	else
+		print "You are neither Dave nor Dan."
+
+-- Switches can also be used as expressions, as well as compare multiple
+-- values. The values can be on the same line as the `when` clause if they
+-- are only one expression.
+
+b = 4
+next_even = switch b
+	when 1 then 2
+	when 2, 3 then 4
+	when 4, 5 then 6
+	else error "I can't count that high! D:"
+
+--------------------------------------------------
+-- 5. Object Oriented Programming
+--------------------------------------------------
+
+-- Classes are created using the `class` keyword followed by an identifier,
+-- typically written using CamelCase. Values specific to a class can use @ as
+-- the identifier instead of `self.value`.
+
+class Inventory
+	new: => @items = {}
+	add_item: (name)=> -- note the use of fat arrow for classes!
+		@items[name] = 0 unless @items[name]
+		@items[name] += 1
+
+-- The `new` function inside of a class is special because it is called when
+-- an instance of the class is created.
+
+-- Creating an instance of the class is as simple as calling the class as a
+-- function. Calling functions inside of the class uses \ to separate the
+-- instance from the function it is calling.
+
+inv = Inventory!
+inv\add_item "t-shirt"
+inv\add_item "pants"
+
+-- Values defined in the class - not the new() function - will be shared across
+-- all instances of the class.
+
+class Person
+	clothes: {}
+	give_item: (name)=>
+		table.insert @clothes name
+
+a = Person!
+b = Person!
+
+a\give_item "pants"
+b\give_item "shirt"
+
+-- prints out both "pants" and "shirt"
+
+print item for item in *a.clothes
+
+-- Class instances have a value `.__class` that are equal to the class object
+-- that created the instance.
+
+assert(b.__class == Person)
+
+-- Variables declared in class body the using the `=` operator are locals,
+-- so these "private" variables are only accessible within the current scope.
+
+class SomeClass
+	x = 0
+	reveal: ->
+		x += 1
+		print x
+
+a = SomeClass!
+b = SomeClass!
+print a.x -- nil
+a.reveal! -- 1
+b.reveal! -- 2
+
+--------------------------------------------------
+-- 5.1 Inheritance
+--------------------------------------------------
+
+-- The `extends` keyword can be used to inherit properties and methods from
+-- another class.
+
+class Backpack extends Inventory
+	size: 10
+	add_item: (name)=>
+		error "backpack is full" if #@items > @size
+		super name -- calls Inventory.add_item with `name`.
+
+-- Because a `new` method was not added, the `new` method from `Inventory` will
+-- be used instead. If we did want to use a constructor while still using the
+-- constructor from `Inventory`, we could use the magical `super` function
+-- during `new()`.
+
+-- When a class extends another, it calls the method `__inherited` on the 
+-- parent class (if it exists). It is always called with the parent and the
+-- child object.
+
+class ParentClass
+	@__inherited: (child)=>
+		print "#{@__name} was inherited by #{child.__name}"
+	a_method: (a, b) => print a .. ' ' .. b
+
+-- Will print 'ParentClass was inherited by MyClass'
+
+class MyClass extends ParentClass
+	a_method: =>
+		super "hello world", "from MyClass!" 
+		assert super == ParentClass
+
+--------------------------------------------------
+-- 6. Scope
+--------------------------------------------------
+
+-- All values are local by default. The `export` keyword can be used to
+-- declare the variable as a global value.
+
+export var_1, var_2
+var_1, var_3 = "hello", "world" -- var_3 is local, var_1 is not.
+
+export this_is_global_assignment = "Hi!"
+
+-- Classes can also be prefixed with `export` to make them global classes.
+-- Alternatively, all CamelCase variables can be exported automatically using
+-- `export ^`, and all values can be exported using `export *`.
+
+-- `do` lets you manually create a scope, for when you need local variables.
+
+do
+	x = 5
+print x -- nil
+
+-- Here we use `do` as an expression to create a closure.
+
+counter = do 
+	i = 0
+	->
+		i += 1
+		return i
+
+print counter!  -- 1
+print counter!  -- 2
+
+-- The `local` keyword can be used to define variables
+-- before they are assigned.
+
+local var_4
+if something
+	var_4 = 1
+print var_4 -- works because `var_4` was set in this scope, not the `if` scope.
+
+-- The `local` keyword can also be used to shadow an existing variable.
+
+x = 10
+if false
+	local x
+	x = 12
+print x -- 10
+
+-- Use `local *` to forward-declare all variables. 
+-- Alternatively, use `local ^` to forward-declare all CamelCase values.
+
+local *
+
+first = ->
+	second!
+
+second = ->
+	print data
+
+data = {}
+
+--------------------------------------------------
+-- 6.1 Import
+--------------------------------------------------
+
+-- Values from a table can be brought to the current scope using the `import`
+-- and `from` keyword. Names in the `import` list can be preceded by `\` if
+-- they are a module function.
+
+import insert from table -- local insert = table.insert
+import \add from state: 100, add: (value)=> @state + value
+print add 22
+
+-- Like tables, commas can be excluded from `import` lists to allow for longer
+-- lists of imported items.
+
+import
+	asdf, gh, jkl
+	antidisestablishmentarianism
+	from {}
+
+--------------------------------------------------
+-- 6.2 With
+--------------------------------------------------
+
+-- The `with` statement can be used to quickly call and assign values in an
+-- instance of a class or object.
+
+file = with File "lmsi15m.moon" -- `file` is the value of `set_encoding()`.
+	\set_encoding "utf8"
+
+create_person = (name, relatives)->
+	with Person!
+		.name = name
+		\add_relative relative for relative in *relatives
+me = create_person "Ryan", {"sister", "sister", "brother", "dad", "mother"}
+
+with str = "Hello" -- assignment as expression! :D
+	print "original: #{str}"
+	print "upper: #{\upper!}"
+
+--------------------------------------------------
+-- 6.3 Destructuring
+--------------------------------------------------
+
+-- Destructuring can take arrays, tables, and nested tables and convert them
+-- into local variables.
+
+obj2 =
+	numbers: {1, 2, 3, 4}
+	properties:
+		color: "green"
+		height: 13.5
+
+{numbers: {first, second}, properties: {:color}} = obj2
+
+print first, second, color -- 1 2 green
+
+-- `first` and `second` return [1] and [2] because they are as an array, but
+-- `:color` is like `color: color` so it sets itself to the `color` value.
+
+-- Destructuring can be used in place of `import`.
+
+{:max, :min, random: rand} = math -- rename math.random to rand
+
+-- Destructuring can be done anywhere assignment can be done.
+
+for {left, right} in *{{"hello", "world"}, {"egg", "head"}}
+	print left, right
+```
+
+## Additional Resources
+
+- [Language Guide](https://moonscript.org/reference/)
+- [Online Compiler](https://moonscript.org/compiler/)
diff --git a/ms-my/clojure-macros-my.html.markdown b/ms-my/clojure-macros-my.html.markdown
new file mode 100644
index 00000000..325f92e0
--- /dev/null
+++ b/ms-my/clojure-macros-my.html.markdown
@@ -0,0 +1,151 @@
+---
+language: "clojure macros"
+filename: learnclojuremacros-ms.clj
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+translators:
+    - ["Burhanuddin Baharuddin", "https://github.com/burhanloey"]
+lang: ms-my
+---
+
+Sama seperti Lisp yang lain, sifat Clojure yang mempunyai [homoiconicity](https://en.wikipedia.org/wiki/Homoiconic)
+membolehkan anda untuk menggunakan sepenuhnya language ini untuk menulis code yang boleh generate code sendiri yang
+dipanggil "macro". Macro memberi cara yang sangat menarik untuk mengubahsuai language mengikut kehendak anda.
+
+Jaga-jaga. Penggunaan macro boleh dikatakan tidak elok jika digunakan secara berlebihan jika function sahaja sudah mencukupi.
+Gunakan macro hanya apabila anda mahu lebih kawalan terhadap sesuatu form.
+
+Biasakan diri dengan Clojure terlebih dahulu. Pastikan anda memahami semuanya di 
+[Clojure in Y Minutes](/docs/ms-my/clojure-my/).
+
+```clojure
+;; Define macro menggunakan defmacro. Macro anda akan output list yang boleh
+;; dijalankan sebagai code clojure.
+;;
+;; Macro ini adalah sama seperti (reverse "Hello World")
+(defmacro my-first-macro []
+  (list reverse "Hello World"))
+
+;; Lihat hasil macro tersebut menggunakan macroexpand atau macroexpand-1.
+;;
+;; Pastikan panggilan kepada macro tersebut mempunyai tanda petikan
+(macroexpand '(my-first-macro))
+;; -> (#<core$reverse clojure.core$reverse@xxxxxxxx> "Hello World")
+
+;; Anda boleh menggunakan eval terus kepada macroexpand untuk mendapatkan hasil:
+(eval (macroexpand '(my-first-macro)))
+; -> (\d \l \o \r \W \space \o \l \l \e \H)
+
+;; Tetapi anda sepatutnya menggunakan cara yang lebih ringkas, sama seperti panggilan kepada function:
+(my-first-macro)  ; -> (\d \l \o \r \W \space \o \l \l \e \H)
+
+;; Anda boleh memudahkan cara untuk membuat macro dengan mengguna tanda petikan
+;; untuk membuat list untuk macro:
+(defmacro my-first-quoted-macro []
+  '(reverse "Hello World"))
+
+(macroexpand '(my-first-quoted-macro))
+;; -> (reverse "Hello World")
+;; Perhatikan yang reverse bukan lagi function tetapi adalah simbol.
+
+;; Macro boleh mengambil argument.
+(defmacro inc2 [arg]
+  (list + 2 arg))
+
+(inc2 2) ; -> 4
+
+;; Tetapi jika anda membuat cara yang sama menggunakan tanda petikan, anda akan mendapat error sebab
+;; argument tersebut juga akan mempunyai tanda petikan. Untuk mengatasi masalah ini, Clojure memberi
+;; cara untuk meletak tanda petikan untuk macro: `. Di dalam `, anda boleh menggunakan ~ untuk mendapatkan scope luaran
+(defmacro inc2-quoted [arg]
+  `(+ 2 ~arg))
+
+(inc2-quoted 2)
+
+;; Anda boleh menggunakan destructuring untuk argument seperti biasa. Gunakan ~@ untuk mengembangkan variable
+(defmacro unless [arg & body]
+  `(if (not ~arg)
+     (do ~@body))) ; Jangan lupa do!
+
+(macroexpand '(unless true (reverse "Hello World")))
+;; ->
+;; (if (clojure.core/not true) (do (reverse "Hello World")))
+
+;; (unless) mengembalikan body jika argument yang pertama adalah false.
+;; Jika tidak, (unless) akan memulangkan nil
+
+(unless true "Hello") ; -> nil
+(unless false "Hello") ; -> "Hello"
+
+;; Jika tidak berhati-hati, macro boleh memeningkan anda dengan mencampuradukkan nama variable
+(defmacro define-x []
+  '(do
+     (def x 2)
+     (list x)))
+
+(def x 4)
+(define-x) ; -> (2)
+(list x) ; -> (2)
+
+;; Untuk mengelakkan masalah ini, gunakan gensym untuk mendapatkan identifier yang berbeza
+(gensym 'x) ; -> x1281 (atau yang sama waktu dengannya)
+
+(defmacro define-x-safely []
+  (let [sym (gensym 'x)]
+    `(do
+       (def ~sym 2)
+       (list ~sym))))
+
+(def x 4)
+(define-x-safely) ; -> (2)
+(list x) ; -> (4)
+
+;; Anda boleh menggunakan # di dalam ` untuk menghasilkan gensym untuk setiap simbol secara automatik
+(defmacro define-x-hygienically []
+  `(do
+     (def x# 2)
+     (list x#)))
+
+(def x 4)
+(define-x-hygienically) ; -> (2)
+(list x) ; -> (4)
+
+;; Kebiasaannya helper function digunakan untuk membuat macro. Jom buat beberapa function untuk
+;; membuatkan program boleh memahami inline arithmetic. Saja suka-suka.
+(declare inline-2-helper)
+(defn clean-arg [arg]
+  (if (seq? arg)
+    (inline-2-helper arg)
+    arg))
+
+(defn apply-arg
+  "Diberi argument [x (+ y)], pulangkan (+ x y)"
+  [val [op arg]]
+  (list op val (clean-arg arg)))
+
+(defn inline-2-helper
+  [[arg1 & ops-and-args]]
+  (let [ops (partition 2 ops-and-args)]
+    (reduce apply-arg (clean-arg arg1) ops)))
+
+;; Kita boleh test terlebih dahulu tanpa membuat macro
+(inline-2-helper '(a + (b - 2) - (c * 5))) ; -> (- (+ a (- b 2)) (* c 5))
+
+; Tetapi, kita perlu membuat macro jika kita mahu jalankan code tersebut
+(defmacro inline-2 [form]
+  (inline-2-helper form))
+
+(macroexpand '(inline-2 (1 + (3 / 2) - (1 / 2) + 1)))
+; -> (+ (- (+ 1 (/ 3 2)) (/ 1 2)) 1)
+
+(inline-2 (1 + (3 / 2) - (1 / 2) + 1))
+; -> 3 (sepatutnya, 3N, sebab nombor tersebut ditukarkan kepada pecahan rasional menggunakan /)
+```
+
+### Bacaaan Lanjut
+
+[Writing Macros daripada](http://www.braveclojure.com/writing-macros/)
+
+[Dokumen rasmi](http://clojure.org/macros)
+
+[Bila perlu guna macro?](https://lispcast.com/when-to-use-a-macro/)
diff --git a/ms-my/common-lisp-my.html.markdown b/ms-my/common-lisp-my.html.markdown
new file mode 100644
index 00000000..f5914aae
--- /dev/null
+++ b/ms-my/common-lisp-my.html.markdown
@@ -0,0 +1,692 @@
+---
+
+language: "Common Lisp"
+filename: commonlisp-ms.lisp
+contributors:
+  - ["Paul Nathan", "https://github.com/pnathan"]
+  - ["Rommel Martinez", "https://ebzzry.io"]
+translators:
+  - ["Burhanuddin Baharuddin", "https://github.com/burhanloey"]
+lang: ms-my
+---
+
+Common Lisp ialah programming language yang general-purpose (boleh digunakan untuk semua benda) dan multi-paradigm (konsep yang pelbagai) sesuai untuk pelbagai kegunaan di dalam
+industri aplikasi. Common Lisp biasa digelar sebagai programmable programming language (programming language yang boleh di-program-kan).
+
+Sumber bacaan yang klasik ialah [Practical Common Lisp](http://www.gigamonkeys.com/book/). Sumber bacaan yang lain dan
+yang terbaru ialah [Land of Lisp](http://landoflisp.com/). Buku baru mengenai best practices (amalan terbaik),
+[Common Lisp Recipes](http://weitz.de/cl-recipes/), baru sahaja diterbitkan.
+
+
+
+```common-lisp
+
+;;;-----------------------------------------------------------------------------
+;;; 0. Syntax
+;;;-----------------------------------------------------------------------------
+
+;;; General form (Bentuk umum)
+
+;;; Ada dua asas dalam syntax CL: ATOM dan S-EXPRESSION.
+;;; Kebiasaannya, gabungan S-expression dipanggil sebagai `forms`.
+
+10            ; atom; bermaksud seperti yang ditulis iaitu nombor 10
+:thing        ; juga atom; bermaksud simbol :thing
+t             ; juga atom, bermaksud true (ya/betul/benar)
+(+ 1 2 3 4)   ; s-expression
+'(4 :foo t)   ; juga s-expression
+
+
+;;; Comment (Komen)
+
+;;; Comment satu baris bermula dengan semicolon; gunakan empat untuk comment
+;;; mengenai file, tiga untuk seksyen penghuraian, dua untuk yang dalam definition,
+;;; dan satu untuk satu baris. Sebagai contoh,
+
+;;;; life.lisp
+
+;;; Foo bar baz, disebabkan quu quux. Sangat optimum untuk krakaboom dan umph.
+;;; Diperlukan oleh function LINULUKO. Ini merepek sahaja kebaboom.
+
+(defun meaning (life)
+  "Memulangkan hasil pengiraan makna KEHIDUPAN"
+  (let ((meh "abc"))
+    ;; Jalankan krakaboom
+    (loop :for x :across meh
+       :collect x)))                    ; Simpan hasil ke x, kemudian pulangkan
+
+;;; Komen berbentuk blok, sebaliknya, membenarkan komen untuk bentuk bebas. Komen
+;;; tersebut berada di antara #| dan |#
+
+#| Ini adalah komen berbentuk blok di mana
+   tulisan boleh ditulis dalam beberapa baris dan
+    #|
+       juga boleh dalam bentuk nested (berlapis-lapis)!
+    |#
+|#
+
+
+;;; Environment (benda-benda yang diperlukan untuk program menggunakan Common Lisp)
+
+;;; Common Lisp ada banyak jenis; kebanyakannya mengikut standard. SBCL
+;;; ialah titik permulaan yang baik. Quicklisp boleh digunakan untuk install 
+;;; library third party.
+
+;;; CL kebiasaannya digunakan dengan text editor dan Real Eval Print
+;;; Loop (REPL) yang dilancarkan dengan serentak. REPL membolehkan kita menjelajah
+;;; program secara interaktif semasa program tersebut sedang berjalan secara "live".
+
+
+;;;-----------------------------------------------------------------------------
+;;; 1. Datatype primitif dan operator
+;;;-----------------------------------------------------------------------------
+
+;;; Simbol
+
+'foo ; => FOO  Perhatikan simbol menjadi huruf besar secara automatik.
+
+;;; INTERN menjadikan string sebagai simbol secara manual.
+
+(intern "AAAA")        ; => AAAA
+(intern "aaa")         ; => |aaa|
+
+;;; Nombor
+
+9999999999999999999999 ; integer
+#b111                  ; binary => 7
+#o111                  ; octal => 73
+#x111                  ; hexadecimal => 273
+3.14159s0              ; single
+3.14159d0              ; double
+1/2                    ; ratio
+#C(1 2)                ; complex number
+
+;;; Function ditulis sebagai (f x y z ...) di mana f ialah function dan
+;;; x, y, z, ... adalah argument.
+
+(+ 1 2)                ; => 3
+
+;;; Jika anda ingin membuat data sebagai data bukannya function, gunakan QUOTE
+;;; untuk mengelakkan data tersebut daripada dikira oleh program
+
+(quote (+ 1 2))        ; => (+ 1 2)
+(quote a)              ; => A
+
+;;; Singkatan untuk QUOTE ialah ' (tanda petikan)
+
+'(+ 1 2)               ; => (+ 1 2)
+'a                     ; => A
+
+;;; Operasi arithmetic asas
+
+(+ 1 1)                ; => 2
+(- 8 1)                ; => 7
+(* 10 2)               ; => 20
+(expt 2 3)             ; => 8
+(mod 5 2)              ; => 1
+(/ 35 5)               ; => 7
+(/ 1 3)                ; => 1/3
+(+ #C(1 2) #C(6 -4))   ; => #C(7 -2)
+
+;;; Boolean
+
+t                      ; true; semua nilai yang bukan NIL ialah true
+nil                    ; false; termasuklah list yang kosong: ()
+(not nil)              ; => T
+(and 0 t)              ; => T
+(or 0 nil)             ; => 0
+
+;;; Character
+
+#\A                    ; => #\A
+#\λ                    ; => #\GREEK_SMALL_LETTER_LAMDA
+#\u03BB                ; => #\GREEK_SMALL_LETTER_LAMDA
+
+;;; String ialah array character yang tidak berubah panjang
+
+"Hello, world!"
+"Benjamin \"Bugsy\" Siegel"   ; backslash ialah escape character
+
+;;; String boleh digabungkan
+
+(concatenate 'string "Hello, " "world!") ; => "Hello, world!"
+
+;;; String boleh diperlakukan seperti urutan character
+
+(elt "Apple" 0) ; => #\A
+
+;;; FORMAT digunakan untuk output mengikut format, daripada penggubahan string
+;;; yang simple sehinggalah loop dan conditional. Argument pertama untuk FORMAT
+;;; menentukan ke mana string akan pergi. Jika NIL, FORMAT
+;;; akan pulangkan string sebagai data string; jika T, FORMAT akan output
+;;; ke standard output, biasanya di screen, kemudian pulangkan NIL.
+
+(format nil "~A, ~A!" "Hello" "world")   ; => "Hello, world!"
+(format t "~A, ~A!" "Hello" "world")     ; => NIL
+
+
+;;;-----------------------------------------------------------------------------
+;;; 2. Variable
+;;;-----------------------------------------------------------------------------
+
+;;; Anda boleh membuat variable global (dynamically scoped) menggunakan DEFVAR dan
+;;; DEFPARAMETER. Nama variable boleh guna mana-mana character kecuali: ()",'`;#|\
+
+;;; Beza antara DEFVAR dengan DEFPARAMETER ialah DEFVAR tidak akan ubah nilai
+;;; variable jika dijalankan semula. Manakala DEFPARAMETER, akan mengubah nilai
+;;; jika dijalankan semula.
+
+;;; Kebiasaannya, variable global diletakkan earmuff (asterisk) pada nama.
+
+(defparameter *some-var* 5)
+*some-var* ; => 5
+
+;;; Anda juga boleh menggunakan character unicode.
+(defparameter *AΛB* nil)
+
+;;; Variable yang tidak wujud boleh diakses tetapi akan menyebabkan undefined
+;;; behavior. Jangan buat.
+
+;;; Anda boleh membuat local binding menggunakan LET. Dalam snippet berikut, `me`
+;;; terikat dengan "dance with you" hanya dalam (let ...). LET mesti akan pulangkan
+;;; nilai `form` yang paling terakhir.
+
+(let ((me "dance with you")) me) ; => "dance with you"
+
+
+;;;-----------------------------------------------------------------------------;
+;;; 3. Struct dan collection
+;;;-----------------------------------------------------------------------------;
+
+
+;;; Struct
+
+(defstruct dog name breed age)
+(defparameter *rover*
+    (make-dog :name "rover"
+              :breed "collie"
+              :age 5))
+*rover*            ; => #S(DOG :NAME "rover" :BREED "collie" :AGE 5)
+(dog-p *rover*)    ; => T
+(dog-name *rover*) ; => "rover"
+
+;;; DOG-P, MAKE-DOG, dan DOG-NAME semuanya dibuat oleh DEFSTRUCT secara automatik
+
+
+;;; Pair
+
+;;; CONS membuat pair. CAR dan CDR pulangkan head (kepala) dan tail (ekor) CONS-pair.
+
+(cons 'SUBJECT 'VERB)         ; => '(SUBJECT . VERB)
+(car (cons 'SUBJECT 'VERB))   ; => SUBJECT
+(cdr (cons 'SUBJECT 'VERB))   ; => VERB
+
+
+;;; List
+
+;;; List ialah data structure linked-list, dihasilkan daripada pair CONS dan
+;;; berakhir dengan NIL (atau '()) menandakan akhirnya list tersebut
+
+(cons 1 (cons 2 (cons 3 nil)))     ; => '(1 2 3)
+
+;;; LIST ialah constructor untuk memudahkan penghasilan list
+
+(list 1 2 3)                       ; => '(1 2 3)
+
+;;; Apabila argument pertama untuk CONS ialah atom dan argument kedua ialah
+;;; list, CONS akan pulangkan CONS-pair baru dengan argument pertama sebagai
+;;; item pertama dan argument kedua sebagai CONS-pair yang lain
+
+(cons 4 '(1 2 3))                  ; => '(4 1 2 3)
+
+;;; Gunakan APPEND untuk menggabungkan list
+
+(append '(1 2) '(3 4))             ; => '(1 2 3 4)
+
+;;; Atau CONCATENATE
+
+(concatenate 'list '(1 2) '(3 4))  ; => '(1 2 3 4)
+
+;;; List ialah type utama, jadi ada pelbagai function untuk mengendalikan
+;;; list, contohnya:
+
+(mapcar #'1+ '(1 2 3))             ; => '(2 3 4)
+(mapcar #'+ '(1 2 3) '(10 20 30))  ; => '(11 22 33)
+(remove-if-not #'evenp '(1 2 3 4)) ; => '(2 4)
+(every #'evenp '(1 2 3 4))         ; => NIL
+(some #'oddp '(1 2 3 4))           ; => T
+(butlast '(subject verb object))   ; => (SUBJECT VERB)
+
+
+;;; Vector
+
+;;; Vector ialah array yang tidak berubah panjang
+
+#(1 2 3) ; => #(1 2 3)
+
+;;; Gunakan CONCATENATE untuk menggabungkan vector
+
+(concatenate 'vector #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6)
+
+
+;;; Array
+
+;;; Vector dan string adalah sejenis array.
+
+;;; 2D array
+
+(make-array (list 2 2))         ; => #2A((0 0) (0 0))
+(make-array '(2 2))             ; => #2A((0 0) (0 0))
+(make-array (list 2 2 2))       ; => #3A(((0 0) (0 0)) ((0 0) (0 0)))
+
+;;; Perhatian: nilai awal MAKE-ARRAY adalah bergantung kepada jenis Common Lisp.
+;;; Untuk meletakkan nilai awal secara manual:
+
+(make-array '(2) :initial-element 'unset)  ; => #(UNSET UNSET)
+
+;;; Untuk mengakses element di kedudukan 1, 1, 1:
+
+(aref (make-array (list 2 2 2)) 1 1 1)     ;  => 0
+
+
+;;; Adjustable vector (vector yang boleh berubah)
+
+;;; Adjustable vector mempunyai rupa yang sama dengan
+;;; vector yang tidak berubah panjang.
+
+(defparameter *adjvec* (make-array '(3) :initial-contents '(1 2 3)
+                                   :adjustable t :fill-pointer t))
+*adjvec* ; => #(1 2 3)
+
+;;; Tambah element baru
+
+(vector-push-extend 4 *adjvec*)   ; => 3
+*adjvec*                          ; => #(1 2 3 4)
+
+
+;;; Set hanyalah list:
+
+(set-difference '(1 2 3 4) '(4 5 6 7))   ; => (3 2 1)
+(intersection '(1 2 3 4) '(4 5 6 7))     ; => 4
+(union '(1 2 3 4) '(4 5 6 7))            ; => (3 2 1 4 5 6 7)
+(adjoin 4 '(1 2 3 4))                    ; => (1 2 3 4)
+
+;;; Tetapi, anda perlukan data structure yang lebih baik untuk digunakan dengan
+;;; data set yang sangat banyak
+
+;;; Kamus dibuat menggunakan hash table.
+
+;;; Bina hash table
+
+(defparameter *m* (make-hash-table))
+
+;;; Tetapkan nilai
+
+(setf (gethash 'a *m*) 1)
+
+;;; Baca nilai
+
+(gethash 'a *m*) ; => 1, T
+
+;;; CL boleh memulangkan beberapa nilai (multiple value).
+
+(values 1 2) ; => 1, 2
+
+;;; dan boleh digunakan dengan MULTIPLE-VALUE-BIND untuk bind setiap nilai
+
+(multiple-value-bind (x y)
+    (values 1 2)
+  (list y x))
+
+; => '(2 1)
+
+;;; GETHASH antara contoh function yang memulangkan multiple value. Value
+;;; pertama ialah nilai untuk key dalam hash table; jika key tidak
+;;; jumpa GETHASH akan pulangkan NIL.
+
+;;; Value kedua menentukan sama ada key tersebut betul-betul wujud dalam hash
+;;; table. Jika key tidak jumpa dalam table value tersebut ialah NIL. Cara ini
+;;; membolehkan kita untuk periksa sama ada value untuk key ialah NIL.
+
+;;; Dapatkan value yang tidak wujud akan pulangkan nil
+
+(gethash 'd *m*) ;=> NIL, NIL
+
+;;; Anda boleh menentukan value default untuk key yang tidak wujud
+
+(gethash 'd *m* :not-found) ; => :NOT-FOUND
+
+;;; Jom lihat penggunaan multiple return value di dalam code.
+
+(multiple-value-bind (a b)
+    (gethash 'd *m*)
+  (list a b))
+; => (NIL NIL)
+
+(multiple-value-bind (a b)
+    (gethash 'a *m*)
+  (list a b))
+; => (1 T)
+
+
+;;;-----------------------------------------------------------------------------
+;;; 3. Function
+;;;-----------------------------------------------------------------------------
+
+;;; Gunakan LAMBDA untuk membuat anonymous function. Function sentiasa memulangkan
+;;; value untuk expression terakhir.
+
+(lambda () "Hello World") ; => #<FUNCTION (LAMBDA ()) {1004E7818B}>
+
+;;; Gunakan FUNCALL untuk memanggil anonymous function
+
+(funcall (lambda () "Hello World"))   ; => "Hello World"
+(funcall #'+ 1 2 3)                   ; => 6
+
+;;; Panggilan kepada FUNCALL juga boleh terjadi apabila lambda tersebut ialah CAR
+;;; (yang pertama) untuk list (yang tidak mempunyai tanda petikan)
+
+((lambda () "Hello World"))           ; => "Hello World"
+((lambda (val) val) "Hello World")    ; => "Hello World"
+
+;;; FUNCALL digunakan apabila argument sudah diketahui. Jika tidak, gunakan APPLY
+
+(apply #'+ '(1 2 3))   ; => 6
+(apply (lambda () "Hello World") nil) ; => "Hello World"
+
+;;; Untuk menamakan sebuah function, guna DEFUN
+
+(defun hello-world () "Hello World")
+(hello-world) ; => "Hello World"
+
+;;; Simbol () di atas bermaksud list kepada argument
+
+(defun hello (name) (format nil "Hello, ~A" name))
+(hello "Steve") ; => "Hello, Steve"
+
+;;; Function boleh ada argument optional (tidak wajib); argument tersebut bernilai
+;;; NIL secara default
+
+(defun hello (name &optional from)
+  (if from
+      (format t "Hello, ~A, from ~A" name from)
+      (format t "Hello, ~A" name)))
+
+(hello "Jim" "Alpacas")       ; => Hello, Jim, from Alpacas
+
+;;; Nilai default boleh ditetapkan untuk argument tersebut
+
+(defun hello (name &optional (from "The world"))
+   (format nil "Hello, ~A, from ~A" name from))
+
+(hello "Steve")               ; => Hello, Steve, from The world
+(hello "Steve" "the alpacas") ; => Hello, Steve, from the alpacas
+
+;;; Function juga mempunyai keyword argument untuk membolehkan argument diletakkan
+;;; tidak mengikut kedudukan
+
+(defun generalized-greeter (name &key (from "the world") (honorific "Mx"))
+  (format t "Hello, ~A ~A, from ~A" honorific name from))
+
+(generalized-greeter "Jim")
+; => Hello, Mx Jim, from the world
+
+(generalized-greeter "Jim" :from "the alpacas you met last summer" :honorific "Mr")
+; => Hello, Mr Jim, from the alpacas you met last summer
+
+
+;;;-----------------------------------------------------------------------------
+;;; 4. Kesamaan
+;;;-----------------------------------------------------------------------------
+
+;;; CL mempunyai sistem kesaksamaan yang canggih. Antaranya adalah seperti berikut.
+
+;;; Untuk nombor, guna `='
+(= 3 3.0)               ; => T
+(= 2 1)                 ; => NIL
+
+;;; Untuk identiti object (lebih kurang) guna EQL
+(eql 3 3)               ; => T
+(eql 3 3.0)             ; => NIL
+(eql (list 3) (list 3)) ; => NIL
+
+;;; untuk list, string, dan bit-vector, guna EQUAL
+(equal (list 'a 'b) (list 'a 'b)) ; => T
+(equal (list 'a 'b) (list 'b 'a)) ; => NIL
+
+
+;;;-----------------------------------------------------------------------------
+;;; 5. Control Flow
+;;;-----------------------------------------------------------------------------
+
+;;; Conditional (syarat)
+
+(if t                ; test expression
+    "this is true"   ; then expression
+    "this is false") ; else expression
+; => "this is true"
+
+;;; Dalam conditional, semua value yang bukan NIL ialah true
+
+(member 'Groucho '(Harpo Groucho Zeppo)) ; => '(GROUCHO ZEPPO)
+(if (member 'Groucho '(Harpo Groucho Zeppo))
+    'yep
+    'nope)
+; => 'YEP
+
+;;; Guna COND untuk meletakkan beberapa test
+(cond ((> 2 2) (error "wrong!"))
+      ((< 2 2) (error "wrong again!"))
+      (t 'ok)) ; => 'OK
+
+;;; TYPECASE adalah seperti switch tetapi untuk data type value tersebut
+(typecase 1
+  (string :string)
+  (integer :int))
+; => :int
+
+
+;;; Loop
+
+;;; Recursion
+
+(defun fact (n)
+  (if (< n 2)
+      1
+    (* n (fact(- n 1)))))
+
+(fact 5) ; => 120
+
+;;; Iteration
+
+(defun fact (n)
+  (loop :for result = 1 :then (* result i)
+     :for i :from 2 :to n
+     :finally (return result)))
+
+(fact 5) ; => 120
+
+(loop :for x :across "abc" :collect x)
+; => (#\a #\b #\c #\d)
+
+(dolist (i '(1 2 3 4))
+  (format t "~A" i))
+; => 1234
+
+
+;;;-----------------------------------------------------------------------------
+;;; 6. Mutation
+;;;-----------------------------------------------------------------------------
+
+;;; Guna SETF untuk meletakkan nilai baru untuk variable yang sedia ada. Ini sama
+;;; seperti contoh hash table di atas.
+
+(let ((variable 10))
+    (setf variable 2))
+; => 2
+
+;;; Sebaik-baiknya kurangkan penggunaan destructive function dan elakkan
+;;; mutation jika boleh.
+
+
+;;;-----------------------------------------------------------------------------
+;;; 7. Class dan object
+;;;-----------------------------------------------------------------------------
+
+;;; Takde dah class untuk haiwan. Jom buat Human-Powered Mechanical
+;;; Conveyances (Kenderaan Mekanikal Berkuasa Manusia).
+
+(defclass human-powered-conveyance ()
+  ((velocity
+    :accessor velocity
+    :initarg :velocity)
+   (average-efficiency
+    :accessor average-efficiency
+   :initarg :average-efficiency))
+  (:documentation "A human powered conveyance"))
+
+;;; Argument untuk DEFCLASS, mengikut susunan ialah:
+;;; 1. nama class
+;;; 2. list untuk superclass
+;;; 3. list untuk slot
+;;; 4. specifier optional (tidak wajib)
+
+;;; Apabile list untuk superclass tidak ditetapkan, list yang kosong bermaksud
+;;; class standard-object. Ini *boleh* ditukar, kalau anda tahu apa yang anda buat.
+;;; Baca Art of the Metaobject Protocol untuk maklumat lebih lanjut.
+
+(defclass bicycle (human-powered-conveyance)
+  ((wheel-size
+    :accessor wheel-size
+    :initarg :wheel-size
+    :documentation "Diameter of the wheel.")
+   (height
+    :accessor height
+    :initarg :height)))
+
+(defclass recumbent (bicycle)
+  ((chain-type
+    :accessor chain-type
+    :initarg :chain-type)))
+
+(defclass unicycle (human-powered-conveyance) nil)
+
+(defclass canoe (human-powered-conveyance)
+  ((number-of-rowers
+    :accessor number-of-rowers
+    :initarg :number-of-rowers)))
+
+;;; Panggilan DESCRIBE kepada class HUMAN-POWERED-CONVEYANCE di REPL akan memberi:
+
+(describe 'human-powered-conveyance)
+
+; COMMON-LISP-USER::HUMAN-POWERED-CONVEYANCE
+;  [symbol]
+;
+; HUMAN-POWERED-CONVEYANCE names the standard-class #<STANDARD-CLASS
+;                                                    HUMAN-POWERED-CONVEYANCE>:
+;  Documentation:
+;    A human powered conveyance
+;  Direct superclasses: STANDARD-OBJECT
+;  Direct subclasses: UNICYCLE, BICYCLE, CANOE
+;  Not yet finalized.
+;  Direct slots:
+;    VELOCITY
+;      Readers: VELOCITY
+;      Writers: (SETF VELOCITY)
+;    AVERAGE-EFFICIENCY
+;      Readers: AVERAGE-EFFICIENCY
+;      Writers: (SETF AVERAGE-EFFICIENCY)
+
+;;; Perhatikan apa yang berlaku. CL memang direka sebagai sistem interaktif.
+
+;;; Untuk membuat method, jom kira berapa panjang lilitan untuk
+;;; roda basikal menggunakan formula: C = d * pi
+
+(defmethod circumference ((object bicycle))
+  (* pi (wheel-size object)))
+
+;;; Nilai PI memang sudah ada dalam CL
+
+;;; Katakanlah kita ingin ambil tahu efficiency value (nilai keberkesanan)
+;;; rower (pendayung) di dalam canoe (perahu) adalah berbentuk logarithmic. Ini
+;;; boleh ditetapkan di dalam constructor/initializer.
+
+;;; Untuk initialize instance selepas CL sudah siap construct:
+
+(defmethod initialize-instance :after ((object canoe) &rest args)
+  (setf (average-efficiency object)  (log (1+ (number-of-rowers object)))))
+
+;;; Kemudian untuk construct sesebuah instance dan periksa purata efficiency...
+
+(average-efficiency (make-instance 'canoe :number-of-rowers 15))
+; => 2.7725887
+
+
+;;;-----------------------------------------------------------------------------
+;;; 8. Macro
+;;;-----------------------------------------------------------------------------
+
+;;; Macro membolehkan anda untuk menambah syntax language. CL tidak ada
+;;; WHILE loop, tetapi, kita boleh mencipta syntax ter. Jika kita buat menggunakan
+;;; naluri, kita akan dapat:
+
+(defmacro while (condition &body body)
+    "While `condition` is true, `body` is executed.
+`condition` is tested prior to each execution of `body`"
+    (let ((block-name (gensym)) (done (gensym)))
+        `(tagbody
+           ,block-name
+           (unless ,condition
+               (go ,done))
+           (progn
+           ,@body)
+           (go ,block-name)
+           ,done)))
+
+;;; Jom lihat versi yang lebih high-level:
+
+(defmacro while (condition &body body)
+    "While `condition` is true, `body` is executed.
+`condition` is tested prior to each execution of `body`"
+  `(loop while ,condition
+         do
+         (progn
+            ,@body)))
+
+;;; Namun, dengan compiler yang modern, cara ini tidak diperlukan; form LOOP
+;;; compile sama sahaja dan juga mudah dibaca.
+
+;;; Perhatikan ``` digunakan, sama juga `,` dan `@`. ``` ialah operator jenis quote
+;;; yang dipanggil quasiquote; operator tersebut membolehkan penggunaan `,` .
+;;; `,` membolehkan variable "di-unquote-kan". @ mengembangkan list.
+
+;;; GENSYM membuat simbol unik yang pasti tidak wujud di tempat-tempat yang
+;;; lain. Ini kerana macro dikembangkan semasa compile dan
+;;; nama variable di dalam macro boleh bertembung dengan nama variable yang
+;;; digunakan dalam code yang biasa.
+
+;;; Baca Practical Common Lisp dan On Lisp untuk maklumat lebih lanjut mengenai macro.
+```
+
+
+## Bacaan lanjut
+
+- [Practical Common Lisp](http://www.gigamonkeys.com/book/)
+- [Common Lisp: A Gentle Introduction to Symbolic Computation](https://www.cs.cmu.edu/~dst/LispBook/book.pdf)
+
+
+## Maklumat tambahan
+
+- [CLiki](http://www.cliki.net/)
+- [common-lisp.net](https://common-lisp.net/)
+- [Awesome Common Lisp](https://github.com/CodyReichert/awesome-cl)
+- [Lisp Lang](http://lisp-lang.org/)
+
+
+## Kredit
+
+Terima kasih banyak diucapkan kepada ahli Scheme yang membuat permulaan yang sangat
+bagus dan mudah untuk diguna pakai untuk Common Lisp.
+
+- [Paul Khuong](https://github.com/pkhuong) untuk review yang bagus.
diff --git a/ms-my/elisp-my.html.markdown b/ms-my/elisp-my.html.markdown
new file mode 100644
index 00000000..73dff0f4
--- /dev/null
+++ b/ms-my/elisp-my.html.markdown
@@ -0,0 +1,347 @@
+---
+language: elisp
+contributors:
+    - ["Bastien Guerry", "https://bzg.fr"]
+    - ["Saurabh Sandav", "http://github.com/SaurabhSandav"]
+translators:
+    - ["Burhanuddin Baharuddin", "https://github.com/burhanloey"]
+lang: ms-my
+filename: learn-emacs-lisp-ms.el
+---
+
+```scheme
+;; Ini adalah pengenalan kepada Emacs Lisp dalam masa 15 minit (v0.2d)
+;;
+;; Mula-mula pastikan anda sudah membaca artikel daripada Peter Norvig ini:
+;; http://norvig.com/21-days.html
+;;
+;; Kemudian install GNU Emacs 24.3:
+;;
+;; Debian: apt-get install emacs (atau lihat arahan untuk distro anda)
+;; OSX: http://emacsformacosx.com/emacs-builds/Emacs-24.3-universal-10.6.8.dmg
+;; Windows: http://ftp.gnu.org/gnu/windows/emacs/emacs-24.3-bin-i386.zip
+;;
+;; Maklumat lanjut boleh didapati di:
+;; http://www.gnu.org/software/emacs/#Obtaining
+
+;; Amaran penting:
+;;
+;; Tutorial ini tidak akan merosakkan komputer anda melainkan jika anda berasa
+;; terlalu marah sehingga anda menghempap komputer anda ke lantai. Kalau begitu,
+;; saya dengan ini tidak akan bertanggungjawab terhadap apa-apa. Berseronoklah ya!
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Buka Emacs.
+;;
+;; Tekan `q' untuk tutup mesej selamat datang.
+;;
+;; Sekarang lihat garis kelabu di bahagian bawah window:
+;;
+;; "*scratch*" ialah nama ruangan untuk anda edit.
+;; Ruangan ini disebut sebagai "buffer".
+;;
+;; Buffer scratch ialah buffer yang default setiap kali Emacs dibuka.
+;; Anda bukannya edit file: anda edit buffer yang kemudiannya
+;; boleh save ke file.
+;;
+;; "Lisp interaction (interaksi)" merujuk kepada command yang wujud di sini.
+;;
+;; Emacs mempunyai beberapa command yang sedia ada dalam setiap buffer,
+;; dan sesetengah command yang lain boleh didapati jika sesetengah mode
+;; diaktifkan.  Di sini kita menggunakan `lisp-interaction-mode', yang
+;; mempunyai command untuk menjalankan dan mengendalikan code Elisp.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Semicolon akan menjadikan comment sepanjang baris tersebut.
+;;
+;; Program Elisp mengandungi symbolic expressions ("sexps"):
+(+ 2 2)
+
+;; Symbolic expression di atas dibaca begini "Tambah 2 pada 2".
+
+;; Sexps dilitupi oleh parentheses, dan boleh dalam bentuk nested (parentheses
+;; dalam parentheses):
+(+ 2 (+ 1 1))
+
+;; Symbolic expression mengandungi atom atau symbolic expression
+;; yang lain.  Untuk contoh di atas, 1 dan 2 ialah atom,
+;; (+ 2 (+ 1 1)) dan (+ 1 1) ialah symbolic expression.
+
+;; Dengan menggunakan `lisp-interaction-mode', anda boleh evaluate
+;; (mendapatkan hasil pengiraan) sexps. Letak cursor selepas parenthesis penutup
+;; kemudian tekan control dan j ("C-j").
+
+(+ 3 (+ 1 2))
+;;           ^ cursor di sini
+;; `C-j' => 6
+
+;; `C-j' memasukkan jawapan pengiraan ke dalam buffer.
+
+;; `C-xC-e' memaparkan jawapan yang sama di bahagian bawah Emacs,
+;; yang dipanggil "minibuffer".  Secara umumnya kita akan menggunakan `C-xC-e',
+;; sebab kita tidak mahu memenuhi buffer dengan teks yang tidak penting.
+
+;; `setq' menyimpan value ke dalam variable:
+(setq my-name "Bastien")
+;; `C-xC-e' => "Bastien" (terpapar di mini-buffer)
+
+;; `insert' akan memasukkan "Hello!" di tempat di mana cursor berada:
+(insert "Hello!")
+;; `C-xC-e' => "Hello!"
+
+;; Di atas, kita menggunakan `insert' dengan satu argument "Hello!", tetapi
+;; kita boleh meletakkan beberapa argument -- di sini kita letak dua:
+
+(insert "Hello" " world!")
+;; `C-xC-e' => "Hello world!"
+
+;; Anda boleh menggunakan variable selain string:
+(insert "Hello, I am " my-name)
+;; `C-xC-e' => "Hello, I am Bastien"
+
+;; Anda boleh menggabungkan sexps untuk membuat function:
+(defun hello () (insert "Hello, I am " my-name))
+;; `C-xC-e' => hello
+
+;; Anda boleh evaluate function:
+(hello)
+;; `C-xC-e' => Hello, I am Bastien
+
+;; Parentheses kosong di dalam function bermaksud function tersebut tidak
+;; terima argument.  Sekarang kita tukar function untuk menerima satu argument.
+;; Di sini, argument tersebut dinamakan "name":
+
+(defun hello (name) (insert "Hello " name))
+;; `C-xC-e' => hello
+
+;; Sekarang panggil function tersebut dengan string "you" sebagai value
+;; untuk argument:
+(hello "you")
+;; `C-xC-e' => "Hello you"
+
+;; Yay!
+
+;; Tarik nafas.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Sekarang tukar ke buffer baru dengan nama "*test*" di window yang lain:
+
+(switch-to-buffer-other-window "*test*")
+;; `C-xC-e'
+;; => [The screen has two windows and cursor is in the *test* buffer]
+
+;; Gerakkan mouse ke window atas dan klik kiri untuk pergi balik ke buffer scratch.
+;; Cara lain adalah dengan menggunakan `C-xo' (i.e. tekan control-x kemudian
+;; tekan o) untuk pergi ke window yang lain.
+
+;; Anda boleh menggabungkan beberapa sexps menggunakan `progn':
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (hello "you"))
+;; `C-xC-e'
+;; => [The screen has two windows and cursor is in the *test* buffer]
+
+;; Mulai dari sekarang saya tidak akan beritahu anda untuk tekan `C-xC-e' lagi:
+;; buat untuk setiap sexp yang akan datang.
+
+;; Pergi balik ke buffer *scratch* menggunakan mouse atau `C-xo'.
+
+;; Seelok-eloknya padam buffer tersebut:
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello "there"))
+
+;; Atau pergi balik ke window lain:
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello "you")
+  (other-window 1))
+
+;; Anda boleh menetapkan value dengan local variable menggunakan `let':
+(let ((local-name "you"))
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello local-name)
+  (other-window 1))
+
+;; Tidak perlu menggunakan `progn', sebab `let' juga menggabungkan
+;; beberapa sexps.
+
+;; Jom format string:
+(format "Hello %s!\n" "visitor")
+
+;; %s ialah tempat untuk meletakkan string, digantikan dengan "visitor".
+;; \n ialah character untuk membuat baris baru.
+
+;; Jom tukar function kita menggunakan format:
+(defun hello (name)
+  (insert (format "Hello %s!\n" name)))
+
+(hello "you")
+
+;; Jom buat function lain menggunakan `let':
+(defun greeting (name)
+  (let ((your-name "Bastien"))
+    (insert (format "Hello %s!\n\nI am %s."
+                    name       ; argument untuk function
+                    your-name  ; variable "Bastien" daripada let
+                    ))))
+
+;; Kemudian evaluate:
+(greeting "you")
+
+;; Sesetengah function adalah interaktif:
+(read-from-minibuffer "Enter your name: ")
+
+;; Function tersebut akan memulangkan kembali apa yang anda masukkan ke prompt.
+
+;; Jom jadikan function `greeting' untuk prompt nama anda:
+(defun greeting (from-name)
+  (let ((your-name (read-from-minibuffer "Enter your name: ")))
+    (insert (format "Hello!\n\nI am %s and you are %s."
+                    from-name ; argument untuk function
+                    your-name ; variable daripada let, yang dimasukkan dari prompt
+                    ))))
+
+(greeting "Bastien")
+
+;; Jom siapkan function dengan memaparkan result di window yang lain:
+(defun greeting (from-name)
+  (let ((your-name (read-from-minibuffer "Enter your name: ")))
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    (insert (format "Hello %s!\n\nI am %s." your-name from-name))
+    (other-window 1)))
+
+;; Test function tersebut:
+(greeting "Bastien")
+
+;; Tarik nafas.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Jom simpan senarai nama:
+;; Jika anda ingin membuat list(senarai) data, guna ' untuk elak
+;; daripada list tersebut evaluate.
+(setq list-of-names '("Sarah" "Chloe" "Mathilde"))
+
+;; Dapatkan elemen pertama daripada list menggunakan `car':
+(car list-of-names)
+
+;; Dapatkan semua elemen kecuali yang pertama menggunakan `cdr':
+(cdr list-of-names)
+
+;; Tambah elemen di awal list menggunakan `push':
+(push "Stephanie" list-of-names)
+
+;; NOTA: `car' dan `cdr' tidak ubah suai list, tetapi `push' ya.
+;; Perbezaan ini penting: sesetengah function tiada side-effects (kesan sampingan)
+;; (seperti `car') dan yang lain ada side-effect (seperti `push').
+
+;; Jom panggil `hello' untuk setiap elemen dalam `list-of-names':
+(mapcar 'hello list-of-names)
+
+;; Tukar `greeting' supaya ucapkan hello kepada semua orang dalam `list-of-names':
+(defun greeting ()
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    (mapcar 'hello list-of-names)
+    (other-window 1))
+
+(greeting)
+
+;; Ingat lagi function `hello' di atas? Function tersebut mengambil satu
+;; argument, iaitu nama.  `mapcar' memanggil `hello', kemudian menggunakan setiap
+;; nama dalam `list-of-names' sebagai argument untuk function `hello'.
+
+;; Sekarang kita susun sedikit untuk apa yang terpapar di buffer:
+
+(defun replace-hello-by-bonjour ()
+    (switch-to-buffer-other-window "*test*")
+    (goto-char (point-min))
+    (while (search-forward "Hello")
+      (replace-match "Bonjour"))
+    (other-window 1))
+
+;; (goto-char (point-min)) akan pergi ke permulaan buffer.
+;; (search-forward "Hello") akan mencari string "Hello".
+;; (while x y) evaluate sexp(s) y selagi x masih pulangkan sesuatu.
+;; Jika x pulangkan `nil', kita akan keluar daripada while loop.
+
+(replace-hello-by-bonjour)
+
+;; Anda akan dapat melihat semua "Hello" dalam buffer *test*
+;; ditukarkan dengan "Bonjour".
+
+;; Anda juga akan dapat error: "Search failed: Hello".
+;;
+;; Bagi mengelakkan error tersebut, anda perlu beritahu `search-forward' sama ada
+;; perlu berhenti mencari pada suatu ketika, dan sama ada perlu diam jika
+;; tidak jumpa apa yang dicari:
+
+;; (search-forward "Hello" nil 't) selesai masalah:
+
+;; Argument `nil' cakap: carian tidak mengikut kedudukan.
+;; Argument `'t'  cakap: diam saja jika tidak jumpa apa yang dicari.
+
+;; Kita guna sexp ini di function berikut, barulah tidak keluar error:
+
+(defun hello-to-bonjour ()
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    ;; Ucap hello pada nama-nama dalam `list-of-names'
+    (mapcar 'hello list-of-names)
+    (goto-char (point-min))
+    ;; Ganti "Hello" dengan "Bonjour"
+    (while (search-forward "Hello" nil 't)
+      (replace-match "Bonjour"))
+    (other-window 1))
+
+(hello-to-bonjour)
+
+;; Jom jadikan nama-nama tersebut bold:
+
+(defun boldify-names ()
+    (switch-to-buffer-other-window "*test*")
+    (goto-char (point-min))
+    (while (re-search-forward "Bonjour \\(.+\\)!" nil 't)
+      (add-text-properties (match-beginning 1)
+                           (match-end 1)
+                           (list 'face 'bold)))
+    (other-window 1))
+
+;; Function ini memperkenalkan `re-search-forward': anda mencari menggunakan
+;; pattern iaitu "regular expression", bukannya mencari string "Bonjour".
+
+;; Regular expression tersebut ialah "Bonjour \\(.+\\)!" dan dibaca begini:
+;; string "Bonjour ", dan
+;; kumpulan                | ini ialah \\( ... \\)
+;;   mana-mana character   | ini ialah .
+;;   yang boleh berulang   | ini ialah +
+;; dan string "!".
+
+;; Dah sedia?  Test function tersebut!
+
+(boldify-names)
+
+;; `add-text-properties' tambah... ciri-ciri teks, seperti face.
+
+;; OK, kita sudah selesai.  Selamat ber-hacking!
+
+;; Jika anda ingin tahu lebih mengenai variable atau function:
+;;
+;; C-h v a-variable RET
+;; C-h f a-function RET
+;;
+;; Jika anda ingin membaca manual Emacs Lisp menggunakan Emacs:
+;;
+;; C-h i m elisp RET
+;;
+;; Jika ingin membaca pengenalan kepada Emacs Lisp secara online:
+;; https://www.gnu.org/software/emacs/manual/html_node/eintr/index.html
+```
diff --git a/nix.html.markdown b/nix.html.markdown
index d078395a..5941f0e6 100644
--- a/nix.html.markdown
+++ b/nix.html.markdown
@@ -4,6 +4,7 @@ filename: learn.nix
 contributors:
     - ["Chris Martin", "http://chris-martin.org/"]
     - ["Rommel Martinez", "https://ebzzry.io"]
+    - ["Javier Candeira", "https://candeira.com/"]
 ---
 
 Nix is a simple functional language developed for the
@@ -12,7 +13,7 @@ Nix is a simple functional language developed for the
 
 You can evaluate Nix expressions using
 [nix-instantiate](https://nixos.org/nix/manual/#sec-nix-instantiate)
-or [`nix-repl`](https://github.com/edolstra/nix-repl).
+or [`nix repl`](https://nixos.org/nix/manual/#ssec-relnotes-2.0).
 
 ```
 with builtins; [
@@ -39,18 +40,26 @@ with builtins; [
   #=> "a"
 
 
-  #  Integers
+  #  Integers and Floats
   #=========================================
 
-  # Integers are the only numeric type.
+  # There are two numeric types: integers and floats
 
   1 0 42 (-3)       # Some integers
 
+  123.43 .27e13     # A couple of floats
+
+  # Operations will preserve numeric type
+
   (4 + 6 + 12 - 2)  # Addition
   #=> 20
+  (4 - 2.5)
+  #=> 1.5
 
   (7 / 2)           # Division
   #=> 3
+  (7 / 2.0)
+  #=> 3.5
 
 
   #  Strings
@@ -238,13 +247,20 @@ with builtins; [
   }.a.c
   #=> { d = 2; e = 3; }
 
-  # An attribute's descendants cannot be assigned in this
-  # way if the attribute itself has been directly assigned.
+  # Sets are immutable, so you can't redefine an attribute:
+  {
+    a = { b = 1; };
+    a.b = 2;
+  }
+  #=> attribute 'a.b' at (string):3:5 already defined at (string):2:11
+
+  # However, an attribute's set members can also be defined piecewise
+  # way even if the attribute itself has been directly assigned.
   {
     a = { b = 1; };
     a.c = 2;
   }
-  #=> error: attribute ‘a’ already defined
+  #=> { a = { b = 1; c = 2; }; }
 
 
   #  With
@@ -321,8 +337,8 @@ with builtins; [
   #=========================================
 
   # Because repeatability of builds is critical to the Nix package
-  # manager, in which, functional purity is emphasized in the Nix
-  # language. But there are a few impurities.
+  # manager, functional purity is emphasized in the Nix language
+  # used to describe Nix packages. But there are a few impurities.
 
   # You can refer to environment variables.
   (getEnv "HOME")
diff --git a/nl-nl/dynamic-programming-nl.html.markdown b/nl-nl/dynamic-programming-nl.html.markdown
new file mode 100644
index 00000000..e56a9774
--- /dev/null
+++ b/nl-nl/dynamic-programming-nl.html.markdown
@@ -0,0 +1,55 @@
+---
+category: Algorithms & Data Structures
+name: Dynamic Programming
+contributors:
+    - ["Akashdeep Goel", "http://github.com/akashdeepgoel"]
+translators:
+  - ["Jasper Haasdijk", "https://github.com/jhaasdijk"]
+lang: nl-nl
+---
+
+# Dynamisch Programmeren
+
+## Introductie
+
+Dynamisch programmeren is een krachtige techniek die, zoals we zullen zien, gebruikt kan worden om een bepaalde klasse van problemen op te lossen. Het idee is eenvoudig. Als je een oplossing hebt voor een probleem met een bepaalde input, sla dit resultaat dan op. Hiermee kan je voorkomen dat je in de toekomst nog een keer hetzelfde probleem moet gaan oplossen omdat je het resultaat vergeten bent.
+
+Onthoud altijd!
+"Zij die het verleden niet kunnen herinneren, zijn gedoemd het te herhalen."
+
+## Verschillende aanpakken
+
+1. *Top-Down* : Oftewel, van boven naar beneden. Begin je oplossing met het afbreken van het probleem in kleine stukken. Kom je een stukje tegen dat je eerder al hebt opgelost, kijk dan enkel naar het opgeslagen antwoord. Kom je een stukje tegen dat je nog niet eerder hebt opgelost, los het op en sla het antwoord op. Deze manier is voor veel mensen de makkelijke manier om erover na te denken, erg intuitief. Deze methode wordt ook wel Memoization genoemd.
+
+2. *Bottom-Up* : Oftewel, van beneden naar boven. Analyseer het probleem en bekijk de volgorde waarin de sub-problemen opgelost kunnen worden. Begin met het oplossen van de triviale gevallen en maak zodoende de weg naar het gegeven probleem. In dit process is het gegarandeerd dat de sub-problemen eerder worden opgelost dan het gegeven probleem. Deze methode wordt ook wel Dynamisch Programmeren genoemd.
+
+## Voorbeeld van Dynamisch Programmeren
+
+Het langst stijgende sequentie probleem is het probleem waarbij je binnen een bepaalde reeks op zoek bent naar het langste aaneengesloten stijgende stuk. Gegeven een reeks `S = {a1 , a2 , a3, a4, ............., an-1, an }` zijn we op zoek naar het langst aaneengesloten stuk zodanig dat voor alle `j` en `i`, `j<i` in de reeks `aj<ai`.
+
+Ten eerste moeten we de waarde van de langste subreeksen(LSi) op elke index i vinden waar het laatste element van de reeks ai is. Daarna zal LSi het langste subreeks in de gegeven reeks zijn. Om te beginnen heeft LSi de waarde 1 omdat ai een element van de reeks(laatste element) is. Daarna zal voor alle `j` zodanig dat `j<i` en `aj<ai` de grootste LSj gevonden en toegevoegd worden aan LSi. Het algoritme duurt *O(n2)* tijd.
+
+Pseudo-code voor het vinden van de lengte van de langst stijgende subreeks:
+De complexiteit van het algoritme kan worden vermindert door het gebruik van een betere data structuur dan een simpele lijst. Het opslaan van een voorgangers lijst en een variabele als `langste_reeks_dusver` en de index daarvan, kan ook een hoop tijd schelen.
+
+Een soortgelijk concept kan worden toegepast in het vinden van het langste pad in een gerichte acyclische graaf.
+
+```python
+for i=0 to n-1
+    LS[i]=1
+    for j=0 to i-1
+        if (a[i] >  a[j] and LS[i]<LS[j])
+            LS[i] = LS[j]+1
+for i=0 to n-1
+    if (langste < LS[i])
+```
+
+### Enkele beroemde DP problemen
+
+- [Floyd Warshall Algorithm - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code)
+- [Integer Knapsack Problem - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem)
+- [Longest Common Subsequence - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence) 
+
+## Online Bronnen
+
+* [codechef](https://www.codechef.com/wiki/tutorial-dynamic-programming)
diff --git a/nl-nl/markdown-nl.html.markdown b/nl-nl/markdown-nl.html.markdown
index 35cc67c5..b5b4681c 100644
--- a/nl-nl/markdown-nl.html.markdown
+++ b/nl-nl/markdown-nl.html.markdown
@@ -12,7 +12,7 @@ Markdown is gecreëerd door John Gruber in 2004. Het is bedoeld om met een gemak
 schrijven syntax te zijn die gemakkelijk omgevormd kan worden naar HTML (en op heden verschillende
 andere formaten)
 
-```markdown
+```md
 <!-- Markdown erft over van HTML, dus ieder HTML bestand is een geldig Markdown
 bestand. Dit betekend ook dat html elementen gebruikt kunnen worden in Markdown
 zoals het commentaar element. Echter, als je een html element maakt in een Markdown 
diff --git a/nl-nl/vim-nl.html.markdown b/nl-nl/vim-nl.html.markdown
new file mode 100644
index 00000000..a69c031c
--- /dev/null
+++ b/nl-nl/vim-nl.html.markdown
@@ -0,0 +1,272 @@
+---
+category: tool
+tool: vim
+contributors:
+    - ["RadhikaG", "https://github.com/RadhikaG"]
+translators:
+  - ["Rick Haan", "https://github.com/RickHaan"]
+filename: learnvim-nl.yaml
+lang: nl-nl
+---
+
+# Vim in het Nederlands
+
+[Vim](http://www.vim.org)
+(Vi IMproved) is een kopie van de populaire vi editor voor Unix. Het is
+ontworpen voor snelheid, verhoogde productiviteit en is beschikbaar in de meeste
+unix-gebaseerde systemen. Het heeft verscheidene toetscombinaties voor snelle
+navigatie en aanpassingen in het doelbestand.
+
+## De Basis van het navigeren in Vim
+
+``` Vim
+    vim <bestandsnaam> # Open <bestandsnaam> in vim
+    :help <onderwerp>  # Open ingebouwde documentatie over <onderwerp> als
+    deze bestaat
+    :q               # Vim afsluiten
+    :w               # Huidig bestand opslaan
+    :wq              # Huidig bestand opslaan en vim afsluiten
+    ZZ               # Huidig bestand opslaan en vim afsluiten
+    :x               # Huidig bestand opslaan en vim afsluiten, verkorte versie
+    :q!              # Afsluiten zonder opslaan
+                     # ! *forceert* het normale afsluiten met :q
+
+    u                # Ongedaan maken
+    CTRL+R           # Opnieuw doen
+
+    h                # Ga 1 karakter naar links
+    j                # Ga 1 regel naar beneden
+    k                # Ga 1 regel omhoog
+    l                # Ga 1 karakter naar rechts
+
+    Ctrl+B           # Ga 1 volledig scherm terug
+    Ctrl+F           # Ga 1 volledig scherm vooruit
+    Ctrl+D           # Ga 1/2 scherm vooruit
+    Ctrl+U           # Ga 1/2 scherm terug
+
+    # Verplaatsen over de regel
+
+    0                # Verplaats naar het begin van de regel
+    $                # Verplaats naar het eind van de regel
+    ^                # Verplaats naar het eerste niet-lege karakter op de regel
+
+    # Zoeken in de tekst
+
+    /word            # Markeert alle voorvallen van 'word' na de cursor
+    ?word            # Markeert alle voorvallen van 'word' voor de cursor
+    n                # Verplaatst de cursor naar het volgende voorval van
+    de zoekopdracht
+    N                # Verplaatst de cursor naar het vorige voorval van
+    de zoekopdracht
+
+    :%s/foo/bar/g    # Verander 'foo' naar 'bar' op elke regel van het bestand
+    :s/foo/bar/g     # Verander 'foo' naar 'bar' op de huidge regel in
+    het bestand
+    :%s/\n/\r/g      # Vervang nieuwe regel karakters met nieuwe regel karakters
+
+    # Spring naar karakters
+
+    f<character>     # Spring vooruit en land op <character>
+    t<character>     # Spring vooruit en land net voor <character>
+
+    # Bijvoorbeeld,
+    f<               # Spring vooruit en land op <
+    t<               # Spring vooruit en land net voor <
+
+    # Verplaatsen per woord
+
+    w                # Ga 1 woord vooruit
+    b                # Ga 1 woord achteruit
+    e                # Ga naar het einde van het huidige woord
+
+    # Andere karakters om mee te verplaatsen
+
+    gg               # Ga naar de bovenkant van het bestand
+    G                # Ga naar de onderkant van het bestand
+    :NUM             # Ga naar regel NUM (NUM is elk nummer)
+    H                # Ga naar de bovenkant van het scherm
+    M                # Ga naar het midden van het scherm
+    L                # Ga naar de onderkant van het scherm
+```
+
+## Help documentatie
+
+Vim heeft ingebouwde help documentatie dat benaderd kan worden met
+`:help <onderwerp>`. Bijvoorbeeld `:help navigation` geeft documentatie weer hoe
+door vim te navigeren. `:help` kan ook gebruikt worden zonder onderwerp. Dan wordt de standaard documentatie weergeven die bedoelt is om vim toegankelijker te maken.
+
+## Modus
+
+Vim is gebaseerd op het concept van **modus**.
+
+* Command (opdracht) modus - Vim wordt opgestart in deze mode. Deze mode wordt
+gebruikt om opdrachten te geven en te navigeren
+* Insert (invoer) modus - Wordt gebruikt voor het aanpassen van het bestand
+* Zichtbare (Visual) modus - Wordt gebruikt voor het markeren en bewerken van
+tekst
+* Ex modus - Wordt gebruikt voor het uitvoeren van opdrachten met `:`
+
+``` Vim
+    i                # Zet vim in de Command modus voor de cursor positie
+    a                # Zet vim in de Insert modus na de cursor positie (append)
+    v                # Zet vim in de Visual modus
+    :                # Zet vim in de ex modus
+    <esc>            # 'Escapes' vanuit elke modus naar de Command modus
+
+    # Het kopiëren en plakken van tekst
+
+    y                # Yank (kopieer) wat geselecteerd is
+    yy               # Yank (kopieer) de huidige regel
+    d                # Verwijder wat geselecteerd is
+    dd               # Verwijder de huidige regel
+    p                # Plak de huidige tekst op de cursor positie
+    P                # Plak de huidige tekst voor de cursor positie
+    x                # Verwijder karakter op cursor positie
+```
+
+## De 'gramatica' van vim
+
+Vim kan aangeleerd worden als een set van acties in het 'Verb-Modifier-Noun'
+formaat waar:
+
+Verb (werkwoord) - De uit te voeren actie
+Modifier (bijwoord) - Hoe de actie uitgevoerd dient te worden
+Noun - Het object waarop de actie uitgevoerd wordt
+
+Een paar belangrijke voorbeelden van 'Verbs', 'Modifiers', en 'Nouns' zijn:
+
+``` Vim
+    # 'Verbs'
+
+    d       # Verwijder
+    c       # Verander
+    y       # Kopieer
+    v       # Zichtbaar selecteren
+
+    # 'Modifiers'
+
+    i       # Binnen
+    a       # Rondom
+    NUM     # Elk nummer
+    f       # Zoekt iets en selecteerd het
+    t       # Zoekt iets en selecteerd het karakter voor het
+    /       # Vindt een combinatie van tekens vanaf de cursor
+    ?       # Vindt een combinatie van tekens voor de cursor
+
+    # 'Nouns'
+
+    w       # Woord
+    s       # Zin
+    p       # Paragraaf
+    b       # Blok
+
+    # Voorbeeld 'zinnen' of opdrachten
+
+    d2w     # Verwijder twee woorden
+    cis     # Verander in de zin
+    yip     # Kopiereer in de paragraaf
+    ct<     # Verander naar haakje openen
+            # Verander de tekst vanaf de huidige positie tot het volgende haakje
+            openen
+    d$      # Verwijder tot het einde van de regel
+```
+
+## Een aantal afkortingen en trucs
+
+``` Vim
+    >               # Verspring de selectie met 1 blok
+    <               # Verspring de selectie met 1 blok terug
+    :earlier 15     # Zet het document terug naar de situatie van 15 minuten
+    geleden
+    :later 15       # Zet het document in de situatie 15 minuten in de toekomst
+    (omgekeerde van de vorige opdracht)
+    ddp             # Wissel de positie van opeenvolgende regels. dd daarna p
+    .               # Herhaal de vorige opdracht
+    :w !sudo tee%   # Sla het huidige bestand op als root
+    :set syntax=c   # Stel syntax uitlichten in op 'c'
+    :sort           # Sorteer alle regels
+    :sort!          # Sorteer alle regels omgekeerd
+    :sort u         # Sorteer alle regels en verwijder duplicaten
+    ~               # Stel letter case in voor geselecteerde tekst
+    u               # Verander de geselecteerde tekst naar kleine letters
+    U               # Verander de geselecteerde tekst naar hoofdletters
+
+    # Fold text
+    zf              # Creeer een vouw op de geslecteerde tekst
+    zo              # Open huidige vouw
+    zc              # Sluit huidige vouw
+    zR              # Open alle vouwen
+    zM              # Sluit alle vouwen
+```
+
+## Macro's
+
+Macro's zijn opgeslagen opdrachten. Wanneer je begint met het opnemen van een
+macro dan worden **alle** acties opgenomen, totdat je stopt met opnemen. Als de
+macro uitgevoerd wordt, worden alle acties in de zelfde volgorde als tijdens het
+opnemen uitgevoerd.
+
+``` Vim
+    qa  # Start met het opnemen van de makro genaamd 'a'
+    q   # Stop met opnemen
+    @a  # Gebruik macro 'a'
+```
+
+## Configureren van .vimrc
+
+Het .vimrc bestand kan gebruikt worden voor het opslaan van een
+standaardconfiguratie van Vim. Het bestand wordt opgeslagen in de home map van de gebruiker. Hieronder staat een voorbeeld van een .vimrc bestand.
+
+``` Vim
+" Voorbeeld ~/.vimrc
+" 2015.10
+
+" In te stellen dat Vim niet samenwerkt met Vi
+set nocompatible
+
+" Stel in dat Vim kijkt naar de bestandstype voor syntax uitlichting en
+automatish inspringen
+filetype indent plugin on
+
+" Zet inspringen aan
+syntax on
+
+" Betere opdracht regel aanvulling
+set wildmenu
+
+" Gebruik niet hoofdlettergevoelig zoeken.
+set ignorecase
+set smartcase
+
+" Gebruik automatisch inspringen
+set autoindent
+
+" Geef regelnummers weer
+set number
+
+" Het aantal zichtbare spatie's per TAB
+set tabstop=4
+
+" Het aantal spatie's tijdens het aanpassen
+set softtabstop=4
+
+" Aantal spatie's wanneer (>> en <<) worden gebruikt
+
+" Maak van TAB's spatie's
+set expandtab
+
+" Gebruik slimme tabs spatie's voor inspringen en uitlijnen
+set smarttab
+```
+
+## Referenties (Engels)
+
+[Vim | Home](http://www.vim.org/index.php)
+
+`$ vimtutor`
+
+[A vim Tutorial and Primer](https://danielmiessler.com/study/vim/)
+
+[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about)
+
+[Arch Linux Wiki](https://wiki.archlinux.org/index.php/Vim)
\ No newline at end of file
diff --git a/objective-c.html.markdown b/objective-c.html.markdown
index 04c4e529..de3884af 100644
--- a/objective-c.html.markdown
+++ b/objective-c.html.markdown
@@ -731,7 +731,10 @@ if ([myClass conformsToProtocol:@protocol(CarUtilities)]) {
 ///////////////////////////////////////
 // Blocks are statements of code, just like a function, that are able to be used as data.
 // Below is a simple block with an integer argument that returns the argument plus 4.
-int (^addUp)(int n); // Declare a variable to store the block.
+^(int n) {
+    return n + 4;
+}
+int (^addUp)(int n); // Declare a variable to store a block.
 void (^noParameterBlockVar)(void); // Example variable declaration of block with no arguments.
 // Blocks have access to variables in the same scope. But the variables are readonly and the
 // value passed to the block is the value of the variable when the block is created.
diff --git a/ocaml.html.markdown b/ocaml.html.markdown
index 74eb7993..b631df0a 100644
--- a/ocaml.html.markdown
+++ b/ocaml.html.markdown
@@ -161,7 +161,7 @@ let my_lambda = fun x -> x * x ;;
 
 (*** Operators ***)
 
-(* There is little distintion between operators and functions.
+(* There is little distinction between operators and functions.
    Every operator can be called as a function. *)
 
 (+) 3 4  (* Same as 3 + 4 *)
diff --git a/opencv.html.markdown b/opencv.html.markdown
new file mode 100644
index 00000000..f8763b35
--- /dev/null
+++ b/opencv.html.markdown
@@ -0,0 +1,144 @@
+---
+category: tool
+tool: OpenCV
+filename: learnopencv.py
+contributors:
+    - ["Yogesh Ojha", "http://github.com/yogeshojha"]
+---
+### Opencv
+
+OpenCV (Open Source Computer Vision) is a library of programming functions mainly aimed at real-time computer vision. 
+Originally developed by Intel, it was later supported by Willow Garage then Itseez (which was later acquired by Intel). 
+Opencv currently supports wide variety of languages like, C++, Python, Java etc
+
+#### Installation
+Please refer to these articles for installation of OpenCV on your computer.
+
+* Windows Installation Instructions: [https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_setup/py_setup_in_windows/py_setup_in_windows.html#install-opencv-python-in-windows]()
+* Mac Installation Instructions (High Sierra): [https://medium.com/@nuwanprabhath/installing-opencv-in-macos-high-sierra-for-python-3-89c79f0a246a]()
+* Linux Installation Instructions (Ubuntu 18.04): [https://www.pyimagesearch.com/2018/05/28/ubuntu-18-04-how-to-install-opencv]()
+
+### Here we will be focusing on python implementation of OpenCV
+
+```python
+# Reading image in OpenCV
+import cv2
+img = cv2.imread('cat.jpg')
+
+# Displaying the image
+# imshow() function is used to display the image
+cv2.imshow('Image',img)
+# Your first arguement is the title of the window and second parameter is image
+# If you are getting error, Object Type None, your image path may be wrong. Please recheck the pack to the image
+cv2.waitKey(0)
+# waitKey() is a keyboard binding function and takes arguement in milliseconds. For GUI events you MUST use waitKey() function.
+
+# Writing an image
+cv2.imwrite('catgray.png',img)
+# first arguement is the file name and second is the image
+
+# Convert image to grayscale
+gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+# Capturing Video from Webcam
+cap = cv2.VideoCapture(0)
+#0 is your camera, if you have multiple camera, you need to enter their id
+while(True):
+    # Capturing frame-by-frame
+    _, frame = cap.read()
+    cv2.imshow('Frame',frame)
+    # When user presses q -> quit
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+# Camera must be released
+cap.release()
+
+# Playing Video from file
+cap = cv2.VideoCapture('movie.mp4')
+while(cap.isOpened()):
+    _, frame = cap.read()
+    # Play the video in grayscale
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    cv2.imshow('frame',gray)
+    if cv2.waitKey(1) & 0xFF == ord('q'):
+        break
+cap.release()
+
+# Drawing The Line in OpenCV
+# cv2.line(img,(x,y),(x1,y1),(color->r,g,b->0 to 255),thickness)
+cv2.line(img,(0,0),(511,511),(255,0,0),5)
+
+# Drawing Rectangle
+# cv2.rectangle(img,(x,y),(x1,y1),(color->r,g,b->0 to 255),thickness)
+# thickness = -1 used for filling the rectangle
+cv2.rectangle(img,(384,0),(510,128),(0,255,0),3)
+
+# Drawing Circle
+cv2.circle(img,(xCenter,yCenter), radius, (color->r,g,b->0 to 255), thickness)
+cv2.circle(img,(200,90), 100, (0,0,255), -1)
+
+# Drawing Ellipse
+cv2.ellipse(img,(256,256),(100,50),0,0,180,255,-1)
+
+# Adding Text On Images
+cv2.putText(img,"Hello World!!!", (x,y), cv2.FONT_HERSHEY_SIMPLEX, 2, 255)
+
+# Blending Images
+img1 = cv2.imread('cat.png')
+img2 = cv2.imread('openCV.jpg')
+dst = cv2.addWeighted(img1,0.5,img2,0.5,0)
+
+# Thresholding image
+# Binary Thresholding
+_,thresImg = cv2.threshold(img,127,255,cv2.THRESH_BINARY)
+# Adaptive Thresholding
+adapThres = cv2.adaptiveThreshold(img,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY,11,2)
+
+# Blur Image
+# Gaussian Blur
+blur = cv2.GaussianBlur(img,(5,5),0)
+# Median Blur
+medianBlur = cv2.medianBlur(img,5)
+
+# Canny Edge Detection
+img = cv2.imread('cat.jpg',0)
+edges = cv2.Canny(img,100,200)
+
+# Face Detection using Haar Cascades
+# Download Haar Cascades from https://github.com/opencv/opencv/blob/master/data/haarcascades/
+import cv2
+import numpy as np
+face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
+eye_cascade = cv2.CascadeClassifier('haarcascade_eye.xml')
+
+img = cv2.imread('human.jpg')
+gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+aces = face_cascade.detectMultiScale(gray, 1.3, 5)
+for (x,y,w,h) in faces:
+    cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
+    roi_gray = gray[y:y+h, x:x+w]
+    roi_color = img[y:y+h, x:x+w]
+    eyes = eye_cascade.detectMultiScale(roi_gray)
+    for (ex,ey,ew,eh) in eyes:
+        cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)
+
+cv2.imshow('img',img)
+cv2.waitKey(0)
+
+cv2.destroyAllWindows()
+# destroyAllWindows() destroys all windows. 
+# If you wish to destroy specific window pass the exact name of window you created.
+```
+
+### Further Reading:
+
+* Download Cascade from [https://github.com/opencv/opencv/blob/master/data/haarcascades]()
+* OpenCV drawing Functions [https://docs.opencv.org/2.4/modules/core/doc/drawing_functions.html]()
+* An up-to-date language reference can be found at [https://opencv.org]()
+* Additional resources may be found at [https://en.wikipedia.org/wiki/OpenCV]()
+* Good OpenCv Tutorials
+    * [https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_tutorials.html]()
+    * [https://realpython.com/python-opencv-color-spaces]()
+    * [https://pyimagesearch.com]()
+    * [https://www.learnopencv.com]()
diff --git a/opengl.html.markdown b/opengl.html.markdown
new file mode 100644
index 00000000..83ace3e8
--- /dev/null
+++ b/opengl.html.markdown
@@ -0,0 +1,765 @@
+---

+category: tool

+tool: OpenGL

+filename: learnopengl.cpp

+contributors:

+    - ["Simon Deitermann", "s.f.deitermann@t-online.de"]

+---

+

+**Open Graphics Library** (**OpenGL**) is a cross-language cross-platform application programming interface

+(API) for rendering 2D computer graphics and 3D vector graphics.<sup>[1]</sup> In this tutorial we will be

+focusing on modern OpenGL from 3.3 and above, ignoring "immediate-mode", Displaylists and

+VBO's without use of Shaders.

+I will be using C++ with SFML for window, image and context creation aswell as GLEW

+for modern OpenGL extensions, though there are many other librarys available.

+

+```cpp

+// Creating an SFML window and OpenGL basic setup.

+#include <GL/glew.h>

+#include <GL/gl.h>

+#include <SFML/Graphics.h>

+#include <iostream>

+

+int main() {

+    // First we tell SFML how to setup our OpenGL context.

+    sf::ContextSettings context{ 24,   // depth buffer bits

+                                  8,   // stencil buffer bits

+                                  4,   // MSAA samples

+                                  3,   // major opengl version

+                                  3 }; // minor opengl version

+    // Now we create the window, enable VSync

+    // and set the window active for OpenGL.

+    sf::Window window{ sf::VideoMode{ 1024, 768 },

+                       "opengl window",

+                       sf::Style::Default,

+		       context };

+    window.setVerticalSyncEnabled(true);

+    window.setActive(true);

+    // After that we initialise GLEW and check if an error occured.

+    GLenum error;

+    glewExperimental = GL_TRUE;

+    if ((err = glewInit()) != GLEW_OK)

+        std::cout << glewGetErrorString(err) << std::endl;

+    // Here we set the color glClear will clear the buffers with.

+    glClearColor(0.0f,    // red

+                 0.0f,    // green

+                 0.0f,    // blue

+                 1.0f);   // alpha

+    // Now we can start the event loop, poll for events and draw objects.

+    sf::Event event{ };

+    while (window.isOpen()) {

+        while (window.pollEvent(event)) {

+            if (event.type == sf::Event::Closed)

+                window.close;

+        }

+        // Tell OpenGL to clear the color buffer

+        // and the depth buffer, this will clear our window.

+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

+        // Flip front- and backbuffer.

+        window.display();

+    }

+    return 0;

+}

+```

+

+## Loading Shaders

+

+After creating a window and our event loop we should create a function,

+that sets up our shader program.

+

+```cpp

+GLuint createShaderProgram(const std::string& vertexShaderPath,

+                           const std::string& fragmentShaderPath) {

+    // Load the vertex shader source.

+    std::stringstream ss{ };

+    std::string vertexShaderSource{ };

+    std::string fragmentShaderSource{ };

+    std::ifstream file{ vertexShaderPath };

+    if (file.is_open()) {

+        ss << file.rdbuf();

+        vertexShaderSource = ss.str();

+        file.close();

+    }

+    // Clear the stringstream and load the fragment shader source.

+    ss.str(std::string{ });

+    file.open(fragmentShaderPath);

+    if (file.is_open()) {

+        ss << file.rdbuf();

+        fragmentShaderSource = ss.str();

+        file.close();

+    }

+    // Create the program.

+    GLuint program = glCreateProgram();

+    // Create the shaders.

+    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);

+    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

+    // Now we can load the shader source into the shader objects and compile them.

+    // Because glShaderSource() wants a const char* const*,

+    // we must first create a const char* and then pass the reference.

+    const char* cVertexSource = vertexShaderSource.c_str();

+    glShaderSource(vertexShader,     // shader

+                   1,                // number of strings

+                   &cVertexSource,   // strings

+                   nullptr);         // length of strings (nullptr for 1)

+    glCompileShader(vertexShader);

+    // Now we have to do the same for the fragment shader.

+    const char* cFragmentSource = fragmentShaderSource.c_str();

+    glShaderSource(fragmentShader, 1, &cFragmentSource, nullptr);

+    glCompileShader(fragmentShader);

+    // After attaching the source and compiling the shaders,

+    // we attach them to the program;

+    glAttachShader(program, vertexShader);

+    glAttachShader(program, fragmentShader);

+    glLinkProgram(program);

+    // After linking the shaders we should detach and delete

+    // them to prevent memory leak.

+    glDetachShader(program, vertexShader);

+    glDetachShader(program, fragmentShader);

+    glDeleteShader(vertexShader);

+    glDeleteShader(fragmentShader);

+    // With everything done we can return the completed program.

+    return program;

+}

+```

+

+If you want to check the compilation log you can add the following between <code>glCompileShader()</code> and <code>glAttachShader()</code>.

+

+```cpp

+GLint logSize = 0;

+std::vector<GLchar> logText{ };

+glGetShaderiv(vertexShader,         // shader

+              GL_INFO_LOG_LENGTH,   // requested parameter

+              &logSize);            // return object

+if (logSize > 0) {

+    logText.resize(logSize);

+    glGetShaderInfoLog(vertexShader,      // shader

+                       logSize,           // buffer length

+                       &logSize,          // returned length

+                       logText.data());   // buffer

+    std::cout << logText.data() << std::endl;

+}

+```

+

+The same is possibile after <code>glLinkProgram()</code>, just replace <code>glGetShaderiv()</code> with <code>glGetProgramiv()</code>

+and <code>glGetShaderInfoLog()</code> with <code>glGetProgramInfoLog()</code>.

+

+```cpp

+// Now we can create a shader program with a vertex and a fragment shader.

+// ...

+glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

+

+GLuint program = createShaderProgram("vertex.glsl", "fragment.glsl");

+

+sf::Event event{ };

+// ...

+// We also have to delete the program at the end of the application.

+// ...

+    }

+    glDeleteProgram(program);	

+    return 0;

+}

+// ...

+```

+

+Ofcourse we have to create the vertex and fragment shader before we can load them,

+so lets create two basic shaders.

+

+**Vertex Shader**

+

+```glsl

+// Declare which version of GLSL we use.

+// Here we declare, that we want to use the OpenGL 3.3 version of GLSL.

+#version 330 core

+// At attribute location 0 we want an input variable of type vec3,

+// that contains the position of the vertex.

+// Setting the location is optional, if you don't set it you can ask for the

+// location with glGetAttribLocation().

+layout(location = 0) in vec3 position;

+// Every shader starts in it's main function.

+void main() {

+    // gl_Position is a predefined variable that holds

+    // the final vertex position.

+    // It consists of a x, y, z and w coordinate.

+    gl_Position = vec4(position, 1.0);

+}

+```

+

+**Fragment Shader**

+

+```glsl

+#version 330 core

+// The fragment shader does not have a predefined variable for

+// the vertex color, so we have to define a output vec4,

+// that holds the final vertex color.

+out vec4 outColor;

+

+void main() {

+    // We simply set the ouput color to red.

+    // The parameters are red, green, blue and alpha.

+    outColor = vec4(1.0, 0.0, 0.0, 1.0);

+}

+```

+

+## VAO and VBO

+Now we need to define some vertex position we can pass to our shaders. Lets define a simple 2D quad.

+

+```cpp

+// The vertex data is defined in a counter-clockwise way,

+// as this is the default front face.

+std::vector<float> vertexData {

+    -0.5f,  0.5f, 0.0f,

+    -0.5f, -0.5f, 0.0f,

+     0.5f, -0.5f, 0.0f,

+     0.5f,  0.5f, 0.0f

+};

+// If you want to use a clockwise definition, you can simply call

+glFrontFace(GL_CW);

+// Next we need to define a Vertex Array Object (VAO).

+// The VAO stores the current state while its active.

+GLuint vao = 0;

+glGenVertexArrays(1, &vao);

+glBindVertexArray(vao);

+// With the VAO active we can now create a Vertex Buffer Object (VBO).

+// The VBO stores our vertex data.

+GLuint vbo = 0;

+glGenBuffers(1, &vbo);

+glBindBuffer(GL_ARRAY_BUFFER, vbo);

+// For reading and copying there are also GL_*_READ and GL_*_COPY,

+// if your data changes more often use GL_DYNAMIC_* or GL_STREAM_*.

+glBufferData(GL_ARRAY_BUFFER,     // target buffer

+             sizeof(vertexData[0]) * vertexData.size(),   // size

+             vertexData.data(),   // data

+             GL_STATIC_DRAW);     // usage

+// After filling the VBO link it to the location 0 in our vertex shader,

+// which holds the vertex position.

+// ...

+// To ask for the attibute location, if you haven't set it:

+GLint posLocation = glGetAttribLocation(program, "position");

+// ..

+glEnableVertexAttribArray(0);

+glVertexAttribPointer(0, 3,       // location and size

+                      GL_FLOAT,   // type of data

+                      GL_FALSE,   // normalized (always false for floats)

+                      0,          // stride (interleaved arrays)

+                      nullptr);   // offset (interleaved arrays)

+// Everything should now be saved in our VAO and we can unbind it and the VBO.

+glBindVertexArray(0);

+glBindBuffer(GL_ARRAY_BUFFER, 0);

+// Now we can draw the vertex data in our render loop.

+// ...

+glClear(GL_COLOR_BUFFER_BIT);

+// Tell OpenGL we want to use our shader program.

+glUseProgram(program);

+// Binding the VAO loads the data we need.

+glBindVertexArray(vao);

+// We want to draw a quad starting at index 0 of the VBO using 4 indices.

+glDrawArrays(GL_QUADS, 0, 4);

+glBindVertexArray(0);

+window.display();

+// ...

+// Ofcource we have to delete the allocated memory for the VAO and VBO at

+// the end of our application.

+// ...

+glDeleteBuffers(1, &vbo);

+glDeleteVertexArrays(1, &vao);

+glDeleteProgram(program);

+return 0;

+// ...

+```

+

+You can find the current code here: [OpenGL - 1](https://pastebin.com/W8jdmVHD).

+

+## More VBO's and Color

+Let's create another VBO for some colors.

+

+```cpp

+std::vector<float> colorData {

+    1.0f, 0.0f, 0.0f,

+    0.0f, 1.0f, 0.0f,

+    0.0f, 0.0f, 1.0f,

+    1.0f, 1.0f, 0.0f

+};

+```

+

+Next we can simply change some previous parameters to create a second VBO for our colors.

+

+```cpp

+// ...

+GLuint vbo[2];

+glGenBuffers(2, vbo);

+glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);

+// ...

+glDeleteBuffers(2, vbo);

+/ ...

+// With these changes made we now have to load our color data into the new VBO

+// ...

+glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);

+

+glBindBuffer(GL_ARRAY_BUFFER, vbo[1]);

+glBufferData(GL_ARRAY_BUFFER, sizeof(colorData[0]) * colorData.size(),

+             colorData.data(), GL_STATIC_DRAW);

+glEnableVertexAttribArray(1);

+glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, nullptr);

+

+glBindVertexArray(0);  

+// ...

+```

+

+Next we have to change our vertex shader to pass the color data to the fragment shader.<br>

+**Vertex Shader**

+

+```glsl

+#version 330 core

+

+layout(location = 0) in vec3 position;

+// The new location has to differ from any other input variable.

+// It is the same index we need to pass to

+// glEnableVertexAttribArray() and glVertexAttribPointer().

+layout(location = 1) in vec3 color;

+

+out vec3 fColor;

+

+void main() {

+    fColor = color;

+    gl_Position = vec4(position, 1.0);

+}

+```

+

+**Fragment Shader**

+

+```glsl

+#version 330 core

+

+in vec3 fColor;

+

+out vec4 outColor;

+

+void main() {

+    outColor = vec4(fColor, 1.0);

+}

+```

+

+We define a new input variable ```color``` which represents our color data, this data

+is passed on to ```fColor```, which is an output variable of our vertex shader and

+becomes an input variable for our fragment shader.

+It is imporatant that variables passed between shaders have the exact same name

+and type.

+

+## Handling VBO's

+

+```cpp

+// If you want to completely clear and refill a VBO use glBufferData(),

+// just like we did before.

+// ...

+// There are two mains ways to update a subset of a VBO's data.

+// To update a VBO with existing data

+std::vector<float> newSubData {

+	-0.25f, 0.5f, 0.0f

+};

+glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);

+glBufferSubData(GL_ARRAY_BUFFER,      // target buffer

+                0,                    // offset

+                sizeof(newSubData[0]) * newSubData.size(),   // size

+                newSubData.data());   // data

+// This would update the first three values in our vbo[0] buffer.

+// If you want to update starting at a specific location just set the second

+// parameter to that value and multiply by the types size.

+// ...

+// If you are streaming data, for example from a file,

+// it is faster to directly pass the data to the buffer.

+// Other access values are GL_READ_ONLY and GL_READ_WRITE.

+glBindBuffer(GL_ARRAY_BUFFER, vbo[0]);

+// You can static_cast<float*>() the void* to be more safe.

+void* Ptr = glMapBuffer(GL_ARRAY_BUFFER,   // buffer to map

+                        GL_WRITE_ONLY);    // access to buffer

+memcpy(Ptr, newSubData.data(), sizeof(newSubData[0]) * newSubData.size());

+// To copy to a specific location add a destination offset to memcpy().

+glUnmapBuffer(GL_ARRAY_BUFFER);

+// ...

+// There is also a way to copy data from one buffer to another,

+// If we have two VBO's vbo[0] and vbo[1], we can copy like so

+// You can also read from GL_ARRAY_BUFFER.

+glBindBuffer(GL_COPY_READ_BUFFER, vbo[0]);

+// GL_COPY_READ_BUFFER and GL_COPY_WRITE_BUFFER are specifically for

+// copying buffer data.

+glBindBuffer(GL_COPY_WRITE_BUFFER, vbo[1]);

+glCopyBufferSubData(GL_COPY_READ_BUFFER,    // read buffer

+                    GL_COPY_WRITE_BUFFER,   // write buffer

+                    0, 0,                   // read and write offset

+                    sizeof(vbo[0]) * 3);    // copy size

+// This will copy the first three elements from vbo[0] to vbo[1].

+```

+

+## Uniforms

+

+**Fragment Shader**

+

+```glsl

+// Uniforms are variables like in and out, however,

+// we can change them easily by passing new values with glUniform().

+// Lets define a time variable in our fragment shader.

+#version 330 core

+// Unlike a in/out variable we can use a uniform in every shader,

+// without the need to pass it to the next one, they are global.

+// Don't use locations already used for attributes!

+// Uniform layout locations require OpenGL 4.3!

+layout(location = 10) uniform float time;

+

+in vec3 fColor;

+

+out vec4 outColor;

+

+void main() {

+    // Create a sine wave from 0 to 1 based on the time passed to the shader.

+    float factor = (sin(time * 2) + 1) / 2;

+    outColor = vec4(fColor.r * factor, fColor.g * factor, fColor.b * factor, 1.0);

+}

+```

+

+Back to our source code.

+

+```cpp

+// If we haven't set the layout location, we can ask for it.

+GLint timeLocation = glGetUniformLocation(program, "time");

+// ...

+// Also we should define a Timer counting the current time.

+sf::Clock clock{ };

+// In out render loop we can now update the uniform every frame.

+    // ...

+    window.display();

+    glUniform1f(10,   // location

+                clock.getElapsedTime().asSeconds());   // data

+}

+// ...

+```

+

+With the time getting updated every frame the quad should now be changing from

+fully colored to pitch black.

+There are different types of glUniform() you can find simple documentation here:

+[glUniform - OpenGL Refpage](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glUniform.xhtml)

+

+## Indexing and IBO's

+

+Element Array Buffers or more commonly Index Buffer Objects (IBO) allow us to use the

+same vertex data again which makes drawing a lot easier and faster. here's an example:

+

+```cpp

+// Lets create a quad from two rectangles.

+// We can simply use the old vertex data from before.

+// First, we have to create the IBO.

+// The index is referring to the first declaration in the VBO.

+std::vector<unsigned int> iboData {

+    0, 1, 2,

+    0, 2, 3

+};

+// That's it, as you can see we could reuse 0 - the top left

+// and 2 - the bottom right.

+// Now that we have our data, we have to fill it into a buffer.

+// Note that this has to happen between the two glBindVertexArray() calls,

+// so it gets saved into the VAO.

+GLuint ibo = 0;

+glGenBufferrs(1, &ibo);

+glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);

+glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(iboData[0]) * iboData.size(),

+             iboData.data(), GL_STATIC_DRAW);

+// Next in our render loop, we replace glDrawArrays() with:

+glDrawElements(GL_TRIANGLES, iboData.size(), GL_UNSINGED_INT, nullptr);

+// Remember to delete the allocated memory for the IBO.

+```

+

+You can find the current code here: [OpenGL - 2](https://pastebin.com/R3Z9ACDE).

+

+## Textures

+

+To load out texture we first need a library that loads the data, for simplicity I will be

+using SFML, however there are a lot of librarys for loading image data.

+

+```cpp

+// Lets save we have a texture called "my_tex.tga", we can load it with:

+sf::Image image;

+image.loadFromFile("my_tex.tga");

+// We have to flip the texture around the y-Axis, because OpenGL's texture

+// origin is the bottom left corner, not the top left.

+image.flipVertically();

+// After loading it we have to create a OpenGL texture.

+GLuint texture = 0;

+glGenTextures(1, &texture);

+glBindTexture(GL_TEXTURE_2D, texture);

+// Specify what happens when the coordinates are out of range.

+glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);

+glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

+// Specify the filtering if the object is very large.

+glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

+glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

+// Load the image data to the texture.

+glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.getSize().x, image.getSize().y,

+             0, GL_RGBA, GL_UNSIGNED_BYTE, image.getPixelsPtr());

+// Unbind the texture to prevent modifications.

+glBindTexture(GL_TEXTURE_2D, 0);

+// Delete the texture at the end of the application.

+// ...

+glDeleteTextures(1, &texture);

+```

+

+Ofcourse there are more texture formats than only 2D textures,

+You can find further information on parameters here:

+[glBindTexture - OpenGL Refpage](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glBindTexture.xhtml)<br>

+[glTexImage2D - OpenGL Refpage](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glTexImage2D.xhtml)<br>

+[glTexParameter - OpenGL Refpage](https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glTexParameter.xhtml)<br>

+

+```cpp

+// With the texture created, we now have to specify the UV,

+// or in OpenGL terms ST coordinates.

+std::vector<float> texCoords {

+    // The texture coordinates have to match the triangles/quad

+    // definition.

+    0.0f, 1.0f,	   // start at top-left

+    0.0f, 0.0f,	   // go round counter-clockwise

+    1.0f, 0.0f,

+    1.0f, 1.0f     // end at top-right

+};

+// Now we increase the VBO's size again just like we did for the colors.

+// ...

+GLuint vbo[3];

+glGenBuffers(3, vbo);

+// ...

+glDeleteBuffers(3, vbo);

+// ...

+// Load the texture coordinates into the new buffer.

+glBindBuffer(GL_ARRAY_BUFFER, vbo[2]);

+glBufferData(GL_ARRAY_BUFFER, sizeof(texCoords[0]) * texCoords.size(),

+             texCoords.data(), GL_STATIC_DRAW);

+glEnableVertexAttribArray(2);

+glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, nullptr);

+// Because the VAO does not store the texture we have to bind it before drawing.

+// ...

+glBindVertexArray(vao);

+glBindTexture(GL_TEXTURE_2D, texture);

+glDrawElements(GL_TRIANGLES, iboData.size(), GL_UNSINGED_INT, nullptr);

+// ...

+```

+

+Change the shaders to pass the data to the fragment shader.<br>

+

+**Vertex Shader**

+

+```glsl

+#version 330 core

+

+layout(location = 0) in vec3 position;

+layout(location = 1) in vec3 color;

+layout(location = 2) in vec2 texCoords;

+

+out vec3 fColor;

+out vec2 fTexCoords;

+

+void main() {

+    fColor = color;

+    fTexCoords = texCoords;

+    gl_Position = vec4(position, 1.0);

+}

+```

+

+**Fragment Shader**

+

+```glsl

+#version 330 core

+// sampler2D represents our 2D texture.

+uniform sampler2D tex;

+uniform float time;

+

+in vec3 fColor;

+in vec2 fTexCoords;

+

+out vec4 outColor;

+

+void main() {

+    // texture() loads the current texure data at the specified texture coords,

+    // then we can simply multiply them by our color.

+    outColor = texture(tex, fTexCoords) * vec4(fColor, 1.0);

+}

+```

+

+You can find the current code here: [OpenGL - 3](https://pastebin.com/u3bcwM6q)

+

+## Matrix Transformation

+

+**Vertex Shader**

+

+```glsl

+#version 330 core

+

+layout(location = 0) in vec3 position;

+layout(location = 1) in vec3 color;

+layout(location = 2) in vec2 texCoords;

+// Create 2 4x4 matricies, 1 for the projection matrix

+// and 1 for the model matrix.

+// Because we draw in a static scene, we don't need a view matrix.

+uniform mat4 projection;

+uniform mat4 model;

+

+out vec3 fColor;

+out vec2 fTexCoords;

+

+void main() {

+    fColor = color;

+    fTexCoords = texCoords;

+    // Multiplay the position by the model matrix and then by the

+    // projection matrix.

+    // Beware order of multiplication for matricies!

+    gl_Position = projection * model * vec4(position, 1.0);

+}

+```

+

+In our source we now need to change the vertex data, create a model- and a projection matrix.

+

+```cpp

+// The new vertex data, counter-clockwise declaration.

+std::vector<float> vertexData {  

+    0.0f, 1.0f, 0.0f,   // top left

+    0.0f, 0.0f, 0.0f,   // bottom left

+    1.0f, 0.0f, 0.0f,   // bottom right

+    1.0f, 1.0f, 0.0f    // top right

+};

+// Request the location of our matricies.

+GLint projectionLocation = glGetUniformLocation(program, "projection");

+GLint modelLocation = glGetUniformLocation(program, "model");

+// Declaring the matricies.

+// Orthogonal matrix for a 1024x768 window.

+std::vector<float> projection {  

+    0.001953f,       0.0f,  0.0f, 0.0f,

+         0.0f, -0.002604f,  0.0f, 0.0f,

+         0.0f,       0.0f, -1.0f, 0.0f,

+        -1.0f,       1.0f,  0.0f, 1.0f

+};

+// Model matrix translating to x 50, y 50

+// and scaling to x 200, y 200.

+std::vector<float> model {  

+    200.0f,   0.0f, 0.0f, 0.0f,

+      0.0f, 200.0f, 0.0f, 0.0f,

+      0.0f,   0.0f, 1.0f, 0.0f,

+     50.0f,  50.0f, 0.0f, 1.0f

+};

+// Now we can send our calculated matricies to the program.

+glUseProgram(program);

+glUniformMatrix4fv(projectionLocation,   // location

+                   1,                    // count

+                   GL_FALSE,             // transpose the matrix

+                   projection.data());   // data

+glUniformMatrix4fv(modelLocation, 1, GL_FALSE, model.data());

+glUseProgram(0);

+// The glUniform*() calls have to be done, while the program is bound.

+```

+

+The application should now display the texture at the defined position and size.<br>

+You can find the current code here: [OpenGL - 4](https://pastebin.com/9ahpFLkY)

+

+```cpp

+// There are many math librarys for OpenGL, which create

+// matricies and vectors, the most used in C++ is glm (OpenGL Mathematics).

+// Its a header only library.

+// The same code using glm would look like:

+glm::mat4 projection{ glm::ortho(0.0f, 1024.0f, 768.0f, 0.0f) };

+glUniformMatrix4fv(projectionLocation, 1, GL_FALSE,

+                   glm::value_ptr(projection));

+// Initialise the model matrix to the identity matrix, otherwise every

+// multiplication would be 0.

+glm::mat4 model{ 1.0f };

+model = glm::translate(model, glm::vec3{ 50.0f, 50.0f, 0.0f });

+model = glm::scale(model, glm::vec3{ 200.0f, 200.0f, 0.0f });

+glUniformMatrix4fv(modelLocation, 1, GL_FALSE,

+                   glm::value_ptr(model));

+```

+

+## Geometry Shader

+

+Gemoetry shaders were introduced in OpenGL 3.2, they can produce vertices

+that are send to the rasterizer. They can also change the primitive type e.g.

+they can take a point as an input and output other primitives.

+Geometry shaders are inbetween the vertex and the fragment shader.

+

+**Vertex Shader**

+

+```glsl

+#version 330 core

+

+layout(location = 0) in vec3 position;

+layout(location = 1) in vec3 color;

+// Create an output interface block passed to the next shadaer stage.

+// Interface blocks can be used to structure data passed between shaders.

+out VS_OUT {

+    vec3 color;

+} vs_out;

+

+void main() {

+    vs_out.color = color

+    gl_Position = vec4(position, 1.0);

+}

+```

+

+**Geometry Shader**

+

+```glsl

+#version 330 core

+// The geometry shader takes in points.

+layout(points) in;

+// It outputs a triangle every 3 vertices emitted.

+layout(triangle_strip, max_vertices = 3) out;

+// VS_OUT becomes an input variable in the geometry shader.

+// Every input to the geometry shader in treated as an array.

+in VS_OUT {

+    vec3 color;

+} gs_in[];

+// Output color for the fragment shader.

+// You can also simply define color as 'out vec3 color',

+// If you don't want to use interface blocks.

+out GS_OUT {

+    vec3 color;

+} gs_out;

+

+void main() {

+    // Each emit calls the fragment shader, so we set a color for each vertex.

+    gs_out.color = mix(gs_in[0].color, vec3(1.0, 0.0, 0.0), 0.5);

+    // Move 0.5 units to the left and emit the new vertex.

+    // gl_in[] is the current vertex from the vertex shader, here we only

+    // use 0, because we are receiving points.

+    gl_Position = gl_in[0].gl_Position + vec4(-0.5, 0.0, 0.0, 0.0);

+    EmitVertex();

+    gs_out.color = mix(gs_in[0].color, vec3(0.0, 1.0, 0.0), 0.5);

+    // Move 0.5 units to the right and emit the new vertex.

+    gl_Position = gl_in[0].gl_Position + vec4(0.5, 0.0, 0.0, 0.0);

+    EmitVertex();

+    gs_out.color = mix(gs_in[0].color, vec3(0.0, 0.0, 1.0), 0.5);

+    // Move 0.5 units up and emit the new vertex.

+    gl_Position = gl_in[0].gl_Position + vec4(0.0, 0.75, 0.0, 0.0);

+    EmitVertex();

+    EndPrimitive();

+}

+```

+

+**Fragment Shader**

+

+```glsl

+in GS_OUT {

+    vec3 color;

+} fs_in;

+

+out vec4 outColor;

+

+void main() {

+    outColor = vec4(fs_in.color, 1.0);

+}

+```

+

+If you now store a single point with a single color in a VBO and draw them,

+you should see a triangle, with your color mixed half way between

+red, green and blue on each vertex.

+

+

+## Quotes

+<sup>[1]</sup>[OpenGL - Wikipedia](https://en.wikipedia.org/wiki/OpenGL)

+

+## Books

+

+- OpenGL Superbible - Fifth Edition (covering OpenGL 3.3)

+- OpenGL Programming Guide - Eighth Edition (covering OpenGL 4.3)

diff --git a/p5.html.markdown b/p5.html.markdown
new file mode 100644
index 00000000..be22d3e5
--- /dev/null
+++ b/p5.html.markdown
@@ -0,0 +1,53 @@
+---
+category: tool
+tool: p5
+contributors:
+    - ['Amey Bhavsar', 'https://github.com/ameybhavsar24']
+    - ['Claudio Busatto', 'https://github.com/cjcbusatto']
+filename: p5.js
+---
+
+p5.js is a JavaScript library that starts with the original goal of [Processing](http://processing.org"), to make coding accessible for artists, designers, educators, and beginners, and reinterprets this for today's web.
+Since p5 is a JavaScript library, you should learn [Javascript](https://learnxinyminutes.com/docs/javascript/) first.
+
+```js
+///////////////////////////////////
+// p5.js has two important functions to work with.
+
+function setup() {
+    // the setup function gets executed just once when the window is loaded
+}
+function draw() {
+    // the draw function gets called every single frame. This means that for a frameRate(30) it would get called 30 times per second.
+}
+
+// the following code explains all features
+
+function setup() {
+    createCanvas(640, 480); // creates a new canvas element with 640px as width as 480px as height
+    background(128); // changes the background color of the canvas, can accept rgb values like background(100,200,20) else grayscale values like background(0) = black or background(255) = white
+}
+
+function draw() {
+    ellipse(10, 10, 50, 50); // creates a ellipse at the 10px from the left and 10px from the top with width adn height as 50 each, so its basically a circle.
+    //remember in p5.js the origin is at the top-left corner of the canvas
+
+    if (mouseIsPressed) {
+        // mouseIsPressed is a boolean variable that changes to true if the mouse buttton is pressed down at that instant
+
+        fill(0); // fill refers to the innner color or filling color of whatever shape you are going to draw next
+    } else {
+        fill(255); // you can give in rgb values like fill(72, 240, 80) to get colors, else a single values determines the grayscale where fill(255) stands for #FFF(white) and fill(0) stands for #000(black)
+    }
+
+    ellipse(mouseX, mouseY, 80, 80);
+    // mouseX is the x-coordinate of the mouse's current position and mouseY is the y-coordinate of the mouse's current position
+
+    // the above code creates a circle wherever mouse's current position and fills it either black or white based on the mouseIsPressed
+}
+```
+
+## Further Reading
+
+- [p5.js | get started](http://p5js.org/get-started/) The official documentation
+- [Code! Programming for Beginners with p5.js - YouTube](https://www.youtube.com/watch?v=yPWkPOfnGsw&vl=en) Introduction and Coding challenges using Processing and p5.js by Coding Train
diff --git a/pascal.html.markdown b/pascal.html.markdown
index 6877afef..9fb51c3b 100644
--- a/pascal.html.markdown
+++ b/pascal.html.markdown
@@ -3,6 +3,7 @@ language: Pascal
 filename: learnpascal.pas
 contributors:
     - ["Ganesha Danu", "http://github.com/blinfoldking"]
+    - ["Keith Miyake", "https://github.com/kaymmm"]
 ---
 
 
@@ -24,6 +25,10 @@ to compile and run a pascal program you could use a free pascal compiler. [Downl
 //name of the program
 program learn_pascal; //<-- dont forget a semicolon
 
+const
+    {
+        this is where you should declare constant values
+    }
 type
     {
         this is where you should delcare a custom
@@ -54,17 +59,71 @@ var
 //or this
 var a,b : integer;
 ```
+
 ```pascal
 program Learn_More;
 //Lets learn about data types and their operations
 
+const
+    PI = 3.141592654;
+    GNU = 'GNU''s Not Unix';
+        // constants are conventionally named using CAPS
+        // their values are fixed and cannot be changed during runtime
+        // holds any standard data type (integer, real, boolean, char, string)
+
+type
+    ch_array : array [0..255] of char;
+        // arrays are new 'types' specifying the length and data type
+        // this defines a new data type that contains 255 characters
+        // (this is functionally equivalent to a string[256] variable)
+    md_array : array of array of integer;
+        // nested arrays are equivalent to multidimensional arrays
+        // can define zero (0) length arrays that are dynamically sized
+        // this is a 2-dimensional array of integers
+
 //Declaring variables
-var 
-    int : integer; // a variable that contains an integer number data types
-    ch  : char;    // a variable that contains a character data types
-    str : string; // a variable that contains a string data types
-    r   : real;   // a variable that contains a real number data types
-    bool : boolean; //a variables that contains a Boolean(True/False) value data types
+var
+    int, c, d  : integer;
+           // three variables that contain integer numbers
+           // integers are 16-bits and limited to the range [-32,768..32,767]
+    r    : real;
+           // a variable that contains a real number data types
+           // reals can range between [3.4E-38..3.4E38]
+    bool : boolean;
+           // a variable that contains a Boolean(True/False) value
+    ch   : char;
+           // a variable that contains a character value
+           // char variables are stored as 8-bit data types so no UTF
+    str  : string;
+           // a non-standard variable that contains a string value
+           // strings are an extension included in most Pascal compilers
+           // they are stored as an array of char with default length of 255.
+    s    : string[50];
+           // a string with maximum length of 50 chars.
+           // you can specify the length of the string to minimize memory usage
+    my_str: ch_array;
+           // you can declare variables of custom types
+    my_2d : md_array;
+           // dynamically sized arrays need to be sized before they can be used.
+
+    // additional integer data types
+    b    : byte;     // range [0..255]
+    shi  : shortint; // range [-128..127]
+    smi  : smallint; // range [-32,768..32,767] (standard Integer)
+    w    : word;     // range [0..65,535]
+    li   : longint;  // range [-2,147,483,648..2,147,483,647]
+    lw   : longword; // range [0..4,294,967,295]
+    c    : cardinal; // longword
+    i64  : int64;    // range [-9223372036854775808..9223372036854775807]
+    qw   : qword;    // range [0..18,446,744,073,709,551,615]
+
+    // additional real types
+    rr   : real;     // range depends on platform (i.e., 8-bit, 16-bit, etc.)
+    rs   : single;   // range [1.5E-45..3.4E38]
+    rd   : double;   // range [5.0E-324 .. 1.7E308]
+    re   : extended; // range [1.9E-4932..1.1E4932]
+    rc   : comp;     // range [-2E64+1 .. 2E63-1]
+
 Begin
     int := 1;// how to assign a value to a variable
     r   := 3.14;
@@ -75,22 +134,73 @@ Begin
     //arithmethic operation
     int := 1 + 1; // int = 2 overwriting the previous assignment
     int := int + 1; // int = 2 + 1 = 3;
-    int := 4 div 2; //int = 2 a division operation which the result will be floored
+    int := 4 div 2; //int = 2 division operation where result will be floored
     int := 3 div 2; //int = 1
     int := 1 div 2; //int = 0
 
     bool := true or false; // bool = true
     bool := false and true; // bool = false
     bool := true xor true; // bool = false
-    
+
     r := 3 / 2; // a division operator for real
-    r := int; // you can assign an integer to a real variable but not the otherwise
+    r := int; // can assign an integer to a real variable but not the reverse
 
     c := str[1]; // assign the first letter of str to c
     str := 'hello' + 'world'; //combining strings
+
+    my_str[0] := 'a'; // array assignment needs an index
+
+    setlength(my_2d,10,10); // initialize dynamically sized arrays: 10×10 array
+    for c := 0 to 9 do // arrays begin at 0 and end at length-1
+        for d := 0 to 9 do // for loop counters need to be declared variables
+        my_2d[c,d] := c * d;
+          // address multidimensional arrays with a single set of brackets
+
 End.
 ```
 
 ```pascal
+program Functional_Programming;
+
+Var
+    i, dummy : integer;
+
+function factorial_recursion(const a: integer) : integer;
+{ recursively calculates the factorial of integer parameter a }
+
+// Declare local variables within the function
+// e.g.:
+// Var
+//    local_a : integer;
+
+Begin
+    If a >= 1 Then
+    // return values from functions by assigning a value to the function name
+        factorial_recursion := a * factorial_recursion(a-1)
+    Else
+        factorial_recursion := 1;
+End; // terminate a function using a semicolon after the End statement.
+
+procedure get_integer(var i : integer; dummy : integer);
+{ get user input and store it in the integer parameter i.
+  parameters prefaced with 'var' are variable, meaning their value can change
+  outside of the parameter. Value parameters (without 'var') like 'dummy' are
+  static and changes made within the scope of the function/procedure do not
+  affect the variable passed as a parameter }
+
+Begin
+    write('Enter an integer: ');
+    readln(i);
+    dummy := 4; // dummy will not change value outside of the procedure
+End;
+
+Begin // main program block
+    dummy := 3;
+    get_integer(i, dummy);
+    writeln(i, '! = ', factorial_recursion(i));
+    // outputs i!
+    writeln('dummy = ', dummy); // always outputs '3' since dummy is unchanged.
+End.
+
+```
 
-```
\ No newline at end of file
diff --git a/pcre.html.markdown b/pcre.html.markdown
index 0b61653d..9e091721 100644
--- a/pcre.html.markdown
+++ b/pcre.html.markdown
@@ -3,16 +3,18 @@ language: PCRE
 filename: pcre.txt
 contributors:
     - ["Sachin Divekar", "http://github.com/ssd532"]
-    
+
 ---
 
-A regular expression (regex or regexp for short) is a special text string for describing a search pattern. e.g. to extract domain name from a string we can say `/^[a-z]+:/` and it will match `http:` from `http://github.com/`.  
+A regular expression (regex or regexp for short) is a special text string for describing a search pattern. e.g. to extract domain name from a string we can say `/^[a-z]+:/` and it will match `http:` from `http://github.com/`.
 
 PCRE (Perl Compatible Regular Expressions) is a C library implementing regex. It was written in 1997 when Perl was the de-facto choice for complex text processing tasks. The syntax for patterns used in PCRE closely resembles Perl. PCRE syntax is being used in many big projects including PHP, Apache, R to name a few.
 
 
 There are two different sets of metacharacters:
+
 * Those that are recognized anywhere in the pattern except within square brackets
+
 ```
   \      general escape character with several uses
   ^      assert start of string (or line, in multiline mode)
@@ -32,18 +34,19 @@ There are two different sets of metacharacters:
 ```
 
 * Those that are recognized within square brackets. Outside square brackets. They are also called as character classes.
- 
+
 ```
- 
+
   \      general escape character
   ^      negate the class, but only if the first character
   -      indicates character range
   [      POSIX character class (only if followed by POSIX syntax)
   ]      terminates the character class
-  
-```  
 
-PCRE provides some generic character types, also called as character classes. 
+```
+
+PCRE provides some generic character types, also called as character classes.
+
 ```
   \d     any decimal digit
   \D     any character that is not a decimal digit
@@ -59,24 +62,22 @@ PCRE provides some generic character types, also called as character classes.
 
 ## Examples
 
-We will test our examples on following string `66.249.64.13 - - [18/Sep/2004:11:07:48 +1000] "GET /robots.txt HTTP/1.0" 200 468 "-" "Googlebot/2.1"`. It is a standard Apache access log.
+We will test our examples on the following string:
 
-| Regex | Result          | Comment |
-| :---- | :-------------- | :------ |
-| GET   | GET | GET matches the characters GET literally (case sensitive) |
-| \d+.\d+.\d+.\d+ | 66.249.64.13 | `\d+` match a digit [0-9] one or more times defined by `+` quantifier, `\.` matches `.` literally |
-| (\d+\.){3}\d+ | 66.249.64.13 | `(\d+\.){3}` is trying to match group (`\d+\.`) exactly three times. |
-| \[.+\] | [18/Sep/2004:11:07:48 +1000] | `.+` matches any character (except newline), `.` is any character |
-| ^\S+ | 66.249.64.13 | `^` means start of the line, `\S+` matches any number of non-space characters |
-| \+[0-9]+ | +1000 | `\+` matches the character `+` literally. `[0-9]` character class means single number. Same can be achieved using `\+\d+` |
-
-All these examples can be tried at https://regex101.com/ 
+```
+66.249.64.13 - - [18/Sep/2004:11:07:48 +1000] "GET /robots.txt HTTP/1.0" 200 468 "-" "Googlebot/2.1"
+```
 
-1. Copy the example string in `TEST STRING` section
-2. Copy regex code in `Regular Expression` section 
-3. The web application will show the matching result
+ It is a standard Apache access log.
 
+| Regex | Result          | Comment |
+| :---- | :-------------- | :------ |
+| `GET`   | GET | GET matches the characters GET literally (case sensitive) |
+| `\d+.\d+.\d+.\d+` | 66.249.64.13 | `\d+` match a digit [0-9] one or more times defined by `+` quantifier, `\.` matches `.` literally |
+| `(\d+\.){3}\d+` | 66.249.64.13 | `(\d+\.){3}` is trying to match group (`\d+\.`) exactly three times. |
+| `\[.+\]` | [18/Sep/2004:11:07:48 +1000] | `.+` matches any character (except newline), `.` is any character |
+| `^\S+` | 66.249.64.13 | `^` means start of the line, `\S+` matches any number of non-space characters |
+| `\+[0-9]+` | +1000 | `\+` matches the character `+` literally. `[0-9]` character class means single number. Same can be achieved using `\+\d+` |
 
 ## Further Reading
-
-
+[Regex101](https://regex101.com/) - Regular Expression tester and debugger
diff --git a/perl.html.markdown b/perl.html.markdown
index 17a538e3..08001ab0 100644
--- a/perl.html.markdown
+++ b/perl.html.markdown
@@ -152,7 +152,7 @@ while (condition) {
   ...
 }
 
-
+my $max = 5;
 # for loops and iteration
 for my $i (0 .. $max) {
   print "index is $i";
diff --git a/perl6-pod.html.markdown b/perl6-pod.html.markdown
new file mode 100644
index 00000000..80a501b8
--- /dev/null
+++ b/perl6-pod.html.markdown
@@ -0,0 +1,622 @@
+---
+language: Pod
+contributors:
+    - ["Luis F. Uceta", "https://uzluisf.gitlab.io/"]
+filename: learnpod.pod6
+---
+
+Pod is an easy-to-use and purely descriptive mark-up language, 
+with no presentational components. Besides its use for documenting
+Raku Perl 6 programs and modules, Pod can be utilized to write language
+documentation, blogs, and other types of document composition as well.
+
+Pod documents can be easily converted to HTML and many other formats
+(e.g., Markdown, Latex, plain text, etc.) by using the corresponding
+variant of the `Pod::To` modules (e.g. `Pod::To::HTML` for HTML conversion).
+
+- [General Info](#general-info)
+- [Pod Basics](#pod-basics)
+	- [Basic Text Formatting](#basic-text-formatting)
+	- [Headings](#headings)
+	- [Ordinary Paragraphs](#ordinary-paragraphs)
+	- [Lists](#lists)
+	- [Code Blocks](#code-blocks)
+	- [Comments](#comments)
+	- [Links](#links)
+	- [Tables](#tables)
+- [Block Structures](#block-structures)
+	- [Abbreviated Blocks](#abbreviated-blocks)
+	- [Delimited Blocks](#delimited-blocks)
+	- [Paragraph Blocks](#paragraph-blocks)
+- [Configuration Data](#configuration-data)
+	- [Standard Configuration Options](#standard-configuration-options)
+	- [Block Pre-configuration](#block-pre-configuration)
+- [Semantic Blocks](#semantic-blocks)
+- [Miscellaneous](#miscellaneous)
+	- [Notes](#notes)
+	- [Keyboard Input](#keyboard-input)
+	- [Terminal Output](#terminal-output)
+	- [Unicode](#unicode)
+- [Rendering Pod](#rendering-pod)
+- [Accessing Pod](#accessing-pod)
+
+## General Info
+
+Every Pod document has to begin with `=begin pod` and end with `=end pod`.
+Everything between these two delimiters will be processed and used to
+generate documentation.
+
+```
+=begin pod
+
+A very simple Raku Perl 6 Pod document. All the other directives go here!
+
+=end pod
+```
+
+Pod documents usually coexist with Raku Perl 6 code. If by themselves, 
+Pod files often have the `.pod6` suffix. Moving forward, it's assumed that
+the constructs being discussed are surrounded by the `=begin pod ... =end pod`
+directives.
+
+## Pod Basics
+
+### Basic Text Formatting
+
+Text can be easily styled as bold, italic, underlined or verbatim (for code
+formatting) using the following formatting codes: `B<>`, `I<>`, `U<>`
+and `C<>`. 
+
+```
+B<This text is in Bold.>
+
+I<This text is in Italics.>
+
+U<This text is Underlined.>
+
+The function C<sub sum { $^x + $^y}> is treated as verbatim.
+```
+
+There are more formatting codes (e.g., `L<>`, `T<>`, etc.) but they'll be
+discussed later throughout the document. You'll recognize them because they're
+just a single capital letter followed immediately by a set of single or double
+angle brackets. The Unicode variant («») of the angle brackets can also be
+used.
+
+### Headings 
+
+Headings are created by using the `=headN` directive where `N` is the
+heading level.
+
+```
+=head1 This is level 1
+=head2 This is level 2
+=head3 This is level 3
+=head4 This is level 4
+=head5 This is level 5
+=head6 This is level 6
+```
+
+### Ordinary Paragraphs
+
+Ordinary paragraphs consist of one or more adjacent lines of text, each of
+which starts with a non-whitespace character. Any paragraph is terminated
+by the first blank line or block directive.
+
+```
+=head1 First level heading block
+
+=head2 Paragraph 1
+
+This is an ordinary paragraph. Its text will be squeezed and
+short lines filled. It is terminated by the first blank line.
+
+=head2 Paragraph 2
+
+This is another ordinary paragraph albeit shorter.
+```
+
+Alternatively, the `=para` directive can be used to explicitly mark adjacent
+lines of text as a paragraph.
+
+```
+=head1 First level heading block
+
+=head2 Paragraph 1
+
+=para
+This is an ordinary paragraph. Its text will be squeezed and
+short lines filled. It is terminated by the first blank line.
+
+=head2 Paragraph 2
+
+=para
+This is another ordinary paragraph albeit shorter.
+```
+
+### Lists
+
+Unordered lists can be created using the `=item` directive.
+
+```
+=item Item
+=item Item
+=item Another item
+```
+
+Sublists are achieved with items at each level specified using the `=item1`,
+`=item2`, `=item3`, `...`, `=itemN` etc. directives. The `=item` directive 
+defaults to `=item1`.
+
+```
+=item1 Item one
+=item1 Item two
+=item1 Item three
+    =item2 Sub-item
+    =item2 Sub-item
+=item1 Item four
+```
+
+Definition lists that define terms or commands use the `=defn` directive. 
+This is equivalent to the `<dl>` element in HTML.
+
+```
+=defn Beast of Bodmin
+A large feline inhabiting Bodmin Moor.
+
+=defn Morgawr
+A sea serpent.
+
+=defn Owlman
+A giant owl-like creature.
+```
+
+### Code Blocks
+
+A code block is created (which uses the HTML `<code>` element) by starting each
+line with one or more whitespace characters.
+
+```
+    #`( this is comment )
+    my $sum = -> $x, $y { $x + $y }
+    say $sum(12, 5);
+```
+
+As shown in the [Basic Text Formatting](#basic-text-formatting) section,
+inline code can be created using the `C<>` code.
+
+```
+In Raku Perl 6, there are several functions/methods to output text. Some of them
+are C<print>, C<put> and C<say>.
+```
+
+### Comments
+
+Although Pod blocks are ignored by the Raku Perl 6 compiler, everything
+indentified as a Pod block will be read and interpreted by Pod renderers. In
+order to prevent Pod blocks from being rendered by any renderer, use the
+`=comment` directive.
+
+```
+=comment Add more here about the algorithm.
+
+=comment Pod comments are great for documenting the documentation.
+```
+
+To create inline comments, use the `Z<>` code.
+
+```
+Pod is awesome Z<Of course it is!>. And Raku Perl 6 too!
+```
+
+Given that the Perl interpreter never executes embedded Pod blocks,
+comment blocks can also be used as an alternative form of nestable block
+comments in Raku Perl 6.
+
+### Links
+
+Creating links in Pod is quite easy and is done by enclosing them in
+a `L<>` code. The general format is `L<Label|Url>` with `Label`
+being optional. 
+
+```
+Raku Perl 6 homepage is L<https://perl6.org>.
+L<Click me!|http://link.org/>.
+```
+
+Relative paths work too.
+
+```
+L<Go to music|/music/>.
+```
+
+Linking to a section in the same document works as well.
+
+```
+L<Link to Headings|#Headings>
+```
+
+### Tables
+
+The Pod specifications are not completely handled properly yet and this
+includes the handling of table. For simplicity's sake, only one way of
+constructing tables is shown here. To learn about good practices and see
+examples of both good and bad tables, please visit
+<https://docs.perl6.org/language/tables>.
+
+```
+=begin table
+Option      | Description     
+============|================  
+data        | path to data files.
+engine      | engine to be used for processing templates.
+ext         | extension to be used for dest files.
+=end table
+```
+
+## Block Structures
+
+As mentioned earlier, Pod documents are specified using directives, which are
+used to delimit blocks of textual content and declare optional
+[configuration information](#configuration-data). Every directive starts with
+an equals sign (`=`) in the first column. The content of a document is
+specified within one or more blocks. Every Pod block may be declared in any of
+three equivalent forms: delimited style, paragraph style, or abbreviated style.
+
+Up to this point, we have only used the abbreviated style for the block
+types (e.g., `=head1`, `=para`, `=comment`, `=item`, etc).
+
+### Abbreviated Blocks
+
+Abbreviated blocks are introduced by an `=` sign in the first column, which
+is followed immediately by the `typename` of the block and then the content.
+The rest of the line is treated as block data, rather than as configuration.
+The content terminates at the next Pod directive or the first blank line
+(which is not part of the block data). The general syntax is
+
+```
+=BLOCK_TYPE  BLOCK_DATA
+```
+For example:
+
+```
+=head1 Top level heading
+```
+
+### Delimited Blocks
+
+Delimited blocks are bounded by `=begin` and `=end` markers, both of which are
+followed by a valid Pod identifier, which is the `typename` of the block.
+The general syntax is 
+
+```
+=begin BLOCK_TYPE
+BLOCK_DATA
+=end BLOCK_TYPE
+```
+
+For example:
+
+```
+=begin head1
+Top level heading
+=end head1
+```
+
+This type of blocks is useful for creating headings, list items, code blocks,
+etc. with multiple paragraphs. For example, 
+
+* a multiline item of a list
+
+```
+=begin item
+This is a paragraph in list item.
+
+This is another paragraph in the same list item.
+=end item
+```
+
+* a code block
+
+```
+=begin code
+#`(
+A non-efficient recursive implementation of a power function using multi subs.
+)
+
+multi pow( Real $base, 0 ) { 1 }
+
+multi pow( Real $base, Int $exp where * ≥ 0) {
+	$base * pow($base, $exp - 1)
+}
+
+multi pow( Real $base ) {
+     pow($base, 2)
+}
+
+say pow(3, 0);   #=> 1
+say pow(4.2, 2); #=> 17.64
+say pow(6);      #=> 36
+=end code
+```
+
+### Paragraph Blocks
+
+Paragraph blocks are introduced by a `=for` marker and terminated by
+the next Pod directive or the first blank line (which is not considered to
+be part of the block's contents). The `=for` marker is followed by the
+`typename` of the block. The general syntax is 
+
+```
+=for BLOCK_TYPE
+BLOCK DATA
+```
+
+For example:
+
+```
+=for head1
+Top level heading
+```
+
+## Configuration Data
+ 
+Except for abbreviated blocks, both delimited blocks and paragraph
+blocks can be supplied with configuration information about their
+contents right after the `typename` of the block. Thus the following 
+are more general syntaxes for these blocks:
+
+* Delimited blocks
+
+```
+=begin BLOCK_TYPE OPTIONAL_CONFIG_INFO
+=                 ADDITIONAL_CONFIG_INFO
+BLOCK_DATA
+=end BLOCK_TYPE
+```
+
+* Paragraph blocks
+
+```
+=for BLOCK_TYPE OPTIONAL_CONFIG_INFO
+=               ADDITIONAL_CONFIG_INFO
+BLOCK DATA
+```
+
+The configuration information is provided in a format akin to the
+["colon pair"](https://docs.perl6.org/language/glossary#index-entry-Colon_Pair)
+syntax in Raku Perl 6. The following table is a simplified version of the 
+different ways in which configuration info can be supplied. Please go to 
+<https://docs.perl6.org/language/pod#Configuration_information> for a more
+thorough treatment of the subject.
+
+| Value     | Specify with...             | Example                        |
+| :-------- | :------                     | :------                        |
+| List      | :key($elem1, $elem2, ...)   | :tags('Pod', 'Perl6')          |
+| Hash      | :key{$key1 => $value1, ...} | :feeds{url => 'perl6.org'}     |
+| Boolean   | :key/:key(True)             | :skip-test(True)               |
+| Boolean   | :!key/:key(False)           | :!skip-test                    |
+| String    | :key('string')              | :nonexec-reason('SyntaxError') |
+| Int       | :key(2)                     | :post-number(6)                |
+
+
+### Standard Configuration Options
+
+Pod provides a small number of standard configuration options that can
+be applied uniformly to built-in block types. Some of them are:
+
+* `:numbered`
+
+This option specifies that the block is to be numbered. The most common
+use of this option is to create numbered headings and ordered lists, but it
+can be applied to any block.
+
+For example:
+
+```
+=for head1 :numbered
+The Problem
+=for head1 :numbered
+The Solution
+=for head2 :numbered
+Analysis
+=for head3 :numbered
+Overview
+```
+
+* `:allow`
+
+The value of the `:allow` option must be a list of the (single-letter) names
+of one or more formatting codes. Those codes will then remain active inside
+the code block. The option is most often used on `=code` blocks to allow
+mark-up within those otherwise verbatim blocks, though it can be used in any
+block that contains verbatim text.
+
+Given the following snippet:
+
+```
+=begin code :allow('B', 'I')
+B<sub> greet( $name ) {
+    B<say> "Hello, $nameI<!>";
+}
+=end code
+```
+
+we get the following output:
+
+<pre><strong>sub</strong> greet( $name ) {
+    <strong>say</strong> &quot;Hello, $name<em>!</em>&quot;;
+}
+</pre>
+
+This is highly dependent on the format output. For example, while this works
+when Pod is converted to HTML, it might not be preserved when converted 
+to Markdown.
+
+### Block Pre-configuration
+
+The `=config` directive allows you to prespecify standard configuration
+information that is applied to every block of a particular type.
+The general syntax for configuration directives is:
+
+```
+=config BLOCK_TYPE  CONFIG OPTIONS
+=                  ADDITIONAL_CONFIG_INFO
+```
+
+For example, to specify that every heading level 1 be numbered, bold
+and underlined, you preconfigure the `=head1` as follows:
+
+```
+=config head1 :formatted('B', 'U') :numbered
+```
+
+## Semantic Blocks
+
+All uppercase block typenames are reserved for specifying standard
+documentation, publishing, source components, or meta-information.
+Some of them are:
+
+```
+=NAME
+=AUTHOR
+=VERSION
+=CREATED
+=SYNOPSIS
+=DESCRIPTION
+=USAGE
+```
+
+Most of these blocks would typically be used in their full
+delimited forms. For example,
+
+```
+=NAME B<Doc::Magic>
+
+=begin DESCRIPTION
+This module helps you generate documentation automagically.
+Not source code needed! Most of it is outsourced from a black hole.
+=end DESCRIPTION
+
+=begin SYNOPSIS
+=begin code
+	use Doc::Magic;
+
+ 	my Doc::Magic $doc .= new();
+
+    my $result = $doc.create-documentation($fh);
+=end code
+=end SYNOPSIS
+
+=AUTHOR Authorius Docus
+=VERSION 42
+```
+
+## Miscellaneous
+
+### Notes
+
+Notes are rendered as footnotes and created by enclosing a note in a
+`N<>` code.
+
+```
+In addition, the language is also multi-paradigmatic N<According to Wikipedia,
+this means that it supports procedural, object-oriented, and functional
+programming.>
+```
+
+### Keyboard Input
+
+To flag text as keyboard input enclose it in a `K<>` code.
+
+```
+Enter your name K<John Doe>
+```
+
+### Terminal Output
+
+To flag text as terminal output enclose it in `T<>` code.
+
+```
+Hello, T<John Doe>
+```
+
+### Unicode
+
+To include Unicode code points or HTML5 character references in
+a Pod document, enclose them in a `E<>` code.
+
+For example:
+
+```
+Raku Perl 6 makes considerable use of the E<171> and E<187> characters.
+Raku Perl 6 makes considerable use of the E<laquo> and E<raquo> characters.
+```
+
+is rendered as:
+
+Raku Perl 6 makes considerable use of the « and » characters.
+Raku Perl 6 makes considerable use of the « and » characters.
+
+## Rendering Pod
+
+To generate any output (i.e., Markdown, HTML, Text, etc.), you need to 
+have the Raku Perl 6 compiler installed. In addition, you must install 
+a module (e.g., `Pod::To::Markdown`, `Pod::To::HTML`, `Pod::To::Text`, etc.)
+that generates your desired output from Pod.
+
+For instructions about installing Raku Perl 6,
+[look here](https://perl6.org/downloads/).
+
+Run the following command to generate a certain output:
+
+```
+perl6 --doc=TARGET input.pod6 > output.html
+```
+
+with `TARGET` being `Markdown`, `HTML`, `Text`, etc. Thus to generate
+Markdown from Pod, run this:
+
+```
+perl6 --doc=Markdown input.pod6 > output.html
+```
+
+## Accessing Pod
+
+In order to access Pod documentation from within a Raku Perl 6 program, 
+it is required to use the special `=` twigil (e.g., `$=pod`, `$=SYNOPSIS`,etc).
+
+The `$=` construct provides the introspection over the Pod structure, 
+producing a `Pod::Block` tree root from which it is possible to access
+the whole structure of the Pod document.
+
+If we place the following piece of Raku Perl 6 code and the Pod documentation
+in the section [Semantic blocks](#semantic-blocks) in the same file:
+
+```
+my %used-directives;
+for $=pod -> $pod-item {
+    for $pod-item.contents -> $pod-block {
+        next unless $pod-block ~~ Pod::Block::Named;
+        %used-directives{$pod-block.name} = True;
+    }
+}
+
+say %used-directives.keys.join("\n");
+```
+
+we get the following output:
+
+```
+SYNOPSIS
+NAME
+VERSION
+AUTHOR
+DESCRIPTION
+```
+
+## Additional Information 
+
+* <https://docs.perl6.org/language/pod> for the Pod documentation.
+* <https://docs.perl6.org/language/tables> for advices about Pod tables.
+* <https://design.perl6.org/S26.html> for the Pod specification.
diff --git a/perl6.html.markdown b/perl6.html.markdown
index 04f9c6e3..c7fde218 100644
--- a/perl6.html.markdown
+++ b/perl6.html.markdown
@@ -13,24 +13,28 @@ least the next hundred years.
 The primary Perl 6 compiler is called [Rakudo](http://rakudo.org), which runs on
 the JVM and [the MoarVM](http://moarvm.com).
 
-Meta-note : double pound signs (##) are used to indicate paragraphs, while 
-single pound signs (#) indicate notes.
+Meta-note: double pound signs (`##`) are used to indicate paragraphs,
+while single pound signs (`#`) indicate notes.
 
 `#=>` represents the output of a command.
 
 ```perl6
-# Single line comment start with a pound
+# Single line comments start with a pound sign.
 
-#`(
-  Multiline comments use #` and a quoting construct.
+#`( Multiline comments use #` and a quoting construct.
   (), [], {}, 「」, etc, will work.
 )
+
+# Use the same syntax for multiline comments to embed comments.
+for #`(each element in) @array {
+    put #`(or print element) $_ #`(with newline);
+}
 ```
 
 ## Variables
 
 ```perl6
-## In Perl 6, you declare a lexical variable using `my`
+## In Perl 6, you declare a lexical variable using the `my` keyword:
 my $variable;
 ## Perl 6 has 3 basic types of variables: scalars, arrays, and hashes.
 ```
@@ -38,79 +42,81 @@ my $variable;
 ### Scalars
 
 ```perl6
-# Scalars represent a single value. They start with a `$`
-
+# Scalars represent a single value. They start with the `$` sigil:
 my $str = 'String';
-# double quotes allow for interpolation (which we'll see later):
+
+# Double quotes allow for interpolation (which we'll see later):
 my $str2 = "String";
 
 ## Variable names can contain but not end with simple quotes and dashes,
-## and can contain (and end with) underscores :
-my $weird'variable-name_ = 5; # works !
+## and can contain (and end with) underscores:
+my $person's-belongings = 'towel'; # this works!
 
-my $bool = True; # `True` and `False` are Perl 6's boolean values.
-my $inverse = !$bool; # You can invert a bool with the prefix `!` operator
-my $forced-bool = so $str; # And you can use the prefix `so` operator
-                           # which turns its operand into a Bool
+my $bool = True;             # `True` and `False` are Perl 6's boolean values.
+my $inverse = !$bool;        # Invert a bool with the prefix `!` operator.
+my $forced-bool = so $str;   # And you can use the prefix `so` operator
+$forced-bool = ?$str;        # to turn its operand into a Bool. Or use `?`.
 ```
 
 ### Arrays and Lists
 
 ```perl6
-## Arrays represent multiple values. Their name start with `@`.
-## Lists are similar but are an immutable type.
+## Arrays represent multiple values. An array variable starts with the `@`
+## sigil. Unlike lists, from which arrays inherit, arrays are mutable.
 
 my @array = 'a', 'b', 'c';
-# equivalent to :
+# equivalent to:
 my @letters = <a b c>; # array of words, delimited by space.
                        # Similar to perl5's qw, or Ruby's %w.
-my @array = 1, 2, 3;
+@array = 1, 2, 3;
 
-say @array[2]; # Array indices start at 0 -- This is the third element
+say @array[2];         # Array indices start at 0. Here the third element
+                       # is being accessed.
 
-say "Interpolate all elements of an array using [] : @array[]";
-#=> Interpolate all elements of an array using [] : 1 2 3
+say "Interpolate an array using []: @array[]";
+#=> Interpolate an array using []: 1 2 3
 
-@array[0] = -1; # Assign a new value to an array index
-@array[0, 1] = 5, 6; # Assign multiple values
+@array[0]    = -1;     # Assigning a new value to an array index
+@array[0, 1] = 5, 6;   # Assigning multiple values
 
 my @keys = 0, 2;
 @array[@keys] = @letters; # Assignment using an array containing index values
-say @array; #=> a 6 b
+say @array;               #=> a 6 b
 ```
 
 ### Hashes, or key-value Pairs.
 
 ```perl6
-## Hashes are pairs of keys and values.
-## You can construct a Pair object using the syntax `Key => Value`.
-## Hash tables are very fast for lookup, and are stored unordered.
-## Keep in mind that keys get "flattened" in hash context, and any duplicated
-## keys are deduplicated.
-my %hash = 1 => 2,
-           3 => 4;
-my %hash = foo => "bar", # keys get auto-quoted
-            "some other" => "value", # trailing commas are okay
-            ;
+## Hashes are pairs of keys and values. You can construct a `Pair` object
+## using the syntax `Key => Value`. Hash tables are very fast for lookup,
+## and are stored unordered. Keep in mind that keys get "flattened" in hash
+## context, and any duplicated keys are deduplicated.
+my %hash = 'a' => 1, 'b' => 2;
+
+%hash = a => 1,  # keys get auto-quoted when => (fat comma) is used.
+        b => 2,  # Trailing commas are okay.
+;
 
 ## Even though hashes are internally stored differently than arrays,
 ## Perl 6 allows you to easily create a hash from an even numbered array:
-my %hash = <key1 value1 key2 value2>;
-
-my %hash = key1 => 'value1', key2 => 'value2'; # same result as above
-
-## You can also use the "colon pair" syntax:
-## (especially handy for named parameters that you'll see later)
-my %hash = :w(1),    # equivalent to `w => 1`
-                     # this is useful for the `True` shortcut:
-           :truey,   # equivalent to `:truey(True)`, or `truey => True`
-                     # and for the `False` one:
-           :!falsey, # equivalent to `:falsey(False)`, or `falsey => False`
-           ;
-
-say %hash{'key1'}; # You can use {} to get the value from a key
-say %hash<key2>;   # If it's a string, you can actually use <>
-                   # (`{key1}` doesn't work, as Perl6 doesn't have barewords)
+%hash = <key1 value1 key2 value2>;          # Or:
+%hash = "key1", "value1", "key2", "value2";
+
+%hash = key1 => 'value1', key2 => 'value2'; # same result as above
+
+## You can also use the "colon pair" syntax. This syntax is especially
+## handy for named parameters that you'll see later.
+%hash = :w(1),    # equivalent to `w => 1`
+        :truey,   # equivalent to `:truey(True)` or `truey => True`
+        :!falsey, # equivalent to `:falsey(False)` or `falsey => False`
+;
+## The :truey and :!falsey constructs are known as the
+## `True` and `False` shortcuts respectively.
+
+say %hash{'key1'};   # You can use {} to get the value from a key.
+say %hash<key2>;     # If it's a string without spaces, you can actually use
+                     # <> (quote-words operator). `{key1}` doesn't work,
+                     # as Perl6 doesn't have barewords.
 ```
 
 ## Subs
@@ -120,112 +126,112 @@ say %hash<key2>;   # If it's a string, you can actually use <>
 ## created with the `sub` keyword.
 sub say-hello { say "Hello, world" }
 
-## You can provide (typed) arguments.
-## If specified, the type will be checked at compile-time if possible,
-## otherwise at runtime.
-sub say-hello-to(Str $name) {
+## You can provide (typed) arguments. If specified, the type will be checked
+## at compile-time if possible, otherwise at runtime.
+sub say-hello-to( Str $name ) {
     say "Hello, $name !";
 }
 
-## A sub returns the last value of the block.
-sub return-value {
-    5;
-}
-say return-value; # prints 5
-sub return-empty {
-}
-say return-empty; # prints Nil
+## A sub returns the last value of the block. Similarly, the semicolon in
+## the last can be omitted.
+sub return-value { 5 }
+say return-value;      # prints 5
 
-## Some control flow structures produce a value, like if:
+sub return-empty { }
+say return-empty;      # prints Nil
+
+## Some control flow structures produce a value, like `if`:
 sub return-if {
-	if True {
-		"Truthy";
-	}
+	if True { "Truthy" }
 }
-say return-if; # prints Truthy
+say return-if;         # prints Truthy
 
-## Some don't, like for:
+## Some don't, like `for`:
 sub return-for {
-    for 1, 2, 3 { }
+    for 1, 2, 3 { 'Hi' }
 }
-say return-for; # prints Nil
+say return-for;        # prints Nil
 
-## A sub can have optional arguments:
-sub with-optional($arg?) { # the "?" marks the argument optional
-  say "I might return `(Any)` (Perl's 'null'-like value) if I don't have
-        an argument passed, or I'll return my argument";
+## Positional arguments are required by default. To make them optional, use
+## the `?` after the parameters' names.
+sub with-optional( $arg? ) {
+  # This sub returns `(Any)` (Perl's null-like value) if
+  # no argument is passed. Otherwise, it returns its argument.
   $arg;
 }
-with-optional; # returns Any
-with-optional(); # returns Any
-with-optional(1); # returns 1
+with-optional;     # returns Any
+with-optional();   # returns Any
+with-optional(1);  # returns 1
 
-## You can also give them a default value when they're not passed:
-sub hello-to($name = "World") {
-  say "Hello, $name !";
+## You can also give them a default value when they're not passed.
+## Required parameters must come before optional ones.
+sub greeting( $name, $type = "Hello" ) {
+  say "$type, $name!";
 }
-hello-to; #=> Hello, World !
-hello-to(); #=> Hello, World !
-hello-to('You'); #=> Hello, You !
+
+greeting("Althea");                 #=> Hello, Althea!
+greeting("Arthur", "Good morning"); #=> Good morning, Arthur!
 
 ## You can also, by using a syntax akin to the one of hashes
-## (yay unified syntax !), pass *named* arguments to a `sub`.
-## They're optional, and will default to "Any".
-sub with-named($normal-arg, :$named) {
-  say $normal-arg + $named;
+## (yay unified syntax !), pass *named* arguments to a `sub`. They're
+## optional, and will default to "Any".
+sub with-named( $normal-arg, :$named ) {
+	say $normal-arg + $named;
 }
 with-named(1, named => 6); #=> 7
-## There's one gotcha to be aware of, here:
-## If you quote your key, Perl 6 won't be able to see it at compile time,
-##  and you'll have a single Pair object as a positional parameter,
-##  which means this fails:
-with-named(1, 'named' => 6);
 
-with-named(2, :named(5)); #=> 7
+## There's one gotcha to be aware of, here: If you quote your key, Perl 6
+## won't be able to see it at compile time, and you'll have a single `Pair`
+## object as a positional parameter, which means
+## `with-named(1, 'named' => 6);` fails.
+
+with-named(2, :named(5));  #=> 7
 
-## To make a named argument mandatory, you can use `?`'s inverse, `!`
-sub with-mandatory-named(:$str!)  {
-  say "$str !";
+## To make a named argument mandatory, you can append `!` to the parameter,
+## which is the inverse of `?`:
+sub with-mandatory-named( :$str! )  {
+    say "$str!";
 }
-with-mandatory-named(str => "My String"); #=> My String !
-with-mandatory-named;   # run time error: "Required named parameter not passed"
-with-mandatory-named(3);# run time error:"Too many positional parameters passed"
+with-mandatory-named(str => "My String"); #=> My String!
+with-mandatory-named;   # runtime error:"Required named parameter not passed"
+with-mandatory-named(3);# runtime error:"Too many positional parameters passed"
 
-## If a sub takes a named boolean argument ...
-sub takes-a-bool($name, :$bool) {
-  say "$name takes $bool";
+## If a sub takes a named boolean argument...
+sub takes-a-bool( $name, :$bool ) {
+    say "$name takes $bool";
 }
 ## ... you can use the same "short boolean" hash syntax:
-takes-a-bool('config', :bool); # config takes True
-takes-a-bool('config', :!bool); # config takes False
+takes-a-bool('config', :bool);  #=> config takes True
+takes-a-bool('config', :!bool); #=> config takes False
 
-## You can also provide your named arguments with defaults:
-sub named-def(:$def = 5) {
-  say $def;
+## You can also provide your named arguments with default values:
+sub named-def( :$def = 5 ) {
+    say $def;
 }
-named-def; #=> 5
+named-def;            #=> 5
 named-def(def => 15); #=> 15
 
 ## Since you can omit parenthesis to call a function with no arguments,
-## you need "&" in the name to store `say-hello` in a variable.
+## you need `&` in the name to store `say-hello` in a variable. This means
+## `&say-hello` is a code object and not a subroutine call.
 my &s = &say-hello;
-my &other-s = sub { say "Anonymous function !" }
+my &other-s = sub { say "Anonymous function!" }
 
-## A sub can have a "slurpy" parameter, or "doesn't-matter-how-many"
-sub as-many($head, *@rest) {  #`*@` (slurpy) will "take everything else"
-## Note: you can have parameters *before* a slurpy one (like here),
-## but not *after*.
-  say @rest.join(' / ') ~ " !";
+## A sub can have a "slurpy" parameter, or "doesn't-matter-how-many". For
+## this, you must use `*@` (slurpy) which will "take everything else". You can
+## have as many parameters *before* a slurpy one, but not *after*.
+sub as-many($head, *@rest) {
+    say @rest.join(' / ') ~ " !";
 }
-say as-many('Happy', 'Happy', 'Birthday'); #=> Happy / Birthday !
-                                           # Note that the splat (the *) did not
-                                           # consume the parameter before.
+say as-many('Happy', 'Happy', 'Birthday');#=> Happy / Birthday !
+                                          # Note that the splat (the *) did not
+                                          # consume the parameter before it.
 
-## You can call a function with an array using the
-## "argument list flattening" operator `|`
-## (it's not actually the only role of this operator, but it's one of them)
+## You can call a function with an array using the "argument list flattening"
+## operator `|` (it's not actually the only role of this operator,
+## but it's one of them).
 sub concat3($a, $b, $c) {
-  say "$a, $b, $c";
+    say "$a, $b, $c";
 }
 concat3(|@array); #=> a, b, c
                   # `@array` got "flattened" as a part of the argument list
@@ -234,159 +240,189 @@ concat3(|@array); #=> a, b, c
 ## Containers
 
 ```perl6
-## In Perl 6, values are actually stored in "containers".
-## The assignment operator asks the container on the left to store the value on
-## its right. When passed around, containers are marked as immutable.
-## Which means that, in a function, you'll get an error if you try to
-## mutate one of your arguments.
-## If you really need to, you can ask for a mutable container using `is rw`:
-sub mutate($n is rw) {
-  $n++;
-  say "\$n is now $n !";
+## In Perl 6, values are actually stored in "containers". The assignment
+## operator asks the container on the left to store the value on its right.
+## When passed around, containers are marked as immutable which means that,
+## in a function, you'll get an error if you try to mutate one of your
+## arguments. If you really need to, you can ask for a mutable container by
+## using the `is rw` trait:
+sub mutate( $n is rw ) {
+    $n++; # postfix ++ operator increments its argument but returns its old value
 }
 
 my $m = 42;
-mutate $m; # $n is now 43 !
+mutate $m; # the value is incremented but the old value is returned
+           #=> 42
+say $m;    #=> 43
 
-## This works because we are passing the container $m to mutate.  If we try
-## to just pass a number instead of passing a variable it won't work because
-## there is no container being passed and integers are immutable by themselves:
+## This works because we are passing the container $m to the `mutate` sub.
+## If we try to just pass a number instead of passing a variable it won't work
+## because there is no container being passed and integers are immutable by
+## themselves:
 
 mutate 42; # Parameter '$n' expected a writable container, but got Int value
 
-## If what you want a copy instead, use `is copy`.
+## Similar error would be obtained, if a bound variable is passed to
+## to the subroutine:
+
+my $v := 50; # binding 50 to the variable $v
+mutate $v; # Parameter '$n' expected a writable container, but got Int value
+
+## If what you want is a copy instead, use the `is copy` trait which will
+## cause the argument to be copied and allow you to modify the argument
+## inside the routine.
 
 ## A sub itself returns a container, which means it can be marked as rw:
 my $x = 42;
 sub x-store() is rw { $x }
 x-store() = 52; # in this case, the parentheses are mandatory
                 # (else Perl 6 thinks `x-store` is an identifier)
-say $x; #=> 52
+say $x;         #=> 52
 ```
 
 ## Control Flow Structures
+
 ### Conditionals
 
 ```perl6
 ## - `if`
 ## Before talking about `if`, we need to know which values are "Truthy"
-## (represent True), and which are "Falsey" (or "Falsy") -- represent False.
-## Only these values are Falsey: 0, (), {}, "", Nil, A type (like `Str` or
-## `Int`) and of course False itself.
-## Every other value is Truthy.
+## (represent True), and which are "Falsey" (represent False). Only these
+## values are Falsey: 0, (), {}, "", Nil, A type (like `Str` or `Int`) and
+## of course False itself. Any other value is Truthy.
 if True {
-  say "It's true !";
+    say "It's true!";
 }
 
 unless False {
-  say "It's not false !";
+    say "It's not false!";
 }
 
-## As you can see, you don't need parentheses around conditions.
-## However, you do need the brackets around the "body" block:
-# if (true) say; # This doesn't work !
+## As you can see, you don't need parentheses around conditions. However, you
+## do need the curly braces around the "body" block. For example,
+## `if (true) say;` doesn't work.
 
-## You can also use their postfix versions, with the keyword after:
-say "Quite truthy" if True;
+## You can also use their statement modifier (postfix) versions:
+say "Quite truthy" if True;      #=> Quite truthy
+say "Quite falsey" unless False; #=> Quite falsey
 
-## - Ternary conditional, "?? !!" (like `x ? y : z` in some other languages)
-##   returns $value-if-true if the condition is true and $value-if-false
-##   if it is false.
-##   my $result = $value condition ?? $value-if-true !! $value-if-false;
+## - Ternary operator, "x ?? y !! z"
+## This returns $value-if-true if the condition is true and $value-if-false
+## if it is false.
+## my $result = condition ?? $value-if-true !! $value-if-false;
 
 my $age = 30;
 say $age > 18 ?? "You are an adult" !! "You are under 18";
+#=> You are an adult
 ```
 
-### given/when, or switch
+### given/when, or Perl 6's switch construct
 
 ```perl6
-## - `given`-`when` looks like other languages' `switch`, but is much more
+## `given...when` looks like other languages' `switch`, but is much more
 ## powerful thanks to smart matching and Perl 6's "topic variable", $_.
 ##
-## This variable contains the default argument of a block,
-##  a loop's current iteration (unless explicitly named), etc.
+## The topic variable $_ contains the default argument of a block, a loop's
+## current iteration (unless explicitly named), etc.
 ##
 ## `given` simply puts its argument into `$_` (like a block would do),
 ##  and `when` compares it using the "smart matching" (`~~`) operator.
 ##
 ## Since other Perl 6 constructs use this variable (as said before, like `for`,
-## blocks, etc), this means the powerful `when` is not only applicable along 
+## blocks, etc), this means the powerful `when` is not only applicable along
 ## with a `given`, but instead anywhere a `$_` exists.
 
 given "foo bar" {
-  say $_; #=> foo bar
-  when /foo/ { # Don't worry about smart matching yet – just know `when` uses it
-               # This is equivalent to `if $_ ~~ /foo/`.
-    say "Yay !";
-  }
-  when $_.chars > 50 { # smart matching anything with True is True,
-                       # i.e. (`$a ~~ True`) 
-                       # so you can also put "normal" conditionals.
-                       # This `when` is equivalent to this `if`:
-                       #  if $_ ~~ ($_.chars > 50) {...}
-                       # Which means:
-                       #  if $_.chars > 50 {...}
-    say "Quite a long string !";
-  }
-  default { # same as `when *` (using the Whatever Star)
-    say "Something else"
-  }
+    say $_;            #=> foo bar
+    when /foo/ {       # Don't worry about smart matching yet. Just know
+        say "Yay !";   # `when` uses it. This is equivalent to `if $_ ~~ /foo/`.
+
+    }
+    when $_.chars > 50 { # smart matching anything with True is True,
+                         # i.e. (`$a ~~ True`)
+                         # so you can also put "normal" conditionals.
+                         # This `when` is equivalent to this `if`:
+                         # `if $_ ~~ ($_.chars > 50) {...}`
+                         # which means: `if $_.chars > 50 {...}`
+        say "Quite a long string !";
+    }
+    default { # same as `when *` (using the Whatever Star)
+        say "Something else"
+    }
 }
 ```
 
 ### Looping constructs
 
 ```perl6
-## - `loop` is an infinite loop if you don't pass it arguments,
-## but can also be a C-style `for` loop:
+## - `loop` is an infinite loop if you don't pass it arguments, but can also
+## be a C-style `for` loop:
 loop {
-  say "This is an infinite loop !";
-  last; # last breaks out of the loop, like the `break` keyword in other
-        # languages
+    say "This is an infinite loop !";
+    last;                             # last breaks out of the loop, like
+                                      # the `break` keyword in other languages
 }
 
 loop (my $i = 0; $i < 5; $i++) {
-  next if $i == 3; # `next` skips to the next iteration, like `continue`
+    next if $i == 3; # `next` skips to the next iteration, like `continue`
                    # in other languages. Note that you can also use postfix
                    # conditionals, loops, etc.
-  say "This is a C-style for loop !";
+    say "This is a C-style for loop!";
 }
 
-## - `for` - Passes through an array
+## - `for` - Iterating through an array
+
+my @array = 1, 2, 6, 7, 3;
+
+## Accessing the array's elements with the topic variable $_.
+for @array {
+    say "I've got $_ !";
+}
+
+## Accessing the array's elements with a "pointy block", `->`.
+## Here each element is read-only.
 for @array -> $variable {
-  say "I've got $variable !";
+    say "I've got $variable !";
 }
 
-## As we saw with given, for's default "current iteration" variable is `$_`.
-## That means you can use `when` in a `for` just like you were in a `given`.
+## Accessing the array's elements with a "doubly pointy block", `<->`.
+## Here each element is read-write so mutating `$variable` mutates
+## that element in the array.
+for @array <-> $variable {
+    say "I've got $variable !";
+}
+
+## As we saw with given, a for loop's default "current iteration" variable
+## is `$_`. That means you can use `when` in a `for`loop just like you were
+## able to in a `given`.
 for @array {
-  say "I've got $_";
+    say "I've got $_";
 
-  .say; # This is also allowed.
-        # A dot call with no "topic" (receiver) is sent to `$_` by default
-  $_.say; # the above and this are equivalent.
+    .say;   # This is also allowed. A dot call with no "topic" (receiver)
+            # is sent to `$_` by default
+    $_.say; # This is equivalent to the above statement.
 }
 
 for @array {
-  # You can...
-  next if $_ == 3; # Skip to the next iteration (`continue` in C-like languages)
-  redo if $_ == 4; # Re-do the iteration, keeping the same topic variable (`$_`)
-  last if $_ == 5; # Or break out of a loop (like `break` in C-like languages)
+    # You can...
+    next if $_ == 3; # Skip to the next iteration (`continue` in C-like lang.)
+    redo if $_ == 4; # Re-do iteration, keeping the same topic variable (`$_`)
+    last if $_ == 5; # Or break out of loop (like `break` in C-like lang.)
 }
 
-## The "pointy block" syntax isn't specific to for.
-## It's just a way to express a block in Perl6.
+## The "pointy block" syntax isn't specific to the `for` loop. It's just a way
+## to express a block in Perl 6.
+sub long-computation { "Finding factors of large primes" }
 if long-computation() -> $result {
-  say "The result is $result";
+    say "The result is $result.";
 }
 ```
 
 ## Operators
 
 ```perl6
-## Since Perl languages are very much operator-based languages,
-## Perl 6 operators are actually just funny-looking subroutines, in syntactic
+## Since Perl languages are very much operator-based languages, Perl 6
+## operators are actually just funny-looking subroutines, in syntactic
 ## categories, like infix:<+> (addition) or prefix:<!> (bool not).
 
 ## The categories are:
@@ -394,105 +430,136 @@ if long-computation() -> $result {
 ## - "postfix": after (like `++` in `$a++`).
 ## - "infix": in between (like `*` in `4 * 3`).
 ## - "circumfix": around (like `[`-`]` in `[1, 2]`).
-## - "post-circumfix": around, after another term (like `{`-`}` in 
-##                     `%hash{'key'}`)
+## - "post-circumfix": around, after another term (like `{`-`}` in
+##                    `%hash{'key'}`)
 
 ## The associativity and precedence list are explained below.
 
-## Alright, you're set to go !
+## Alright, you're set to go!
 
-## * Equality Checking
+## Equality Checking
+##------------------
 
 ## - `==` is numeric comparison
-3 == 4; # False
-3 != 4; # True
+3 == 4; #=> False
+3 != 4; #=> True
 
 ## - `eq` is string comparison
-'a' eq 'b';
-'a' ne 'b'; # not equal
-'a' !eq 'b'; # same as above
+'a' eq 'b';  #=> False
+'a' ne 'b';  #=> True, not equal
+'a' !eq 'b'; #=> True, same as above
 
 ## - `eqv` is canonical equivalence (or "deep equality")
-(1, 2) eqv (1, 3);
+(1, 2) eqv (1, 3); #=> False
+(1, 2) eqv (1, 2); #=> True
+Int === Int        #=> True
 
-## - Smart Match Operator: `~~`
+## - `~~` is the smart match operator
 ## Aliases the left hand side to $_ and then evaluates the right hand side.
 ## Here are some common comparison semantics:
 
-## String or Numeric Equality
-
+## String or numeric equality
 'Foo' ~~ 'Foo'; # True if strings are equal.
-12.5 ~~ 12.50; # True if numbers are equal.
+12.5 ~~ 12.50;  # True if numbers are equal.
 
 ## Regex - For matching a regular expression against the left side.
-## Returns a (Match) object, which evaluates as True if regexp matches.
+## Returns a `Match` object, which evaluates as True if regexp matches.
 
 my $obj = 'abc' ~~ /a/;
-say $obj; # ｢a｣
-say $obj.WHAT; # (Match)
+say $obj;       #=> ｢a｣
+say $obj.WHAT;  #=> (Match)
 
 ## Hashes
-'key' ~~ %hash; # True if key exists in hash
-
-## Type - Checks if left side "has type" (can check superclasses and roles)
-
-1 ~~ Int; # True
+'key' ~~ %hash; # True if key exists in hash.
 
-## Smart-matching against a boolean always returns that boolean (and will warn).
+## Type - Checks if left side "is of type" (can check superclasses and
+## roles).
+say 1 ~~ Int;       #=> True
 
-1 ~~ True; # True
-False ~~ True; # True
+## Smart-matching against a boolean always returns that boolean
+## (and will warn).
+say 1 ~~ True;      #=> True
+say False ~~ True;  #=> True
 
-## General syntax is $arg ~~ &bool-returning-function;
-## For a complete list of combinations, use this table:
+## General syntax is `$arg ~~ &bool-returning-function;`. For a complete list
+## of combinations, use this table:
 ## http://perlcabal.org/syn/S03.html#Smart_matching
 
-## You also, of course, have `<`, `<=`, `>`, `>=`.
-## Their string equivalent are also available : `lt`, `le`, `gt`, `ge`.
-3 > 4;
+## Of course, you also use `<`, `<=`, `>`, `>=` for numeric comparison.
+## Their string equivalent are also available: `lt`, `le`, `gt`, `ge`.
+3 > 4;       # False
+3 >= 4;      # False
+3 < 4;       # True
+3 <= 4;      # True
+'a' gt 'b';  # False
+'a' ge 'b';  # False
+'a' lt 'b';  # True
+'a' le 'b';  # True
+
+
+## Range constructor
+##------------------
+3 .. 7;          # 3 to 7, both included. 
+3 ..^ 7;         # 3 to 7, exclude right endpoint.
+3 ^.. 7;         # 3 to 7, exclude left endpoint.
+3 ^..^ 7;        # 3 to 7, exclude both endpoints.
+		 # 3 ^.. 7 almost like 4 .. 7 when we only consider integers.
+		 # But when we consider decimals :
+3.5 ~~ 4 .. 7;	 # False
+3.5 ~~ 3 ^.. 7;	 # True, This Range also contains decimals greater than 3.
+		 # We describe it like this in some math books: 3.5 ∈ (3,7]
+		 # If you don’t want to understand the concept of interval 
+		 # for the time being. At least we should know：
+3 ^.. 7 ~~ 4 .. 7; # False
+
 
-## * Range constructors
-3 .. 7; # 3 to 7, both included
-## `^` on either side them exclusive on that side :
-3 ^..^ 7; # 3 to 7, not included (basically `4 .. 6`)
 ## This also works as a shortcut for `0..^N`:
-^10; # means 0..^10
+^10;             # means 0..^10
 
 ## This also allows us to demonstrate that Perl 6 has lazy/infinite arrays,
 ## using the Whatever Star:
-my @array = 1..*; # 1 to Infinite ! `1..Inf` is the same.
-say @array[^10]; # you can pass arrays as subscripts and it'll return
-                 #  an array of results. This will print
-                 # "1 2 3 4 5 6 7 8 9 10" (and not run out of memory !)
-## Note : when reading an infinite list, Perl 6 will "reify" the elements
+my @array = 1..*;  # 1 to Infinite! Equivalent to `1..Inf`.
+say @array[^10];   # You can pass ranges as subscripts and it'll return
+                   # an array of results. This will print
+                   # "1 2 3 4 5 6 7 8 9 10" (and not run out of memory!)
+
+## Note: when reading an infinite list, Perl 6 will "reify" the elements
 ## it needs, then keep them in memory. They won't be calculated more than once.
 ## It also will never calculate more elements that are needed.
-## Trying 
 
-## An array subscript can also be a closure.
-## It'll be called with the length as the argument
+## An array subscript can also be a closure. It'll be called with the length
+## as the argument:
 say join(' ', @array[15..*]); #=> 15 16 17 18 19
 ## which is equivalent to:
 say join(' ', @array[-> $n { 15..$n }]);
+
 ## Note: if you try to do either of those with an infinite array,
-##       you'll trigger an infinite loop (your program won't finish)
+##       you'll trigger an infinite loop (your program won't finish).
 
-## You can use that in most places you'd expect, even assigning to an array
+## You can use that in most places you'd expect, even when assigning to
+## an array:
 my @numbers = ^20;
 
-## Here numbers increase by "6"; more on `...` operator later.
-my @seq =  3, 9 ... * > 95; # 3 9 15 21 27 [...] 81 87 93 99;
+## Here the numbers increase by 6, like an arithmetic sequence; more on the
+## sequence (`...`) operator later.
+my @seq =  3, 9 ... * > 95;  # 3 9 15 21 27 [...] 81 87 93 99;
 @numbers[5..*] = 3, 9 ... *; # even though the sequence is infinite,
                              # only the 15 needed values will be calculated.
-say @numbers; #=> 0 1 2 3 4 3 9 15 21 [...] 81 87
-              # (only 20 values)
+say @numbers;                #=> 0 1 2 3 4 3 9 15 21 [...] 81 87
+                             # (only 20 values)
+
+## and (&&), or (||)
+##------------------
+3 && 4;     # 4, which is Truthy. Calls `.Bool` on both 3 and 4 and gets `True`
+            # so it returns 4 since both are `True`.
+3 && 0;     # 0
+0 && 4;     # 0
 
-## * And &&, Or ||
-3 && 4; # 4, which is Truthy. Calls `.Bool` on `4` and gets `True`.
-0 || False; # False. Calls `.Bool` on `0`
+0 || False; # False. Calls `.Bool` on `0` and `False` which are both `False`
+            # so it retusns `False` since both are `False`.
 
-## * Short-circuit (and tight) versions of the above
-#    Returns the first argument that evaluates to False, or the last argument.
+## Short-circuit (and tight) versions of the above
+## Return the first argument that evaluates to False, or the last argument.
 
 my ( $a, $b, $c ) = 1, 0, 2;
 $a && $b && $c; # Returns 0, the first False value
@@ -500,203 +567,242 @@ $a && $b && $c; # Returns 0, the first False value
 ## || Returns the first argument that evaluates to True
 $b || $a; # 1
 
-## And because you're going to want them,
-## you also have compound assignment operators:
-$a *= 2; # multiply and assignment. Equivalent to $a = $a * 2;
-$b %%= 5; # divisible by and assignment
+## And because you're going to want them, you also have compound assignment
+## operators:
+$a *= 2;        # multiply and assignment. Equivalent to $a = $a * 2;
+$b %%= 5;       # divisible by and assignment. Equivalent to $b = $b %% 2;
+$c div= 3;      # return divisor and assignment. Equivalent to $c = $c div 3;
+$d mod= 4;      # return remainder and assignment. Equivalent to $d = $d mod 4;
 @array .= sort; # calls the `sort` method and assigns the result back
 ```
 
-## More on subs !
+## More on subs!
 
 ```perl6
-## As we said before, Perl 6 has *really* powerful subs. We're going to see
-## a few more key concepts that make them better than in any other language :-).
+## As we said before, Perl 6 has *really* powerful subs. We're going
+## to see a few more key concepts that make them better than in any
+## other language :-).
 ```
 
-### Unpacking !
+### Unpacking!
 
 ```perl6
-## It's the ability to "extract" arrays and keys (AKA "destructuring").
-## It'll work in `my`s and in parameter lists.
+## Unpacking is the ability to "extract" arrays and keys
+## (AKA "destructuring"). It'll work in `my`s and in parameter lists.
 my ($f, $g) = 1, 2;
-say $f; #=> 1
-my ($, $, $h) = 1, 2, 3; # keep the non-interesting anonymous
-say $h; #=> 3
+say $f;                  #=> 1
+my ($, $, $h) = 1, 2, 3; # keep the non-interesting values anonymous (`$`)
+say $h;                  #=> 3
 
 my ($head, *@tail) = 1, 2, 3; # Yes, it's the same as with "slurpy subs"
 my (*@small) = 1;
 
-sub unpack_array(@array [$fst, $snd]) {
-  say "My first is $fst, my second is $snd ! All in all, I'm @array[].";
+sub unpack_array( @array [$fst, $snd] ) {
+  say "My first is $fst, my second is $snd! All in all, I'm @array[].";
   # (^ remember the `[]` to interpolate the array)
 }
-unpack_array(@tail); #=> My first is 2, my second is 3 ! All in all, I'm 2 3
+unpack_array(@tail); #=> My first is 2, my second is 3! All in all, I'm 2 3.
 
 
 ## If you're not using the array itself, you can also keep it anonymous,
 ## much like a scalar:
-sub first-of-array(@ [$fst]) { $fst }
+sub first-of-array( @ [$fst] ) { $fst }
 first-of-array(@small); #=> 1
-first-of-array(@tail); # Throws an error "Too many positional parameters passed"
-                       # (which means the array is too big).
+first-of-array(@tail);  # Error: "Too many positional parameters passed"
+                        # (which means the array is too big).
 
-## You can also use a slurp ...
+## You can also use a slurp...
 sub slurp-in-array(@ [$fst, *@rest]) { # You could keep `*@rest` anonymous
-  say $fst + @rest.elems; # `.elems` returns a list's length.
-                          # Here, `@rest` is `(3,)`, since `$fst` holds the `2`.
+    say $fst + @rest.elems;            # `.elems` returns a list's length.
+                                       # Here, `@rest` is `(3,)`, since `$fst`
+                                       # holds the `2`.
 }
-slurp-in-array(@tail); #=> 3
+slurp-in-array(@tail);                 #=> 3
 
 ## You could even extract on a slurpy (but it's pretty useless ;-).)
-sub fst(*@ [$fst]) { # or simply : `sub fst($fst) { ... }`
-  say $fst;
+sub fst(*@ [$fst]) { # or simply: `sub fst($fst) { ... }`
+    say $fst;
 }
-fst(1); #=> 1
+fst(1);    #=> 1
 fst(1, 2); # errors with "Too many positional parameters passed"
 
-## You can also destructure hashes (and classes, which you'll learn about later)
-## The syntax is basically `%hash-name (:key($variable-to-store-value-in))`.
+## You can also destructure hashes (and classes, which you'll learn about
+## later). The syntax is basically the same as
+## `%hash-name (:key($variable-to-store-value-in))`.
 ## The hash can stay anonymous if you only need the values you extracted.
-sub key-of(% (:value($val), :qua($qua))) {
-  say "Got val $val, $qua times.";
+sub key-of( % (:value($val), :qua($qua)) ) {
+ 	say "Got val $val, $qua times.";
 }
 
-## Then call it with a hash: (you need to keep the brackets for it to be a hash)
-key-of({value => 'foo', qua => 1});
+## Then call it with a hash. You need to keep the curly braces for it to be a
+## hash or use `%()` instead to indicate a hash is being passed.
+key-of({value => 'foo', qua => 1});  #=> Got val foo, 1 times.
+key-of(%(value => 'foo', qua => 1)); #=> Got val foo, 1 times.
 #key-of(%hash); # the same (for an equivalent `%hash`)
 
-## The last expression of a sub is returned automatically
-## (though you may use the `return` keyword, of course):
-sub next-index($n) {
-  $n + 1;
+## The last expression of a sub is returned automatically (though you may
+## indicate explicitly by using the `return` keyword, of course):
+sub next-index( $n ) {
+ 	$n + 1;
 }
 my $new-n = next-index(3); # $new-n is now 4
 
-## This is true for everything, except for the looping constructs
-## (due to performance reasons): there's reason to build a list
-## if we're just going to discard all the results.
-## If you still want to build one, you can use the `do` statement prefix:
-## (or the `gather` prefix, which we'll see later)
-sub list-of($n) {
-  do for ^$n { # note the use of the range-to prefix operator `^` (`0..^N`)
-    $_ # current loop iteration
-  }
+## This is true for everything, except for the looping constructs (due to
+## performance reasons): there's no reason to build a list if we're just going to
+## discard all the results. If you still want to build one, you can use the
+## `do` statement prefix or the `gather` prefix, which we'll see later:
+
+sub list-of( $n ) {
+ 	do for ^$n { # note the range-to prefix operator `^` (`0..^N`)
+  		$_       # current loop iteration known as the "topic" variable
+  	}
 }
 my @list3 = list-of(3); #=> (0, 1, 2)
 ```
 
-### lambdas
+### lambdas (or anonymous subroutines)
 
 ```perl6
-## You can create a lambda with `-> {}` ("pointy block") or `{}` ("block")
-my &lambda = -> $argument { "The argument passed to this lambda is $argument" }
+## You can create a lambda with `-> {}` ("pointy block") ,
+## `{}` ("block") or `sub {}`.
+
+my &lambda1 = -> $argument {
+	"The argument passed to this lambda is $argument"
+}
+
+my &lambda2 = {
+	"The argument passed to this lambda is $_"
+}
+
+my &lambda3 = sub ($argument) {
+	"The argument passed to this lambda is $argument"
+}
+
 ## `-> {}` and `{}` are pretty much the same thing, except that the former can
 ## take arguments, and that the latter can be mistaken as a hash by the parser.
 
-## We can, for example, add 3 to each value of an array using map:
+## We can, for example, add 3 to each value of an array using the
+## `map` function with a lambda:
 my @arrayplus3 = map({ $_ + 3 }, @array); # $_ is the implicit argument
 
 ## A sub (`sub {}`) has different semantics than a block (`{}` or `-> {}`):
 ## A block doesn't have a "function context" (though it can have arguments),
-## which means that if you return from it,
-## you're going to return from the parent function. Compare:
-sub is-in(@array, $elem) {
-  # this will `return` out of the `is-in` sub
-  # once the condition evaluated to True, the loop won't be run anymore
-  map({ return True if $_ == $elem }, @array);
-}
-sub truthy-array(@array) {
-  # this will produce an array of `True` and `False`:
-  # (you can also say `anon sub` for "anonymous subroutine")
-  map(sub ($i) { if $i { return True } else { return False } }, @array);
-  # ^ the `return` only returns from the anonymous `sub`
-}
-
-## You can also use the "whatever star" to create an anonymous function
+## which means that if you return from it, you're going to return from the
+## parent function. Compare:
+sub is-in( @array, $elem ) {
+    # this will `return` out of the `is-in` sub once the condition evaluated
+    ## to True, the loop won't be run anymore.
+    map({ return True if $_ == $elem }, @array);
+}
+## with:
+sub truthy-array( @array ) {
+    # this will produce an array of `True` and `False`:
+    # (you can also say `anon sub` for "anonymous subroutine")
+    map(sub ($i) { if $i { return True } else { return False } }, @array);
+    # ^ the `return` only returns from the anonymous `sub`
+}
+
+## The `anon` declarator can be used to create an anonymous sub from a
+## regular subroutine. The regular sub knows its name but its symbol is
+## prevented from getting installed in the lexical scope, the method table
+## and everywhere else.
+
+my $anon-sum = anon sub summation(*@a) { [+] *@a }
+say $anon-sum.name;     #=> summation
+say $anon-sum(2, 3, 5); #=> 10
+#say summation;         #=> Error: Undeclared routine: ...
+
+## You can also use the "whatever star" to create an anonymous subroutine.
 ## (it'll stop at the furthest operator in the current expression)
-my @arrayplus3 = map(*+3, @array); # `*+3` is the same as `{ $_ + 3 }`
+my @arrayplus3 = map(*+3, @array);   # `*+3` is the same as `{ $_ + 3 }`
 my @arrayplus3 = map(*+*+3, @array); # Same as `-> $a, $b { $a + $b + 3 }`
                                      # also `sub ($a, $b) { $a + $b + 3 }`
-say (*/2)(4); #=> 2
-              # Immediately execute the function Whatever created.
+say (*/2)(4);     #=> 2
+                  # Immediately execute the function Whatever created.
 say ((*+3)/5)(5); #=> 1.6
-                  # works even in parens !
-
-## But if you need to have more than one argument (`$_`)
-## in a block (without wanting to resort to `-> {}`),
-## you can also use the implicit argument syntax, `$^` :
-map({ $^a + $^b + 3 }, @array); # equivalent to following:
-map(sub ($a, $b) { $a + $b + 3 }, @array); # (here with `sub`)
-
-## Note : those are sorted lexicographically.
-# `{ $^b / $^a }` is like `-> $a, $b { $b / $a }`
+                  # It works even in parens!
+
+## But if you need to have more than one argument (`$_`) in a block (without
+## wanting to resort to `-> {}`), you can also use the implicit argument
+## syntax, `$^`:
+map({ $^a + $^b + 3 }, @array);
+# which is equivalent to the following which uses a `sub`:
+map(sub ($a, $b) { $a + $b + 3 }, @array);
+
+## The parameters `$^a`, `$^b`, etc. are known as placeholder parameters or
+## self-declared positional parameters. They're sorted lexicographically so
+## `{ $^b / $^a }` is equivalent `-> $a, $b { $b / $a }`.
 ```
 
 ### About types...
 
 ```perl6
-## Perl6 is gradually typed. This means you can specify the type
-## of your variables/arguments/return types, or you can omit them
-## and they'll default to "Any".
-## You obviously get access to a few base types, like Int and Str.
-## The constructs for declaring types are "class", "role",
-## which you'll see later.
-
-## For now, let us examine "subset":
-## a "subset" is a "sub-type" with additional checks.
-## For example: "a very big integer is an Int that's greater than 500"
-## You can specify the type you're subtyping (by default, Any),
-## and add additional checks with the "where" keyword:
+## Perl 6 is gradually typed. This means you can specify the type of your
+## variables/arguments/return types, or you can omit the type annotations in
+## in which case they'll default to `Any`. Obviously you get access to a few
+## base types, like `Int` and `Str`. The constructs for declaring types are
+## "subset", "class", "role", etc. which you'll see later.
+
+## For now, let us examine "subset" which is a "sub-type" with additional
+## checks. For example, "a very big integer is an Int that's greater than 500".
+## You can specify the type you're subtyping (by default, `Any`), and add
+## additional checks with the `where` clause:
 subset VeryBigInteger of Int where * > 500;
+## Or the set of the whole numbers:
+subset WholeNumber of Int where * >= 0;
 ```
 
 ### Multiple Dispatch
 
 ```perl6
 ## Perl 6 can decide which variant of a `sub` to call based on the type of the
-## arguments, or on arbitrary preconditions, like with a type or a `where`:
+## arguments, or on arbitrary preconditions, like with a type or `where`:
 
-## with types
-multi sub sayit(Int $n) { # note the `multi` keyword here
+## with types:
+multi sub sayit( Int $n ) { # note the `multi` keyword here
   say "Number: $n";
 }
-multi sayit(Str $s) { # a multi is a `sub` by default
+multi sayit( Str $s ) {     # a multi is a `sub` by default
   say "String: $s";
 }
-sayit("foo"); # prints "String: foo"
-sayit(True); # fails at *compile time* with
-             # "calling 'sayit' will never work with arguments of types ..."
+sayit("foo"); #=> "String: foo"
+sayit(25);    #=> "Number: 25"
+sayit(True);  # fails at *compile time* with "calling 'sayit' will never
+              # work with arguments of types ..."
 
-## with arbitrary precondition (remember subsets?):
-multi is-big(Int $n where * > 50) { "Yes !" } # using a closure
-multi is-big(Int $ where 10..50) { "Quite." } # Using smart-matching
-                                              # (could use a regexp, etc)
+## with arbitrary preconditions (remember subsets?):
+multi is-big(Int $n where * > 50) { "Yes!" }    # using a closure
+multi is-big(Int $n where {$_ > 50}) { "Yes!" } # similar to above
+multi is-big(Int $ where 10..50)  { "Quite." }  # Using smart-matching
+                                                # (could use a regexp, etc)
 multi is-big(Int $) { "No" }
 
 subset Even of Int where * %% 2;
-
 multi odd-or-even(Even) { "Even" } # The main case using the type.
                                    # We don't name the argument.
-multi odd-or-even($) { "Odd" } # "else"
+multi odd-or-even($) { "Odd" }     # "everthing else" hence the $ variable
 
-## You can even dispatch based on a positional's argument presence !
-multi with-or-without-you(:$with!) { # You need make it mandatory to
-                                     # be able to dispatch against it.
-  say "I can live ! Actually, I can't.";
+## You can even dispatch based on the presence of positional and
+## named arguments:
+multi with-or-without-you($with) {
+     say "I wish I could but I can't";
+}
+multi with-or-without-you(:$with) {
+     say "I can live! Actually, I can't.";
 }
 multi with-or-without-you {
-  say "Definitely can't live.";
+     say "Definitely can't live.";
 }
-## This is very, very useful for many purposes, like `MAIN` subs (covered 
-## later), and even the language itself is using it in several places.
+
+## This is very, very useful for many purposes, like `MAIN` subs (covered
+## later), and even the language itself uses it in several places.
 ##
 ## - `is`, for example, is actually a `multi sub` named `trait_mod:<is>`,
 ## and it works off that.
 ## - `is rw`, is simply a dispatch to a function with this signature:
 ## sub trait_mod:<is>(Routine $r, :$rw!) {}
 ##
-## (commented because running this would be a terrible idea !)
+## (commented out because running this would be a terrible idea!)
 ```
 
 ## Scoping
@@ -705,175 +811,207 @@ multi with-or-without-you {
 ## In Perl 6, unlike many scripting languages, (such as Python, Ruby, PHP),
 ## you must declare your variables before using them. The `my` declarator
 ## you have learned uses "lexical scoping". There are a few other declarators,
-## (`our`, `state`, ..., ) which we'll see later.
-## This is called "lexical scoping", where in inner blocks,
-## you can access variables from outer blocks.
+## (`our`, `state`, ..., ) which we'll see later. This is called
+## "lexical scoping", where in inner blocks,  you can access variables from
+## outer blocks.
 my $file_scoped = 'Foo';
 sub outer {
-  my $outer_scoped = 'Bar';
-  sub inner {
-    say "$file_scoped $outer_scoped";
-  }
-  &inner; # return the function
+    my $outer_scoped = 'Bar';
+    sub inner {
+        say "$file_scoped $outer_scoped";
+    }
+    &inner; # return the function
 }
-outer()(); #=> 'Foo Bar'
+outer()();  #=> 'Foo Bar'
 
 ## As you can see, `$file_scoped` and `$outer_scoped` were captured.
-## But if we were to try and use `$bar` outside of `foo`,
+## But if we were to try and use `$outer_scoped` outside the `outer` sub,
 ## the variable would be undefined (and you'd get a compile time error).
 ```
 
 ## Twigils
 
 ```perl6
-## There are many special `twigils` (composed sigil's) in Perl 6.
-## Twigils define the variables' scope.
+## There are many special `twigils` (composed sigils) in Perl 6. Twigils
+## define the variables' scope.
 ## The * and ? twigils work on standard variables:
 ## * Dynamic variable
 ## ? Compile-time variable
 ## The ! and the . twigils are used with Perl 6's objects:
-## ! Attribute (class member)
+## ! Attribute (instance attribute)
 ## . Method (not really a variable)
 
-## `*` Twigil: Dynamic Scope
-## These variables use the`*` twigil to mark dynamically-scoped variables.
+## `*` twigil: Dynamic Scope
+## These variables use the `*` twigil to mark dynamically-scoped variables.
 ## Dynamically-scoped variables are looked up through the caller, not through
-## the outer scope
+## the outer scope.
 
 my $*dyn_scoped_1 = 1;
 my $*dyn_scoped_2 = 10;
 
 sub say_dyn {
-  say "$*dyn_scoped_1 $*dyn_scoped_2";
+    say "$*dyn_scoped_1 $*dyn_scoped_2";
 }
 
 sub call_say_dyn {
   my $*dyn_scoped_1 = 25; # Defines $*dyn_scoped_1 only for this sub.
-  $*dyn_scoped_2 = 100; # Will change the value of the file scoped variable.
-  say_dyn(); #=> 25 100 $*dyn_scoped 1 and 2 will be looked for in the call.
-             # It uses the value of $*dyn_scoped_1 from inside this sub's 
-             # lexical scope even though the blocks aren't nested (they're 
-             # call-nested).
-}
-say_dyn(); #=> 1 10
+  $*dyn_scoped_2 = 100;   # Will change the value of the file scoped variable.
+  say_dyn();              #=> 25 100, $*dyn_scoped 1 and 2 will be looked
+                          # for in the call.
+                          # It uses the value of $*dyn_scoped_1 from inside
+                          #	this sub's lexical scope even though the blocks
+                          # aren't nested (they're call-nested).
+}
+say_dyn();      #=> 1 10
 call_say_dyn(); #=> 25 100
                 # Uses $*dyn_scoped_1 as defined in call_say_dyn even though
                 # we are calling it from outside.
-say_dyn(); #=> 1 100 We changed the value of $*dyn_scoped_2 in call_say_dyn
-           #         so now its value has changed.
+say_dyn();      #=> 1 100 We changed the value of $*dyn_scoped_2 in
+				# call_say_dyn so now its value has changed.
 ```
 
 ## Object Model
 
 ```perl6
 ## To call a method on an object, add a dot followed by the method name:
-## => $object.method
+## `$object.method`
+
 ## Classes are declared with the `class` keyword. Attributes are declared
-## with the `has` keyword, and methods declared with `method`.
-## Every attribute that is private uses the ! twigil for example: `$!attr`.
-## Immutable public attributes use the `.` twigil.
-## (you can make them mutable with `is rw`)
-## The easiest way to remember the `$.` twigil is comparing it to how methods
-## are called.
-
-## Perl 6's object model ("SixModel") is very flexible,
-## and allows you to dynamically add methods, change semantics, etc ...
-## (these will not all be covered here, and you should refer to:
+## with the `has` keyword, and methods declared with the `method` keyword.
+
+## Every attribute that is private uses the ! twigil. For example: `$!attr`.
+## Immutable public attributes use the `.` twigil which creates a read-only
+## method named after the attribute. In fact, declaring an attribute with `.`
+## is equivalent to declaring the same attribute with `!` and then creating
+## a read-only method with the attribute's name. However, this is done for us
+## by Perl 6 automatically. The easiest way to remember the `$.` twigil is
+## by comparing it to how methods are called.
+
+## Perl 6's object model ("SixModel") is very flexible, and allows you to
+## dynamically add methods, change semantics, etc... Unfortunately, these will
+## not all be covered here, and you should refer to:
 ## https://docs.perl6.org/language/objects.html.
 
-class Attrib-Class {
-  has $.attrib; # `$.attrib` is immutable.
-               # From inside the class, use `$!attrib` to modify it.
-  has $.other-attrib is rw; # You can mark a public attribute `rw`.
-  has Int $!private-attrib = 10;
+class Human {
+    has Str $.name;           # `$.name` is immutable but with an accessor method.
+    has Str $.bcountry;       # Use `$!bcountry` to modify it inside the class.
+	has Str $.ccountry is rw; # This attribute can be modified from outside.
+	has Int $!age = 0;        # A private attribute with default value.
 
-  method get-value {
-    $.attrib + $!private-attrib;
-  }
-
-  method set-value($param) { # Methods can take parameters
-    $!attrib = $param;   # This works, because `$!` is always mutable.
-	# $.attrib = $param; # Wrong: You can't use the `$.` immutable version.
+	method birthday {
+		$!age += 1; # Add a year to human's age
+	}
 
-    $.other-attrib = 5; # This works, because `$.other-attrib` is `rw`.
-  }
+	method get-age {
+		return $!age;
+	}
 
-  method !private-method {
-    say "This method is private to the class !";
-  }
+	# This method is private to the class. Note the `!` before the
+	# method's name.
+	method !do-decoration {
+    	return "$!name was born in $!bcountry and now lives in	$!ccountry."
+  	}
+
+  	# This method is public, just like `birthday` and `get-age`.
+  	method get-info {
+  		self.do-decoration; # Invoking a method on `self` inside the class.
+  		                    # Use `self!priv-method` for private method.
+  		                    # Use `self.publ-method` for public method.
+  	}
 };
 
-## Create a new instance of Attrib-Class with $.attrib set to 5 :
+## Create a new instance of Human class.
 ## Note: you can't set private-attribute from here (more later on).
-my $class-obj = Attrib-Class.new(attrib => 5);
-say $class-obj.get-value; #=> 15
-# $class-obj.attrib = 5; # This fails, because the `has $.attrib` is immutable
-$class-obj.other-attrib = 10; # This, however, works, because the public
-                              # attribute is mutable (`rw`).
+my $person1 = Human.new(
+	name => "Jord",
+	bcountry = "Togo",
+	ccountry => "Togo"
+);
+
+say $person1.name;     #=> Jord
+say $person1.bcountry; #=> Togo
+say $person1.ccountry; #=> Togo
+
+
+# $person1.bcountry = "Mali"; # This fails, because the `has $.bcountry`
+                              # is immutable. Jord can't change his birthplace.
+$person1.ccountry = "France"; # This works because the `$.ccountry` is mutable
+                              # (`is rw`). Now Jord's current country is France.
+
+# Calling methods on the instance objects.
+$person1.birthday;      #=> 1
+$person1.get-info;      #=> Jord was born in Togo and now lives in France.
+$person1.do-decoration; # This fails since the method `do-decoration` is
+					    # private.
 ```
 
 ### Object Inheritance
 
 ```perl6
-## Perl 6 also has inheritance (along with multiple inheritance)
-## While `method`'s are inherited, `submethod`'s are not.
-## Submethods are useful for object construction and destruction tasks,
-## such as BUILD, or methods that must be overridden by subtypes.
-## We will learn about BUILD later on.
+## Perl 6 also has inheritance (along with multiple inheritance). While
+## methods are inherited, submethods are not. Submethods are useful for
+## object construction and destruction tasks, such as BUILD, or methods that
+## must be overridden by subtypes. We will learn about BUILD later on.
 
 class Parent {
-  has $.age;
-  has $.name;
-  # This submethod won't be inherited by Child.
-  submethod favorite-color {
-    say "My favorite color is Blue";
-  }
-  # This method is inherited
-  method talk { say "Hi, my name is $!name" }
+  	has $.age;
+ 	has $.name;
+
+  	# This submethod won't be inherited by the Child class.
+  	submethod favorite-color {
+    	say "My favorite color is Blue";
+  	}
+
+  	# This method is inherited
+  	method talk { say "Hi, my name is $!name" }
 }
+
 # Inheritance uses the `is` keyword
 class Child is Parent {
-  method talk { say "Goo goo ga ga" }
-  # This shadows Parent's `talk` method, This child hasn't learned to speak yet!
+  	method talk { say "Goo goo ga ga" }
+  	# This shadows Parent's `talk` method.
+  	# This child hasn't learned to speak yet!
 }
+
 my Parent $Richard .= new(age => 40, name => 'Richard');
-$Richard.favorite-color; #=> "My favorite color is Blue"
-$Richard.talk; #=> "Hi, my name is Richard"
-## $Richard is able to access the submethod, he knows how to say his name.
+$Richard.favorite-color;  #=> "My favorite color is Blue"
+$Richard.talk;            #=> "Hi, my name is Richard"
+## $Richard is able to access the submethod and he knows how to say his name.
 
 my Child $Madison .= new(age => 1, name => 'Madison');
-$Madison.talk; # prints "Goo goo ga ga" due to the overridden method.
-# $Madison.favorite-color # does not work since it is not inherited
+$Madison.talk;            #=> "Goo goo ga ga", due to the overridden method.
+# $Madison.favorite-color # does not work since it is not inherited.
 
 ## When you use `my T $var`, `$var` starts off with `T` itself in it,
 ## so you can call `new` on it.
 ## (`.=` is just the dot-call and the assignment operator:
-##  `$a .= b` is the same as `$a = $a.b`)
+## `$a .= b` is the same as `$a = $a.b`)
 ## Also note that `BUILD` (the method called inside `new`)
-## will set parent properties too, so you can pass `val => 5`.
+## will set parent's properties too, so you can pass `val => 5`.
 ```
 
 ### Roles, or Mixins
 
 ```perl6
-## Roles are supported too (also called Mixins in other languages)
+## Roles are supported too (which are called Mixins in other languages)
 role PrintableVal {
-  has $!counter = 0;
-  method print {
-    say $.val;
-  }
+  	has $!counter = 0;
+  	method print {
+    	say $.val;
+  	}
 }
 
-## you "import" a mixin (a "role") with "does":
+## you "apply" a role (or mixin) with `does` keyword:
 class Item does PrintableVal {
-  has $.val;
+  	has $.val;
 
-  ## When `does`-ed, a `role` literally "mixes in" the class:
-  ## the methods and attributes are put together, which means a class can access
-  ## the private attributes/methods of its roles (but not the inverse !):
-  method access {
-    say $!counter++;
-  }
+    ## When `does`-ed, a `role` literally "mixes in" the class:
+    ## the methods and attributes are put together, which means a class
+    ## can access the private attributes/methods of its roles (but
+    ## not the inverse!):
+  	method access {
+  		say $!counter++;
+  	}
 
   ## However, this:
   ## method print {}
@@ -881,9 +1019,9 @@ class Item does PrintableVal {
   ## (this means a parent class can shadow a child class's `multi print() {}`,
   ##  but it's an error if a role does)
 
-  ## NOTE: You can use a role as a class (with `is ROLE`). In this case, 
-  ##       methods will be shadowed, since the compiler will consider `ROLE` to 
-  ##       be a class.
+  ## NOTE: You can use a role as a class (with `is ROLE`). In this case,
+  ##       methods will be shadowed, since the compiler will consider `ROLE`
+  ##       to be a class.
 }
 ```
 
@@ -891,91 +1029,109 @@ class Item does PrintableVal {
 
 ```perl6
 ## Exceptions are built on top of classes, in the package `X` (like `X::IO`).
-## In Perl6 exceptions are automatically 'thrown'
-open 'foo'; #> Failed to open file foo: no such file or directory
-## It will also print out what line the error was thrown at and other error info
+## In Perl6 exceptions are automatically 'thrown':
+open 'foo';   #=> Failed to open file foo: no such file or directory
+## It will also print out what line the error was thrown at
+## and other error info.
 
 ## You can throw an exception using `die`:
 die 'Error!'; #=> Error!
 
 ## Or more explicitly:
-die X::AdHoc.new(payload => 'Error!');
+X::AdHoc.new(payload => 'Error!').throw; #=> Error!
 
 ## In Perl 6, `orelse` is similar to the `or` operator, except it only matches
-## undefined variables instead of anything evaluating as false.
+## undefined variables instead of anything evaluating as `False`.
 ## Undefined values include: `Nil`, `Mu` and `Failure` as well as `Int`, `Str`
 ## and other types that have not been initialized to any value yet.
 ## You can check if something is defined or not using the defined method:
 my $uninitialized;
-say $uninitiazilzed.defined; #> False
-## When using `orelse` it will disarm the exception and alias $_ to that failure
-## This will avoid it being automatically handled and printing lots of scary
-## error messages to the screen.
-## We can use the exception method on $_ to access the exception
+say $uninitiazilzed.defined; #=> False
+
+## When using `orelse` it will disarm the exception and alias $_ to that
+## failure. This will prevent it to being automatically handled and printing
+## lots of scary error messages to the screen. We can use the `exception`
+## method on the `$_` variable to access the exception
 open 'foo' orelse say "Something happened {.exception}";
 
 ## This also works:
-open 'foo' orelse say "Something happened $_"; #> Something happened
-              #>  Failed to open file foo: no such file or directory
-## Both of those above work but in case we get an object from the left side that
-## is not a failure we will probably get a warning.  We see below how we can use
-## `try` and `CATCH` to be more specific with the exceptions we catch.
+open 'foo' orelse say "Something happened $_"; #=> Something happened
+              #=>  Failed to open file foo: no such file or directory
+## Both of those above work but in case we get an object from the left side
+## that is not a failure we will probably get a warning. We see below how we
+## can use try` and `CATCH` to be more specific with the exceptions we catch.
 ```
 
 ### Using `try` and `CATCH`
 
 ```perl6
 ## By using `try` and `CATCH` you can contain and handle exceptions without
-## disrupting the rest of the program. `try` will set the last exception to
-## the special variable `$!` Note: This has no relation to $!variables.
+## disrupting the rest of the program. The `try` block will set the last
+## exception to the special variable `$!` (known as the error variable).
+## Note: This has no relation to $!variables seen inside class definitions.
+
 try open 'foo';
-say "Well, I tried! $!" if defined $!; #> Well, I tried! Failed to open file
-                                       #foo: no such file or directory
+say "Well, I tried! $!" if defined $!;
+#=> Well, I tried! Failed to open file foo: no such file or directory
+
 ## Now, what if we want more control over handling the exception?
 ## Unlike many other languages, in Perl 6, you put the `CATCH` block *within*
-## the block to `try`. Similar to how $_ was set when we 'disarmed' the
-## exception with orelse, we also use $_ in the CATCH block.
-## Note: ($! is only set *after* the `try` block)
-## By default, a `try` has a `CATCH` block that catches
-## any exception (`CATCH { default {} }`).
+## the block to `try`. Similar to how the `$_` variable was set when we
+## 'disarmed' the exception with `orelse`, we also use `$_` in the CATCH block.
+## Note: The `$!` variable is only set *after* the `try` block has caught an
+## exception. By default, a `try` block has a `CATCH` block of its own that
+## catches any exception (`CATCH { default {} }`).
 
-try { my $a = (0 %% 0);  CATCH { say "Something happened: $_" } }
- #=> Something happened: Attempt to divide by zero using infix:<%%>
+try {
+    my $a = (0 %% 0);
+    CATCH {
+        say "Something happened: $_"
+    }
+}
+#=> Something happened: Attempt to divide by zero using infix:<%%>
+
+## You can redefine it using `when`s (and `default`) to handle the exceptions
+## you want to catch explicitly:
 
-## You can redefine it using `when`s (and `default`)
-## to handle the exceptions you want:
 try {
   open 'foo';
-  CATCH {     # In the `CATCH` block, the exception is set to $_
-    when X::AdHoc { say "Error: $_" }
-     #=>Error: Failed to open file /dir/foo: no such file or directory
-
-    ## Any other exception will be re-raised, since we don't have a `default`
-    ## Basically, if a `when` matches (or there's a `default`) marks the
-	  ## exception as
-    ## "handled" so that it doesn't get re-thrown from the `CATCH`.
-    ## You still can re-throw the exception (see below) by hand.
+    CATCH {
+        # In the `CATCH` block, the exception is set to the $_ variable.
+        when X::AdHoc {
+            say "Error: $_"
+        }
+        when X::Numeric::DivideByZero {
+            say "Error: $_";
+        }
+    ## Any other exceptions will be re-raised, since we don't have a `default`.
+    ## Basically, if a `when` matches (or there's a `default`), the
+	## exception is marked as "handled" so as to prevent its re-throw
+    ## from the `CATCH` block. You still can re-throw the exception (see below)
+    ## by hand.
   }
 }
+#=>Error: Failed to open file /dir/foo: no such file or directory
 
 ## There are also some subtleties to exceptions. Some Perl 6 subs return a
-## `Failure`, which is a kind of "unthrown exception". They're not thrown until
-## you tried to look at their content, unless you call `.Bool`/`.defined` on
-## them - then they're handled.
+## `Failure`, which is a wrapper around an `Exception` object which is
+## "unthrown". They're not thrown until you try to use the variables containing
+## them unless you call `.Bool`/`.defined` on them - then they're handled.
 ## (the `.handled` method is `rw`, so you can mark it as `False` back yourself)
-##
 ## You can throw a `Failure` using `fail`. Note that if the pragma `use fatal`
 ## is on, `fail` will throw an exception (like `die`).
+
 fail "foo"; # We're not trying to access the value, so no problem.
 try {
-  fail "foo";
-  CATCH {
-    default { say "It threw because we tried to get the fail's value!" }
+    fail "foo";
+    CATCH {
+        default {
+            say "It threw because we tried to get the fail's value!"
+        }
   }
 }
 
 ## There is also another kind of exception: Control exceptions.
-## Those are "good" exceptions, which happen when you change your program's 
+## Those are "good" exceptions, which happen when you change your program's
 ## flow, using operators like `return`, `next` or `last`.
 ## You can "catch" those with `CONTROL` (not 100% working in Rakudo yet).
 ```
@@ -989,29 +1145,35 @@ try {
 ## Packages are important - especially as Perl is well-known for CPAN,
 ## the Comprehensive Perl Archive Network.
 
-## You can use a module (bring its declarations into scope) with `use`
+## You can use a module (bring its declarations into scope) with
+## the `use` keyword:
 use JSON::Tiny; # if you installed Rakudo* or Panda, you'll have this module
 say from-json('[1]').perl; #=> [1]
 
 ## You should not declare packages using the `package` keyword (unlike Perl 5).
 ## Instead, use `class Package::Name::Here;` to declare a class, or if you only
-## want to export variables/subs, you can use `module`.
+## want to export variables/subs, you can use `module` instead.
 
-module Hello::World { # Bracketed form
-                      # If `Hello` doesn't exist yet, it'll just be a "stub",
-                      #  that can be redeclared as something else later.
-  # ... declarations here ...
+module Hello::World { # bracketed form
+    # If `Hello` doesn't exist yet, it'll just be a "stub",
+    # that can be redeclared as something else later.
+
+    # ... declarations here ...
 }
-unit module Parse::Text; # file-scoped form
 
-grammar Parse::Text::Grammar { # A grammar is a package, which you could `use`
-}                    # You will learn more about grammars in the regex section
+unit module Parse::Text; # file-scoped form which extends until
+                         # the end of the file
+
+grammar Parse::Text::Grammar {
+    # A grammar is a package, which you could `use`.
+    # You will learn more about grammars in the regex section
+}
 
 ## As said before, any part of the six model is also a package.
 ## Since `JSON::Tiny` uses its own `JSON::Tiny::Actions` class, you can use it:
 my $actions = JSON::Tiny::Actions.new;
 
-## We'll see how to export variables and subs in the next part:
+## We'll see how to export variables and subs in the next part.
 ```
 
 ## Declarators
@@ -1020,36 +1182,38 @@ my $actions = JSON::Tiny::Actions.new;
 ## In Perl 6, you get different behaviors based on how you declare a variable.
 ## You've already seen `my` and `has`, we'll now explore the others.
 
-## * `our` declarations happen at `INIT` time -- (see "Phasers" below)
-## It's like `my`, but it also creates a package variable.
-## (All packagish things (`class`, `role`, etc) are `our` by default)
-module Var::Increment {
-  our $our-var = 1; # Note: you can't put a type constraint like Int on an
-  my $my-var = 22;  # `our` variable.
-  our sub Inc {
+## `our` - these declarations happen at `INIT` time -- (see "Phasers" below).
+## It's like `my`, but it also creates a package variable. All packagish
+## things such as `class`, `role`, etc. are `our` by default.
 
-    our sub available { # If you try to make inner `sub`s `our`...
-                        # Better know what you're doing (Don't !).
-      say "Don't do that. Seriously. You'll get burned.";
-    }
-
-    my sub unavailable { # `my sub` is the default
-      say "Can't access me from outside, I'm 'my'!";
-    }
-    say ++$our-var; # Increment the package variable and output its value
+module Var::Increment {
+    our $our-var = 1; # Note: `our`-declared variables cannot be typed.
+    my $my-var = 22;
+
+    our sub Inc {
+        our sub available { # If you try to make inner `sub`s `our`...
+                            # ... Better know what you're doing (Don't !).
+            say "Don't do that. Seriously. You'll get burned.";
+        }
+
+        my sub unavailable { # `sub`s are `my`-declared by default
+            say "Can't access me from outside, I'm 'my'!";
+        }
+        say ++$our-var; # Increment the package variable and output its value
   }
 
 }
-say $Var::Increment::our-var; #=> 1 This works
-say $Var::Increment::my-var; #=> (Any) This will not work.
 
-Var::Increment::Inc; #=> 2
-Var::Increment::Inc; #=> 3 # Notice how the value of $our-var was
-                         # retained.
-Var::Increment::unavailable; #> Could not find symbol '&unavailable'
+say $Var::Increment::our-var; #=> 1, this works!
+say $Var::Increment::my-var;  #=> (Any), this will not work!
+
+Var::Increment::Inc;          #=> 2
+Var::Increment::Inc;          #=> 3 , notice how the value of $our-var was
+                              # retained.
+Var::Increment::unavailable;  #=> Could not find symbol '&unavailable'
 
-## * `constant` (happens at `BEGIN` time)
-## You can use the `constant` keyword to declare a compile-time variable/symbol:
+## `constant` - these declarations happen at `BEGIN` time. You can use
+## the `constant` keyword to declare a compile-time variable/symbol:
 constant Pi = 3.14;
 constant $var = 1;
 
@@ -1057,12 +1221,12 @@ constant $var = 1;
 constant why-not = 5, 15 ... *;
 say why-not[^5]; #=> 5 15 25 35 45
 
-## * `state` (happens at run time, but only once)
-## State variables are only initialized one time
-## (they exist in other languages such as C as `static`)
+## `state` - these declarations happen at run time, but only once. State
+## variables are only initialized one time. In other languages such as C
+## they exist as `static` variables.
 sub fixed-rand {
-  state $val = rand;
-  say $val;
+    state $val = rand;
+    say $val;
 }
 fixed-rand for ^10; # will print the same number 10 times
 
@@ -1070,40 +1234,42 @@ fixed-rand for ^10; # will print the same number 10 times
 ## If you declare a function with a `state` within a loop, it'll re-create the
 ## variable for each iteration of the loop. See:
 for ^5 -> $a {
-  sub foo {
-    state $val = rand; # This will be a different value for every value of `$a`
-  }
-  for ^5 -> $b {
-    say foo; # This will print the same value 5 times, but only 5.
-             # Next iteration will re-run `rand`.
-  }
+    sub foo {
+        state $val = rand; # This will be a different value for
+                           # every value of `$a`
+    }
+    for ^5 -> $b {
+        say foo;           # This will print the same value 5 times,
+                           # but only 5. Next iteration will re-run `rand`.
+    }
 }
 ```
 
 ## Phasers
 
 ```perl6
-## Phasers in Perl 6 are blocks that happen at determined points of time in your
-## program.  They are called phasers because they mark a change in the phase
-## of a program.  For example, when the program is compiled, a for loop runs,
-## you leave a block, or an exception gets thrown. 
-## (`CATCH` is actually a phaser!)
-## Some of them can be used for their return values, some of them can't
-## (those that can have a "[*]" in the beginning of their explanation text).
-## Let's have a look !
-
-## * Compile-time phasers
+## Phasers in Perl 6 are blocks that happen at determined points of time in
+## your program. They are called phasers because they mark a change in the
+## phase of a program.  For example, when the program is compiled, a for loop
+## runs, you leave a block, or an exception gets thrown (The `CATCH` block is
+## actually a phaser!). Some of them can be used for their return values,
+## some of them can't (those that can have a "[*]" in the beginning of their
+## explanation text). Let's have a look!
+
+## Compile-time phasers
 BEGIN { say "[*] Runs at compile time, as soon as possible, only once" }
 CHECK { say "[*] Runs at compile time, as late as possible, only once" }
 
-## * Run-time phasers
+## Run-time phasers
 INIT { say "[*] Runs at run time, as soon as possible, only once" }
-END { say "Runs at run time, as late as possible, only once" }
+END  { say "Runs at run time, as late as possible, only once" }
 
-## * Block phasers
+## Block phasers
 ENTER { say "[*] Runs everytime you enter a block, repeats on loop blocks" }
-LEAVE { say "Runs everytime you leave a block, even when an exception
-    happened. Repeats on loop blocks." }
+LEAVE {
+    say "Runs everytime you leave a block, even when an exception
+    happened. Repeats on loop blocks."
+}
 
 PRE {
     say "Asserts a precondition at every block entry,
@@ -1112,7 +1278,7 @@ PRE {
         an exception of type X::Phaser::PrePost is thrown.";
 }
 
-## example:
+## Example:
 for 0..2 {
     PRE { $_ > 1 } # This is going to blow up with "Precondition failed"
 }
@@ -1123,83 +1289,86 @@ POST {
     say "If this block doesn't return a truthy value,
         an exception of type X::Phaser::PrePost is thrown, like PRE.";
 }
+
 for 0..2 {
     POST { $_ < 2 } # This is going to blow up with "Postcondition failed"
 }
 
-## * Block/exceptions phasers
+## Block/exceptions phasers
 sub {
     KEEP { say "Runs when you exit a block successfully
                 (without throwing an exception)" }
-    UNDO { say "Runs when you exit a block unsuccessfully 
+    UNDO { say "Runs when you exit a block unsuccessfully
                 (by throwing an exception)" }
 }
 
-## * Loop phasers
+## Loop phasers
 for ^5 {
   FIRST { say "[*] The first time the loop is run, before ENTER" }
-  NEXT { say "At loop continuation time, before LEAVE" }
-  LAST { say "At loop termination time, after LEAVE" }
+  NEXT  { say "At loop continuation time, before LEAVE" }
+  LAST  { say "At loop termination time, after LEAVE" }
 }
 
-## * Role/class phasers
+## Role/class phasers
 COMPOSE { "When a role is composed into a class. /!\ NOT YET IMPLEMENTED" }
 
-## They allow for cute tricks or clever code ...:
+## They allow for cute tricks or clever code...:
 say "This code took " ~ (time - CHECK time) ~ "s to compile";
 
 ## ... or clever organization:
 sub do-db-stuff {
-  $db.start-transaction; # start a new transaction
-  KEEP $db.commit; # commit the transaction if all went well
-  UNDO $db.rollback; # or rollback if all hell broke loose
+  	$db.start-transaction; # start a new transaction
+  	KEEP $db.commit;       # commit the transaction if all went well
+  	UNDO $db.rollback;     # or rollback if all hell broke loose
 }
 ```
 
 ## Statement prefixes
 
 ```perl6
-## Those act a bit like phasers: they affect the behavior of the following code.
-## Though, they run in-line with the executable code, so they're in lowercase.
-## (`try` and `start` are theoretically in that list, but explained elsewhere)
-## Note: all of these (except start) don't need explicit brackets `{` and `}`.
+## Those act a bit like phasers: they affect the behavior of the following
+## code. Though, they run in-line with the executable code, so they're in
+## lowercase. (`try` and `start` are theoretically in that list, but explained
+## elsewhere) Note: all of these (except start) don't need explicit curly
+## braces `{` and `}`.
 
-## - `do` (that you already saw) - runs a block or a statement as a term
-## You can't normally use a statement as a value (or "term"):
-##
-##    my $value = if True { 1 } # `if` is a statement - parse error
-##
-## This works:
-my $a = do if True { 5 } # with `do`, `if` is now a term.
-
-## - `once` - Makes sure a piece of code only runs once
-for ^5 { once say 1 }; #=> 1
-                       # Only prints ... once.
-## Like `state`, they're cloned per-scope
-for ^5 { sub { once say 1 }() } #=> 1 1 1 1 1
-                                # Prints once per lexical scope
-
-## - `gather` - Co-routine thread
-## Gather allows you to `take` several values in an array,
-##  much like `do`, but allows you to take any expression.
+## `do` - (which you already saw) runs a block or a statement as a term.
+## Normally you cannot use a statement as a value (or "term"). `do` helps us
+## do it.
+
+# my $value = if True { 1 } # this fails since `if` is a statement
+my $a = do if True { 5 }    # with `do`, `if` is now a term returning a value
+
+## `once` - makes sure a piece of code only runs once.
+for ^5 {
+	once say 1
+}; #=> 1, only prints ... once
+
+## Similar to `state`, they're cloned per-scope.
+for ^5 {
+	sub { once say 1 }()
+}; #=> 1 1 1 1 1, prints once per lexical scope.
+
+## `gather` - co-routine thread. The `gather` constructs allows us to `take`
+## several values from an array/list, much like `do`.
 say gather for ^5 {
-  take $_ * 3 - 1;
-  take $_ * 3 + 1;
-} #=> -1 1 2 4 5 7 8 10 11 13
+    take $_ * 3 - 1;
+    take $_ * 3 + 1;
+}
+#=> -1 1 2 4 5 7 8 10 11 13
+
 say join ',', gather if False {
-  take 1;
-  take 2;
-  take 3;
-} # Doesn't print anything.
+    take 1;
+    take 2;
+    take 3;
+}
+# Doesn't print anything.
 
-## - `eager` - Evaluate statement eagerly (forces eager context)
+## `eager` - evaluates a statement eagerly (forces eager context)
 ## Don't try this at home:
-##
-##    eager 1..*; # this will probably hang for a while (and might crash ...).
-##
+# eager 1..*; # this will probably hang for a while (and might crash ...).
 ## But consider:
 constant thrice = gather for ^3 { say take $_ }; # Doesn't print anything
-
 ## versus:
 constant thrice = eager gather for ^3 { say take $_ }; #=> 0 1 2
 ```
@@ -1207,102 +1376,105 @@ constant thrice = eager gather for ^3 { say take $_ }; #=> 0 1 2
 ## Iterables
 
 ```perl6
-## Iterables are objects that can be iterated similar to the `for` construct
-## `flat`, flattens iterables:
-say (1, 10, (20, 10) ); #> (1 10 (20 10)) Notice how grouping is maintained
-say (1, 10, (20, 10) ).flat; #> (1 10 20 10) Now the iterable is flat
+## Iterables are objects that can be iterated over which are
+## are similar to the `for` construct.
 
-## - `lazy` - Defer actual evaluation until value is fetched 
-## (forces lazy context)
+## `flat` - flattens iterables.
+say (1, 10, (20, 10) );      #=> (1 10 (20 10)),  notice how neste lists are
+                             # preserved
+say (1, 10, (20, 10) ).flat; #=> (1 10 20 10), now the iterable is flat
+
+## - `lazy` - defers actual evaluation until value is fetched by forcing
+## lazy context.
 my @lazy-array = (1..100).lazy;
-say @lazy-array.is-lazy; #> True # Check for laziness with the `is-lazy` method.
-say @lazy-array; #> [...] List has not been iterated on!
+say @lazy-array.is-lazy; #=> True, check for laziness with the `is-lazy` method.
+say @lazy-array;         #=> [...] List has not been iterated on!
 my @lazy-array { .print }; # This works and will only do as much work as
                            # is needed.
-[//]: # ( TODO explain that gather/take and map are all lazy)
-## - `sink` - An `eager` that discards the results (forces sink context)
+
+# ( **TODO** explain that gather/take and map are all lazy)
+
+## `sink` - an `eager` that discards the results by forcing sink context.
 constant nilthingie = sink for ^3 { .say } #=> 0 1 2
-say nilthingie.perl; #=> Nil
+say nilthingie.perl;                       #=> Nil
 
-## - `quietly` blocks will suppress warnings:
+## `quietly` - suppresses warnings in blocks.
 quietly { warn 'This is a warning!' }; #=> No output
 
-## - `contend` - Attempts side effects under STM
-## Not yet implemented !
+## `contend` - attempts side effects under STM
+## Not yet implemented!
 ```
 
-## More operators thingies !
+## More operators thingies!
 
 ```perl6
-## Everybody loves operators ! Let's get more of them
+## Everybody loves operators! Let's get more of them.
 
 ## The precedence list can be found here:
 ## https://docs.perl6.org/language/operators#Operator_Precedence
 ## But first, we need a little explanation about associativity:
 
-## * Binary operators:
+## Binary operators:
 $a ! $b ! $c; # with a left-associative `!`, this is `($a ! $b) ! $c`
 $a ! $b ! $c; # with a right-associative `!`, this is `$a ! ($b ! $c)`
 $a ! $b ! $c; # with a non-associative `!`, this is illegal
 $a ! $b ! $c; # with a chain-associative `!`, this is `($a ! $b) and ($b ! $c)`
 $a ! $b ! $c; # with a list-associative `!`, this is `infix:<>`
 
-## * Unary operators:
+## Unary operators:
 !$a! # with left-associative `!`, this is `(!$a)!`
 !$a! # with right-associative `!`, this is `!($a!)`
 !$a! # with non-associative `!`, this is illegal
 ```
 
-### Create your own operators !
+### Create your own operators!
 
 ```perl6
-## Okay, you've been reading all of that, so I guess I should try
-## to show you something exciting.
-## I'll tell you a little secret (or not-so-secret):
+## Okay, you've been reading all of that, so you might want to try something
+## more exciting?! I'll tell you a little secret (or not-so-secret):
 ## In Perl 6, all operators are actually just funny-looking subroutines.
 
 ## You can declare an operator just like you declare a sub:
-sub prefix:<win>($winner) { # refer to the operator categories
-                            # (yes, it's the "words operator" `<>`)
-  say "$winner Won !";
+# prefix refers to the operator categories (prefix, infix, postfix, etc).
+sub prefix:<win>( $winner ) {
+	say "$winner Won!";
 }
-win "The King"; #=> The King Won !
-                # (prefix is before)
+win "The King"; #=> The King Won!
+                # (prefix means 'before')
 
 ## you can still call the sub with its "full name":
-say prefix:<!>(True); #=> False
+say prefix:<!>(True);      #=> False
+prefix:<win>("The Queen"); #=> The Queen Won!
 
-sub postfix:<!>(Int $n) {
-  [*] 2..$n; # using the reduce meta-operator ... See below ;-) !
+sub postfix:<!>( Int $n ) {
+    [*] 2..$n; # using the reduce meta-operator... See below ;-)!
 }
 say 5!; #=> 120
-        # Postfix operators (after) have to come *directly* after the term.
+        # Postfix operators ('after') have to come *directly* after the term.
         # No whitespace. You can use parentheses to disambiguate, i.e. `(5!)!`
 
-
-sub infix:<times>(Int $n, Block $r) { # infix in the middle
-  for ^$n {
-    $r(); # You need the explicit parentheses to call the function in `$r`,
-          #  else you'd be referring at the variable itself, like with `&r`.
-  }
+sub infix:<times>( Int $n, Block $r ) { # infix ('between')
+    for ^$n {
+        $r(); # You need the explicit parentheses to call the function in `$r`,
+              # else you'd be referring at the variable itself, like with `&r`.
+    }
 }
 3 times -> { say "hello" }; #=> hello
                             #=> hello
                             #=> hello
-                            # You're very recommended to put spaces
-                            # around your infix operator calls.
+## It's recommended to put spaces around your
+## infix operator calls.
 
 ## For circumfix and post-circumfix ones
-sub circumfix:<[ ]>(Int $n) {
-  $n ** $n
+sub circumfix:<[ ]>( Int $n ) {
+    $n ** $n
 }
 say [5]; #=> 3125
-         # circumfix is around. Again, no whitespace.
+         # circumfix means 'around'. Again, no whitespace.
 
-sub postcircumfix:<{ }>(Str $s, Int $idx) {
-  ## post-circumfix is
-  ## "after a term, around something"
-  $s.substr($idx, 1);
+sub postcircumfix:<{ }>( Str $s, Int $idx ) {
+    ## post-circumfix is 'after a term, around something'
+    $s.substr($idx, 1);
 }
 say "abc"{1}; #=> b
               # after the term `"abc"`, and around the index (1)
@@ -1312,47 +1484,47 @@ say "abc"{1}; #=> b
 ## (a simple named argument underneath):
 %h{$key}:delete;
 ## equivalent to:
-postcircumfix:<{ }>(%h, $key, :delete); # (you can call operators like that)
+postcircumfix:<{ }>( %h, $key, :delete ); # (you can call operators like this)
 
-## It's *all* using the same building blocks!
-## Syntactic categories (prefix infix ...), named arguments (adverbs), ...,
-##  - used to build the language - are available to you.
-## (you are, obviously, recommended against making an operator out of
-## *everything* -- with great power comes great responsibility)
+## It's *all* using the same building blocks! Syntactic categories
+## (prefix infix ...), named arguments (adverbs), ..., etc. used to build
+## the language - are available to you. Obviously, you're advised against
+## making an operator out of *everything* -- with great power comes great
+## responsibility.
 ```
 
-### Meta operators !
+### Meta operators!
 
 ```perl6
-## Oh boy, get ready. Get ready, because we're delving deep
-## into the rabbit's hole, and you probably won't want to go
-## back to other languages after reading that.
-## (I'm guessing you don't want to already at that point).
+## Oh boy, get ready!. Get ready, because we're delving deep into the rabbit's
+## hole, and you probably won't want to go back to other languages after
+## reading this. (I'm guessing you don't want to go back at this point but
+## let's continue, for the journey is long and enjoyable!).
+
 ## Meta-operators, as their name suggests, are *composed* operators.
-## Basically, they're operators that apply another operator.
+## Basically, they're operators that act on another operators.
+
+## The reduce meta-operator is a prefix meta-operator that takes a binary
+## function and one or many lists. If it doesn't get passed any argument,
+## it either returns a "default value" for this operator (a meaningless value)
+## or `Any` if there's none (examples below). Otherwise, it pops an element
+## from the list(s) one at a time, and applies the binary function to the last
+## result (or the list's first element) and the popped element.
 
-## * Reduce meta-operator
-## It's a prefix meta-operator that takes a binary function and
-##  one or many lists. If it doesn't get passed any argument,
-##  it either returns a "default value" for this operator
-##  (a meaningless value) or `Any` if there's none (examples below).
-##
-## Otherwise, it pops an element from the list(s) one at a time, and applies
-##  the binary function to the last result (or the list's first element)
-##  and the popped element.
-##
 ## To sum a list, you could use the reduce meta-operator with `+`, i.e.:
-say [+] 1, 2, 3; #=> 6
-## equivalent to `(1+2)+3`
+say [+] 1, 2, 3; #=> 6, equivalent to (1+2)+3.
 
-say [*] 1..5; #=> 120
-## equivalent to `((((1*2)*3)*4)*5)`.
+## To multiply a list
+say [*] 1..5; #=> 120, equivalent to ((((1*2)*3)*4)*5).
 
 ## You can reduce with any operator, not just with mathematical ones.
-## For example, you could reduce with `//` to get
-## the first defined element of a list:
-say [//] Nil, Any, False, 1, 5; #=> False
-                                # (Falsey, but still defined)
+## For example, you could reduce with `//` to get first defined element
+## of a list:
+say [//] Nil, Any, False, 1, 5;  #=> False
+                                 # (Falsey, but still defined)
+## Or with relational operators, i.e., `>` to check elements of a list
+## are ordered accordingly:
+say say [>] 234, 156, 6, 3, -20; #=> True
 
 ## Default value examples:
 say [*] (); #=> 1
@@ -1365,15 +1537,14 @@ say [//];   #=> (Any)
 sub add($a, $b) { $a + $b }
 say [[&add]] 1, 2, 3; #=> 6
 
-## * Zip meta-operator
-## This one is an infix meta-operator that also can be used as a "normal"
-## operator.  It takes an optional binary function (by default, it just creates
-## a pair), and will pop one value off of each array and call its binary 
-## function on these until it runs out of elements. It returns an array with 
-## all of these new elements.
-(1, 2) Z (3, 4); # ((1, 3), (2, 4)), since by default, the function 
-                 # makes an array.
-1..3 Z+ 4..6; # (5, 7, 9), using the custom infix:<+> function
+## The zip meta-operator is an infix meta-operator that also can be used as a
+## "normal" operator. It takes an optional binary function (by default, it
+## just creates a pair), and will pop one value off of each array and call
+## its binary function on these until it runs out of elements. It returns an
+## array with all of these new elements.
+say (1, 2) Z (3, 4); #=> ((1, 3), (2, 4)), since by default the function
+                     # makes an array.
+say 1..3 Z+ 4..6;    #=> (5, 7, 9), using the custom infix:<+> function
 
 ## Since `Z` is list-associative (see the list above),
 ## you can use it on more than one list
@@ -1385,252 +1556,258 @@ say [[&add]] 1, 2, 3; #=> 6
 
 ## And to end the operator list:
 
-## * Sequence operator
 ## The sequence operator is one of Perl 6's most powerful features:
 ## it's composed of first, on the left, the list you want Perl 6 to deduce from
 ## (and might include a closure), and on the right, a value or the predicate
-## that says when to stop (or Whatever for a lazy infinite list).
-my @list = 1, 2, 3 ... 10; # basic deducing
-#my @list = 1, 3, 6 ... 10; # this dies because Perl 6 can't figure out the end
-my @list = 1, 2, 3 ...^ 10; # as with ranges, you can exclude the last element
-                            # (the iteration when the predicate matches).
-my @list = 1, 3, 9 ... * > 30; # you can use a predicate
-                               # (with the Whatever Star, here).
-my @list = 1, 3, 9 ... { $_ > 30 }; # (equivalent to the above)
-
-my @fib = 1, 1, *+* ... *; # lazy infinite list of fibonacci series,
-                           #  computed using a closure!
+## that says when to stop (or a Whatever Star for a lazy infinite list).
+
+my @list = 1, 2, 3...10;     # basic arithmetic sequence
+# my @list = 1, 3, 6...10;   # this dies because Perl 6 can't figure out the end
+my @list = 1, 2, 3...^10;    # as with ranges, you can exclude the last element
+                             # (the iteration ends when the predicate matches).
+my @list = 1, 3, 9...* > 30; # you can use a predicate (with the Whatever Star).
+my @list = 1, 3, 9 ... { $_ > 30 }; # (equivalent to the above
+                                    # using a block here).
+
+my @fib = 1, 1, *+* ... *;   # lazy infinite list of fibonacci sequence,
+                             # computed using a closure!
 my @fib = 1, 1, -> $a, $b { $a + $b } ... *; # (equivalent to the above)
-my @fib = 1, 1, { $^a + $^b } ... *; #(... also equivalent to the above)
+my @fib = 1, 1, { $^a + $^b } ... *;         # (also equivalent to the above)
 ## $a and $b will always take the previous values, meaning here
-##  they'll start with $a = 1 and $b = 1 (values we set by hand).
-##  then $a = 1 and $b = 2 (result from previous $a+$b), and so on.
+## they'll start with $a = 1 and $b = 1 (values we set by hand),
+## then $a = 1 and $b = 2 (result from previous $a+$b), and so on.
 
 say @fib[^10]; #=> 1 1 2 3 5 8 13 21 34 55
                # (using a range as the index)
-## Note : as for ranges, once reified, elements aren't re-calculated.
+## Note: as for ranges, once reified, elements aren't re-calculated.
 ## That's why `@primes[^100]` will take a long time the first time you print
-## it, then be instant.
+## it, then will be instateneous.
 ```
 
 ## Regular Expressions
 
 ```perl6
-## I'm sure a lot of you have been waiting for this one.
-## Well, now that you know a good deal of Perl 6 already, we can get started.
-## First off, you'll have to forget about "PCRE regexps" (perl-compatible 
-## regexps).
+## I'm sure a lot of you have been waiting for this one. Well, now that you know
+## a good deal of Perl 6 already, we can get started. First off, you'll have to
+## forget about "PCRE regexps" (perl-compatible regexps).
 ##
-## IMPORTANT: Don't skip them because you know PCRE. They're different.
-## Some things are the same (like `?`, `+`, and `*`),
-##  but sometimes the semantics change (`|`).
-## Make sure you read carefully, because you might trip over a new behavior.
+## IMPORTANT: Don't skip them because you know PCRE. They're different. Some
+## things are the same (like `?`, `+`, and `*`), but sometimes the semantics
+## change (`|`). Make sure you read carefully, because you might trip over a
+## new behavior.
 ##
 ## Perl 6 has many features related to RegExps. After all, Rakudo parses itself.
-## We're first going to look at the syntax itself,
-##  then talk about grammars (PEG-like), differences between
-##  `token`, `regex` and `rule` declarators, and some more.
-## Side note: you still have access to PCRE regexps using the `:P5` modifier.
-##  (we won't be discussing this in this tutorial, however)
+## We're first going to look at the syntax itself, then talk about grammars
+## (PEG-like), differences between `token`, `regex` and `rule` declarators,
+## and some more. Side note: you still have access to PCRE regexps using the
+## `:P5` modifier which we won't be discussing this in this tutorial, though.
 ##
 ## In essence, Perl 6 natively implements PEG ("Parsing Expression Grammars").
 ## The pecking order for ambiguous parses is determined by a multi-level
-##  tie-breaking test:
-##  - Longest token matching. `foo\s+` beats `foo` (by 2 or more positions)
-##  - Longest literal prefix. `food\w*` beats `foo\w*` (by 1)
+## tie-breaking test:
+##  - Longest token matching: `foo\s+` beats `foo` (by 2 or more positions)
+##  - Longest literal prefix: `food\w*` beats `foo\w*` (by 1)
 ##  - Declaration from most-derived to less derived grammars
-##     (grammars are actually classes)
+##    (grammars are actually classes)
 ##  - Earliest declaration wins
-say so 'a' ~~ /a/; #=> True
-say so 'a' ~~ / a /; #=> True #  More readable with some spaces!
+say so 'a' ~~ /a/;   #=> True
+say so 'a' ~~ / a /; #=> True, more readable with some spaces!
 
 ## In all our examples, we're going to use the smart-matching operator against
-##  a regexp. We're converting the result using `so`, but in fact, it's
-##  returning a `Match` object. They know how to respond to list indexing,
-##  hash indexing, and return the matched string.
-## The results of the match are available as `$/` (implicitly lexically-scoped).
-## You can also use the capture variables which start at 0:
-##    `$0`, `$1', `$2`...
+## a regexp. We're converting the result using `so` to a Boolean value because,
+## in fact, it's returning a `Match` object. They know how to respond to list
+## indexing, hash indexing, and return the matched string. The results of the
+## match are available in the `$/` variable (implicitly lexically-scoped). You
+## can also use the capture variables which start at 0: `$0`, `$1', `$2`...
 ##
-## You can also note that `~~` does not perform start/end checking
-##  (meaning the regexp can be matched with just one char of the string),
-##  we're going to explain later how you can do it.
-
-## In Perl 6, you can have any alphanumeric as a literal,
-## everything else has to be escaped, using a backslash or quotes.
-say so 'a|b' ~~ / a '|' b /; # `True`. Wouldn't mean the same if `|` wasn't 
-                             # escaped
-say so 'a|b' ~~ / a \| b /;  # `True`. Another way to escape it.
-
-## The whitespace in a regexp is actually not significant,
-##  unless you use the `:s` (`:sigspace`, significant space) adverb.
-say so 'a b c' ~~ / a  b  c /; #> `False`. Space is not significant here
-say so 'a b c' ~~ /:s a b c /; #> `True`. We added the modifier `:s` here.
+## You can also note that `~~` does not perform start/end checking, meaning
+## the regexp can be matched with just one character of the string. We'll
+## explain later how you can do it.
+
+## In Perl 6, you can have any alphanumeric as a literal, everything else has
+## to be escaped by using a backslash or quotes.
+say so 'a|b' ~~ / a '|' b /; #=> `True`, it wouldn't mean the same thing if
+                             # `|` wasn't escaped.
+say so 'a|b' ~~ / a \| b /;  #=> `True`, another way to escape it.
+
+## The whitespace in a regexp is actually not significant, unless you use the
+## `:s` (`:sigspace`, significant space) adverb.
+say so 'a b c' ~~ / a  b  c /; #=> `False`, space is not significant here!
+say so 'a b c' ~~ /:s a b c /; #=> `True`, we added the modifier `:s` here.
+
 ## If we use only one space between strings in a regex, Perl 6 will warn us:
-say so 'a b c' ~~ / a b c /; #> 'False' #> Space is not significant here; 
-## please use quotes or :s (:sigspace) modifier (or, to suppress this warning,
-## omit the space, or otherwise change the spacing)
-## To fix this and make the spaces less ambiguous,  either use at least two
-## spaces between strings or use the `:s` adverb.
+say so 'a b c' ~~ / a b c /;   #=> `False`, with warning about space
+say so 'a b c' ~~ / a  b  c /; #=> `False`
+
+## Please use quotes or :s (:sigspace) modifier (or, to suppress this warning,
+## omit the space, or otherwise change the spacing). To fix this and make the
+## spaces less ambiguous, either use at least two spaces between strings
+## or use the `:s` adverb.
 
-## As we saw before, we can embed the `:s` inside the slash delimiters, but we 
+## As we saw before, we can embed the `:s` inside the slash delimiters, but we
 ## can also put it outside of them if we specify `m` for 'match':
-say so 'a b c' ~~ m:s/a  b  c/; #> `True`
-## By using `m` to specify 'match', we can also use delimiters other 
-## than slashes:
-say so 'abc' ~~ m{a  b  c}; #> `True`
+say so 'a b c' ~~ m:s/a  b  c/; #=> `True`
+
+## By using `m` to specify 'match', we can also use delimiters other than
+## slashes:
+say so 'abc' ~~ m{a  b  c};     #=> `True`
+say so 'abc' ~~ m[a  b  c];     #=> `True`
+# m/.../ is equivalent to /.../
 
 ## Use the :i adverb to specify case insensitivity:
-say so 'ABC' ~~ m:i{a  b  c}; #> `True`
+say so 'ABC' ~~ m:i{a  b  c};   #=> `True`
 
-## It is, however, important as for how modifiers (that you're gonna see just 
-## below) are applied ...
+## However, whitespace is important as for how modifiers are applied (
+## (which you'll see just below) ...
 
 ## Quantifying - `?`, `+`, `*` and `**`.
-## - `?` - 0 or 1
-so 'ac' ~~ / a  b  c /; # `False`
-so 'ac' ~~ / a  b?  c /; # `True`, the "b" matched 0 times.
-so 'abc' ~~ / a  b?  c /; # `True`, the "b" matched 1 time.
+## `?` - zero or one match
+so 'ac' ~~ / a  b  c /;   #=> `False`
+so 'ac' ~~ / a  b?  c /;  #=> `True`, the "b" matched 0 times.
+so 'abc' ~~ / a  b?  c /; #=> `True`, the "b" matched 1 time.
 
-## ... As you read just before, whitespace is important because it determines
-##  which part of the regexp is the target of the modifier:
-so 'def' ~~ / a  b  c? /; # `False`. Only the `c` is optional
-so 'def' ~~ / a  b?  c /; # `False`. Whitespace is not significant
-so 'def' ~~ / 'abc'? /; # `True`. The whole "abc" group is optional.
+## ...As you read before, whitespace is important because it determines which
+## part of the regexp is the target of the modifier:
+so 'def' ~~ / a  b  c? /; #=> `False`, only the `c` is optional
+so 'def' ~~ / a  b?  c /; #=> `False`, whitespace is not significant
+so 'def' ~~ / 'abc'? /;   #=> `True`, the whole "abc" group is optional
 
 ## Here (and below) the quantifier applies only to the `b`
 
-## - `+` - 1 or more
-so 'ac' ~~ / a  b+  c /; # `False`; `+` wants at least one matching
-so 'abc' ~~ / a  b+  c /; # `True`; one is enough
-so 'abbbbc' ~~ / a  b+  c /; # `True`, matched 4 "b"s
-
-## - `*` - 0 or more
-so 'ac' ~~ / a  b*  c /; # `True`, they're all optional.
-so 'abc' ~~ / a  b*  c /; # `True`
-so 'abbbbc' ~~ / a  b*  c /; # `True`
-so 'aec' ~~ / a  b*  c /; # `False`. "b"(s) are optional, not replaceable.
-
-## - `**` - (Unbound) Quantifier
-## If you squint hard enough, you might understand
-##  why exponentation is used for quantity.
-so 'abc' ~~ / a  b**1  c /; # `True` (exactly one time)
-so 'abc' ~~ / a  b**1..3  c /; # `True` (one to three times)
-so 'abbbc' ~~ / a  b**1..3  c /; # `True`
-so 'abbbbbbc' ~~ / a  b**1..3  c /; # `False` (too much)
-so 'abbbbbbc' ~~ / a  b**3..*  c /; # `True` (infinite ranges are okay)
-
-## - `<[]>` - Character classes
-## Character classes are the equivalent of PCRE's `[]` classes, but
-##  they use a more perl6-ish syntax:
-say 'fooa' ~~ / f <[ o a ]>+ /; #=> 'fooa'
+## `+` - one or more matches
+so 'ac' ~~ / a  b+  c /;     #=> `False`, `+` wants at least one matching
+so 'abc' ~~ / a  b+  c /;    #=> `True`, one is enough
+so 'abbbbc' ~~ / a  b+  c /; #=> `True`, matched 4 "b"s
+
+## `*` - zero or more matches
+so 'ac' ~~ / a  b*  c /;     #=> `True`, they're all optional.
+so 'abc' ~~ / a  b*  c /;    #=> `True`
+so 'abbbbc' ~~ / a  b*  c /; #=> `True`
+so 'aec' ~~ / a  b*  c /;    #=> `False`. "b"(s) are optional, not replaceable.
+
+## `**` - (Unbound) Quantifier
+## If you squint hard enough, you might understand why exponentation is used
+## for quantity.
+so 'abc' ~~ / a  b**1  c /;         #=> `True`, (exactly one time)
+so 'abc' ~~ / a  b**1..3  c /;      #=> `True`, (one to three times)
+so 'abbbc' ~~ / a  b**1..3  c /;    #=> `True`
+so 'abbbbbbc' ~~ / a  b**1..3  c /; #=> `False, (too much)
+so 'abbbbbbc' ~~ / a  b**3..*  c /; #=> `True`, (infinite ranges are okay)
+
+## `<[]>` - Character classes
+## Character classes are the equivalent of PCRE's `[]` classes, but they use a
+## more perl6-ish syntax:
+say 'fooa' ~~ / f <[ o a ]>+ /;  #=> 'fooa'
 
 ## You can use ranges:
 say 'aeiou' ~~ / a <[ e..w ]> /; #=> 'ae'
 
-## Just like in normal regexes, if you want to use a special character, 
-## escape it (the last one is escaping a space)
+## Just like in normal regexes, if you want to use a special character, escape
+## it (the last one is escaping a space which would be equivalent to using
+## ' '):
 say 'he-he !' ~~ / 'he-' <[ a..z \! \  ]> + /; #=> 'he-he !'
 
-## You'll get a warning if you put duplicate names
-## (which has the nice effect of catching the wrote quoting:)
-'he he' ~~ / <[ h e ' ' ]> /; # Warns "Repeated characters found in characters
-                              # class"
+## You'll get a warning if you put duplicate names (which has the nice effect
+## of catching the raw quoting):
+'he he' ~~ / <[ h e ' ' ]> /;
+# Warns "Repeated character (') unexpectedly found in character class"
 
-## You can also negate them ... (equivalent to `[^]` in PCRE)
-so 'foo' ~~ / <-[ f o ]> + /; # False
+## You can also negate character classes... (`<-[]>` equivalent to `[^]` in PCRE)
+so 'foo' ~~ / <-[ f o ]> + /;             #=> False
 
-## ... and compose them: :
-so 'foo' ~~ / <[ a..z ] - [ f o ]> + /;   # False (any letter except f and o)
-so 'foo' ~~ / <-[ a..z ] + [ f o ]> + /;  # True (no letter except f and o)
-so 'foo!' ~~ / <-[ a..z ] + [ f o ]> + /; # True (the + doesn't replace the 
+## ... and compose them:
+so 'foo' ~~ / <[ a..z ] - [ f o ]> + /;   #=> `False`, (any letter except f and o)
+so 'foo' ~~ / <-[ a..z ] + [ f o ]> + /;  #=> `True`, (no letter except f and o)
+so 'foo!' ~~ / <-[ a..z ] + [ f o ]> + /; #=> `True`, (the + doesn't replace the
                                           # left part)
 ```
 
 ### Grouping and capturing
 
 ```perl6
-## Group: you can group parts of your regexp with `[]`.
-## These groups are *not* captured (like PCRE's `(?:)`).
-so 'abc' ~~ / a [ b ] c /; # `True`. The grouping does pretty much nothing
+## Group: you can group parts of your regexp with `[]`. Unlike PCRE's `(?:)`,
+## these groups are *not* captured.
+so 'abc' ~~ / a [ b ] c /;  # `True`. The grouping does pretty much nothing
 so 'foo012012bar' ~~ / foo [ '01' <[0..9]> ] + bar /;
-## The previous line returns `True`.
-## We match the "012" 1 or more time (the `+` was applied to the group).
+
+## The previous line returns `True`. The regex matches "012" 1 or more time
+## (achieved by the the `+` applied to the group).
 
 ## But this does not go far enough, because we can't actually get back what
 ## we matched.
-## Capture: We can actually *capture* the results of the regexp, 
-## using parentheses.
+
+## Capture: The results of a regexp can be *captured* by using parentheses.
 so 'fooABCABCbar' ~~ / foo ( 'A' <[A..Z]> 'C' ) + bar /; # `True`. (using `so`
                                                          #  here, `$/` below)
 
 ## So, starting with the grouping explanations.
-## As we said before, our `Match` object is available as `$/`:
-say $/; # Will print some weird stuff (we'll explain) (or "Nil" if 
-        # nothing matched).
+## As we said before, our `Match` object is stored inside the `$/` variable:
+say $/;    # Will either print some weird stuff or `Nil` if nothing matched.
 
 ## As we also said before, it has array indexing:
 say $/[0]; #=> ｢ABC｣ ｢ABC｣
-           # These weird brackets are `Match` objects.
+           # These corner brackets are `Match` objects.
            # Here, we have an array of these.
-say $0; # The same as above.
+say $0;    # The same as above.
 
-## Our capture is `$0` because it's the first and only one capture in the 
+## Our capture is `$0` because it's the first and only one capture in the
 ## regexp. You might be wondering why it's an array, and the answer is simple:
-## Some capture (indexed using `$0`, `$/[0]` or a named one) will be an array
-## IFF it can have more than one element
-## (so, with `*`, `+` and `**` (whatever the operands), but not with `?`).
+## Some captures (indexed using `$0`, `$/[0]` or a named one) will be an array
+## if and only if they can have more than one element. Thus any capture with
+## `*`, `+` and `**` (whatever the operands), but not with `?`.
 ## Let's use examples to see that:
 
 ## Note: We quoted A B C to demonstrate that the whitespace between them isn't
-##       significant. If we want the whitespace to *be* significant there, we 
+##       significant. If we want the whitespace to *be* significant there, we
 ##       can use the :sigspace modifier.
-so 'fooABCbar' ~~ / foo ( "A" "B" "C" )? bar /; # `True`
-say $/[0]; #=> ｢ABC｣
+say so 'fooABCbar' ~~ / foo ( "A" "B" "C" )? bar /; #=> `True`
+say $/[0];   #=> ｢ABC｣
 say $0.WHAT; #=> (Match)
              # There can't be more than one, so it's only a single match object.
-so 'foobar' ~~ / foo ( "A" "B" "C" )? bar /; #=> True
+say so 'foobar' ~~ / foo ( "A" "B" "C" )? bar /;    #=> True
 say $0.WHAT; #=> (Any)
              # This capture did not match, so it's empty
-so 'foobar' ~~ / foo ( "A" "B" "C" ) ** 0..1 bar /; # `True`
+so 'foobar' ~~ / foo ( "A" "B" "C" ) ** 0..1 bar /; #=> `True`
 say $0.WHAT; #=> (Array)
              # A specific quantifier will always capture an Array,
-             #  may it be a range or a specific value (even 1).
+             # be a range or a specific value (even 1).
 
-## The captures are indexed per nesting. This means a group in a group will be 
+## The captures are indexed per nesting. This means a group in a group will be
 ## nested under its parent group: `$/[0][0]`, for this code:
 'hello-~-world' ~~ / ( 'hello' ( <[ \- \~ ]> + ) ) 'world' /;
-say $/[0].Str; #=> hello~
+say $/[0].Str;    #=> hello~
 say $/[0][0].Str; #=> ~
 
-## This stems from a very simple fact: `$/` does not contain strings, integers 
-## or arrays, it only contains match objects. These contain the `.list`, `.hash`
-## and `.Str` methods. (but you can also just use `match<key>` for hash access
-## and `match[idx]` for array access)
+## This stems from a very simple fact: `$/` does not contain strings, integers
+## or arrays, it only contains Match objects. These contain the `.list`, `.hash`
+## and `.Str` methods but you can also just use `match<key>` for hash access
+## and `match[idx]` for array access.
 say $/[0].list.perl; #=> (Match.new(...),).list
-                     # We can see it's a list of Match objects. Those contain
-                     # a bunch of infos: where the match started/ended,
-                     #    the "ast" (see actions later), etc.
+                     # We can see it's a list of Match objects. These contain
+                     # a bunch of info: where the match started/ended,
+                     # the "ast" (see actions later), etc.
                      # You'll see named capture below with grammars.
 
-## Alternatives - the `or` of regexps
+## Alternation - the `or` of regexps
 ## WARNING: They are DIFFERENT from PCRE regexps.
-so 'abc' ~~ / a [ b | y ] c /; # `True`. Either "b" or "y".
-so 'ayc' ~~ / a [ b | y ] c /; # `True`. Obviously enough ...
-
-## The difference between this `|` and the one you're used to is LTM.
-## LTM means "Longest Token Matching". This means that the engine will always
-## try to match as much as possible in the strng
-'foo' ~~ / fo | foo /; # `foo`, because it's longer.
-## To decide which part is the "longest", it first splits the regex in 
+say so 'abc' ~~ / a [ b | y ] c /; #=> `True`. Either "b" or "y".
+say so 'ayc' ~~ / a [ b | y ] c /; #=> `True`. Obviously enough...
+
+## The difference between this `|` and the one you're used to is
+## LTM ("Longest Token Matching"). This means that the engine will always
+## try to match as much as possible in the string.
+say 'foo' ~~ / fo | foo /; #=> `foo`, instead of `fo`, because it's longer.
+
+## To decide which part is the "longest", it first splits the regex in
 ## two parts:
 ## The "declarative prefix" (the part that can be statically analyzed)
-## and the procedural parts.
-## Declarative prefixes include alternations (`|`), conjunctions (`&`),
-## sub-rule calls (not yet introduced), literals, characters classes and 
+## and the procedural parts:
+## - The declarative prefixes include alternations (`|`), conjunctions (`&`),
+## sub-rule calls (not yet introduced), literals, characters classes and
 ## quantifiers.
-## The latter include everything else: back-references, code assertions,
-## and other things that can't traditionnaly be represented by normal regexps.
+## - The procedural part include everything else: back-references,
+## code assertions, and other things that can't traditionnaly be represented
+## by normal regexps.
 ##
 ## Then, all the alternatives are tried at once, and the longest wins.
 ## Examples:
@@ -1639,109 +1816,110 @@ so 'ayc' ~~ / a [ b | y ] c /; # `True`. Obviously enough ...
 ## DECLARATIVE (nested groups are not a problem)
 / \s* [ \w & b ] [ c | d ] /;
 ## However, closures and recursion (of named regexps) are procedural.
-## ... There are also more complicated rules, like specificity
-##  (literals win over character classes)
+## There are also more complicated rules, like specificity (literals win over
+## character classes).
 
 ## Note: the first-matching `or` still exists, but is now spelled `||`
-'foo' ~~ / fo || foo /; # `fo` now.
+say 'foo' ~~ / fo || foo /; #=> `fo` now.
 ```
 
 ## Extra: the MAIN subroutine
 
 ```perl6
-## The `MAIN` subroutine is called when you run a Perl 6 file directly.
-## It's very powerful, because Perl 6 actually parses the arguments
-##  and pass them as such to the sub. It also handles named argument (`--foo`)
-##  and will even go as far as to autogenerate a `--help`
-sub MAIN($name) { say "Hello, $name !" }
+## The `MAIN` subroutine is called when you run a Perl 6 file directly. It's
+## very powerful, because Perl 6 actually parses the arguments and pass them
+## as such to the sub. It also handles named argument (`--foo`) and will even
+## go as far as to autogenerate a `--help` flag.
+sub MAIN($name) {
+    say "Hello, $name!";
+}
 ## This produces:
-##    $ perl6 cli.pl
-##    Usage:
-##      t.pl <name>
+## $ perl6 cli.pl
+## Usage:
+##  t.pl <name>
 
 ## And since it's a regular Perl 6 sub, you can have multi-dispatch:
 ## (using a "Bool" for the named argument so that we can do `--replace`
-##  instead of `--replace=1`)
+## instead of `--replace=1`. The presence of `--replace` indicates truthness
+## while its absence falseness).
+
 subset File of Str where *.IO.d; # convert to IO object to check the file exists
 
 multi MAIN('add', $key, $value, Bool :$replace) { ... }
 multi MAIN('remove', $key) { ... }
 multi MAIN('import', File, Str :$as) { ... } # omitting parameter name
+
 ## This produces:
-##    $ perl6 cli.pl
-##    Usage:
-##      t.pl [--replace] add <key> <value>
-##      t.pl remove <key>
-##      t.pl [--as=<Str>] import (File)
-## As you can see, this is *very* powerful.
-## It even went as far as to show inline the constants.
-## (the type is only displayed if the argument is `$`/is named)
+## $ perl6 cli.pl
+## Usage:
+##   cli.p6 [--replace] add <key> <value>
+##   cli.p6 remove <key>
+##   cli.p6 [--as=<Str>] import <File>
+
+## As you can see, this is *very* powerful. It even went as far as to show inline
+## the constants (the type is only displayed if the argument is `$`/is named).
 ```
 
 ## APPENDIX A:
 ### List of things
 
 ```perl6
-## It's considered by now you know the Perl6 basics.
-## This section is just here to list some common operations,
-##  but which are not in the "main part" of the tutorial to bloat it up
+## It's assumed by now you know the Perl6 basics. This section is just here to
+## list some common operations, but which are not in the "main part" of the
+## tutorial to avoid bloating it up.
 
 ## Operators
 
-
-## * Sort comparison
-## They return one value of the `Order` enum : `Less`, `Same` and `More`
-##  (which numerify to -1, 0 or +1).
-1 <=> 4; # sort comparison for numerics
-'a' leg 'b'; # sort comparison for string
-$obj eqv $obj2; # sort comparison using eqv semantics
-
-## * Generic ordering
-3 before 4; # True
-'b' after 'a'; # True
-
-## * Short-circuit default operator
-## Like `or` and `||`, but instead returns the first *defined* value :
-say Any // Nil // 0 // 5; #=> 0
-
-## * Short-circuit exclusive or (XOR)
-## Returns `True` if one (and only one) of its arguments is true
-say True ^^ False; #=> True
-## * Flip Flop
-## The flip flop operators (`ff` and `fff`, equivalent to P5's `..`/`...`).
-##  are operators that take two predicates to test:
-## They are `False` until their left side returns `True`, then are `True` until
-##  their right side returns `True`.
-## Like for ranges, you can exclude the iteration when it became `True`/`False`
-##  by using `^` on either side.
-## Let's start with an example :
+## Sort comparison - they return one value of the `Order` enum: `Less`, `Same`
+## and `More` (which numerify to -1, 0 or +1 respectively).
+1 <=> 4;                         # sort comparison for numerics
+'a' leg 'b';                     # sort comparison for string
+$obj eqv $obj2;                  # sort comparison using eqv semantics
+
+## Generic ordering
+3 before 4;                      # True
+'b' after 'a';                   # True
+
+## Short-circuit default operator - similar to `or` and `||`, but instead
+## returns the first *defined* value:
+say Any // Nil // 0 // 5;        #=> 0
+
+## Short-circuit exclusive or (XOR) - returns `True` if one (and only one) of
+## its arguments is true
+say True ^^ False;               #=> True
+
+## Flip flops - these operators (`ff` and `fff`, equivalent to P5's `..`
+## and `...`) are operators that take two predicates to test: They are `False`
+## until their left side returns `True`, then are `True` until their right
+## side returns `True`. Similar to ranges, you can exclude the iteration when
+## it become `True`/`False` by using `^` on either side. Let's start with an
+## example :
 for <well met young hero we shall meet later> {
-  # by default, `ff`/`fff` smart-match (`~~`) against `$_`:
-  if 'met' ^ff 'meet' { # Won't enter the if for "met"
-                        #  (explained in details below).
-    .say
-  }
+    # by default, `ff`/`fff` smart-match (`~~`) against `$_`:
+    if 'met' ^ff 'meet' { # Won't enter the if for "met"
+        .say              # (explained in details below).
+    }
 
-  if rand == 0 ff rand == 1 { # compare variables other than `$_`
-    say "This ... probably will never run ...";
-  }
+    if rand == 0 ff rand == 1 { # compare variables other than `$_`
+        say "This ... probably will never run ...";
+    }
 }
-## This will print "young hero we shall meet" (excluding "met"):
-## the flip-flop will start returning `True` when it first encounters "met"
-## (but will still return `False` for "met" itself, due to the leading `^`
-##  on `ff`), until it sees "meet", which is when it'll start returning `False`.
-
-## The difference between `ff` (awk-style) and `fff` (sed-style) is that
-##  `ff` will test its right side right when its left side changes to `True`,
-##  and can get back to `False` right away
-##  (*except* it'll be `True` for the iteration that matched) -
-## While `fff` will wait for the next iteration to
-##  try its right side, once its left side changed:
+
+## This will print "young hero we shall meet" (excluding "met"): the flip-flop
+## will start returning `True` when it first encounters "met" (but will still
+## return `False` for "met" itself, due to the leading `^` on `ff`), until it
+## sees "meet", which is when it'll start returning `False`.
+
+## The difference between `ff` (awk-style) and `fff` (sed-style) is that `ff`
+## will test its right side right when its left side changes to `True`, and can
+## get back to `False` right away (*except* it'll be `True` for the iteration
+## that matched) while `fff` will wait for the next iteration to try its right
+## side, once its left side changed:
 .say if 'B' ff 'B' for <A B C B A>; #=> B B
                                     # because the right-hand-side was tested
                                     # directly (and returned `True`).
-                                    # "B"s are printed since it matched that 
-                                    # time (it just went back to `False` 
+                                    # "B"s are printed since it matched that
+                                    # time (it just went back to `False`
                                     # right away).
 .say if 'B' fff 'B' for <A B C B A>; #=> B C B
                                     # The right-hand-side wasn't tested until
@@ -1750,50 +1928,49 @@ for <well met young hero we shall meet later> {
 
 ## A flip-flop can change state as many times as needed:
 for <test start print it stop not printing start print again stop not anymore> {
-  .say if $_ eq 'start' ^ff^ $_ eq 'stop'; # exclude both "start" and "stop",
-                                           #=> "print it print again"
+    .say if $_ eq 'start' ^ff^ $_ eq 'stop'; # exclude both "start" and "stop",
+                                             #=> "print it print again"
 }
 
-## You might also use a Whatever Star,
-## which is equivalent to `True` for the left side or `False` for the right:
+## You might also use a Whatever Star, which is equivalent to `True` for the
+## left side or `False` for the right:
 for (1, 3, 60, 3, 40, 60) { # Note: the parenthesis are superfluous here
                             # (sometimes called "superstitious parentheses")
- .say if $_ > 50 ff *; # Once the flip-flop reaches a number greater than 50,
-                       #  it'll never go back to `False`
-                       #=> 60 3 40 60
+    .say if $_ > 50 ff *;   # Once the flip-flop reaches a number greater
+                            # than 50, it'll never go back to `False`
+                            #=> 60 3 40 60
 }
 
-## You can also use this property to create an `If`
-## that'll not go through the first time :
+## You can also use this property to create an `if` that'll not go through the
+## first time:
 for <a b c> {
-  .say if * ^ff *; # the flip-flop is `True` and never goes back to `False`,
-                   #  but the `^` makes it *not run* on the first iteration
-                   #=> b c
+    .say if * ^ff *; # the flip-flop is `True` and never goes back to `False`,
+                     #  but the `^` makes it *not run* on the first iteration
+                     #=> b c
 }
 
-
-## - `===` is value identity and uses `.WHICH` on the objects to compare them
-## - `=:=` is container identity and uses `VAR()` on the objects to compare them
-
+## The `===` operator is the value identity operator and uses `.WHICH` on the
+## objects to compare them  while `=:=` is the container identity operator
+## and uses `VAR()` on the objects to compare them.
 ```
 
 If you want to go further, you can:
 
  - Read the [Perl 6 Docs](https://docs.perl6.org/). This is a great
- resource on Perl6.  If you are looking for something, use the search bar.
+ resource on Perl6. If you are looking for something, use the search bar.
  This will give you a dropdown menu of all the pages referencing your search
- term (Much better than using Google to find Perl 6 documents!)
+ term (Much better than using Google to find Perl 6 documents!).
  - Read the [Perl 6 Advent Calendar](http://perl6advent.wordpress.com/). This
- is a great source of Perl 6 snippets and explanations.  If the docs don't
+ is a great source of Perl 6 snippets and explanations. If the docs don't
  describe something well enough, you may find more detailed information here.
  This information may be a bit older but there are many great examples and
- explanations.  Posts stopped at the end of 2015 when the language was declared
+ explanations. Posts stopped at the end of 2015 when the language was declared
  stable and Perl 6.c was released.
- - Come along on `#perl6` at `irc.freenode.net`. The folks here are 
+ - Come along on `#perl6` at `irc.freenode.net`. The folks here are
  always helpful.
- - Check the [source of Perl 6's functions and 
- classes](https://github.com/rakudo/rakudo/tree/nom/src/core). Rakudo is 
+ - Check the [source of Perl 6's functions and
+ classes](https://github.com/rakudo/rakudo/tree/nom/src/core). Rakudo is
  mainly written in Perl 6 (with a lot of NQP, "Not Quite Perl", a Perl 6 subset
  easier to implement and optimize).
- - Read [the language design documents](http://design.perl6.org). They explain 
+ - Read [the language design documents](http://design.perl6.org). They explain
  P6 from an implementor point-of-view, but it's still very interesting.
diff --git a/php.html.markdown b/php.html.markdown
index d4fbaa32..40c9dd01 100644
--- a/php.html.markdown
+++ b/php.html.markdown
@@ -443,7 +443,7 @@ echo $function_name(1, 2); // => 3
 // Or, use call_user_func(callable $callback [, $parameter [, ... ]]);
 
 
-// You can get the all the parameters passed to a function
+// You can get all the parameters passed to a function
 function parameters() {
     $numargs = func_num_args();
     if ($numargs > 0) {
@@ -794,7 +794,7 @@ But I'm ChildClass
 
 /**********************
 *  Magic constants
-*  
+*
 */
 
 // Get current class name. Must be used inside a class declaration.
@@ -826,7 +826,7 @@ echo "Current trait is " . __TRAIT__;
 
 /**********************
 *  Error Handling
-*  
+*
 */
 
 // Simple error handling can be done with try catch block
@@ -837,11 +837,14 @@ try {
     // Handle exception
 }
 
-// When using try catch blocks in a namespaced environment use the following
+// When using try catch blocks in a namespaced environment it is important to
+// escape to the global namespace, because Exceptions are classes, and the
+// Exception class exists in the global namespace. This can be done using a
+// leading backslash to catch the Exception.
 
 try {
     // Do something
-} catch (Exception $e) {
+} catch (\Exception $e) {
     // Handle exception
 }
 
@@ -871,6 +874,9 @@ and community input.
 If you're interested in up-to-date best practices, visit
 [PHP The Right Way](http://www.phptherightway.com/).
 
+A tutorial covering basics of language, setting up coding environment and making
+few practical projects at [Codecourse - PHP Basics](https://www.youtube.com/playlist?list=PLfdtiltiRHWHjTPiFDRdTOPtSyYfz3iLW).
+
 If you're coming from a language with good package management, check out
 [Composer](http://getcomposer.org/).
 
diff --git a/pl-pl/bf-pl.html.markdown b/pl-pl/bf-pl.html.markdown
index 88f928cf..54772961 100644
--- a/pl-pl/bf-pl.html.markdown
+++ b/pl-pl/bf-pl.html.markdown
@@ -7,6 +7,7 @@ contributors:
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
 translators:
     - ["Jakub Młokosiewicz", "https://github.com/hckr"]
+    - ["Mateusz Burniak", "https://gitbub.com/matbur"]
 lang: pl-pl
 
 ---
@@ -32,9 +33,9 @@ Oto osiem poleceń brainfucka:
 . : wyświetla wartość bieżącej komórki (w formie znaku ASCII, np. 65 = 'A')
 , : wczytuje (jeden) znak z wejścia do bieżącej komórki
     (konkretnie jego numer z tabeli ASCII)
-[ : jeśli wartość w bieżącej komórce jest rózna zero, przechodzi do
+[ : jeśli wartość w bieżącej komórce jest równa zeru, przechodzi do
     odpowiadającego ]; w przeciwnym wypdaku przechodzi do następnej instrukcji
-] : Jeśli wartość w bieżącej komórce jest rózna od zera, przechodzi do
+] : Jeśli wartość w bieżącej komórce jest równa zeru, przechodzi do
     następnej instrukcji; w przeciwnym wypdaku przechodzi do odpowiadającego [
 
 [ i ] oznaczają pętlę while. Oczywiście każda pętla rozpoczęta [
diff --git a/pl-pl/java-pl.html.markdown b/pl-pl/java-pl.html.markdown
new file mode 100644
index 00000000..0da449c5
--- /dev/null
+++ b/pl-pl/java-pl.html.markdown
@@ -0,0 +1,1026 @@
+---
+language: java
+filename: LearnJavaPl.java
+contributors:
+    - ["Jake Prather", "https://github.com/JakeHP"]
+    - ["Jakukyo Friel", "https://weakish.github.io"]
+    - ["Madison Dickson", "https://github.com/mix3d"]
+    - ["Simon Morgan", "https://sjm.io/"]
+    - ["Zachary Ferguson", "https://github.com/zfergus2"]
+    - ["Cameron Schermerhorn", "https://github.com/cschermerhorn"]
+    - ["Rachel Stiyer", "https://github.com/rstiyer"]
+    - ["Michael Dähnert", "https://github.com/JaXt0r"]
+    - ["Rob Rose", "https://github.com/RobRoseKnows"]
+    - ["Sean Nam", "https://github.com/seannam"]
+    - ["Shawn M. Hanes", "https://github.com/smhanes15"]
+filename: LearnJava.java
+translators:
+    - ["Jacek Wachowiak", "https://github.com/jacekwachowiak"]
+lang: pl-pl
+---
+
+Java jest współbieżnym, opartym na klasach, obiektowym językiem programowania
+ogólnego zastosowania.
+[Tu znajdziesz więcej informacji po angielsku.]
+(https://docs.oracle.com/javase/tutorial/java/)
+
+```java
+// Pojedyncze komentarze oznaczamy //
+
+/*
+Komentarze wieloliniowe wyglądają tak
+*/
+
+/**
+ * Komentarze JavaDoc wygladają w ten sposób. Używane są do opisu klas lub
+ * różnych właściwości klas.
+ * Główne właściwości:
+ *
+ * @author      Imię i nazwisko (i kontakt np. email) autora.
+ * @version     Aktualna wersja programu.
+ * @since       Kiedy ta część programu została dodana.
+ * @param       Służy do opisu parametrów metody.
+ * @return      Służy do opisu zwracanej wartości.
+ * @deprecated  Służy do oznaczenia nieaktualnego lub niezalecanego kodu.
+ * @see         Linki do innej cześci dokumentacji.
+*/
+
+// Import klasy ArrayList z paczki java.util
+import java.util.ArrayList;
+// Import wszystkich klas z paczki java.security
+import java.security.*;
+
+public class LearnJava {
+
+    // Aby móc uruchomić program w języku java musi on mieć główną metodę jako
+    // punkt wejścia.
+    public static void main(String[] args) {
+
+    ///////////////////////////////////////
+    // Operacje wejścia/wyjścia (input/output)
+    ///////////////////////////////////////
+
+        /*
+        * Wyjście
+        */
+
+        // System.out.println() służy do wyświetlania linii tekstu.
+        System.out.println("Hello World!");
+        System.out.println(
+            "Integer: " + 10 +
+            " Double: " + 3.14 +
+            " Boolean: " + true);
+
+        // Aby wyświetlić  bez nowej linii użyj System.out.print().
+        System.out.print("Hello ");
+        System.out.print("World");
+
+        // System.out.printf() służy do łatwego formatowania wyświetlanego elementu.
+        System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
+
+        /*
+         * Wejście
+         */
+
+        // Scanner służy do wczytywania danych
+        // niezbędny jest import java.util.Scanner;
+        Scanner scanner = new Scanner(System.in);
+
+        // zczytaj string (tekst)
+        String name = scanner.next();
+
+        // zczytaj zmienną typu bajt
+        byte numByte = scanner.nextByte();
+
+        // zczytaj zmienną typu integer - liczba całkowita
+        int numInt = scanner.nextInt();
+
+        // zczytaj zmienną typu float - liczba zmiennoprzecinkowa
+        float numFloat = scanner.nextFloat();
+
+        // zczytaj zmienna typu double -liczba zmiennoprzecinkowa
+        double numDouble = scanner.nextDouble();
+
+        // zczytaj zmienną typu boolowskiego -
+        boolean bool = scanner.nextBoolean();
+
+        ///////////////////////////////////////
+        // Zmienne
+        ///////////////////////////////////////
+
+        /*
+        *  Deklaracja zmiennych
+        */
+        // Zmienną deklaruje się poprzez <rodzaj> <nazwa>
+        int fooInt;
+        // Dozwolona jest deklaracja wielu zmiennych tego samego typu na raz
+        // rodzaj <nazwa1>, <nazwa2>, <nazwa3>
+        int fooInt1, fooInt2, fooInt3;
+
+        /*
+        *  Inicjalizacja zmiennych
+        */
+
+        // Zmienną inicjalizuje się poprzez <rodzaj> <nazwa> = <wartość>
+        int barInt = 1;
+        // Możliwe jest zainicjalizowanie wielu zmiennych tego samego typu tą samą wartością
+        // rodzaj <nazwa1>, <nazwa2>, <nazwa3>
+        // <nazwa1> = <nazwa2> = <nazwa3> = <wartość>
+        int barInt1, barInt2, barInt3;
+        barInt1 = barInt2 = barInt3 = 1;
+
+        /*
+        *  Rodzaje zmiennych
+        */
+        // Bajt - 8-bitowa, zawierająca ujemne wartości zmienna w dwójkowym
+        // systemie pozycyjnym
+        // (-128 <= byte <= 127)
+        byte fooByte = 100;
+
+        // Jeśli chcemy zinterpretować bajt jako zmienną typu unsigned integer
+        // - liczbę całkowitą z wartościami ujemnymi ta operacja może pomóc:
+        int unsignedIntLessThan256 = 0xff & fooByte;
+        // jako kontrast operacja zmiany typu która może zwrócić wartość ujemną.
+        int signedInt = (int) fooByte;
+
+        // Short - 16-bitowa, zawierająca ujemne wartości zmienna w dwójkowym
+        // systemie pozycyjnym (-32,768 <= short <= 32,767)
+        short fooShort = 10000;
+
+        // Integer - 32-bitowa, zawierająca ujemne wartości zmienna w dwójkowym systemie pozycyjnym
+        // (-2,147,483,648 <= int <= 2,147,483,647)
+        int bazInt = 1;
+
+        // Long - 64-bitowa, zawierająca ujemne wartości zmienna w dwójkowym
+        // systemie pozycyjnym
+        // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+        long fooLong = 100000L;
+        // L jest używane do zaznaczenia, że wartość zmiennej jest typu Long;
+        // bez L wszystko inne będzie traktowane z założenia jako integer.
+
+        // Uwaga: byte, short, int and long zawierają ujemne wartości.
+        // Nie istnieją odpowiedniki z jedynie pozytywnymi wartościami.
+        // Jedynie char jest 16-bitowym typem zmiennej, który akceptuje tylko
+        // wartości nieujemne.
+
+        // Float - 32-bitowy typ zmiennoprzecinkowy zgodnie z IEEE 754
+        // Floating Point 2^-149 <= float <= (2-2^-23) * 2^127
+        float fooFloat = 234.5f;
+        // f or F jest używane aby zaznaczyć, że dana zmienna jest typu float;
+        // w przeciwnym razie będzie ona traktowana jako double.
+
+        // Double -  64-bitowy typ zmiennoprzecinkowy zgodnie z IEEE 754
+        // Floating Point 2^-1074 <= x <= (2-2^-52) * 2^1023
+        double fooDouble = 123.4;
+
+        // Typ boolowski - true/prawda & false/fałsz
+        boolean fooBoolean = true;
+        boolean barBoolean = false;
+
+        // Char - pojedynczy 16-bitowy symbol Unicode
+        char fooChar = 'A';
+
+        // zmienne zadeklarowane z użyciem final nie mogą być edytowane,
+        final int HOURS_I_WORK_PER_WEEK = 9001;
+        // ale możliwa jest późniejsza inicjalizacja.
+        final double E;
+        E = 2.71828;
+
+        // BigInteger - Nieedytowalny typ zmiennej o nieograniczonej długości
+        // dla liczb całkowitych
+        //
+        // BigInteger jest typem zmiennej, który pozwala na operacje na liczbach całkowitych dłuższych niż 64 bity.
+        // Liczby są przechowywane jako tablica bajtów
+        // i modyfikowane za pomocą funkcji wbudowanych w BigInteger
+        //
+        // BigInteger może być zainicjalizowany za pomocą tablicy bajtów lub jako string.
+        BigInteger fooBigInteger = new BigInteger(fooByteArray);
+
+        // BigDecimal - Nieedytowalny typ zmiennej o nieograniczonej długości dla
+        // liczb zmiennoprzecinkowych
+        //
+        // BigDecimal zaiwera 2 części: typ integer o arbitralnej precyzji bez skalowania
+        // oraz 32-bitową skalę
+        //
+        // BigDecimal pozwala programiście na całkowitą kontrolę zaokrąglenia dziesiętnego.
+        // Zalecane jest używanie BigDecimal z wartościami walut.
+        // oraz tam, gdzie absolutna dokładność jest niezbędna.
+        //
+        // BigDecimal można zainicjalizowac używając int, long, double or String
+        // a także inicjalizując nieprzeskalowaną wartość (BigInteger) i skalę (int).
+        BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
+
+        // Uwaga na konstruktor, który przyjmuje float lub double jako, że
+        // niedokładność float/double będzie przeniesiona do BigDecimal.
+        // Zalecane jest uzywanie konstruktora typu String gdy konieczne jest
+        // uzyskanie absolutnej precyzji.
+        BigDecimal tenCents = new BigDecimal("0.1");
+
+        // String - zmienna tekstowa
+        String fooString = "Tutaj jest mój string!";
+
+        // \n jest symbolem karetki, która rozpoczyna nową linę
+        String barString = "Wyświetlanie w nowej linii?\nNie ma problemu!";
+        // \t jest symbolem tabulatora, który dodaje odstęp.
+        String bazString = "Chesz dodać tabulator?\tBez problemu!";
+        System.out.println(fooString);
+        System.out.println(barString);
+        System.out.println(bazString);
+
+        // Budowanie Stringów
+        // #1 - za pomocą operatora dodawania
+        // To jest podstawowy sposób (zoptymalizowany)
+        String plusConcatenated = "Stringi mogą " + "być łączone " + "operatorem +.";
+        System.out.println(plusConcatenated);
+        // Wyjście: Stringi będą połączone operatorem +.
+
+        // #2 - za pomocą StringBuilder
+        // Ten sposób nie tworzy żadnych pośrednich stringów, jedynie zachowuje
+        // części i wiąże je po kolei gdy wywołane jest toString().
+        // Wskazówka: Ta klasa nie jest bezpieczna z punktu widzenia wątków.
+        // Bezpieczną alternatywą jest (wiążąca się ze spadkiem wydajności)
+        // StringBuffer.
+        StringBuilder builderConcatenated = new StringBuilder();
+        builderConcatenated.append("Możesz ");
+        builderConcatenated.append("użyć ");
+        builderConcatenated.append("klasy StringBuilder.");
+        System.out.println(builderConcatenated.toString()); // dopiero tutaj
+        //budowany jest string
+        // Wyjście: Używany jest StringBuilder.
+
+        // StringBuilder jest wydajny, gdy połączony string nie jest używany aż do końcowego przetworzenia.
+        StringBuilder stringBuilder = new StringBuilder();
+        String inefficientString = "";
+        for (int i = 0 ; i < 10; i++) {
+            stringBuilder.append(i).append(" ");
+            inefficientString += i + " ";
+        }
+        System.out.println(inefficientString);
+        System.out.println(stringBuilder.toString());
+        // inefficientString wymaga dużo więcej pracy przy stworzeniu ponieważ
+        // tworzy string przy każdej iteracji.
+        // Proste łączenie za pomocą + jest kompilowane do StringBuilder i
+        // toString(). Unikaj łączenia stringów w pętlach.
+
+        // #3 - za pomocą String formatter
+        // Inna możliwość, szybka i czytelna.
+        String.format("%s wolisz %s.", "A może", "String.format()");
+        // Wyjście: Być może wolisz String.format().
+
+        // Tablice
+        // Rozmiar tablicy musi być określony przy stworzeniu.
+        // Podane poniżej sposoby są dozwolone prz deklaracji tablicy
+        // <rodzaj>[] <nazwa> = new <rodzaj>[<rozmiar>];
+        // <rodzaj> <nazwa>[] = new <rodzaj>[<rozmiar>];
+        int[] intArray = new int[10];
+        String[] stringArray = new String[1];
+        boolean boolArray[] = new boolean[100];
+
+        // Inny sposób deklaracji i inicjalizacji tablicy
+        int[] y = {9000, 1000, 1337};
+        String names[] = {"Bob", "John", "Fred", "Juan Pedro"};
+        boolean bools[] = {true, false, false};
+
+        // Indeksowanie tablicy - dostęp do elementów
+        System.out.println("intArray @ 0: " + intArray[0]);
+
+        // Tablice zaczynają się z indeksem 0 i są edytowalne.
+        intArray[1] = 1;
+        System.out.println("intArray @ 1: " + intArray[1]); // => 1
+
+        // Inny typ zmiennej, z którymi warto się zapoznać
+        // ArrayLists - Tablice z większą funkcjonalnością
+        //              i zmiennym rozmiarem.
+        // LinkedLists - Dwustronnie połączone listy. Wszystkie operacje
+        //               na listach zaimpllementowane.
+        // Maps - Mapy zawierające klucz i wartość. Mapa jest interfejsem
+        //        i nie może zostać zainicjalizowana.
+        //        Rodzaj klucza i wartości dla mapy musi zostać określony
+        //        przy inicjalizacji implementującej mapę klasy
+        //        Każdy klucz przypisany jest do tylko jednej wartości,
+        //        każdy klucz może wystąpić tylko raz (brak duplikatów).
+        // HashMaps - Używa tablicy hashów do implementacji interfejsu mapy
+        //            Pozwala to na użycie podstawowych operacji, jak
+        //            get i insert, które pozostają niezmiennie wydajne
+        //            czasowo nawet dla dużych zestawów danych
+        // TreeMap - Mapa posortowana przez klucze. Każda modyfikacja
+        //           utrzymuje sortowanie, zdefiniowane przez komparator
+        //           dodany przy inicjalizacji lub porównanie każdego obiektu
+        //           jeśli zaimplementowany jest interfejs Comparable.
+        //           Niepowodzenie kluczy wimplemntacji Comparable połączone
+        //           z niepowodzeniem dostarczenia komparatora spowoduje
+        //           ClassCastExceptions.
+        //           Dodawanie i usuwanie kosztuje O(log(n)) czasu,
+        //           zalecane jest nieużywanie tego typu jeżeli sortowanie
+        //           nie jest przydatne.
+
+        ///////////////////////////////////////
+        // Operatory
+        ///////////////////////////////////////
+        System.out.println("\n->Operatory");
+
+        int i1 = 1, i2 = 2; // Skrót dla wielokrotnych deklaracji
+
+        // Arytmetyka jest prosta
+        System.out.println("1+2 = " + (i1 + i2)); // => 3
+        System.out.println("2-1 = " + (i2 - i1)); // => 1
+        System.out.println("2*1 = " + (i2 * i1)); // => 2
+        System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int zwraca int)
+        System.out.println("1/2.0 = " + (i1 / (double)i2)); // => 0.5
+
+        // Modulo
+        System.out.println("11%3 = "+(11 % 3)); // => 2
+
+        // Porównania
+        System.out.println("3 == 2? " + (3 == 2)); // => false
+        System.out.println("3 != 2? " + (3 != 2)); // => true
+        System.out.println("3 > 2? " + (3 > 2)); // => true
+        System.out.println("3 < 2? " + (3 < 2)); // => false
+        System.out.println("2 <= 2? " + (2 <= 2)); // => true
+        System.out.println("2 >= 2? " + (2 >= 2)); // => true
+
+        // Operacje boolowskie
+        System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false
+        System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true
+        System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true
+
+        // Operacje na bitach!
+        /*
+        ~      Odwrócenie bitów
+        <<     Przesunięcie w lewo
+        >>     Przesunięcie w prawo, arytmetyczne/dla wartości ujemnych -signed
+        >>>    Przesunięcie w prawo, logiczne/dla wartości dodatnich - unsigned
+        &      Bitowe AND
+        ^      Bitowe XOR
+        |      Bitowe OR
+        */
+
+        // Operatory inkrementacji
+        int i = 0;
+        System.out.println("\n->In/De-krementacja");
+        // Operatory ++ i -- zwiększają lub zmniejszają o 1 daną wartość.
+        // Jeżeli używane są przed zmienną, wykonywane są przed powrotem zmiennej.
+        // Użyte po zmiennej najpierw zwracają zmienną a następnie dokonują
+        // zmiany wartości.
+        System.out.println(i++); // i = 1, wyświetli 0 (post-increment)
+        System.out.println(++i); // i = 2, wyświetli 2 (pre-increment)
+        System.out.println(i--); // i = 1, wyświetli 2 (post-decrement)
+        System.out.println(--i); // i = 0, wyświetli 0 (pre-decrement)
+
+        ///////////////////////////////////////
+        // Przepływ sterowania
+        ///////////////////////////////////////
+        System.out.println("\n->Przepływ sterowania");
+
+        // Instrukcja if wygląda jak w c
+        int j = 10;
+        if (j == 10) {
+            System.out.println("Wyświetlam się");
+        } else if (j > 10) {
+            System.out.println("A ja nie");
+        } else {
+            System.out.println("Ja też nie");
+        }
+
+        // Pętla while
+        int fooWhile = 0;
+        while(fooWhile < 100) {
+            System.out.println(fooWhile);
+            // Licznik jest zwiększany
+            // Iteruje 100 razy, fooWhile 0,1,2...99
+            fooWhile++;
+        }
+        System.out.println("Wartość fooWhile: " + fooWhile);
+
+        // Pętla do while
+        int fooDoWhile = 0;
+        do {
+            System.out.println(fooDoWhile);
+            // Licznik jest zwiększany
+            // Iteruje 99 razy, fooDoWhile 0->99
+            fooDoWhile++;
+        } while(fooDoWhile < 100);
+        System.out.println("Wartość fooDoWhile: " + fooDoWhile);
+
+        // Pętla for
+        // struktura pętli for => for(<początek>; <warunek>; <krok>)
+        for (int fooFor = 0; fooFor < 10; fooFor++) {
+            System.out.println(fooFor);
+            // Iteruje 10 razy, fooFor 0->9
+        }
+        System.out.println("Wartość fooFor: " + fooFor);
+
+        // Wyjście z zagnieżdżonej, oznaczonej pętli for
+        outer:
+        for (int i = 0; i < 10; i++) {
+          for (int j = 0; j < 10; j++) {
+            if (i == 5 && j ==5) {
+              break outer;
+              // wychodzi z zewnętrznej pętli zamiast jednynie z aktualnej z
+              // powodu oznaczenia
+            }
+          }
+        }
+
+        // Pętla for each
+        // Pętla for each może iterować tablice jak i obiekty
+        // które implementują interfejs Iterable.
+        int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+        // Struktura for each => for (<element> : <obiekt iterowany>)
+        // należy rozumieć jako: dla każdego elementu w obiekcie iterowanym
+        // uwaga: typ zdefiniowango elementu musi się zgadzać z typem w
+        //obiekcie iterowanym.
+        for (int bar : fooList) {
+            System.out.println(bar);
+            //Iteruje 9 razy i wyświetla 1-9 w nowych liniach
+        }
+
+        // Switch Case
+        // Switch (przełącznik) działa z zmiennymi typu byte, short, char, int.
+        // Działa również z enumeratorami (zobacz typ Enum),
+        // klasą String, i kilkoma specjalnymi klasami które zawierają typy
+        // podstawowe: Character, Byte, Short, and Integer.
+        // Z wersją Java 7 i wyższymi możliwe jest użycie typu String.
+        // Uwagga: Pamiętaj, że nie dodając "break" na końcu danego case
+        // spowoduje przejście do następnego (jeżeli spełniony jest warunek).
+        int month = 3;
+        String monthString;
+        switch (month) {
+            case 1: monthString = "Styczeń";
+                    break;
+            case 2: monthString = "Luty";
+                    break;
+            case 3: monthString = "Marzec";
+                    break;
+            default: monthString = "Inny miesiąc";
+                     break;
+        }
+        System.out.println("Wynik Switch Case : " + monthString);
+
+
+        // Try-with-resources (Java 7+)
+        // Try-catch-finally działa zgodnie z oczekiwaniami jednakże w Java 7+
+        // dodatkowo jest dostępny try-with-resources statement.
+        // Try-with-resources upraszcza try-catch-finally automatycznie
+        // usuwając zasoby.
+
+        // Aby użyć try-with-resources, użyj instancji klasy
+        // w części "try". Klasa musi implementować java.lang.AutoCloseable.
+        try (BufferedReader br = new BufferedReader(new FileReader("foo.txt"))) {
+            // Tutaj możesz spróbować wywołac wyjątek.
+            System.out.println(br.readLine());
+            // W Java 7 zasoby będą zawsze usuwane nawet jeśli nastąpi wyjątek.
+        } catch (Exception ex) {
+            // Zasób będzie usunięty zanim wykona się catch.
+            System.out.println("readLine() nie powiódł się.");
+        }
+        // Nie ma potrzeby używać sekcji "finally", jako że BufferedReader
+        // został już zamknięty. Ten sposób może zostać użyty aby uniknąć
+        // pewnych wartości brzegowych gdzie "finally" nie zostałoby wywołane
+        // Więcej na ten temat po angielsku:
+        // https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html
+
+
+        // Skrócone instrukcje warunkowe
+        // Dozwolone jest użycie operatora '?' aby szybko sprawdzić warunek
+        // logiczny. Rozumiane jest to jako "Jeśli (warunek) jest spełniony, użyj
+        // <pierwszej wartości>, inaczej, użyj <drugiej wartości>"
+        int foo = 5;
+        String bar = (foo < 10) ? "A" : "B";
+        System.out.println("bar : " + bar); // Wyśwletli "bar : A", poineważ
+        // warunke jest spełniony.
+        // Lub prościej
+        System.out.println("bar : " + (foo < 10 ? "A" : "B"));
+
+
+        ////////////////////////////////////////
+        // Konwersja typów danych
+        ////////////////////////////////////////
+
+        // Konwersja danych
+
+        // Konwersja String do Integer
+        Integer.parseInt("123");//zwraca zmienna typu Integer o wartości "123"
+
+        // Konwersja Integer do String
+        Integer.toString(123);//zwraca zmienną typu String o wartości 123
+
+        // Inne konwersje możesz sprawdzić dla klas:
+        // Double
+        // Long
+        // String
+
+        ///////////////////////////////////////
+        // Klasy i funkcje
+        ///////////////////////////////////////
+
+        System.out.println("\n->Klasy & Funkcje");
+
+        // (definicja klasy Rower nieco niżej)
+
+        // Użyj new aby zainstancjonować klasę
+        Rower trek = new Rower();
+
+        // Wywoływanie metod klasy
+        trek.predkoscZwieksz(3); // Zawsze używaj settera i gettera jako metod
+        trek.setPedalowanie(100);
+
+        // toString zwraca reprezentację typu String tego obiektu.
+        System.out.println("trek info: " + trek.toString());
+
+        // Inicjalizacja za pomocą podwójnego nawiasu
+        // Język Java nie zawiera możliwości stworzenia statycznej kolekcji
+        // Dlatego zwykle odbywa się to w ten sposób:
+        private static final Set<String> KRAJE = new HashSet<String>();
+        static {
+           KRAJE.add("DANIA");
+           KRAJE.add("SZWECJA");
+           KRAJE.add("FINLANDIA");
+        }
+
+        // Jest jednak sprytny sposób aby łatwiej osiągnąc ten sam efekt
+        // używając czegoś nazywanego Double Brace Initialization -
+        // inicjalizacja za pomocą podwójnego nawiasu.
+        private static final Set<String> KRAJE = new HashSet<String>() {{
+            add("DANIA");
+            add("SZWECJA");
+            add("FINLANDIA");
+        }}
+
+        // Pierwszy nawias tworzy nową klasę AnonymousInnerClass,
+        // drugi deklaruje instancję bloku inicjalizacji. Blok ten
+        // jest wywoływany gdy wewnętrzna, anonimowa klasa jest tworzona.
+        // Dany sposób działa nie tylko dla kolekcji, ale również dla
+        // wszystkich nie-finalnych klas.
+
+    } // Koniec metody main
+} // Koniec klasy LearnJava
+
+// Możesz zawrzeć inne, niepubliczne, zewnętrzne klasy w pliku .java,
+// jednak nie jest to zalecane. Zalecane jest dzielenie klas na osobne pliki.
+
+// Składnia deklaracji klasy:
+// <public/private/protected> class <nazwa klasy> {
+//    // pola danych, konstruktory, funkcje.
+//    // w jężyku Java funkcje są wywoływane jako metody.
+// }
+
+class Rower {
+
+    // Zmienne klasy
+    public int pedalowanie; // Public: Dostępne wszędzie
+    private int predkosc;  // Private: Dostępne tylko w klasie
+    protected int przerzutka; // Protected: Dostępne w klasie i podklasach
+    String nazwa; // domyślnie: Dostępne tlyko w danej paczce
+    static String nazwaKlasy; // Zmienna statyczna
+
+    // Blok statyczny
+    // Java nie posiada implemntacji konstruktorów staycznych, ale
+    // posiada blok stayczny, który może  być użyty aby zainicjalizować
+    // statyczne zmienne klasy
+    // Ten blok będzie wywołane gdy klasa jest ładowana.
+    static {
+        nazwaKlasy = "Rower";
+    }
+
+    // Konstruktory służą do stworzenia instancji klas
+    // Too jest konstruktor
+    public Rower() {
+        // Możesz wywołać także  inny konstruktor:
+        // this(1, 50, 5, "Bontrager");
+        przerzutka = 1;
+        pedalowanie = 50;
+        predkosc = 5;
+        nazwa = "Bontrager";
+    }
+    // To jest konstruktor, który przyjmuje argumenty
+        public Rower(int poczatkowePedalowanie, int poczatkowaPredkosc, int początkowaPrzerzutka,
+        String nazwa) {
+        this.przerzutka = początkowaPrzerzutka;
+        this.pedalowanie = poczatkowePedalowanie;
+        this.predkosc = poczatkowaPredkosc;
+        this.nazwa = nazwa;
+    }
+
+    // Składnia metod:
+    // <public/private/protected> <zwracany rodzaj> <nazwa funkcji>(<argumenty>)
+
+    // Klasy często implementują metody getter i setter dla danych wewnątrz
+
+    // Składnia deklaracji metody:
+    // <dostępność> <zwracany rodzaj> <nawa metody>(<argumenty>)
+    public int getPedalowanie() {
+        return pedalowanie;
+    }
+
+    // metody void nie wymagają słowa kluczowego return, nic nie zwracają
+    public void setPedalowanie(int newValue) {
+        pedalowanie = newValue;
+    }
+    public void setPrzerzutka(int newValue) {
+        przerzutka = newValue;
+    }
+    public void predkoscZwieksz(int inkrement) {
+        predkosc += inkrement;
+    }
+    public void predkoscZmniejsz(int dekrement) {
+        predkosc -= dekrement;
+    }
+    public void nadajNazwe(String nowaNazwa) {
+        nazwa = nowaNazwa;
+    }
+    public String zwrocNazwe() {
+        return nazwa;
+    }
+
+    // Metoda do wyświetlenia wartości atrybutów danego obiektu.
+    @Override // Dziedziczy z klasy obiektu.
+    public String toString() {
+        return "przerzutka: " + przerzutka + " pedalowanie: " + pedalowanie + " predkosc: " + predkosc +
+            " nazwa: " + nazwa;
+    }
+} // koniec klasy Rower
+
+// PennyFarthing jest podklasą klasy Rower
+class PennyFarthing extends Rower {
+    // (Penny Farthing to rower z wielkim przednim kołem.
+    // Nie ma przerzutek.)
+
+    public PennyFarthing(int poczatkowePedalowanie, int poczatkowaPredkosc) {
+        // Wywołanie kostruktora klasy z której dziedziczymy za pomocą super
+        super(poczatkowePedalowanie, poczatkowaPredkosc, 0, "PennyFarthing");
+    }
+
+    // Używamy annotacji @annotation przy przeciążaniu metod.
+    // Aby dowiedzieć się więcej o annotacjach przydatne jest przejrzenie
+    // (w języku angielskim):
+    // http://docs.oracle.com/javase/tutorial/java/annotations/
+    @Override
+    public void setPrzerzutka(int przerzutka) {
+        this.przerzutka = 0;
+    }
+}
+
+// Rzutowanie
+// Jako, że  klasa PennyFarthing dziedziczy z klasy Rower, możemy uznać, że
+// instancja PennyFarthing jest typu Rower i napisać :
+// Rower rower = new PennyFarthing();
+// Dana operacja jest rzutowaniem obiektu, gdzie jego domyślna klasa jest inna niż docelowa.
+// Więcej szczegółów i przykładów oraz ciekawych konceptów (po angielsku):
+// https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+// Interfejsy
+// Składnia deklaracji interfejsu
+// <dostępność> interface <nazwa interfejsu> extends <super-interfaces> {
+//     // Zmienne typu constant
+//     // Deklaracje metod
+// }
+
+// Przykład - Jedzenie:
+public interface Jadalne {
+    public void jedz(); // Każda klasa która implemetuje ten interfejs musi
+    // implementować tę metodę.
+}
+
+public interface Przetrawialne {
+    public void przetrawiaj();
+    // Wraz z Java 8, interfejsy mogą mieć metodę domyślną.
+    public default void defaultMethod() {
+        System.out.println("Hej z metody domyślnej ...");
+    }
+}
+
+// Teraz stworzymy klasę, która zaimplementuje oba interfejsy.
+public class Owoc implements Jadalne, Przetrawialne {
+    @Override
+    public void jedz() {
+        // ...
+    }
+
+    @Override
+    public void przetrawiaj() {
+        // ...
+    }
+}
+
+// W Javie możesz dziedziczyć jedynie z jednej klasy, jednak implementować
+// wiele interfejsów. Na przykład:
+public class Przyklad extends Przodek implements Interfejs1,
+    Interfejs2 {
+    @Override
+    public void Interfejs1Metoda() {
+    }
+
+    @Override
+    public void Interfejs2Metoda() {
+    }
+
+}
+
+// Klasy abstrakcyjne
+
+// Składnia deklaracji klasy abstrakcyjnej
+// <dostępność> abstract class <nawa klasy abstrakcyjnej> extends
+// <superklasy, z których dziedziczy> {
+//     // Zmienne i stałe
+//     // Deklaracje metod
+// }
+
+// Klasy abstrakcyjne nie mogą posiadać instancji.
+// Klasy abstrakcyjne mogą definiować  metody abstrakcyjne.
+// Metody abstrakcyjne nie mają ciała funkcji i są oznaczone jako abstrakcyjne.
+// Nieabstrakcyjne klasy-dzieci muszą przeciążać wszystkie abstrakcyjne metody
+// superklasy.
+// Klasy abstrakcyjne są użyteczne gdy wymagana jest powtarzalna logika działania,
+// jednak należy zaauważyć, że jako, że wymagają dziedziczenia, łamią
+// zasadę "Composition over inheritance". Rozważ inne podejścia używając
+// kompozycji. https://en.wikipedia.org/wiki/Composition_over_inheritance
+
+public abstract class Zwierze
+{
+    private int wiek;
+
+    public abstract void dajGlos();
+
+    // Metody mogą mieć ciało
+    public void jedz()
+    {
+        System.out.println("Jestem zwierzeciem i jem.");
+        // Uwaga: Możliwy jest dostęp do zmiennych prywatnych.
+        wiek = 30;
+    }
+
+    public void wyswietlWiek()
+    {
+        System.out.println(wiek);
+    }
+
+    // Klasy abstrakcyjne mogą mieć metodę główną.
+    public static void main(String[] args)
+    {
+        System.out.println("Jestem abstrakcyjna");
+    }
+}
+
+class Pies extends Zwierze
+{
+    // Musimy przeciążyć wszystkie abstrakcyjne metody z klasy abstrakcyjnej
+    @Override
+    public void dajGlos()
+    {
+        System.out.println("Hau");
+        // wiek = 30;    ==> BLAD!    wiek jest typu private dla Zwierze
+    }
+
+    // NOTE: Wystąpi błąd jeżeli użyto annotacji @Override jako, że Java
+    // nie pozwala na przeciążanie metod statycznych.
+    // Występuje tutaj METHOD HIDING - ukrywanie metod.
+    // Więcej w poście na SO: http://stackoverflow.com/questions/16313649/
+    public static void main(String[] args)
+    {
+        Pies pluto = new Pies();
+        pluto.dajGLos();
+        pluto.jedz();
+        pluto.wyswietlWiek();
+    }
+}
+
+// Klasy finalne
+
+// Składnia deklaracji klasy finalnej
+// <dostępność> final <nazwa klasy finalnej> {
+//     // Zmienne i stałe
+//     // Deklaracje Metody
+// }
+
+// Klasy finalne są klasami, które nie mogą być użyte do dziedziczenia, są więc
+// z założenia ostatnim elementem dziedziczenia. W ten sposób są przeciwnością
+// klas abstrakcyjnych, które z założenia muszą być dziedziczone.
+public final class TygrysSzablozebny extends Zwierze
+{
+    // Nadal musimy przeciążyć metody abstrakcyjne klasy abstrakcyjnej Zwierze
+    @Override
+    public void dajGlos()
+    {
+        System.out.println("Roar");
+    }
+}
+
+// Metody finalne
+public abstract class Ssak
+{
+    // Składnia metody finalnej:
+    // <dostępność> final <zwracany rodzaj> <nazwa funkcji>(<argumenty>)
+
+    // Metody finalne, jak klasy finalne nie mogą być przeciążane
+    // i są w ten sposób ostatecznymi implementacjami danej metody.
+    public final boolean jestStalocieplny()
+    {
+        return true;
+    }
+}
+
+// Enumeratory
+//
+// Enumerator jest specjalnym tyme danej, która pozwala zmiennej na bycie
+// zestawem wcześniej zdefiniowanych stałych. Zmienna musi być równa jednej z
+// wartości wcześniej zdefiniowanych. Jako, że są to stałe, nazwy pól typu enum
+// są pisane wielkimi literami. W języku Java typ enum definiujemy przez użycie
+// słowa enum. Na przykład aby zdefiniować dni tygodnia:
+public enum Dzien {
+    PONIEDZIALEK, WTOREK, SRODA, CZWARTEK,
+    PIATEK, SOBOTA, NIEDZIELA
+}
+
+// We can use our enum Day like that:
+public class EnumTest {
+    // Zmienna typu enum
+    Dzien dzien;
+
+    public EnumTest(Dzien dzien) {
+        this.dzien = dzien;
+    }
+
+    public void opiszDzien() {
+        switch (dzien) {
+            case PONIEDZIALEK:
+                System.out.println("Nie lubię poniedziałku!");
+                break;
+            case PIATEK:
+                System.out.println("Piątki są dużo lepsze.");
+                break;
+            case SOBOTA:
+            case NIEDZIELA:
+                System.out.println("Weekendy są najlepsze.");
+                break;
+            default:
+                System.out.println("Środek tygodnia jest taki sobie.");
+                break;
+        }
+    }
+
+    public static void main(String[] args) {
+        EnumTest pierwszyDzien = new EnumTest(Dzien.PONIEDZIALEK);
+        pierwszyDzien.opiszDzien(); // => Nie lubię poniedziałku!
+        EnumTest trzeciDzien = new EnumTest(Dzien.SRODA);
+        trzeciDzien.opiszDzien(); // => Środek tygodnia jest taki sobie.
+    }
+}
+
+// Typ enum jest bardziej wszechstronny niż powyższa demostracja.
+// Ciało typu enum może zawierać metody i inne pola.
+// Rzuć okiem na (angielski) https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
+
+// Wprowadzenie do wyrażeń lambda
+//
+// Nowe w Javie 8 są wyrażenia lambda. Lambdy znajdujemy zwykle w funkcyjnych
+// językach programowania, co oznacza, że są metodami, które potrafią być
+// stowrzone bez klasy i przekazywane jak gdyby były obiektem oraz wykonywane
+// gdy zajdzie potrzeba.
+//
+// Ostatnia uwaga - lambdy muszą implementować funcjonalny interfejs.
+// Interfels funkcjonalny to taki, który ma jedynie jedną zadeklarowaną metodę
+// abstrakcyjną, ale może mieć dowolną ilość domyślnych metod. Wyrażenia lambda
+// mogą być używane jako instancje tego interfejsu. Każdy inteferjs, który
+// spełnia wymagania jest traktowany jako funkcjonalny. Więcej o interfejsach
+// znajdziesz powyżej, w odpowiedniej sekcji.
+//
+import java.util.Map;
+import java.util.HashMap;
+import java.util.function.*;
+import java.security.SecureRandom;
+
+public class Lambdas {
+    public static void main(String[] args) {
+        // Składnia deklaracji lambdy:
+	    // <zero lub więcej parametrów> -> <ciało wyrażenia lub blok instrukcji>
+
+        // Poniżej w przykładzie użyjemy tablicy z hashowaniem.
+        Map<String, String> planety = new HashMap<>();
+            planety.put("Merkury", "87.969");
+            planety.put("Wenus", "224.7");
+            planety.put("Ziemia", "365.2564");
+            planety.put("Mars", "687");
+            planety.put("Jowisz", "4,332.59");
+            planety.put("Saturn", "10,759");
+            planety.put("Uran", "30,688.5");
+            planety.put("Neptun", "60,182");
+
+        // Lambda z zerową liczbą parametrów używając funkcjonalnego interfejsu
+        // Supplier z java.util.function.Supplier. Faktyczną lambdą jest częśc
+        // po numPlanets =.
+        Supplier<String> numPlanety = () -> Integer.toString(planety.size());
+        System.out.format("Liczba planet: %s\n\n", numPlanety.get());
+
+        // Lambda z jednym parametrem używająca funkcjonalnego interfejsu
+        // Consumer z java.util.function.Consumer.planety jest mapą, która
+        // wimplementuje Collection jak i Iterable. Użyty forEach pochodzi z
+        // Iterable i jest użyty w lambdzie na każdym elemencie kolekcji
+        // Domyślna implementacja forEach wygląda tak:
+        /*
+            for (T t : this)
+                action.accept(t);
+        */
+
+        // Faktyczna lambda jest parametrem przekazywanym do forEach.
+        planety.keySet().forEach((p) -> System.out.format("%s\n", p));
+
+        // Jeżeli przekazujemy tyklo pojedynczy argumentpowyższy zapis możemy
+        // przekształcić do (zauważ brak nawiasów dookoła p):
+        planety.keySet().forEach(p -> System.out.format("%s\n", p));
+
+        // Śledząc powyższe widzimy, że planety jest typu HashMap, a keySet()
+        // zwraca zestaw kluczy, forEach stosuje o każdego elementu lambdę:
+        // (parameter p) -> System.out.format("%s\n", p). Za każdym razem
+        // element jest uznawany jako  "konsumowany" i wyrażenie (wyrażenia)
+        // w lambdzie są wykonywane. Pamiętaj, że ciało lambdy to część po
+        // symbolu ->.
+
+        // Powyższy przykład bez użycia lambdy wyglądałby tradycyjnie tak:
+        for (String planeta : planety.keySet()) {
+            System.out.format("%s\n", planeta);
+        }
+
+        // Poniższy przykład różni się od powyższego sposobem implementacji
+        // forEach:  forEach użyty w klasie HashMap implementuje intefejs Map.
+        // Poniższy forEach przyjmuje BiConsumer, który ogólnie ujmując jest
+        // wymyślnym sposobem stwierdzenia, że zajmuje się zestawem par
+        // klucz-wartość Key -> Value dla każdego klucza. Ta domyślna
+        // implementacja działa jak:
+        /*
+            for (Map.Entry<K, V> entry : map.entrySet())
+                action.accept(entry.getKey(), entry.getValue());
+        */
+
+        // Faktyczna lambda jest parametrem przekazywanym do forEach.
+        String orbity = "%s okrąża Słońce w %s dni.\n";
+        planety.forEach((K, V) -> System.out.format(orbity, K, V));
+
+        // Powyższe bez użycia lambdy wyglądałoby tradycyjnie tak:
+        for (String planet : planety.keySet()) {
+            System.out.format(orbity, planet, planety.get(planet));
+        }
+
+        // Lub jeżeli postępujemy zgodnie ze specyfikacją domyślnej implementacji:
+        for (Map.Entry<String, String> planeta : planety.entrySet()) {
+            System.out.format(orbity, planeta.getKey(), planeta.getValue());
+        }
+
+        // Podane przykłady pokrywają jedynie podstawowe zastosowanie wyrażeń
+        // lambda. Być może wydają się one niezbyt przydatne, jednak należy
+        // pamiętać, że lambdy można stworzyć jako obiekty, które nastepnie mogą
+        // zostać przekazane jako parametry do innych metod.
+    }
+}
+```
+
+## Dalsze materiały
+
+Linki zamieszczone poniżej służą pomocą w zrozumieniu wybranego tematu, w razie braku rozwiązania wyszukanie w Google zwykle służy pomocą
+
+**Oficjalne poradniki Oracle po angielsku**:
+
+* [Tutorial w Javie od Sun / Oracle](https://docs.oracle.com/javase/tutorial/index.html)
+
+* [Modyfikacje poziomu dostępu w Java](https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+
+* [Koncepty programowania obiektowego](https://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+    * [Dziedziczenie](https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+    * [Polimorfizm](https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+    * [Abstrakcja](https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Wyjątki](https://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Interfejsy](https://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+
+* [Uogólnianie](https://docs.oracle.com/javase/tutorial/java/generics/index.html)
+
+* [Konwencja kodu Java](https://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
+
+* Nowości z Java 8:
+    * [Funkcje Lambda (programowanie funkcyjne)](https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html)
+    * [Data y czas API (java.time package)](http://www.oracle.com/technetwork/articles/java/jf14-date-time-2125367.html)
+
+**Kursy po polsku**
+
+* [PJWSTK - Podstawy programowania w języku Java](http://edu.pjwstk.edu.pl/wyklady/ppj/scb/)
+
+* [PJWSTK - Programowanie obiektowe w języku Java](http://edu.pjwstk.edu.pl/wyklady/poj/scb/)
+
+**Tutoriale i ćwiczenia online po angielsku**
+
+* [Learneroo.com - Learn Java](http://www.learneroo.com)
+
+* [Codingbat.com](http://codingbat.com/java)
+
+* [Codewars - Java Katas](https://www.codewars.com/?language=java)
+
+**Książki po angielsku**:
+
+* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
+
+* [Thinking in Java](http://www.mindview.net/Books/TIJ/)
+
+* [Objects First with Java](https://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
+
+* [Java The Complete Reference](https://www.amazon.com/gp/product/0071606300)
diff --git a/pl-pl/python-pl.html.markdown b/pl-pl/python-pl.html.markdown
index 023c3e6b..222f753f 100644
--- a/pl-pl/python-pl.html.markdown
+++ b/pl-pl/python-pl.html.markdown
@@ -532,7 +532,7 @@ Czlowiek.grunt()   # => "*grunt*"
 
 # Tak importuje się moduły:
 import math
-print(math.sqrt(16))  # => 4
+print(math.sqrt(16))  # => 4.0
 
 # Można podać konkretne funkcje, np. ceil, floor z modułu math
 from math import ceil, floor
diff --git a/powershell.html.markdown b/powershell.html.markdown
index 5a5050b4..db29bf96 100644
--- a/powershell.html.markdown
+++ b/powershell.html.markdown
@@ -68,6 +68,7 @@ $aString="Some string"
 # Or like this:
 $aNumber = 5 -as [double]
 $aList = 1,2,3,4,5
+$anEmptyList = @()
 $aString = $aList -join '--' # yes, -split exists also
 $aHashtable = @{name1='val1'; name2='val2'}
 
@@ -244,7 +245,7 @@ function New-Website() {
 'string' | gm
 
 # Syntax for calling static .NET methods
-\[System.Reflection.Assembly]::LoadWithPartialName('Microsoft.VisualBasic')
+[System.Reflection.Assembly]::LoadWithPartialName('Microsoft.VisualBasic')
 
 # Note that .NET functions MUST be called with parentheses
 # while PS functions CANNOT be called with parentheses.
diff --git a/processing.html.markdown b/processing.html.markdown
new file mode 100644
index 00000000..e437ee95
--- /dev/null
+++ b/processing.html.markdown
@@ -0,0 +1,467 @@
+---
+language: processing
+filename: learnprocessing.pde
+contributors:
+    - ["Phone Thant Ko", "http://github.com/phonethantko"]
+    - ["Divay Prakash", "https://github.com/divayprakash"]
+---
+
+## Introduction
+
+Processing is a programming language for creation of digital arts and
+multimedia content, allowing non-programmers to learn fundamentals of computer
+programming in a visual context.
+
+While the language is based on Java language, its syntax has been largely
+influenced by both Java and Javascript syntaxes. [See more here](https://processing.org/reference/)
+
+The language is statically typed, and also comes with its official IDE to
+compile and run the scripts.
+
+```
+/* ---------
+   Comments
+   ---------
+*/
+
+// Single-line comment starts with //
+
+/*
+   Since Processing is based on Java,
+   the syntax for its comments are the same as Java (as you may have noticed above)!
+   Multi-line comments are wrapped as seen here.
+*/
+
+/* ---------------------------------------
+   Writing and Running Processing Programs
+   ---------------------------------------
+*/
+
+// In Processing, the program entry point is a function named setup() with a
+// void return type.
+// Note! The syntax looks strikingly similar to that of C++.
+void setup() {
+  // This prints out the classic output "Hello World!" to the console when run.
+  println("Hello World!"); // Another language with a semi-column trap, aint it?
+}
+
+// Normally, we put all the static codes inside the setup() method as the name
+// suggest since it only runs once.
+// It can range from setting the background colours, setting the canvas size.
+background(color); // setting the background colour
+size(width,height,[renderer]); // setting the canvas size with optional
+// parameter defining renderer
+// You will see more of them throughout this document.
+
+// If you want to run the codes indefinitely, it has to be placed in draw()
+// method.
+// draw() must exist if you want the code to run continuously and obviously,
+// there can only be one draw() method.
+int i = 0;
+void draw() {
+  // This block of code loops forever until stopped
+  print(i);
+  i++; // Increment Operator!
+}
+
+// Now that we know how to write the working script and how to run it,
+// we will proceed to explore what data types and collections are supported in
+// Processing.
+
+/* ------------------------
+   Datatypes & collections
+   ------------------------
+*/
+
+// According to Processing References, Processing supports 8 primitive
+// datatypes as follows.
+
+boolean booleanValue = true; // Boolean
+byte byteValueOfA = 23; // Byte
+char charValueOfA = 'A'; // Char
+color colourValueOfWhiteM = color(255, 255, 255); // Colour (Specified using
+// color() method)
+color colourValueOfWhiteH = #FFFFFF; // Colour (Specified using hash value)
+int intValue = 5; // Integer (Number without decimals)
+long longValue = 2147483648L; // "L" is added to number to mark it as a long
+float floatValue = 1.12345; // Float (32-bit floating-point numbers)
+double doubleValue = 1.12345D; // Double (64-bit floating-point numbers)
+
+// NOTE!
+// Although datatypes "long" and "double" work in the language,
+// processing functions do not use these datatypes, therefore
+// they need to be converted into "int" and "float" datatypes respectively,
+// using (int) and (float) syntax before passing into a function.
+
+// There is a whole bunch of default composite datatypes available for use in
+// Processing.
+// Primarily, I will brief through the most commonly used ones to save time.
+
+// String
+// While char datatype uses '', String datatype uses "" - double quotes.
+String sampleString = "Hello, Processing!";
+// String can be constructed from an array of char datatypes as well. We will
+// discuss array very soon.
+char source = {'H', 'E', 'L', 'L', 'O'};
+String stringFromSource = new String(source); // HELLO
+// As in Java, strings can be concatenated using the "+" operator.
+print("Hello " + "World!"); // Hello World!
+
+// Array
+// Arrays in Processing can hold any datatypes including Objects themselves.
+// Since arrays are similar to objects, they must be created with the keyword
+// "new".
+int[] intArray = new int[5];
+int[] intArrayWithValues = {1, 2, 3}; // You can also populate with data.
+
+// ArrayList
+// Functions are similar to those of array; arraylists can hold any datatypes.
+// The only difference is arraylists resize dynamically, as it is a form of
+// resizable-array implementation of the Java "List" interface.
+ArrayList<Integer> intArrayList = new ArrayList<Integer>();
+
+// Object
+// Since it is based on Java, Processing supports object-oriented programming.
+// That means you can basically define any datatypes of your own and manipulate
+// them to your needs.
+// Of course, a class has to be defined before for the object you want.
+// Format --> ClassName InstanceName
+SomeRandomClass myObject // then instantiate later
+//or
+SomeRandomClass myObjectInstantiated = new SomeRandomClass();
+
+// Processing comes up with more collections (eg. - Dictionaries and Lists) by
+// default, for the simplicity sake, I will leave them out of discussion here.
+
+/* ------------
+   Maths
+   ------------
+*/
+
+// Arithmetic
+1 + 1 // 2
+2 - 1 // 0
+2 * 3 // 6
+3 / 2 // 1
+3.0 / 2 // 1.5
+3.0 % 2 // 1.0
+
+// Processing also comes with a set of functions that simplify mathematical
+// operations.
+float f = sq(3); // f = 9.0
+float p = pow(3, 3); // p = 27.0
+int a = abs(-13) // a = 13
+int r1 = round(3.1); // r1 = 3
+int r2 = round(3.7); // r2 = 4
+float sr = sqrt(25); // sr = 5.0
+
+// Vectors
+// Processing provides an easy way to implement vectors in its environment
+// using PVector class. It can describe a two or three dimensional vector and
+// comes with a set of methods which are useful for matrices operations.
+// You can find more information on PVector class and its functions here.
+// (https://processing.org/reference/PVector.html)
+
+// Trigonometry
+// Processing also supports trigonometric operations by supplying a set of
+// functions. sin(), cos(), tan(), asin(), acos(), atan() and also degrees()
+// and radians() for convenient conversion.
+// However, those functions take angle in radians as the parameter so it has
+// to be converted beforehand.
+float one = sin(PI/2); // one = 1.0
+// As you may have noticed, there exists a set of constants for trigonometric
+// uses;
+// PI, HALF_PI, QUARTER_PI and so on...
+
+/* -------------
+   Control Flow
+   -------------
+*/
+
+// Conditional Statements
+// If Statements - The same syntax as if statements in Java.
+if (author.getAppearance().equals("hot")) {
+  print("Narcissism at its best!");
+} else {
+  // You can check for other conditions here.
+  print("Something is really wrong here!");
+}
+// A shortcut for if-else statements can also be used.
+int i = 3;
+String value = (i > 5) ? "Big" : "Small"; // "Small"
+
+// Switch-case structure can be used to check multiple conditions concisely.
+int value = 2;
+switch(value) {
+  case 0:
+    print("Nought!"); // This does not get executed.
+    break; // Jumps to the next statement
+  case 1:
+    print("Getting there..."); // This again does not get executed.
+    break;
+  case 2:
+    print("Bravo!"); // This line gets executed.
+    break;
+  default:
+    print("Not found!"); // This line gets executed if our value was some other value.
+    break;
+}
+
+// Iterative statements
+// For Statements - Again, the same syntax as in Java
+for(int i = 0; i < 5; i ++){
+  print(i); // prints from 0 to 4
+}
+
+// While Statements - Again, nothing new if you are familiar with Java syntax.
+int j = 3;
+while(j > 0) {
+  print(j);
+  j--; // This is important to prevent from the code running indefinitely.
+}
+
+// loop()| noLoop() | redraw() | exit()
+// These are more of Processing-specific functions to configure program flow.
+loop(); // allows the draw() method to run forever while
+noLoop(); // only allows it to run once.
+redraw(); // runs the draw() method once more.
+exit(); // This stops the program. It is useful for programs with draw()
+// running continuously.
+```
+
+## Drawing with Processing
+
+Since you will have understood the basics of the language by now, we will now
+look into the best part of Processing - DRAWING.
+
+```
+/* ------
+   Shapes
+   ------
+*/
+
+// 2D Shapes
+
+// Point
+point(x, y); // In 2D space
+point(x, y, z); // In 3D space
+// Draws a point in the coordinate space.
+
+// Line
+line(x1, y1, x2, y2); // In 2D space
+line(x1, y1, z1, x2, y2, z2); // In 3D space
+// Draws a line connecting two points defined by (x1, y1) and (x2, y2).
+
+// Triangle
+triangle(x1, y1, x2, y2, x3, y3);
+// Draws a triangle connecting three points defined by coordinate paramters.
+
+// Rectangle
+rect(a, b, c, d, [r]); // With optional parameter defining the radius of all corners
+rect(a, b, c, d, [tl, tr, br, bl]); // With optional set of parameters defining
+// radius of each corner
+// Draws a rectangle with {a, b} as a top left coordinate and c and d as width
+// and height respectively.
+
+// Quad
+quad(x, y, x2, y2, x3, y3, x4, y4);
+// Draws a quadrilateral with parameters defining coordinates of each corner
+// point.
+
+// Ellipse
+ellipse(x, y, width, height);
+// Draws an eclipse at point {x, y} with width and height specified.
+
+// Arc
+arc(x, y, width, height, start, stop, [mode]);
+// While the first four parameters are self-explanatory,
+// start and end defined the angles the arc starts and ends (in radians).
+// Optional parameter [mode] defines the filling;
+// PIE gives pie-like outline, CHORD gives the chord-like outline and OPEN is
+// CHORD without strokes
+
+// Curves
+// Processing provides two implementation of curves; using curve() and bezier().
+// Since I plan to keep this simple I wont be discussing any further details.
+// However, if you want to implement it in your sketch, here are the references:
+// (https://processing.org/reference/curve_.html)
+// (https://processing.org/reference/bezier_.html)
+
+// 3D Shapes
+
+// 3D space can be configured by setting "P3D" to the renderer parameter in
+// size() method.
+size(width, height, P3D);
+// In 3D space, you will have to translate to the particular coordinate to
+// render the 3D shapes.
+
+// Box
+box(size);  // Cube with same length defined by size
+box(w, h, d); // Box with width, height and depth separately defined
+
+// Sphere
+sphere(radius); // Its size is defined using the radius parameter
+// Mechanism behind rendering spheres is implemented by tessellating triangles.
+// That said, how much detail being rendered is controlled by function
+// sphereDetail(res)
+// More information here: (https://processing.org/reference/sphereDetail_.html)
+
+// Irregular Shapes
+// What if you wanted to draw something thats not made available by Processing
+// functions?
+// You can use beginShape(), endShape(), vertex(x,y) to define shapes by
+// specifying each point. More information here:
+// (https://processing.org/reference/beginShape_.html)
+// You can also use custom made shapes using PShape class:
+// (https://processing.org/reference/PShape.html)
+
+/* ---------------
+   Transformations
+   ---------------
+*/
+
+// Transformations are particularly useful to keep track of the coordinate
+// space and the vertices of the shapes you have drawn. Particularly;
+// matrix stack methods; pushMatrix(), popMatrix() and translate(x,y)
+pushMatrix(); // Saves the current coordinate system to the stack
+// ... apply all the transformations here ...
+popMatrix(); // Restores the saved coordinate system
+// Using them, the coordinate system can be preserved and visualized without
+// causing any conflicts.
+
+// Translate
+translate(x, y); // Translates to point{x, y} i.e. - setting origin to that point
+translate(x, y, z); // 3D counterpart of the function
+
+// Rotate
+rotate(angle); // Rotate the amount specified by the angle parameter
+// It has 3 3D counterparts to perform rotation, each for every dimension,
+// namely: rotateX(angle), rotateY(angle), rotateZ(angle)
+
+// Scale
+scale(s); // Scale the coordinate system by either expanding or contracting it.
+
+/* --------------------
+   Styling and Textures
+   --------------------
+*/
+
+// Colours
+// As I have discussed earlier, the background colour can be configured using
+// background() function. You can define a color object beforehand and then
+// pass it to the function as an argument.
+color c = color(255, 255, 255); // WHITE!
+// By default, Processing uses RGB colour scheme but it can be configured to
+// HSB using colorMode(). Read more here:
+// (https://processing.org/reference/colorMode_.html)
+background(color); // By now, the background colour should be white.
+// You can use fill() function to select the colour for filling the shapes.
+// It has to be configured before you start drawing shapes so the colours gets
+// applied.
+fill(color(0, 0, 0));
+// If you just want to colour the outlines of the shapes then you can use
+// stroke() function.
+stroke(255, 255, 255, 200); // stroke colour set to yellow with transparency
+// set to a lower value.
+
+// Images
+// Processing can render images and use them in several ways. Mostly stored as
+// PImage datatype.
+filter(shader); // Processing supports several filter functions for image manipulation.
+texture(image); // PImage can be passed into arguments for texture-mapping the shapes.
+```
+
+If you want to take things further, there are more things Processing is powered
+for. Rendering models, shaders and whatnot. There's too much to cover in a
+short documentation, so I will leave them out here. Shoud you be interested,
+please check out the references.
+
+```
+// Before we move on, I will touch a little bit more on how to import libraries
+// so you can extend Processing functionality to another horizon.
+
+/* -------
+   Imports
+   -------
+*/
+
+// The power of Processing can be further visualized when we import libraries
+// and packages into our sketches.
+// Import statement can be written as below at the top of the source code.
+import processing.something.*;
+```
+
+## DTC?
+
+Down To Code? Let's get our hands dirty!
+
+Let us see an example from openprocessing to visualize how much Processing is
+capable of within few lines of code.
+
+Copy the code below into your Processing IDE and see the magic.
+
+```
+// Disclaimer: I did not write this program since I currently am occupied with
+// internship and this sketch is adapted from openprocessing since it shows
+// something cool with simple codes.
+// Retrieved from: (https://www.openprocessing.org/sketch/559769)
+
+float theta;
+float a;
+float col;
+float num;
+
+void setup() {
+  size(600,600);
+}
+
+void draw() {
+  background(#F2F2F2);
+  translate(width/2, height/2);
+  theta = map(sin(millis()/1000.0), -1, 1, 0, PI/6);
+
+  float num=6;
+  for (int i=0; i<num; i++) {
+    a =350;
+    rotate(TWO_PI/num);
+    branch(a);
+  }
+
+}
+
+void branch(float len) {
+  col=map(len, 0, 90, 150, 255);
+  fill(col, 0, 74);
+  stroke (col, 0, 74);
+  line(0, 0, 0, -len);
+  ellipse(0, -len, 3, 3);
+  len *= 0.7;
+
+  if (len>30) {
+    pushMatrix();
+    translate(0, -30);
+    rotate(theta);
+    branch(len);
+    popMatrix();
+
+    pushMatrix();
+    translate(0, -30);
+    rotate(-theta);
+    branch(len);
+    popMatrix();
+
+  }
+}
+```
+
+Processing is easy to learn and is particularly useful to create multimedia
+contents (even in 3D) without having to type a lot of codes. It is so simple
+that you can read through the code and get a rough idea of the program flow.
+
+However, that does not apply when you introduce external libraries, packages
+and even your own classes. (Trust me! Processing projects can get real humongous...)
+
+## Some useful resources
+
+ - [Processing Website](http://processing.org)
+ - [Processing Sketches](http://openprocessing.org)
diff --git a/prolog.html.markdown b/prolog.html.markdown
index f7b55ac6..d4c28cba 100644
--- a/prolog.html.markdown
+++ b/prolog.html.markdown
@@ -75,7 +75,7 @@ magicNumber(42).
 ?- 2 = 3.                            % False - equality test
 ?- X = 3.                            % X = 3 - assignment
 ?- X = 2, X = Y.                     % X = Y = 2 - two assignments
-                                     % Note Y is assigned to, even though it is
+                                     % Note Y is assigned too, even though it is
                                      % on the right hand side, because it is free
 ?- X = 3, X = 2.                     % False
                                      % First acts as assignment and binds X=3
diff --git a/protocol-buffer-3.html.markdown b/protocol-buffer-3.html.markdown
new file mode 100644
index 00000000..46065536
--- /dev/null
+++ b/protocol-buffer-3.html.markdown
@@ -0,0 +1,247 @@
+---
+language: protocol-buffers
+filename: protocol-buffers.proto
+contributors:
+    - ["Shankar Shastri", "https://github.com/shankarshastri"]
+---
+# Protocol Buffers
+
+## Why Protocol Buffers
+
+Protocol buffers are Google's language-neutral, platform-neutral, extensible mechanism for serializing structured data – think XML, but smaller, faster, and simpler.
+You define how you want your data to be structured once, then you can use special generated source code to easily write and read your structured data to and from a variety of data streams and using a variety of languages.
+Protocol Buffers are Schema Of Messages. They are language agnostic.
+They can be converted to binary and converted back to message formats using the code generated by the protoc compiler for various languages.
+
+```
+/*
+* Language Syntax
+*/
+
+/*
+* Specifying Syntax Of Protocol Buffer Version
+* Specifying Which Protocol Buffer Version To Use
+* It can be usually proto3 or proto2
+*/
+syntax = "proto3";
+
+/*
+* Declaring Message In Protocol Buffer:
+* As you can see, each field in the message definition has a unique number.
+* These field numbers are used to identify your fields in the message binary format,
+* and should not be changed once your message type is in use.
+* Note that field numbers in the range 1 through 15 take one byte to encode, including the field number and the field's type (you can find out more about this in Protocol Buffer Encoding).
+* Field numbers in the range 16 through 2047 take two bytes. So you should reserve the numbers 1 through 15 for very frequently occurring message elements.
+* Remember to leave some room for frequently occurring elements that might be added in the future.
+* The smallest field number you can specify is 1, and the largest is 2^29 - 1, or 536,870,911.
+* You also cannot use the numbers 19000 through 19999 (FieldDescriptor::kFirstReservedNumber through FieldDescriptor::kLastReservedNumber),
+* as they are reserved for the Protocol Buffers implementation - the protocol buffer compiler will complain if you use one of these reserved numbers in your .proto.
+* Similarly, you cannot use any previously reserved field numbers.
+*
+*/
+
+/*
+Syntax For Declaring Message:
+    message ${MessageName} {
+        ${Scalar Value Type} ${FieldName1} = ${Tag Number1};
+                .
+                .
+                .
+        ${Scalar Value Type} ${FieldNameN} = ${Tag NumberN};
+    }
+
+Default Values Will be applied any case if the message doesn't contain a existing field defined
+in the message definition
+*/
+
+message MessageTypes {
+    /*
+    * Scalar Value Types
+    */
+    string stringType = 1; // A string must always contain UTF-8 encoded or 7-bit ASCII text. Default value = ""
+
+    // Number Types, Default Value = 0
+    int32 int32Type = 2; // Uses Variable Length Encoding. Inefficient For Negative Numbers, Instead Use sint32.
+    int64 int64Type = 3; // Uses Variable Length Encoding. Inefficient For Negative Numbers, Instead Use sint64.
+    uint32 uInt32Type = 4; // Uses Variable Length Encoding
+    uint64 uInt64Type = 5; // Uses Variable Length Encoding
+    sint32 sInt32Type = 6; // Uses Variable Length Encoding. They are efficient in encoding for negative numbers.
+                           // Use this instead of int32 for negative numbers
+    sint64 sInt64Type = 7; // Uses Variable Length Encoding. They are efficient in encoding for negative numbers.
+    // Use this instead of int64 for negative numbers.
+
+    fixed32 fixed32Type = 8; // Always four bytes. More efficient than uint32 if values are often greater than 2^28.
+    fixed64 fixed64Type = 9; // Always eight bytes. More efficient than uint64 if values are often greater than 2^56
+
+    sfixed32 sfixed32Type = 10; // Always four bytes.
+    sfixed64 sfixed64Type = 11; // Always Eight bytes.
+
+    bool boolType = 12; // Boolean Type. Default Value = false
+
+    bytes bytesType = 13; // May contain any arbitrary sequence of bytes. Default Value = Empty Bytes
+
+    double doubleType = 14;
+    float floatType = 15;
+
+    enum Week {
+        UNDEFINED = 0; // Tag 0 is always used as default in case of enum
+        SUNDAY = 1;
+        MONDAY = 2;
+        TUESDAY = 3;
+        WEDNESDAY = 4;
+        THURSDAY = 5;
+        FRIDAY = 6;
+        SATURDAY = 7;
+    }
+    Week wkDayType = 16;
+
+    /*
+    * Defining Collection Of Scalar Value Type
+    * Syntax: repeated ${ScalarType} ${name} = TagValue
+    */
+    repeated string listOfString = 17; // List[String]
+}
+
+/*
+* Defining Defined Message Types In Other Message Definition
+*/
+message Person {
+    string fname = 1;
+    string sname = 2;
+}
+
+message City {
+    Person p = 1;
+}
+
+/*
+* Nested Message Definitions
+*/
+
+message NestedMessages {
+    message FirstLevelNestedMessage {
+        string firstString = 1;
+        message SecondLevelNestedMessage {
+            string secondString = 2;
+        }
+    }
+    FirstLevelNestedMessage msg = 1;
+    FirstLevelNestedMessage.SecondLevelNestedMessage msg2 = 2;
+}
+
+/*
+* Importing Message From A File
+*/
+
+// one.proto
+// message One {
+//     string oneMsg = 1;
+// }
+
+// two.proto
+//  import "myproject/one.proto"
+//  message Two {
+//       string twoMsg = 2;
+//  }
+
+
+/*
+* Advanced Topics
+*/
+
+/*
+* Handling Message Type Changes:
+* Never Change/Use The TagNumber Of A Message Field Which Was Removed
+* We should use reserved in case of message definition update.
+* (https://developers.google.com/protocol-buffers/docs/proto3#updating)
+*/
+
+/*
+* Reserved Fields
+* It's used in case if we need to add/remove new fields into message.
+* Using Reserved Backward and Forward Compatibility Of Messages can be achieved
+*/
+
+
+message ReservedMessage {
+    reserved 0, 1, 2, 3 to 10; // Set Of Tag Numbers Which Can't be reused.
+    reserved "firstMsg", "secondMsg", "thirdMsg"; // Set Of Labels Which Can't Be reused.
+}
+
+/*
+* Any
+* The Any message type lets you use messages as embedded types without having their .proto definition.
+* An Any contains an arbitrary serialized message as bytes,
+* along with a URL that acts as a globally unique identifier for and resolves to that message's type.
+* For Any to work we need to import it as shown below.
+*/
+/*
+    import "google/protobuf/any.proto";
+    message AnySampleMessage {
+        repeated google.protobuf.Any.details = 1;
+    }
+
+*/
+
+
+/*
+*  OneOf
+* There are cases, wherein only one field at-most might be present as part of the message.
+* Note: OneOf messages can't be repeated.
+*/
+
+message OneOfMessage {
+    oneof msg {
+        string fname = 1;
+        string sname = 2;
+    };
+}
+
+/*
+* Maps
+* Map fields cannot be repeated.
+* Ordering Of A Map Is Not Guaranteed.
+*/
+
+message MessageWithMaps {
+    map<string, string> mapOfMessages = 1;
+}
+
+
+/*
+* Packages
+* Used for preventing name clashes between protocol message types
+* Syntax:
+    package ${packageName};
+
+    To Access the package;
+    ${packageName}.${messageName} = ${tagNumber};
+*/
+
+/*
+* Services
+* Message Types Defined For Using In RPC system.
+*  When protoc compiler generates for various languages it generates stub methods for the services.
+*/
+
+message SearchRequest {
+    string queryString = 1;
+}
+
+message SearchResponse {
+    string queryResponse = 1;
+}
+service SearchService {
+    rpc Search (SearchRequest) returns (SearchResponse);
+}
+```
+
+## Generating Classes In Various Languages For Protocol Buffers
+
+```shell
+protoc --proto_path=IMPORT_PATH --cpp_out=DST_DIR --java_out=DST_DIR --python_out=DST_DIR --go_out=DST_DIR --ruby_out=DST_DIR --objc_out=DST_DIR --csharp_out=DST_DIR path/to/file.proto
+```
+
+## References
+
+[Google Protocol Buffers](https://developers.google.com/protocol-buffers/)
diff --git a/pt-br/asymptotic-notation-pt.html.markdown b/pt-br/asymptotic-notation-pt.html.markdown
index aecc2194..b70d26b7 100644
--- a/pt-br/asymptotic-notation-pt.html.markdown
+++ b/pt-br/asymptotic-notation-pt.html.markdown
@@ -13,7 +13,7 @@ lang: pt-br
 ## O que é?
 
 Notação Assintótica é uma linguagem que nos permite analisar o tempo de execução
- de um algoritmo através da indentificação de seu comportamento com o
+ de um algoritmo através da identificação de seu comportamento com o
  crescimento da entrada oferecida. Isso também é conhecido como taxa de
  crescimento do algoritmo. O algoritmo de repente torna-se lento quando o
  tamanho da entrada cresce? O algoritmo mantém, em geral, seu tempo de execução
@@ -33,12 +33,12 @@ Um modo seria contar o número de operações primitivas com diferentes tamanhos
 
 ## Tipos de Notação Assintótica
 
-Na primeira seção desse documento, descrevemos como Notação Assintótica identifica o comportamento de um algoritmo
+Na primeira seção deste documento, descrevemos como Notação Assintótica identifica o comportamento de um algoritmo
  a medida que o tamanho da entrada cresce. Imaginemos um algoritmo como uma função
  *f*, *n* como o tamanho da entrada e *f(n)* sendo o tempo de execução. Então,
  para dado algoritmo *f*, com entrada de tamanho *n*, você terá tempo de execução
- *f(n)*. Isto resulta em um gráfico onde a coordernada Y é o tempo de execução
-, a coordernada X representa o tamanho da entrada e os pontos representam o tempo
+ *f(n)*. Isto resulta em um gráfico onde a coordenada Y é o tempo de execução, 
+ a coordenada X representa o tamanho da entrada e os pontos representam o tempo
 de execução para dado tamanho de entrada.
 
 Você pode representar a função, ou o algoritmo, com Notação Assintótica de várias
@@ -49,7 +49,7 @@ não avalia o melhor caso, porque essas condições não são atingidas com freq
 Um bom exemplo disto seria em algoritmos de ordenação; especificamente, na adição
 de elementos à árvores. O melhor caso na maioria de algoritmos pode ser de apenas
 uma operação. Entretanto, na maioria dos casos, o elemento a ser adicionado terá
-que percorrer a árvore de forma apropriada, o que pode causar a analise de um
+que percorrer a árvore de forma apropriada, o que pode causar a análise de um
 ramo inteiro.
 Este é o pior caso, e isto é o que você está se preparando.
 
@@ -63,16 +63,16 @@ Função Polinomial - an^z + . . . + an^2 + a*n^1 + a*n^0, onde *z* é uma const
 Função Exponencial -  a^n, onde a é alguma constante
 ```
 Estas são as funções básicas de crescimento usadas em várias notações. A lista
- começa com a de crescimento mais lento (logarítima, a de execução mais rápida)
+ começa com a de crescimento mais lento (logarítmica, a de execução mais rápida)
 e segue para a de crescimento mais rápido (exponencial, de execução mais lenta).
-Repare que enquando *n*, a entrada, cresce, cada uma dessas funções cresce mais
-rápido que quadrático, polinimial e exponencial, comparadas com logaritma e linear.
+Repare que enquanto *n*, a entrada, cresce, cada uma dessas funções cresce mais
+rápido que quadrático, polinomial e exponencial, comparadas com logarítmica e linear.
 
 Uma nota extremamente importante para notações é tentar usar os termos mais simples.
 Isto significa descartar constantes e termos de ordem mais baixa, pois quando o
 tamanho da entrada cresce para o infinito (limites matemáticos), os termos de ordem
 mais baixa e constantes tornam-se irrelevantes. Por exemplo, se você tiver uma
-constante muito grande, 2^9001, a simplificação não afeterá sua notação.
+constante muito grande, 2^9001, a simplificação não afetará sua notação.
 
 Já que queremos as formas mais simples, mudemos nossa tabela um pouco...
 
@@ -87,8 +87,8 @@ Função Exponencial - a^n, onde *a* é uma constante
 ### Big-O
 
 Big-O, também escrita como O, é uma Notação Assintótica para o pior caso. Digamos
-*f(n)* seja o tempo de exeução de um algoritmo e *g(n)) um tempo de complexidade
-arbritário que você quer relacionar com seu algoritmo. *f(n)* é O(g(n)), se, para
+*f(n)* seja o tempo de execução de um algoritmo e *g(n)) um tempo de complexidade
+arbitrário que você quer relacionar com seu algoritmo. *f(n)* é O(g(n)), se, para
 quando constante real c (c > 0), *f(n)* <= *c g(n)* para todo tamanho de entrada
 n (n > 0).
 
@@ -116,7 +116,7 @@ Há alguma constante c que satisfaça a definição para todo n?
 3log n + 100 <= 150 * log n, n > 2 (Indefinido em n = 1)
 ```
 
-Sim! A definição de Big-I for atentida, portante `f(n)` é `O(g(n))`.
+Sim! A definição de Big-O foi atendida, portanto `f(n)` é `O(g(n))`.
 
 *Exemplo 2*
 
@@ -146,7 +146,7 @@ Big-Omega, também escrita como Ω, é uma Notação Assintótica para o melhor
 Sinta-se livre para adicionar mais exemplos. Big-O é a notação primária usada para medir complexidade de algoritmos.
 
 ### Notas Finais
-É difícil manter esse tipo de tópico curto e você deveria ler os livros e artigos listados abaixo. Eles cobrem muito mais profundamente definições e exemplos. Mais x='Algoritms & Data Structures' virá; teremos um documento sobre analisar código em breve.
+É difícil manter esse tipo de tópico curto e você deveria ler os livros e artigos listados abaixo. Eles cobrem muito mais profundamente definições e exemplos. Mais x='Algorithms & Data Structures' virá; teremos um documento sobre analisar código em breve.
 
 ## Livros
 
diff --git a/pt-br/awk-pt.html.markdown b/pt-br/awk-pt.html.markdown
index 75b73abe..9bf770fd 100644
--- a/pt-br/awk-pt.html.markdown
+++ b/pt-br/awk-pt.html.markdown
@@ -1,5 +1,6 @@
 ---
-language: awk
+category: tool
+tool: awk
 filename: learnawk-pt.awk
 contributors:
     - ["Marshall Mason", "http://github.com/marshallmason"]
@@ -171,7 +172,7 @@ function arithmetic_functions(a, b, c,    d) {
     # Muitas implementações AWK possuem algumas funções trigonométricas padrão
     localvar = sin(a)
     localvar = cos(a)
-    localvar = atan2(a, b) # arco-tangente de b / a
+    localvar = atan2(b, a) # arco-tangente de b / a
 
     # E conteúdo logarítmico
     localvar = exp(a)
diff --git a/pt-br/bash-pt.html.markdown b/pt-br/bash-pt.html.markdown
index ae18435a..3a48d994 100644
--- a/pt-br/bash-pt.html.markdown
+++ b/pt-br/bash-pt.html.markdown
@@ -16,7 +16,7 @@ lang: pt-br
 
 Tutorial de shell em português
 
-Bash é o nome do shell do Unix, que também é distribuido como shell do sistema 
+Bash é o nome do shell do Unix, que também é distribuído como shell do sistema 
 operacional GNU e como shell padrão para Linux e Mac OS X. Praticamente todos 
 os exemplos abaixo podem fazer parte de um shell script e pode ser executados
 diretamente no shell.
diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index cd4adde7..42a29991 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -564,15 +564,15 @@ void doSomethingWithAFile(const std::string& filename)
 
 // Isto tem _grandes_ vantagens:
 // 1. Não importa o que aconteça,
-//    o recurso (neste caso, o identificador de ficheiro) irá ser limpo.
+//    o recurso (neste caso, o identificador de ficheiro) será limpo.
 //    Depois de escrever o destruidor corretamente,
 //    É _impossível_ esquecer de fechar e vazar o recurso
 // 2. Nota-se que o código é muito mais limpo.
 //    As alças destructor fecham o arquivo por trás das cenas
 //    sem que você precise se preocupar com isso.
 // 3. O código é seguro de exceção.
-//    Uma exceção pode ser jogado em qualquer lugar na função e a limpeza
-//    irá ainda ocorrer.
+//    Uma exceção pode ser lançada em qualquer lugar na função e a limpeza
+//    ainda irá ocorrer.
 
 // Todos códigos C++ usam RAII extensivamente para todos os recursos.
 // Outros exemplos incluem
@@ -609,7 +609,6 @@ h=sum<double>(f,g);
 ```
 Leitura Adicional:
 
-Uma referência atualizada da linguagem pode ser encontrada em
-<http://cppreference.com/w/cpp>
-
-Uma fonte adicional pode ser encontrada em <http://cplusplus.com>
+* Uma referência atualizada da linguagem pode ser encontrada em [CPP Reference](http://cppreference.com/w/cpp).
+* Uma fonte adicional pode ser encontrada em [CPlusPlus](http://cplusplus.com).
+* Um tutorial cobrindo o básico da linguagem e configurando o ambiente de codificação está disponível em [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb).
diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index d594b7b9..e1c27958 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -538,7 +538,7 @@ int area(retan r)
     return r.largura * r.altura;
 }
 
-// Se você tiver structus grande, você pode passá-las "por ponteiro"
+// Se você tiver structs grandes, você pode passá-las "por ponteiro"
 // para evitar cópia de toda a struct:
 int area(const retan *r)
 {
diff --git a/pt-br/clojure-pt.html.markdown b/pt-br/clojure-pt.html.markdown
index 7e8b3f7b..409394f2 100644
--- a/pt-br/clojure-pt.html.markdown
+++ b/pt-br/clojure-pt.html.markdown
@@ -340,7 +340,7 @@ keymap ; => {:a 1, :b 2, :c 3}
 (def my-atom (atom {}))
 
 ; Atualize o atom com um swap!.
-; swap! pega uma funçnao and chama ela com o valor atual do atom
+; swap! pega uma função e chama ela com o valor atual do atom
 ; como primeiro argumento, e qualquer argumento restante como o segundo
 (swap! my-atom assoc :a 1) ; Coloca o valor do átomo my-atom como o resultado de  (assoc {} :a 1)
 (swap! my-atom assoc :b 2) ; Coloca o valor do átomo my-atom como o resultado de (assoc {:a 1} :b 2)
@@ -382,3 +382,6 @@ Clojuredocs.org tem documentação com exemplos para quase todas as funções pr
 
 Clojure-doc.org tem um bom número de artigos para iniciantes:
 [http://clojure-doc.org/](http://clojure-doc.org/)
+
+Clojure for the Brave and True é um livro de introdução ao Clojure e possui uma versão gratuita online:
+[https://www.braveclojure.com/clojure-for-the-brave-and-true/](https://www.braveclojure.com/clojure-for-the-brave-and-true/)
diff --git a/pt-br/cmake-pt.html.markdown b/pt-br/cmake-pt.html.markdown
new file mode 100644
index 00000000..d11fe4f4
--- /dev/null
+++ b/pt-br/cmake-pt.html.markdown
@@ -0,0 +1,179 @@
+---
+category: tool
+tool: cmake
+contributors:
+    - ["Bruno Alano", "https://github.com/brunoalano"]
+filename: CMake-br
+translators:
+    - ["Lucas Pugliesi", "https://github.com/fplucas"]
+lang: pt-br
+---
+
+CMake é um programa de compilação open-source e multiplataforma. Essa ferramenta
+permitirá testar, compilar e criar pacotes a partir do seu código fonte.
+
+O problema que o CMake tenta resolver são os problemas de configurar os Makefiles
+e Autoconfigure (diferente dos interpretadores make que tem comandos diferentes)
+e sua facilidade de uso envolvendo bibliotecas terceiras.
+
+CMake é um sistema open-source extensível que gerencia o processo de build em um
+sistema operacional e um método independente de compilador. Diferente de sistemas
+multiplataformas, CMake é designado a usar em conjunto ao ambiente de compilação
+nativo. Seus simples arquivos de configuração localizados em seus diretórios
+(chamados arquivos CMakeLists.txt) que são usados para gerar padrões de arquivos
+de compilação (ex: makefiles no Unix e projetos em Windows MSVC) que são usados
+de maneira simples.
+
+```cmake
+# No CMake, isso é um comentário
+
+# Para rodar nosso código, iremos utilizar esses comandos:
+#  - mkdir build && cd build
+#  - cmake ..
+#  - make
+#
+# Com esses comandos, iremos seguir as melhores práticas para compilar em um
+# subdiretório e na segunda linha pediremos ao CMake para gerar um novo Makefile
+# independente de sistema operacional. E finalmente, rodar o comando make.
+
+#------------------------------------------------------------------------------
+# Básico
+#------------------------------------------------------------------------------
+#
+# O arquivo CMake deve ser chamado de "CMakeLists.txt".
+
+# Configura a versão mínima requerida do CMake para gerar o Makefile
+cmake_minimum_required (VERSION 2.8)
+
+# Exibe FATAL_ERROR se a versão for menor que  2.8
+cmake_minimum_required (VERSION 2.8 FATAL_ERROR)
+
+# Configuramos o nome do nosso projeto. Mas antes disso, iremos alterar alguns
+# diretórios em nome da convenção gerada pelo CMake. Podemos enviar a LANG do
+# código como segundo parâmetro
+project (learncmake C)
+
+# Configure o diretório do código do projeto (somente convenção)
+set( LEARN_CMAKE_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} )
+set( LEARN_CMAKE_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR} )
+
+# Isso é muito útil para configurar a versão do nosso código no sistema de compilação
+# usando um estilo `semver`
+set (LEARN_CMAKE_VERSION_MAJOR 1)
+set (LEARN_CMAKE_VERSION_MINOR 0)
+set (LEARN_CMAKE_VERSION_PATCH 0)
+
+# Envie as variáveis (número da versão) para o cabeçalho de código-fonte
+configure_file (
+  "${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
+  "${PROJECT_BINARY_DIR}/TutorialConfig.h"
+)
+
+# Inclua Diretórios
+# No GCC, isso irá invocar o comando "-I"
+include_directories( include )
+
+# Onde as bibliotecas adicionais estão instaladas? Nota: permite incluir o path
+# aqui, na sequência as checagens irão resolver o resto
+set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/CMake/modules/" )
+
+# Condições
+if ( CONDICAO )
+  # reposta!
+
+  # Informação incidental
+  message(STATUS "Minha mensagem")
+
+  # Aviso CMake, continua processando
+  message(WARNING "Minha mensagem")
+
+  # Aviso (dev) CMake, continua processando
+  message(AUTHOR_WARNING "Minha mensagem")
+
+  # Erro CMake, continua processando, mas pula a geração
+  message(SEND_ERROR "Minha mensagem")
+
+  # Erro CMake, para o processamento e a geração
+  message(FATAL_ERROR "Minha mensagem")
+endif()
+
+if( CONDICAO )
+
+elseif( CONDICAO )
+
+else( CONDICAO )
+
+endif( CONDICAO )
+
+# Loops
+foreach(loop_var arg1 arg2 ...)
+  COMANDO1(ARGS ...)
+  COMANDO2(ARGS ...)
+  ...
+endforeach(loop_var)
+
+foreach(loop_var RANGE total)
+foreach(loop_var RANGE start stop [step])
+
+foreach(loop_var IN [LISTS [list1 [...]]]
+                    [ITEMS [item1 [...]]])
+
+while(condicao)
+  COMANDO1(ARGS ...)
+  COMANDO2(ARGS ...)
+  ...
+endwhile(condicao)
+
+
+# Operações Lógicas
+if(FALSE AND (FALSE OR TRUE))
+  message("Não exiba!")
+endif()
+
+# Configure um cache normal, ou uma variável de ambiente com o dado valor.
+# Se a opção PARENT_SCOPE for informada em uma variável que será setada no escopo
+# acima do escopo corrente.
+# `set(<variavel> <valor>... [PARENT_SCOPE])`
+
+# Como refencia variáveis dentro de aspas ou não, argumentos com strings vazias
+# não serão setados
+${nome_da_variavel}
+
+# Listas
+# Configure a lista de arquivos código-fonte
+set( LEARN_CMAKE_SOURCES
+  src/main.c
+  src/imagem.c
+  src/pather.c
+)
+
+# Chama o compilador
+#
+# ${PROJECT_NAME} referencia ao Learn_CMake
+add_executable( ${PROJECT_NAME} ${LEARN_CMAKE_SOURCES} )
+
+# Linka as bibliotecas
+target_link_libraries( ${PROJECT_NAME} ${LIBS} m )
+
+# Onde as bibliotecas adicionais serão instaladas? Nota: nos permite incluir o path
+# aqui, em seguida os testes irão resolver o restante
+set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/CMake/modules/" )
+
+# Condição do compilador (gcc ; g++)
+if ( "${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" )
+  message( STATUS "Setting the flags for ${CMAKE_C_COMPILER_ID} compiler" )
+  add_definitions( --std=c99 )
+endif()
+
+# Checa o Sistema Operacional
+if( UNIX )
+    set( LEARN_CMAKE_DEFINITIONS
+        "${LEARN_CMAKE_DEFINITIONS} -Wall -Wextra -Werror -Wno-deprecated-declarations -Wno-unused-parameter -Wno-comment" )
+endif()
+```
+
+### Mais Recursos
+
++ [cmake tutorial](https://cmake.org/cmake-tutorial/)
++ [cmake documentation](https://cmake.org/documentation/)
++ [mastering cmake](http://amzn.com/1930934319/)
diff --git a/pt-br/coffeescript-pt.html.markdown b/pt-br/coffeescript-pt.html.markdown
index 8b1094b1..7129a463 100644
--- a/pt-br/coffeescript-pt.html.markdown
+++ b/pt-br/coffeescript-pt.html.markdown
@@ -3,19 +3,20 @@ language: coffeescript
 contributors:
   - ["Tenor Biel", "http://github.com/L8D"]
   - ["Xavier Yao", "http://github.com/xavieryao"]
+  - ["Claudio Busatto", "http://github.com/cjcbusatto"]
 translators:
     - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
 lang: pt-br
 filename: learncoffeescript-pt.coffee
 ---
 
-CoffeeScript é uma pequena linguagem que compila um-para-um para o JavaScript 
-equivalente, e não há interpretação em tempo de execução. Como um dos sucessores 
-de JavaScript, CoffeeScript tenta o seu melhor para exibir uma saída legível, 
-bem-impressa e bom funcionamento dos códigos JavaScript em todo o tempo de 
+CoffeeScript é uma pequena linguagem que compila um-para-um para o JavaScript
+equivalente, e não há interpretação em tempo de execução. Como um dos sucessores
+de JavaScript, CoffeeScript tenta o seu melhor para exibir uma saída legível,
+bem-impressa e bom funcionamento dos códigos JavaScript em todo o tempo de
 execução JavaScript.
 
-Veja também [site do CoffeeScript](http://coffeescript.org/), que tem um tutorial 
+Veja também [site do CoffeeScript](http://coffeescript.org/), que tem um tutorial
 completo sobre CoffeeScript.
 
 ``` coffeescript
@@ -23,35 +24,35 @@ completo sobre CoffeeScript.
 #Segue as tendências de muitas linguagens modernas
 #Assim, os comentários são iguais a Ruby e Python, eles usam símbolos numéricos.
 
-### 
-Os comentários em bloco são como estes, e eles traduzem diretamente para '/ *'s e 
+###
+Os comentários em bloco são como estes, e eles traduzem diretamente para '/ *'s e
 '* /'s para o código JavaScript que resulta...
 
-Você deveria entender mais de semântica de JavaScript antes de continuar... 
+Você deveria entender mais de semântica de JavaScript antes de continuar...
 ###
 
-# Tarefa: 
-numero = 42 #=> número var = 42; 
+# Tarefa:
+numero = 42 #=> var numero = 42;
 oposto = true #=> var oposto = true;
 
-# Condições: 
-numero = -42 if oposto #=> if (oposto) {número = -42;}
+# Condições:
+numero = -42 if oposto #=> if (oposto) {numero = -42;}
 
-# Funções: 
+# Funções:
 quadrado = (x) -> x * x #=> var quadrado = function (x) {return x * x;}
 
-preencher = (recipiente, líquido = "coffee") ->
-  "Preenchendo o #{recipiente} with #{líquido}..."
+preencher = (recipiente, liquido = "coffee") ->
+  "Preenchendo o #{recipiente} with #{liquido}..."
 #=>var preencher;
 #
-#preencher = function(recipiente, líquido) {
-#  if (líquido == null) {
-#    líquido = "coffee";
+#preencher = function(recipiente, liquido) {
+#  if (liquido == null) {
+#    liquido = "coffee";
 #  }
-#  return "Preenchendo o " + recipiente + " with " + líquido + "...";
+#  return "Preenchendo o " + recipiente + " with " + liquido + "...";
 #};
 
-# Alcances: 
+# Alcances:
 list = [1 .. 5] #=> lista var = [1, 2, 3, 4, 5];
 
 # Objetos:
@@ -79,7 +80,7 @@ alert "Eu sabia!" if elvis?
 #=> if(typeof elvis !== "undefined" && elvis !== null) { alert("Eu sabia!"); }
 
 # Compressão de Matrizes:
-cubes = (math.cube num for num in list) 
+cubes = (math.cube num for num in list)
 #=>cubes = (function() {
 #   var _i, _len, _results;
 #   _results = [];
@@ -99,8 +100,9 @@ eat alimento for alimento in comidas when alimento isnt 'chocolate'
 #  if (alimento !== 'chocolate') {
 #    eat(alimento);
 #  }
+```
 
 ## Recursos adicionais
 
 - [Smooth CoffeeScript](http://autotelicum.github.io/Smooth-CoffeeScript/)
-- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read)
\ No newline at end of file
+- [CoffeeScript Ristretto](https://leanpub.com/coffeescript-ristretto/read)
diff --git a/pt-br/common-lisp-pt.html.markdown b/pt-br/common-lisp-pt.html.markdown
index c3381824..c22cfd8e 100644
--- a/pt-br/common-lisp-pt.html.markdown
+++ b/pt-br/common-lisp-pt.html.markdown
@@ -19,7 +19,7 @@ Outro livro recente e popular é o
 [Land of Lisp](http://landoflisp.com/).
 
 
-```common-lisp
+```lisp
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;; 0. Sintaxe
diff --git a/pt-br/csharp-pt.html.markdown b/pt-br/csharp-pt.html.markdown
index b6e95d36..2ff59296 100644
--- a/pt-br/csharp-pt.html.markdown
+++ b/pt-br/csharp-pt.html.markdown
@@ -59,7 +59,7 @@ namespace Learning.CSharp
             Console.Write("World");
 
             ///////////////////////////////////////////////////
-            // Tpos e Variáveis
+            // Tipos e Variáveis
             //
             // Declare uma variável usando <tipo> <nome>
             ///////////////////////////////////////////////////
@@ -95,8 +95,8 @@ namespace Learning.CSharp
             float fooFloat = 234.5f; // Precision: 7 digits
             // f is used to denote that this variable value is of type float
 
-            // Decimal - a 128-bits data type, with more precision than other floating-point types,
-            // suited for financial and monetary calculations
+            // Decimal - um tipo de dados de 128 bits, com mais precisão do que outros tipos de ponto flutuante,
+            // adequado para cálculos financeiros e monetários
             decimal fooDecimal = 150.3m;
 
             // Boolean - true & false
@@ -294,9 +294,9 @@ on a new line! ""Wow!"", the masses cried";
                 case 3:
                     monthString = "March";
                     break;
-                // You can assign more than one case to an action
-                // But you can't add an action without a break before another case
-                // (if you want to do this, you would have to explicitly add a goto case x
+                // Você pode declarar mais de um "case" para uma ação
+                // Mas você não pode adicionar uma ação sem um "break" antes de outro "case"
+                // (se você quiser fazer isso, você tem que explicitamente adicionar um "goto case x")
                 case 6:
                 case 7:
                 case 8:
@@ -336,28 +336,28 @@ on a new line! ""Wow!"", the masses cried";
         }
 
         ///////////////////////////////////////
-        // CLASSES - see definitions at end of file
+        // CLASSES - Veja definições no fim do arquivo
         ///////////////////////////////////////
         public static void Classes()
         {
-            // See Declaration of objects at end of file
+            // Veja Declaração de objetos no fim do arquivo
 
-            // Use new to instantiate a class
+            // Use new para instanciar uma classe
             Bicycle trek = new Bicycle();
 
-            // Call object methods
-            trek.SpeedUp(3); // You should always use setter and getter methods
+            // Chame métodos do objeto
+            trek.SpeedUp(3); // Você deve sempre usar métodos setter e getter
             trek.Cadence = 100;
 
-            // ToString is a convention to display the value of this Object.
+            // ToString é uma convenção para exibir o valor desse Objeto.
             Console.WriteLine("trek info: " + trek.Info());
 
-            // Instantiate a new Penny Farthing
+            // Instancie um novo Penny Farthing
             PennyFarthing funbike = new PennyFarthing(1, 10);
             Console.WriteLine("funbike info: " + funbike.Info());
 
             Console.Read();
-        } // End main method
+        } // Fim do método principal
 
         // CONSOLE ENTRY A console application must have a main method as an entry point
         public static void Main(string[] args)
@@ -522,7 +522,7 @@ on a new line! ""Wow!"", the masses cried";
             foreach (var key in responses.Keys)
                 Console.WriteLine("{0}:{1}", key, responses[key]);
 
-            // DYNAMIC OBJECTS (great for working with other languages)
+            // OBJETOS DINÂMICOS (ótimo para trabalhar com outros idiomas)
             dynamic student = new ExpandoObject();
             student.FirstName = "First Name"; // No need to define class first!
 
@@ -730,10 +730,10 @@ on a new line! ""Wow!"", the masses cried";
             set { _hasTassles = value; }
         }
 
-        // You can also define an automatic property in one line
-        // this syntax will create a backing field automatically.
-        // You can set an access modifier on either the getter or the setter (or both)
-        // to restrict its access:
+        // Você também pode definir uma propriedade automática em uma linha
+        // Esta sintaxe criará um campo de apoio automaticamente.
+        // Você pode definir um modificador de acesso no getter ou no setter (ou ambos)
+        // para restringir seu acesso:
         public bool IsBroken { get; private set; }
 
         // Properties can be auto-implemented
@@ -834,7 +834,7 @@ on a new line! ""Wow!"", the masses cried";
         bool Broken { get; } // interfaces can contain properties as well as methods & events
     }
 
-    // Class can inherit only one other class, but can implement any amount of interfaces
+    // Classes podem herdar apenas de uma outra classe, mas podem implementar qualquer quantidade de interfaces.
     class MountainBike : Bicycle, IJumpable, IBreakable
     {
         int damage = 0;
@@ -854,8 +854,8 @@ on a new line! ""Wow!"", the masses cried";
     }
 
     /// <summary>
-    /// Used to connect to DB for LinqToSql example.
-    /// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional)
+    /// Exemplo de como conectar-se ao DB via LinqToSql.
+    /// EntityFramework First Code é impressionante (semelhante ao ActiveRecord de Ruby, mas bidirecional)
     /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
     /// </summary>
     public class BikeRepository : DbContext
diff --git a/pt-br/css-pt.html.markdown b/pt-br/css-pt.html.markdown
index 956b3614..c73669d0 100644
--- a/pt-br/css-pt.html.markdown
+++ b/pt-br/css-pt.html.markdown
@@ -9,6 +9,8 @@ contributors:
     - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
 translators:
     - ["Gabriel Gomes", "https://github.com/gabrielgomesferraz"]
+    - ["Gabriele Luz", "https://github.com/gabrieleluz"]
+
 lang: pt-br
 ---
 
@@ -236,6 +238,45 @@ A precedência de estilo é a seguinte. Lembre-se, a precedência é para cada
 * `B` é o próximo.
 * `D` é a última.
 
+## Media Queries
+Media queries são recursos do CSS3 que permitem especificar quando determinadas regras de CSS devem ser aplicadas; é possível aplicar regras diferentes quando a página é impressa, quando a tela possui determinadas dimensões ou densidade de pixels e quando é lida por um leitor de tela. Media queries não adicionam especificidade ao seletor.
+
+```css
+/* Uma regra que será aplicada a todos os dispositivos */
+h1 {
+  font-size: 2em;
+  color: white;
+  background-color: black;
+}
+
+/* Altera a cor do h1 para utilizar menos tinta durante a impressão */
+@media print {
+  h1 {
+    color: black;
+    background-color: white;
+  }
+}
+
+/* Altera o tamanho da fonte quando exibida numa tela com pelo menos 480px de largura */
+@media screen and (min-width: 480px) {
+  h1 {
+    font-size: 3em;
+    font-weight: normal;
+  }
+}
+```
+Media queries podem incluir os seguintes atributos: `width`, `height`, `device-width`, `device-height`, `orientation`, `aspect-ratio`, `device-aspect-ratio`, `color`, `color-index`, `monochrome`, `resolution`, `scan`, `grid`. A maioria desses atributos pode ser prefixada com `min-` ou `max-`.
+
+O atributo `resolution` não é suportado em dispositivos mais antigos. Em vez disso, use `device-pixel-ratio`.
+
+Muitos smartphones e tablets tentarão renderizar a página como se estivesse num desktop a menos que você utilize a meta-tag `viewport`.
+
+```html
+<head>
+  <meta name="viewport" content="width=device-width; initial-scale=1.0">
+</head>
+```
+
 ## Compatibilidade
 
 A maior parte dos recursos do CSS 2 (e muitos em CSS 3) estão disponíveis em todos os navegadores e dispositivos. Mas é sempre boa prática para verificar antes de usar um novo recurso.
diff --git a/pt-br/cypher-pt.html.markdown b/pt-br/cypher-pt.html.markdown
new file mode 100644
index 00000000..9b60f771
--- /dev/null
+++ b/pt-br/cypher-pt.html.markdown
@@ -0,0 +1,250 @@
+---
+language: cypher
+filename: LearnCypher-br.cql
+contributors:
+    - ["Théo Gauchoux", "https://github.com/TheoGauchoux"]
+
+lang: pt-br
+---
+
+O Cypher é a linguagem de consulta do Neo4j para manipular gráficos facilmente. Ela reutiliza a sintaxe do SQL e a mistura com o tipo de ascii-art para representar gráficos. Este tutorial pressupõe que você já conheça conceitos de gráficos como nós e relacionamentos.
+
+[Leia mais aqui.](https://neo4j.com/developer/cypher-query-language/)
+
+
+Nós
+---
+
+**Representa um registro em um gráfico.**
+
+`()`
+É um *nó* vazio, para indicar que existe um *nó*, mas não é relevante para a consulta.
+
+`(n)`
+É um *nó* referido pela variável **n**, reutilizável na consulta. Começa com minúsculas e usa o camelCase.
+
+`(p:Person)`
+Você pode adicionar um *label* ao seu nó, aqui **Person**. É como um tipo / uma classe / uma categoria. Começa com maiúsculas e usa o camelCase.
+
+`(p:Person:Manager)`
+Um nó pode ter muitos *labels*.
+
+`(p:Person {name : 'Théo Gauchoux', age : 22})`
+Um nó pode ter algumas *propriedades*, aqui **name** e **age**. Começa com minúsculas e usa o camelCase.
+
+Os tipos permitidos nas propriedades:
+
+ - Numeric
+ - Boolean
+ - String
+ - Lista de tipos primitivos anteriores
+
+*Aviso: não há propriedade datetime no Cypher! Você pode usar String com um padrão específico ou um Numeric a partir de uma data específica.*
+
+`p.name`
+Você pode acessar uma propriedade com o estilo de ponto.
+
+
+Relacionamentos (ou Arestas)
+---
+
+**Conecta dois nós**
+
+`[:KNOWS]`
+É um *relacionamento* com o *label* **KNOWS**. É um *label* como um rótulo do nó. Começa com maiúsculas e usa UPPER_SNAKE_CASE.
+
+`[k:KNOWS]`
+O mesmo *relacionamento*, referido pela variável **k**, reutilizável na consulta, mas não é necessário.
+
+`[k:KNOWS {since:2017}]`
+O mesmo *relacionamento*, com *propriedades* (como *nó*), aqui **since**.
+
+`[k:KNOWS*..4]`
+É uma informação estrutural para usar em um *path* (visto posteriormente). Aqui, **\*..4** diz, “Corresponda o padrão, com a relação **k** que é repetida de 1 a 4 vezes.
+
+
+Paths
+---
+
+**A maneira de misturar nós e relacionamentos.**
+
+`(a:Person)-[:KNOWS]-(b:Person)`
+Um path descrevendo que **a** e **b** se conhecem.
+
+`(a:Person)-[:MANAGES]->(b:Person)`
+Um path pode ser direcionado. Este path descreve que **a** é o gerente de **b**.
+
+`(a:Person)-[:KNOWS]-(b:Person)-[:KNOWS]-(c:Person)`
+Você pode encadear vários relacionamentos. Este path descreve o amigo de um amigo.
+
+`(a:Person)-[:MANAGES]->(b:Person)-[:MANAGES]->(c:Person)`
+Uma encadeamento também pode ser direcionada. Este path descreve que **a** é o chefe de **b** e o grande chefe de **c**.
+
+Padrões frequentemente usados ​​(do Neo4j doc) :
+
+```
+// Amigo de um amigo
+(user)-[:KNOWS]-(friend)-[:KNOWS]-(foaf)
+
+// Path mais curto
+path = shortestPath( (user)-[:KNOWS*..5]-(other) )
+
+// Filtragem colaborativa
+(user)-[:PURCHASED]->(product)<-[:PURCHASED]-()-[:PURCHASED]->(otherProduct)
+
+// Navegação de árvore
+(root)<-[:PARENT*]-(leaf:Category)-[:ITEM]->(data:Product)
+
+```
+
+
+Crie consultas
+---
+
+Create a new node
+```
+CREATE (a:Person {name:"Théo Gauchoux"})
+RETURN a
+```
+*`RETURN` permite ter um resultado após a consulta. Pode ser múltiplo, como `RETURN a, b`.*
+
+Crie um novo relacionamento (com 2 novos nós)
+```
+CREATE (a:Person)-[k:KNOWS]-(b:Person)
+RETURN a,k,b
+```
+
+Consultas que casam
+---
+
+Casam todos os nós
+```
+MATCH (n)
+RETURN n
+```
+
+Casam nós por label
+```
+MATCH (a:Person)
+RETURN a
+```
+
+Casam nós por label e propriedade
+```
+MATCH (a:Person {name:"Théo Gauchoux"})
+RETURN a
+```
+
+Casam nós de acordo com os relacionamentos (não direcionados)
+```
+MATCH (a)-[:KNOWS]-(b)
+RETURN a,b
+```
+
+Casam nós de acordo com os relacionamentos (direcionados)
+```
+MATCH (a)-[:MANAGES]->(b)
+RETURN a,b
+```
+
+Casam nós com um cláusula `WHERE`
+```
+MATCH (p:Person {name:"Théo Gauchoux"})-[s:LIVES_IN]->(city:City)
+WHERE s.since = 2015
+RETURN p,state
+```
+
+Você pode usa a cláusula `MATCH WHERE` com a cláusula `CREATE`
+```
+MATCH (a), (b)
+WHERE a.name = "Jacquie" AND b.name = "Michel"
+CREATE (a)-[:KNOWS]-(b)
+```
+
+
+Atualizar consultas
+---
+
+Atualizar uma propriedade específica de um nó
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p.age = 23
+```
+
+Substituir todas as propriedades de um nó
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p = {name: "Michel", age: 23}
+```
+
+Adicionar nova propriedade a um nó
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p + = {studies: "IT Engineering"}
+```
+
+Adicione um label a um nó
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p:Internship
+```
+
+
+Excluir consultas
+---
+
+Excluir um nó específico (os relacionamentos vinculados devem ser excluídos antes)
+```
+MATCH (p:Person)-[relationship]-()
+WHERE p.name = "Théo Gauchoux"
+DELETE relationship, p
+```
+
+Remover uma propriedade em um nó específico
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+REMOVE p.age
+```
+*Prestar atenção à palavra chave `REMOVE`, não é `DELETE` !*
+
+Remover um label de um nó específico
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+DELETE p:Person
+```
+
+Excluir o banco de dados inteiro
+```
+MATCH (n)
+OPTIONAL MATCH (n)-[r]-()
+DELETE n, r
+```
+*Sério, é o `rm -rf /` do Cypher !*
+
+
+Outras cláusulas úteis
+---
+
+`PROFILE`
+Antes de uma consulta, mostre o plano de execução dela.
+
+`COUNT(e)`
+Contar entidades (nós ou relacionamentos) que casam com **e**.
+
+`LIMIT x`
+Limite o resultado aos primeiros x resultados.
+
+
+Dicas Especiais
+---
+
+- Há apenas comentários de uma linha no Cypher, com barras duplas : // Comentários
+- Você pode executar um script Cypher armazenado em um arquivo **.cql** diretamente no Neo4j (é uma importação). No entanto, você não pode ter várias instruções neste arquivo (separadas por **;**).
+- Use o shell Neo4j para escrever Cypher, é realmente incrível.
+- O Cypher será a linguagem de consulta padrão para todos os bancos de dados de gráficos (conhecidos como **OpenCypher**).
diff --git a/pt-br/dynamic-programming-pt.html.markdown b/pt-br/dynamic-programming-pt.html.markdown
index 84b055d9..93171955 100644
--- a/pt-br/dynamic-programming-pt.html.markdown
+++ b/pt-br/dynamic-programming-pt.html.markdown
@@ -63,13 +63,11 @@ grafo acíclico dirigido.
 ```
 
 ## Alguns Problemas Famosos de Programação Dinâmica
-```
-Floyd Warshall Algorithm - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code 
-
-Integer Knapsack Problem - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem 
 
-Longest Common Subsequence - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence 
-```
+- [Floyd Warshall Algorithm - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code)
+- [Integer Knapsack Problem - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem)
+- [Longest Common Subsequence - Tutorial and C Program source code](http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence)
+ 
 
 ## Recursos Online (EN)
 
diff --git a/pt-br/factor-pt.html.markdown b/pt-br/factor-pt.html.markdown
new file mode 100644
index 00000000..b4b5c7f5
--- /dev/null
+++ b/pt-br/factor-pt.html.markdown
@@ -0,0 +1,184 @@
+---
+language: factor
+contributors:
+    - ["hyphz", "http://github.com/hyphz/"]
+filename: learnfactor-br.factor
+
+lang: pt-br
+---
+
+Factor é uma linguagem moderna baseada em pilha, baseado em Forth, criada por Slava Pestov.
+
+Código neste arquivo pode ser digitado em Fator, mas não importado diretamente porque o cabeçalho de vocabulário e importação faria o início completamente confuso.
+
+```factor
+! Este é um comentário
+
+! Como Forth, toda a programação é feita manipulando a pilha.
+! A indicação de um valor literal o coloca na pilha.
+5 2 3 56 76 23 65    ! Nenhuma saída, mas a pilha é impressa no modo interativo
+
+! Esses números são adicionados à pilha, da esquerda para a direita.
+! .s imprime a pilha de forma não destrutiva.
+.s     ! 5 2 3 56 76 23 65
+
+! A aritmética funciona manipulando dados na pilha.
+5 4 +    ! Sem saída
+
+! `.` mostra o resultado superior da pilha e o imprime.
+.    ! 9
+
+! Mais exemplos de aritmética:
+6 7 * .        ! 42
+1360 23 - .    ! 1337
+12 12 / .      ! 1
+13 2 mod .     ! 1
+
+99 neg .       ! -99
+-99 abs .      ! 99
+52 23 max .    ! 52
+52 23 min .    ! 23
+
+! Várias palavras são fornecidas para manipular a pilha, coletivamente conhecidas como palavras embaralhadas.
+
+3 dup -          ! duplica o primeiro item (1st agora igual a 2nd): 3 - 3
+2 5 swap /       ! troca o primeiro com o segundo elemento:         5 / 2
+4 0 drop 2 /     ! remove o primeiro item (não imprima na tela):    4 / 2
+1 2 3 nip .s     ! remove o segundo item (semelhante a drop):       1 3
+1 2 clear .s     ! acaba com toda a pilha
+1 2 3 4 over .s  ! duplica o segundo item para o topo:   1 2 3 4 3
+1 2 3 4 2 pick .s ! duplica o terceiro item para o topo: 1 2 3 4 2 3
+
+! Criando Palavras
+! O `:` conjuntos de palavras do Factor no modo de compilação até que ela veja a palavra `;`.
+: square ( n -- n ) dup * ;    ! Sem saída
+5 square .                     ! 25
+
+! Podemos ver o que as palavra fazem também.
+! \ suprime a avaliação de uma palavra e coloca seu identificador na pilha.
+\ square see    ! : square ( n -- n ) dup * ;
+
+! Após o nome da palavra para criar, a declaração entre parênteses dá o efeito da pilha.
+! Podemos usar os nomes que quisermos dentro da declaração:
+: weirdsquare ( camel -- llama ) dup * ;
+
+! Contanto que sua contagem corresponda ao efeito da pilha da palavra:
+: doubledup ( a -- b ) dup dup ; ! Error: Stack effect declaration is wrong
+: doubledup ( a -- a a a ) dup dup ; ! Ok
+: weirddoubledup ( i -- am a fish ) dup dup ; ! Além disso Ok
+
+! Onde Factor difere do Forth é no uso de citações.
+! Uma citação é um bloco de código que é colocado na pilha como um valor.
+! [ inicia o modo de citação; ] termina.
+[ 2 + ]       ! A citação que adiciona 2 é deixada na pilha
+4 swap call . ! 6
+
+! E assim, palavras de ordem mais alta. TONS de palavras de ordem superior.
+2 3 [ 2 + ] dip .s      ! Retira valor do topo da pilha, execute citação, empurre de volta: 4 3
+3 4 [ + ] keep .s       ! Copie o valor do topo da pilha, execute a citação, envie a cópia: 7 4
+1 [ 2 + ] [ 3 + ] bi .s ! Executar cada citação no valor do topo, empurrar os dois resultados: 3 4
+4 3 1 [ + ] [ + ] bi .s ! As citações em um bi podem extrair valores mais profundos da pilha: 4 5 ( 1+3 1+4 )
+1 2 [ 2 + ] bi@ .s      ! Executar a citação no primeiro e segundo valores
+2 [ + ] curry           ! Injeta o valor fornecido no início da citação: [ 2 + ] é deixado na pilha
+
+! Condicionais
+! Qualquer valor é verdadeiro, exceto o valor interno f.
+! m valor interno não existe, mas seu uso não é essencial.
+! Condicionais são palavras de maior ordem, como com os combinadores acima.
+
+5 [ "Five is true" . ] when                     ! Cinco é verdadeiro
+0 [ "Zero is true" . ] when                     ! Zero é verdadeiro
+f [ "F is true" . ] when                        ! Sem saída
+f [ "F is false" . ] unless                     ! F é falso
+2 [ "Two is true" . ] [ "Two is false" . ] if   ! Two é verdadeiro
+
+! Por padrão, as condicionais consomem o valor em teste, mas variantes com asterisco
+! deixe sozinho se é verdadeiro:
+
+5 [ . ] when*      ! 5
+f [ . ] when*      ! Nenhuma saída, pilha vazia, f é consumida porque é falsa
+
+
+! Laços
+! Você adivinhou .. estas são palavras de ordem mais elevada também.
+
+5 [ . ] each-integer               ! 0 1 2 3 4
+4 3 2 1 0 5 [ + . ] each-integer   ! 0 2 4 6 8
+5 [ "Hello" . ] times              ! Hello Hello Hello Hello Hello
+
+! Here's a list:
+{ 2 4 6 8 }                        ! Goes on the stack as one item
+
+! Aqui está uma lista:
+{ 2 4 6 8 } [ 1 + . ] each          ! Exibe 3 5 7 9
+{ 2 4 6 8 } [ 1 + ] map             ! Sai { 3 5 7 9 } na pilha
+
+! Reduzir laços ou criar listas:
+{ 1 2 3 4 5 } [ 2 mod 0 = ] filter  ! Mantém apenas membros da lista para os quais a citação é verdadeira: { 2 4 }
+{ 2 4 6 8 } 0 [ + ] reduce .        ! Como "fold" em linguagens funcionais: exibe 20 (0+2+4+6+8)
+{ 2 4 6 8 } 0 [ + ] accumulate . .  ! Como reduzir, mas mantém os valores intermediários em uma lista: exibe { 0 2 6 12 } então 20
+1 5 [ 2 * dup ] replicate .         ! Repete a citação 5 vezes e coleta os resultados em uma lista: { 2 4 8 16 32 }
+1 [ dup 100 < ] [ 2 * dup ] produce ! Repete a segunda citação até que a primeira retorne como falsa e colete os resultados: { 2 4 8 16 32 64 128 }
+
+! Se tudo mais falhar, uma finalidade geral, enquanto repete:
+1 [ dup 10 < ] [ "Hello" . 1 + ] while  ! Exibe "Hello" 10 vezes
+                                        ! Sim, é difícil de ler
+                                        ! Isso é o que todos esses loops variantes são para
+
+! Variáveis
+! Normalmente, espera-se que os programas Factor mantenham todos os dados na pilha.
+! Usar variáveis ​​nomeadas torna a refatoração mais difícil (e é chamada de Factor por um motivo)
+! Variáveis ​​globais, se você precisar:
+
+SYMBOL: name            ! Cria o nome como uma palavra identificadora
+"Bob" name set-global   ! Sem saída
+name get-global .       ! "Bob"
+
+! Variáveis ​​locais nomeadas são consideradas uma extensão, mas estão disponíveis
+! Em uma citação ..
+[| m n                  ! A citação captura os dois principais valores da pilha em m e n
+ | m n + ]              ! Leia-os
+
+! Ou em uma palavra..
+:: lword ( -- )           ! Note os dois pontos duplos para invocar a extensão da variável lexica
+   2 :> c                 ! Declara a variável imutável c para manter 2
+   c . ;                  ! Imprima isso
+
+! Em uma palavra declarada dessa maneira, o lado de entrada da declaração de pilha
+! torna-se significativo e fornece os valores das variáveis ​​em que os valores da pilha são capturados
+:: double ( a -- result ) a 2 * ;
+
+! Variáveis ​​são declaradas mutáveis ​​ao terminar seu nome com um ponto de exclamação
+:: mword2 ( a! -- x y )   ! Capture o topo da pilha na variável mutável a
+   a                      ! Empurrar a
+   a 2 * a!               ! Multiplique por 2 e armazene o resultado em a
+   a ;                    ! Empurre novo valor de a
+5 mword2                  ! Pilha: 5 10
+
+! Listas e Sequências
+! Vimos acima como empurrar uma lista para a pilha
+
+0 { 1 2 3 4 } nth         ! Acessar um membro específico de uma lista: 1
+10 { 1 2 3 4 } nth        ! Error: índice de sequência fora dos limites
+1 { 1 2 3 4 } ?nth        ! O mesmo que nth se o índice estiver dentro dos limites: 2
+10 { 1 2 3 4 } ?nth       ! Nenhum erro se estiver fora dos limites: f
+
+{ "at" "the" "beginning" } "Append" prefix    ! { "Append" "at" "the" "beginning" }
+{ "Append" "at" "the" } "end" suffix          ! { "Append" "at" "the" "end" }
+"in" 1 { "Insert" "the" "middle" } insert-nth ! { "Insert" "in" "the" "middle" }
+"Concat" "enate" append                       ! "Concatenate" - strings are sequences too
+"Concatenate" "Reverse " prepend              ! "Reverse Concatenate"
+{ "Concatenate " "seq " "of " "seqs" } concat ! "Concatenate seq of seqs"
+{ "Connect" "subseqs" "with" "separators" } " " join  ! "Connect subseqs with separators"
+
+! E se você quiser obter meta, as citações são seqüências e podem ser desmontadas..
+0 [ 2 + ] nth                              ! 2
+1 [ 2 + ] nth                              ! +
+[ 2 + ] \ - suffix                         ! Quotation [ 2 + - ]
+
+
+```
+
+##Pronto para mais?
+
+* [Documentação do Factor](http://docs.factorcode.org/content/article-help.home.html)
diff --git a/pt-br/go-pt.html.markdown b/pt-br/go-pt.html.markdown
index c7339831..31473ee1 100644
--- a/pt-br/go-pt.html.markdown
+++ b/pt-br/go-pt.html.markdown
@@ -16,7 +16,7 @@ A linguagem Go foi criada a partir da necessidade de ver trabalho feito. Não
 forma de resolver os problemas do mundo real.
 
 Tem conceitos familiares de linguagens imperativas com tipagem estática. É 
-rápida a compilar e rápida a executar, acrescentando mecanismos de concorrência
+rápida para compilar e rápida para executar, acrescentando mecanismos de concorrência
 fáceis de entender para tirar partido dos CPUs multi-core de hoje em dia, e tem
 recursos para ajudar com a programação em larga escala.
 
@@ -39,10 +39,10 @@ import (
 )
 
 // Definição de uma função. Main é especial. É o ponto de entrada para o
-// programa executável. Goste-se ou não, a linguagem Go usa chavetas.
+// programa executável. Goste-se ou não, a linguagem Go usa chaves.
 func main() {
     // A função Println envia uma linha para stdout.
-    // É necessário qualifica-la com o nome do pacote, fmt.
+    // É necessário qualificá-la com o nome do pacote, fmt.
     fmt.Println("Olá Mundo!")
 
     // Chama outra função dentro deste pacote.
diff --git a/pt-br/groovy-pt.html.markdown b/pt-br/groovy-pt.html.markdown
index aed23df1..1eab9cc3 100644
--- a/pt-br/groovy-pt.html.markdown
+++ b/pt-br/groovy-pt.html.markdown
@@ -17,7 +17,7 @@ Groovy - Uma linguagem dinâmica para a plataforma Java. [Leia mais aqui.](http:
   Prepara-se:
 
   1) Instale a máquina virtual de Groovy - http://gvmtool.net/
-  2) Intalse o Groovy: gvm install groovy
+  2) Instale o Groovy: gvm install groovy
   3) Inicie o console groovy digitando: groovyConsole
 
 */
diff --git a/pt-br/haxe-pt.html.markdown b/pt-br/haxe-pt.html.markdown
new file mode 100644
index 00000000..13264dec
--- /dev/null
+++ b/pt-br/haxe-pt.html.markdown
@@ -0,0 +1,795 @@
+---
+language: haxe
+filename: LearnHaxe3-br.hx
+contributors:
+    - ["Justin Donaldson", "https://github.com/jdonaldson/"]
+    - ["Dan Korostelev", "https://github.com/nadako/"]
+translators:
+    - ["David Lima", "https://github.com/davelima/"]
+lang: pt-br
+---
+
+Haxe é uma linguagem baseada na web que provê suporte a C++, C#, SWF/ActionScript,
+Java e Neko byte code (também desenvolvida pelo autor de Haxe). Observe que
+este guia é para a versão 3 de Haxe. Alguns pontos do guia são aplicáveis
+para versões anteriores, mas é recomendado que você busque outras referências
+para essas versões.
+
+
+```csharp
+/*
+   Bem vindo ao Aprenda Haxe 3 em 15 minutos. http://www.haxe.org
+   Este é um tutorial executável. Você pode compilar e rodar este tutorial
+   usando o compilador haxe, estando no mesmo diretório de LearnHaxe.hx:
+   $> haxe -main LearnHaxe3 -x out
+
+   Olhe para os sinais de /* e */ em volta desses parágrafos. Nós estamos
+   dentro de um "Comentário multilinha". Nós podemos colocar observações aqui
+   e elas serão ignoradas pelo compilador.
+
+   Comentários multilinha também são utilizados para gerar documentação haxedoc,
+   seguindo o estilo javadoc. Eles serão usados pelo haxedoc se precerem imediatamente
+   uma classe, uma função de uma classe ou uma variável de uma classe.
+
+ */
+
+// Duas barras, como as dessa linha, farão um comentário de linha única.
+
+
+/*
+   Este será o primeiro código haxe de verdade, e está declarando um pacote vazio.
+   Não é necessário usar um pacote, mas ele será útil se você quiser criar
+   um namespace para o seu código (exemplo: org.seuapp.SuaClasse).
+   
+   Omitir a declaração de pacote é a mesma coisa que declarar um pacote vazio.
+ */
+package; // pacote vazio, sem namespace.
+
+/*
+   Pacotes são diretórios que contém módulos. Cada módulo é um arquivo .hx que
+   contém tipos definidos em um pacote. Nomes de pacotes (ex. org.seuapp)
+   devem estar em letras minúsculas, enquanto nomes de módulos devem começar
+   com uma letra maiúscula. Um módulo contem um ou mais tipos, cujo os nomes
+   também devem começar com uma letra maiúscula.
+
+   Exemplo: a classe "org.seuapp.Foo" deve ter a estrutura de diretório org/module/Foo.hx,
+   sendo acessível do diretório do compilador ou caminho da classe.   
+
+   Se você importar código de outros arquivos, isso deve ser declarado antes
+   do restante do código. Haxe disponibiliza várias classes padrões para você
+   começar:
+ */
+import haxe.ds.ArraySort;
+
+// você pode importar várias classes/módulos de uma vez usando "*"
+import haxe.ds.*;
+
+// você pode importar campos estáticos
+import Lambda.array;
+
+// você também pode usar "*" para importar todos os campos estáticos
+import Math.*;
+
+/*
+   Você também pode importar classes de uma forma diferente, habilitando-as para
+   extender a funcionalidade de outras classes, como um "mixin". Falaremos sobre
+   "using" em breve.
+ */
+using StringTools;
+
+/*
+   Typedefs são como variáveis... para tipos. Eles devem ser declarados antes
+   de qualquer código. Veremos isso em breve.
+ */
+typedef FooString = String;
+
+// Typedefs também podem referenciar tipos "estruturais". Também veremos isso em breve.
+typedef FooObject = { foo: String };
+
+/*
+   Esta é a definição da classe. É a classe principal do arquivo, visto que
+   possui o mesmo nome (LearnHaxe3)
+ */
+class LearnHaxe3{
+    /*
+       Se você quiser que um determinado código rode automaticamente, você
+       precisa colocá-lo em uma função estática "main", e especificar a classe
+       nos argumentos do compilador.
+       Nesse caso, nós especificamos a classe "LearnHaxe3" no nos argumentos
+       do compilador acima.
+     */
+    static function main(){
+
+        /*
+           Trace é o método padrão para imprimir expressões haxe na tela.
+           Temos diferentes métodos para conseguir isso em diferentes destinos.
+           Por exemplo: Java, C++, C#, etc. irão imprimir para stdout.
+           Javascript irá imprimir no console.log, e Flash irá imprimir para um
+           TextField anexado. Todos os "traces" imprimem também uma linha em branco
+           por padrão. Por fim, é possível prevenir um trace de ser exibido usando
+           o argumento "--no-traces" no compilador.
+         */
+        trace("Olá mundo, com trace()!");
+
+        /*
+           Trace pode tratar qualquer tipo de valor ou objeto. O método tentará
+           imprimir a representação de uma expressão da melhor forma. Você também
+           pode concatenar strings usando o operador "+":
+         */
+        trace( " Integer: " + 10 + " Float: " + 3.14 + " Boolean: " + true);
+
+        /*
+           Em Haxe, é obrigatório separar expressões no mesmo bloco com ';'. Mas
+           é possível colocar duas expressões na mesma linha, dessa forma:
+         */
+        trace('duas expressões..'); trace('uma linha');
+
+
+        //////////////////////////////////////////////////////////////////
+        // Tipos & Variáveis
+        //////////////////////////////////////////////////////////////////
+        trace("***Tipos & Variáveis***");
+
+        /*
+           Vcoê pode atrelar valores e referências à estruturas usando a
+           palavra-chave "var":
+         */
+        var um_inteiro:Int = 1;
+        trace(um_inteiro + " é o valor de um_inteiro");
+
+
+        /*
+           Haxe é tipada estaticamente, então "um_inteiro" temos que declarar
+           um valor do tipo "Int", e o restante da expressão atrela o valor "1"
+           a esta variável. Em muitos casos, não é necessário declarar o tipo.
+           Aqui, o compilador haxe assume que o tipo de "outro_inteiro" deve
+           ser "Int"
+         */
+        var outro_inteiro = 2;
+        trace(outro_inteiro + " é o valor de outro_inteiro");
+
+        // O método $type() imprime o tipo que o compilador assume:
+        $type(outro_inteiro);
+
+        // Você também pode representar inteiros em hexadecimal:
+        var hex_inteiro = 0xffffff;
+
+        /*
+           Haxe usa precisão de pltaforma para os tamanhos de Int e Float.
+           Ele também usa o comportamento de plataforma para sobrecarga.
+           (É possível ter outros tipos numéricos e comportamentos usando
+           bibliotecas especiais)
+         */
+
+        /*
+           Em adição a valores simples como Integers, Floats e Booleans,
+           Haxe disponibiliza implementações padrões de bibliotecas para
+           dados comuns de estrutura como strings, arrays, lists e maps:
+         */
+
+        var uma_string = "alguma" + 'string';  // strings podem estar entre aspas simples ou duplas
+        trace(uma_string + " é o valor de uma_string");
+
+        /*
+           Strings podem ser "interpoladas" se inserirmos variáveis em
+           posições específicas. A string deve estar entre aspas simples, e as
+           variáveis devem ser precedidas por "$". Expressões podem estar entre
+           ${...}.
+         */
+        var x = 1;
+        var uma_string_interpolada = 'o valor de x é $x';
+        var outra_string_interpolada = 'o valor de x + 1 é ${x + 1}';
+
+        /*
+           Strings são imutáveis, métodos retornarão uma cópia de partes
+           ou de toda a string. (Veja também a classe StringBuf)
+         */
+        var uma_sub_string = a_string.substr(0,4);
+        trace(uma_sub_string + " é o valor de a_sub_string");
+
+        /*
+           Regex também são suportadas, mas não temos espaço suficiente para
+           entrar em muitos detalhes.
+         */
+        var re = ~/foobar/;
+        trace(re.match('foo') + " é o valor de (~/foobar/.match('foo')))");
+
+        /*
+           Arrays são indexadas a partir de zero, dinâmicas e mutáveis. Valores
+           faltando são definidos como null.
+         */
+        var a = new Array<String>(); // um array que contém Strings
+        a[0] = 'foo';
+        trace(a.length + " é o valor de a.length");
+        a[9] = 'bar';
+        trace(a.length + " é o valor de a.length (depois da modificação)");
+        trace(a[3] + " é o valor de a[3]"); // null
+
+        /*
+           Arrays são *genéricas*, então você pode indicar quais valores elas
+           contém usando um parâmetro de tipo:
+         */
+        var a2 = new Array<Int>(); // um Array de Ints
+        var a3 = new Array<Array<String>>(); // um Array de Arrays (de Strings).
+
+        /*
+           Mapas são estruturas simples de chave/valor. A chave e o valor podem
+           ser de qualquer tipo.
+         */
+        var m = new Map<String, Int>();  // As chaves são strings, os valores são Ints.
+        m.set('foo', 4);
+        // Você também pode usar a notação de array;
+        m['bar'] = 5;
+        trace(m.exists('bar') + " é o valor de m.exists('bar')");
+        trace(m.get('bar') + " é o valor de m.get('bar')");
+        trace(m['bar'] + " é o valor de m['bar']");
+
+        var m2 =  ['foo' => 4, 'baz' => 6]; // Syntaxe alternativa de map
+        trace(m2 + " é o valor de m2");
+
+        /*
+           Lembre-se, você pode usar descoberta de tipo. O compilador
+           Haxe irá decidir o tipo da variável assim que você passar um
+           argumento que define um parâmetro de tipo.
+         */
+        var m3 = new Map();
+        m3.set(6, 'baz'); // m3 agora é Map<Int,String>
+        trace(m3 + " é o valor de m3");
+
+        /*
+           Haxe possui mais algumas estruturas de dados padrões no módulo haxe.ds,
+           tais como List, Stack e BalancedTree
+         */
+
+
+        //////////////////////////////////////////////////////////////////
+        // Operadores
+        //////////////////////////////////////////////////////////////////
+        trace("***OPERADORES***");
+
+        // aritmética básica
+        trace((4 + 3) + " é o valor de (4 + 3)");
+        trace((5 - 1) + " é o valor de (5 - 1)");
+        trace((2 * 4) + " é o valor de (2 * 4)");
+        trace((8 / 3) + " é o valor de (8 / 3) (divisão sempre produz Floats)");
+        trace((12 % 4) + " é o valor de (12 % 4)");
+
+
+        // comparação básica
+        trace((3 == 2) + " é o valor de 3 == 2");
+        trace((3 != 2) + " é o valor de 3 != 2");
+        trace((3 >  2) + " é o valor de 3 > 2");
+        trace((3 <  2) + " é o valor de 3 < 2");
+        trace((3 >= 2) + " é o valor de 3 >= 2");
+        trace((3 <= 2) + " é o valor de 3 <= 2");
+
+        // operadores bit-a-bit padrões
+        /*
+        ~       Complemento bit-a-bit unário
+        <<      Deslocamento a esquerda
+        >>      Deslocamento a direita
+        >>>     Deslocamento a direita com preenchimento de 0
+        &       Bit-a-bit AND
+        ^       Bit-a-bit OR exclusivo
+        |       Bit-a-bit OR inclusivo
+        */
+
+        // incrementos
+        var i = 0;
+        trace("Incrementos e decrementos");
+        trace(i++); //i = 1. Pós-incremento
+        trace(++i); //i = 2. Pré-incremento
+        trace(i--); //i = 1. Pós-decremento
+        trace(--i); //i = 0. Pré-decremento
+
+        //////////////////////////////////////////////////////////////////
+        // Estruturas de controle
+        //////////////////////////////////////////////////////////////////
+        trace("***ESTRUTURAS DE CONTROLE***");
+
+        // operadores if
+        var j = 10;
+        if (j == 10){
+            trace("isto é impresso");
+        } else if (j > 10){
+            trace("não é maior que 10, então não é impresso");
+        } else {
+            trace("também não é impresso.");
+        }
+
+        // temos também um if "ternário":
+        (j == 10) ?  trace("igual a 10") : trace("diferente de 10");
+
+        /*
+           Por fim, temos uma outra forma de estrutura de controle que opera
+           e na hora da compilação: compilação condicional.
+         */
+#if neko
+        trace('olá de neko');
+#elseif js
+        trace('olá de js');
+#else
+        trace('olá de outra plataforma!');
+#end
+        /*
+           O código compilado irá mudar de acordo com o alvo de plataforma.
+           Se estivermos compilando para neko (-x ou -neko), só teremos a
+           saudação de neko.
+         */
+
+
+        trace("Loops e Interações");
+
+        // loop while
+        var k = 0;
+        while(k < 100){
+            // trace(counter); // irá iprimir números de 0 a 99
+            k++;
+        }
+
+        // loop do-while
+        var  l = 0;
+        do{
+            trace("do sempre rodará pelo menos uma vez");
+        } while (l > 0);
+
+        // loop for
+        /*
+           Não há loop for no estilo C para Haxe, pois é propenso
+           a erros e não é necessário. Ao invés disso, Haxe possui
+           uma versão muito mais simples e segura que usa Iterators
+           (veremos isso logo mais).
+         */
+        var m = [1,2,3];
+        for (val in m){
+            trace(val + " é o valor de val no array m");
+        }
+
+        // Perceba que você pode iterar em um índice usando uma lista limitada
+        // (veremos isso em breve também)
+        var n = ['foo', 'bar', 'baz'];
+        for (val in 0...n.length){
+            trace(val + " é o valor de val (um índice de n)");
+        }
+
+
+        trace("Compreensões de array");
+
+        // Compreensões de array servem para que você posse iterar um array
+        // enquanto cria filtros e modificações
+        var n_filtrado = [for (val in n) if (val != "foo") val];
+        trace(n_filtrado + " é o valor de n_filtrado");
+
+        var n_modificado = [for (val in n) val += '!'];
+        trace(n_modificado + " é o valor de n_modificado");
+
+        var n_filtrado_e_modificado = [for (val in n) if (val != "foo") val += "!"];
+        trace(n_filtrado_e_modificado + " é o valor de n_filtrado_e_modificado");
+
+        //////////////////////////////////////////////////////////////////
+        // Blocos Switch (Tipos de valor)
+        //////////////////////////////////////////////////////////////////
+        trace("***BLOCOS SWITCH (Tipos de valor)***");
+
+        /*
+           Blocos Switch no Haxe são muito poderosos. Além de funcionar com
+           valores básicos como strings e ints, também funcionam com tipos
+           algébricos em enums (falaremos sobre enums depois).
+           Veja alguns exemplos de valor básico por enquanto:
+         */
+        var meu_cachorro = "fido";
+        var coisa_favorita  = "";
+        switch(meu_cachorro){
+            case "fido" : favorite_thing = "osso";
+            case "rex"  : favorite_thing = "sapato";
+            case "spot" : favorite_thing = "bola de tênis";
+            default     : favorite_thing = "algum brinquedo desconhecido";
+            // case _   : favorite_thing = "algum brinquedo desconhecido"; // mesma coisa que default
+        }
+        // O case "_" acima é um valor "coringa" que
+        // que funcionará para qualquer coisa.
+
+        trace("O nome do meu cachorro é " + meu_cachorro
+                + ", e sua coisa favorita é: "
+                + coisa_favorita);
+
+        //////////////////////////////////////////////////////////////////
+        // Declarações de expressão
+        //////////////////////////////////////////////////////////////////
+        trace("***DECLARAÇÕES DE EXPRESSÃO***");
+
+        /*
+           As declarações de controle em Haxe são muito poderosas pois
+           toda declaração também é uma expressão, considere o seguinte:
+        */
+
+        // declarações if
+        var k = if (true) 10 else 20;
+
+        trace("k igual a ", k); // retorna 10
+
+        var outra_coisa_favorita = switch(meu_cachorro) {
+            case "fido" : "ursinho";
+            case "rex"  : "graveto";
+            case "spot" : "bola de futebol";
+            default     : "algum brinquedo desconhecido";
+        }
+
+        trace("O nome do meu cachorro é " + meu cachorro
+                + ", e sua outra coisa favorita é: "
+                + outra_coisa_favorita);
+
+        //////////////////////////////////////////////////////////////////
+        // Convertendo tipos de valores
+        //////////////////////////////////////////////////////////////////
+        trace("***CONVERTENDO TIPOS DE VALORES***");
+
+        // Você pode converter strings em ints de forma bem fácil.
+
+        // string para int
+        Std.parseInt("0"); // retorna 0
+        Std.parseFloat("0.4"); // retorna 0.4;
+
+        // int para string
+        Std.string(0); // retorna "0";
+        // concatenar com strings irá converter automaticamente em string.
+        0 + "";  // retorna "0";
+        true + ""; // retorna "true";
+        // Veja a documentação de parseamento em Std para mais detalhes.
+
+
+        //////////////////////////////////////////////////////////////////
+        // Lidando com Tipos
+        //////////////////////////////////////////////////////////////////
+
+        /*
+           Como mencionamos anteriormente, Haxe é uma linguagem tipada
+           estaticamente. Tipagem estática é uma coisa maravilhosa. Isto
+           permite autocompletar mais preciso, e pode ser usado para checar
+           completamente o funcionamento de um programa. Além disso, o compilador
+           Haxe é super rápido.
+
+           *ENTRETANTO*, há momentos em que você espera que o compilador apenas
+           deixe algo passar, e não lance um "type error" em um determinado caso.
+
+           Para fazer isso, Haxe tem duas palavras-chave separadas. A primeira
+           é o tipo "Dynamic":
+         */
+        var din: Dynamic = "qualquer tipo de variável, assim como essa string";
+
+        /*
+           Tudo o que você sabe sobre uma variável Dynamic é que o compilador
+           não irá mais se preocupar com o tipo dela. É como uma variável
+           "coringa": você pode usar isso ao invés de qualquer tipo de variável,
+           e você pode atrelar qualquer valor a essa variável.
+
+           A outra (e mais extrema) opção é a palavra-chave "untyped":
+         */
+
+            untyped {
+                var x:Int = 'foo'; // não faz sentido!
+                var y:String = 4; // loucura!
+            }
+
+        /*
+           A palavra-chave "untyped" opera em *blocos* inteiros de código,
+           ignorando qualquer verificação de tipo que seria obrigatória em
+           outros casos. Essa palavra-chave deve ser usada com muita cautela,
+           como em situações limitadas de compilação condicional onde a
+           verificação de tipo pode ser um obstáculo.
+
+           No geral, ignorar verificações de tipo *não* é recomendado. Use
+           os modelos de enum, herança ou estrutural para garantir o correto
+           funcionamento do seu programa. Só quando você tiver certeza de que
+           nenhum desses modelos funcionam no seu caso, você deve usar "Dynamic"
+           ou "untyped".
+         */
+
+        //////////////////////////////////////////////////////////////////
+        // Programação básica orientada a objetos
+        //////////////////////////////////////////////////////////////////
+        trace("***PROGRAMAÇÃO BÁSICA ORIENTADA A OBJETOS***");
+
+
+        /*
+           Cria uma instância da FooClass. As definicções dessas classes
+           estão no final do arquivo.
+         */
+        var instancia_foo = new FooClass(3);
+
+        // lê a variável pública normalmente
+        trace(instancia_foo.variavel_publica + " é o valor de instancia_foo.variavel_publica");
+
+        // nós podemos ler essa variável
+        trace(instancia_foo.publica_leitura + " é o valor de instancia_foo.publica_leitura");
+        // mas não podemos escrever nela
+        // instancia_foo.publica_leitura = 4; // isso irá causar um erro se descomentado:
+        // trace(instancia_foo.public_escrita); // e isso também.
+
+        // chama o método toString:
+        trace(instancia_foo + " é o valor de instancia_foo");
+        // mesma coisa:
+        trace(instancia_foo.toString() + " é o valor de instancia_foo.toString()");
+
+
+        /*
+           A instancia_foo é do tipo "FooClass", enquanto acceptBarInstance
+           é do tipo BarClass. Entretanto, como FooClass extende BarClass,
+           ela é aceita.
+         */
+        BarClass.acceptBarInstance(instancia_foo);
+
+        /*
+           As classes abaixo têm mais alguns exemplos avançados, o método
+           "example()" executará esses exemplos aqui:
+         */
+        SimpleEnumTest.example();
+        ComplexEnumTest.example();
+        TypedefsAndStructuralTypes.example();
+        UsingExample.example();
+
+    }
+
+}
+
+/*
+   Essa é a "classe filha" do classe principal LearnHaxe3
+ */
+class FooClass extends BarClass implements BarInterface{
+    public var variavel_publica:Int; // variáveis públicas são acessíveis de qualquer lugar
+    public var publica_leitura (default, null): Int; // somente leitura pública habilitada
+    public var publica_escrita (null, default): Int; // somente escrita pública habilitada
+    public var property (get, set): Int; // use este estilo para habilitar getters e setters
+
+    // variáveis privadas não estão disponíveis fora da classe.
+    // veja @:allow para formas de fazer isso.
+    var _private:Int; // variáveis são privadas se não forem marcadas como públicas
+
+    // um construtor público
+    public function new(arg:Int){
+        // chama o construtor do objeto pai, já que nós extendemos a BarClass:
+        super();
+
+        this.variavel_publica = 0;
+        this._private = arg;
+
+    }
+
+    // getter para _private
+    function get_property() : Int {
+        return _private;
+    }
+
+    // setter para _private
+    function set_property(val:Int) : Int {
+        _private = val;
+        return val;
+    }
+
+    // função especial que é chamada sempre que uma instância é convertida em string.
+    public function toString(){
+        return _private + " com o método toString()!";
+    }
+
+    // essa classe precisa ter essa função definida, pois ela implementa
+    // a interface BarInterface
+    public function baseFunction(x: Int) : String{
+        // converte o int em string automaticamente
+        return x + " foi passado pela baseFunction!";
+    }
+}
+
+/*
+    Uma classe simples para extendermos
+*/
+class BarClass {
+    var base_variable:Int;
+    public function new(){
+        base_variable = 4;
+    }
+    public static function acceptBarInstance(b:BarClass){
+    }
+}
+
+/*
+    Uma interface simples para implementarmos
+*/
+interface BarInterface{
+    public function baseFunction(x:Int):String;
+}
+
+//////////////////////////////////////////////////////////////////
+// Declarações Enum e Switch
+//////////////////////////////////////////////////////////////////
+
+/*
+   Enums no Haxe são muito poderosos. Resumidamente, enums são
+   um tipo com um número limitado de estados:
+ */
+
+enum SimpleEnum {
+    Foo;
+    Bar;
+    Baz;
+}
+
+//   Uma classe que faz uso desse enum:
+
+class SimpleEnumTest{
+    public static function example(){
+        var e_explicit:SimpleEnum = SimpleEnum.Foo; // você pode especificar o nome "completo"
+        var e = Foo; // bas descoberta de tipo também funciona.
+        switch(e){
+            case Foo: trace("e era Foo");
+            case Bar: trace("e era Bar");
+            case Baz: trace("e era Baz"); // comente esta linha e teremos um erro.
+        }
+
+        /*
+           Isso não parece tão diferente de uma alteração simples de valor em strings.
+           Entretanto, se nós não incluirmos *todos* os estados, o compilador
+           reclamará. Você pode testar isso comentando a linha mencionada acima.
+           
+           Você também pode especificar um valor padrão (default) para enums:
+         */
+        switch(e){
+            case Foo: trace("e é Foo outra vez");
+            default : trace("default funciona aqui também");
+        }
+    }
+}
+
+/*
+    Enums vão muito mais além que estados simples, nós também
+    podemos enumerar *construtores*, mas nós precisaremos de um
+    exemplo mais complexo de enum:
+ */
+enum ComplexEnum{
+    IntEnum(i:Int);
+    MultiEnum(i:Int, j:String, k:Float);
+    SimpleEnumEnum(s:SimpleEnum);
+    ComplexEnumEnum(c:ComplexEnum);
+}
+// Observação: O enum acima pode incluir *outros* enums também, incluindo ele mesmo!
+// Observação: Isto é o que chamamos de *Tipos de dado algébricos* em algumas outras linguagens.
+
+class ComplexEnumTest{
+    public static function example(){
+        var e1:ComplexEnum = IntEnum(4); // especificando o parâmetro enum
+        /*
+           Agora nós podemos usar switch no enum, assim como extrair qualquer
+           parâmetros que ele possa ter.
+         */
+        switch(e1){
+            case IntEnum(x) : trace('$x foi o parâmetro passado para e1');
+            default: trace("Isso não deve ser impresso");
+        }
+
+        // outro parâmetro aqui que também é um enum... um enum enum?
+        var e2 = SimpleEnumEnum(Foo);
+        switch(e2){
+            case SimpleEnumEnum(s): trace('$s foi o parâmetro passado para e2');
+            default: trace("Isso não deve ser impresso");
+        }
+
+        // enum dentro de enum dentro de enum
+        var e3 = ComplexEnumEnum(ComplexEnumEnum(MultiEnum(4, 'hi', 4.3)));
+        switch(e3){
+            // Você pode buscar por certos enums aninhados especificando-os
+            // explicitamente:
+            case ComplexEnumEnum(ComplexEnumEnum(MultiEnum(i,j,k))) : {
+                trace('$i, $j, e $k foram passados dentro desse monstro aninhado.');
+            }
+            default: trace("Isso não deve ser impresso");
+        }
+        /*
+           Veja outros "tipos de dado algébricos" (GADT, do inglês) para mais
+           detalhes sobre o porque eles são tão úteis.
+         */
+    }
+}
+
+class TypedefsAndStructuralTypes {
+    public static function example(){
+        /*
+           Aqui nós usaremos tipos typedef, ao invés de tipos base.
+           Lá no começo, nós definimos que o tipo "FooString" é um tipo "String". 
+         */
+        var t1:FooString = "alguma string";
+
+        /*
+           Aqui nós usamos typedefs para "tipos estruturais" também. Esses tipos
+           são definidos pela sua estrutura de campos, não por herança de classe.
+           Aqui temos um objeto anônimo com um campo String chamado "foo":
+         */
+
+        var anon_obj = { foo: 'hi' };
+
+        /*
+           A variável anon_obj não tem um tipo declarado, e é um objeto anônimo
+           de acordo com o compilador. Entretanto, lembra que lá no início nós
+           declaramos a typedef FooObj? Visto que o anon_obj tem a mesma estrutura,
+           nós podemos usar ele em qualquer lugar que um "FooObject" é esperado.
+         */
+
+        var f = function(fo:FooObject){
+            trace('$fo foi passado para esta função');
+        }
+        f(anon_obj); // chama a assinatura de FooObject com anon_obj.
+
+        /*
+           Note que typedefs podem ter campos opcionais também, marcados com "?"
+
+           typedef OptionalFooObj = {
+                ?optionalString: String,
+                requiredInt: Int
+           }
+         */
+
+        /*
+           Typedefs também funcionam com compilação condicional. Por exemplo,
+           nós poderíamos ter incluído isso no topo deste arquivo:
+
+#if( js )
+        typedef Surface = js.html.CanvasRenderingContext2D;
+#elseif( nme )
+        typedef Surface = nme.display.Graphics;
+#elseif( !flash9 )
+        typedef Surface = flash8.MovieClip;
+#elseif( java )
+        typedef Surface = java.awt.geom.GeneralPath;
+#end
+
+        E teríamos apenas um tipo "Surface" para funcionar em todas
+        essas plataformas.
+        */
+    }
+}
+
+class UsingExample {
+    public static function example() {
+
+        /*
+           A palavra-chave "using" é um tipo especial de import de classe que
+           altera o comportamento de qualquer método estático na classe.
+
+           Neste arquivo, nós aplicamos "using" em "StringTools", que contém
+           alguns métodos estáticos para tratar tipos String.
+         */
+        trace(StringTools.endsWith("foobar", "bar") + " deve ser verdadeiro!");
+
+        /*
+           Com um import "using", o primeiro argumento é extendido com o método.
+           O que isso significa? Bem, como "endsWith" tem um primeiro argumento
+           de tipo "String", isso significa que todos os tipos "String" agora
+           possuem o método "endsWith":
+         */
+        trace("foobar".endsWith("bar") + " deve ser verdadeiro!");
+
+        /*
+           Essa técnica habilita uma grande quantidade de expressões para certos
+           tipos, e limita o escopo de modificações para um único arquivo.
+
+           Note que a instância String *não* é modificada em tempo de execução.
+           O novo método adicionado não é uma parte da instância anexada, e o
+           compilador ainda irá gerar o código equivalente ao método estático.
+         */
+      }
+
+}
+
+```
+Isso foi apenas o começo do que Haxe pode fazer. Para uma documentação de todos
+os recursos de Haxe, veja o [manual](https://haxe.org/manual) e a
+[documentação de API](https://api.haxe.org/). Para um diretório de bibliotecas de terceiros
+disponíveis, veja a [Haxelib](https://lib.haxe.org/)
+
+Para tópicos mais avançados, dê uma olhada em:
+
+* [Tipos abstratos](https://haxe.org/manual/types-abstract.html)
+* [Macros](https://haxe.org/manual/macro.html)
+* [Recursos do compilador](https://haxe.org/manual/cr-features.html)
+
+Por fim, participe do [forum Haxe](https://community.haxe.org/),
+ou no IRC [#haxe onfreenode](http://webchat.freenode.net/), ou no
+[Chat Gitter](https://gitter.im/HaxeFoundation/haxe).
diff --git a/pt-br/html-pt.html.markdown b/pt-br/html-pt.html.markdown
new file mode 100644
index 00000000..22b7836e
--- /dev/null
+++ b/pt-br/html-pt.html.markdown
@@ -0,0 +1,125 @@
+---
+language: html
+filename: learnhtml-br.txt
+contributors:
+    - ["Christophe THOMAS", "https://github.com/WinChris"]
+translators:
+    - ["Robert Steed", "https://github.com/robochat"]
+lang: pt-br
+---
+
+HTML é um acrônimo de HyperText Markup Language(Linguagem de Marcação de HiperTexto).
+É uma linguagem que nos permite escrever páginas para a "world wide web".
+É uma linguagem de marcação, nos permite escrever páginas na web usando código
+para indicar como o texto e os dados serão ser exibidos.
+De fato, arquivos HTML são simples arquivos de texto.
+O que seria marcação? É um método de organização dos dados da página envolvidos
+por abertura e fechamento de tags.
+Essa marcação serve para dar significado ao texto que envolve.
+Assim como outras linguagens, o HTML tem diversas versões. Aqui falaremos sobre o HTML5.
+
+**NOTA :**  Você pode testar diferentes tags e elementos conforme progride os
+tutoriais em sites como [codepen](http://codepen.io/pen/) podendo ver seus efeitos,
+entendendo como funcionam e se familiarizando com a linguagem.
+Esse artigo tem seu foco principal na sintaxe do HTML e algumas dicas úteis.
+
+
+```html
+<!-- Comentários são envolvidos conforme essa linha! -->
+
+<!-- #################### As Tags #################### -->
+
+<!-- Aqui está um exemplo de arquivo HTML que iremos analisar. -->
+
+<!doctype html>
+	<html>
+		<head>
+			<title>Meu Site</title>
+		</head>
+		<body>
+			<h1>Olá, mundo!</h1>
+			<a href = "http://codepen.io/anon/pen/xwjLbZ">Venha ver como isso aparece</a>
+			<p>Esse é um parágrafo.</p>
+			<p>Esse é um outro parágrafo.</p>
+			<ul>
+				<li>Esse é um item de uma lista não enumerada (bullet list)</li>
+				<li>Esse é um outro item</li>
+				<li>E esse é o último item da lista</li>
+			</ul>
+		</body>
+	</html>
+
+<!-- Um arquivo HTML sempre inicia indicando ao navegador que é uma página HTML. -->
+<!doctype html>
+
+<!-- Após isso, inicia abrindo a tag <html>. -->
+<html>
+
+<!-- Essa tag deverá ser fechada ao final do arquivo com </html>. -->
+</html>
+
+<!-- Não deverá haver nada após o fechamento desta tag. -->
+
+<!-- Entre a abertura e o fechamento das tags <html></html>, nós encontramos: -->
+
+<!-- Um cabeçalho definido por <head> (deverá ser fechado com </head>). -->
+<!-- O cabeçalho contém uma descrição e algumas informações adicionais que não serão exibidas; chamam-se metadados. -->
+
+<head>
+	<title>Meu Site</title><!-- Essa tag <title> indica ao navegador o título a ser exibido na barra de títulos e no nome da aba. -->
+</head>
+
+<!-- Após a seção <head>, nós encontramos a tag - <body> -->
+<!-- Até esse ponto, nada descrito irá aparecer na janela do browser. -->
+<!-- Nós deveremos preencher o body(corpo) com o conteúdo a ser exibido. -->
+
+<body>
+	<h1>Olá, mundo!</h1> <!-- A tag h1 cria um título. -->
+  <!-- Há também subtítulos do <h1>, o mais importante, aos mais precisos (h6). -->
+  <a href = "http://codepen.io/anon/pen/xwjLbZ">Venha ver o que isso exibe</a> <!-- Um hiperlink ao endereço preenchido no atributo href="" -->
+	<p>Esse é um parágrafo.</p> <!-- A tag <p> permite incluir um texto na página. -->
+	<p>Esse é um outro parágrafo.</p>
+	<ul> <!-- A tag <ul> cria uma lista de marcação. -->
+	<!-- Para criar uma lista ordenada, devemos usar <ol>, exibindo 1. para o primeiro elemento, 2. para o segundo, etc. -->
+		<li>Esse é um item de uma lista não-enumerada.</li>
+		<li>Esse é um outro item</li>
+		<li>E esse é o último item da lista</li>
+	</ul>
+</body>
+
+<!-- E é isso, criar um arquivo HTML pode ser bem simples. -->
+
+<!-- Também é possível adicionar alguns outros tipos de tags HTML. -->
+
+<!-- Para inserir uma imagem. -->
+<img src="http://i.imgur.com/XWG0O.gif"/> <!-- O caminho da imagem deve ser indicado usando o atributo src="" -->
+<!-- O caminho da imagem pode ser uma URL ou até mesmo o caminho do arquivo no seu computador. -->
+
+<!-- Também é possível criar uma tabela. -->
+
+<table> <!-- Iniciamos a tabela com a tag <table>. -->
+	<tr> <!-- <tr> nos permite criar uma linha. -->
+		<th>Primeiro cabeçalho</th> <!-- <th> nos permite criar o título de uma coluna. -->
+		<th>Segundo cabeçalho</th>
+	</tr>
+	<tr>
+		<td>Primeira linha, primeira coluna</td> <!-- <td> nos permite criar uma célula da tabela. -->
+		<td>Primeira linha, segunda coluna</td>
+	</tr>
+	<tr>
+		<td>Segunda linha, primeira coluna</td>
+		<td>Segunda linha, segunda coluna</td>
+	</tr>
+</table>
+
+```
+
+## Uso
+
+HTML é escrito em arquivos com a extensão `.html` ou `.htm`. Seu mime type é `text/html`.
+
+## Para aprender mais
+
+* [wikipedia](https://en.wikipedia.org/wiki/HTML)
+* [HTML tutorial](https://developer.mozilla.org/en-US/docs/Web/HTML)
+* [W3School](http://www.w3schools.com/html/html_intro.asp)
diff --git a/pt-br/latex-pt.html.markdown b/pt-br/latex-pt.html.markdown
index a9ed566e..103af28e 100644
--- a/pt-br/latex-pt.html.markdown
+++ b/pt-br/latex-pt.html.markdown
@@ -30,7 +30,7 @@ $ Todo comando LaTeX começa com uma barra invertida (\)
 % Em seguida definimos os pacotes que o documento usa.
 % Se você quiser incluir gráficos, texto colorido, ou código fonte de outra
 % linguagem em outro arquivo em seu documento, você precisa ampliar as
-% capacidade do LaTeX. Isso é feito adicionando-se pacotes.
+% capacidades do LaTeX. Isso é feito adicionando-se pacotes.
 % Serão incluídos os pacotes float e caption para imagens e hyperref
 % para links.
 \usepackage{caption}
@@ -46,7 +46,7 @@ Svetlana Golubeva}
 \date{\today}
 \title{Aprenda \LaTeX \hspace{1pt} em Y Minutos!}
 
-% Agora estamos pronto para começar o documento
+% Agora estamos prontos para começar o documento
 % Tudo antes dessa linha é chamado "preâmbulo".
 \begin{document}
 % Se informarmos os campos author (autores), date (data), "title" (título),
@@ -55,7 +55,7 @@ Svetlana Golubeva}
 % Se tivermos seções, poderemos criar uma tabela de conteúdo. Para isso,
 % o documento deve ser compilado duas vezes, para que tudo apareça na ordem
 % correta.
-% É uma voa prática separar a tabela de conteúdo do corpo do documento. Para
+% É uma boa prática separar a tabela de conteúdo do corpo do documento. Para
 % isso usa-se o comando \newpage
 \newpage
 \tableofcontents
diff --git a/pt-br/less-pt.html.markdown b/pt-br/less-pt.html.markdown
new file mode 100644
index 00000000..f6cf2d71
--- /dev/null
+++ b/pt-br/less-pt.html.markdown
@@ -0,0 +1,390 @@
+---
+language: less
+filename: learnless-br.less
+contributors:
+  - ["Saravanan Ganesh", "http://srrvnn.me"]
+
+lang: pt-br
+---
+
+Less é um pré-processador de CSS, que adiciona recursos como variáveis, aninhamento, mixins e muito mais.
+Less (e outros pré-processadores, como o [Sass](http://sass-lang.com/)) ajudam os desenvolvedores a escreverem código que pode ser mantido e DRY (não se repita).
+
+```css
+
+
+//Comentários de linha única são removidos quando Less é compilado para CSS.
+
+/*Comentários de várias linhas são preservados.*/
+
+
+
+/* Variáveis
+==============================*/
+
+
+/* Você pode armazenar um valor de CSS (como uma cor) em uma variável.
+   Use o símbolo '@' para criar uma variável. */
+
+@primary-color: #a3a4ff;
+@secondary-color: #51527f;
+@body-font: 'Roboto', sans-serif;
+
+/* Você pode usar as variáveis ​​em toda a sua folha de estilo.
+   Agora, se você quiser alterar uma cor, só precisa fazer a alteração uma vez. */
+
+body {
+	background-color: @primary-color;
+	color: @secondary-color;
+	font-family: @body-font;
+}
+
+/* Isso compilará para: */
+
+body {
+	background-color: #a3a4ff;
+	color: #51527F;
+	font-family: 'Roboto', sans-serif;
+}
+
+
+/* Isso é muito mais sustentável do que ter que mudar a cor
+   cada vez que aparece em toda a sua folha de estilo. */
+
+
+
+/* Mixins
+==============================*/
+
+
+/* Se você achar que está escrevendo o mesmo código para mais de um
+   elemento, você pode querer reutilizá-lo facilmente. */
+
+.center {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+}
+
+/* Você pode usar o mixin simplesmente adicionando o seletor como um estilo. */
+
+div {
+	.center;
+	background-color: @primary-color;
+}
+
+/* Que compilaria para: */
+
+.center {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+  left: 0;
+  right: 0;
+}
+div {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+	background-color: #a3a4ff;
+}
+
+/* Você pode omitir o código mixin de ser compilado adicionando parênteses
+   depois do seletor. */
+
+.center() {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+  left: 0;
+  right: 0;
+}
+
+div {
+  .center;
+  background-color: @primary-color;
+}
+
+/* Que compilaria para: */
+div {
+  display: block;
+  margin-left: auto;
+  margin-right: auto;
+  left: 0;
+  right: 0;
+  background-color: #a3a4ff;
+}
+
+
+
+/* Aninhamento
+==============================*/
+
+
+/* Less permite aninhar seletores nos seletores. */
+
+ul {
+	list-style-type: none;
+	margin-top: 2em;
+
+	li {
+		background-color: #f00;
+	}
+}
+
+/* '&' será substituído pelo seletor pai. */
+/* Você também pode aninhar pseudo-classes. */
+/* Tenha em mente que o aninhamento excessivo tornará seu código menos sustentável.
+   As melhores práticas recomendam não ultrapassar 3 níveis de profundidade ao aninhar.
+   Por exemplo: */
+
+ul {
+  list-style-type: none;
+  margin-top: 2em;
+
+  li {
+    background-color: red;
+
+    &:hover {
+      background-color: blue;
+    }
+
+    a {
+      color: white;
+    }
+  }
+}
+
+/* Compila para: */
+
+ul {
+  list-style-type: none;
+  margin-top: 2em;
+}
+
+ul li {
+  background-color: red;
+}
+
+ul li:hover {
+  background-color: blue;
+}
+
+ul li a {
+  color: white;
+}
+
+
+
+/* Functions
+==============================*/
+
+
+/* Less fornece funções que podem ser usadas para realizar uma variedade de
+   tarefas. Considere o seguinte: */
+
+/* Funções podem ser invocadas usando seu nome e passando os
+   argumentos requeridos. */
+
+body {
+  width: round(10.25px);
+}
+
+.header {
+	background-color: lighten(#000, 0.5);
+}
+
+.footer {
+  background-color: fadeout(#000, 0.25)
+}
+
+/* Compila para: */
+
+body {
+  width: 10px;
+}
+
+.header {
+  background-color: #010101;
+}
+
+.footer {
+  background-color: rgba(0, 0, 0, 0.75);
+}
+
+/* Você também pode definir suas próprias funções. Funções são muito semelhantes às
+   mixins. Ao tentar escolher entre uma função ou a um mixin, lembre-se
+   que mixins são melhores para gerar CSS, enquanto as funções são melhores para
+   lógica que pode ser usada em todo o seu código Less. Os exemplos na
+   seção 'Operadores Matemáticos' são candidatos ideais para se tornarem funções reutilizáveis. */
+
+/* Esta função calcula a média de dois números: */
+
+.average(@x, @y) {
+  @average-result: ((@x + @y) / 2);
+}
+
+div {
+  .average(16px, 50px); // "chama" o mixin
+  padding: @average-result;    // use seu valor de "retorno"
+}
+
+/* Compila para: */
+
+div {
+  padding: 33px;
+}
+
+
+
+/* Estender (herança)
+==============================*/
+
+
+/* Estender é uma maneira de compartilhar as propriedades de um seletor com outro. */
+
+.display {
+  height: 50px;
+}
+
+.display-success {
+  &:extend(.display);
+	border-color: #22df56;
+}
+
+/* Compila para: */
+
+.display,
+.display-success {
+  height: 50px;
+}
+.display-success {
+  border-color: #22df56;
+}
+
+/* Estender uma instrução CSS é preferível para criar um mixin
+   por causa da maneira como agrupa as classes que compartilham
+   o mesmo estilo base. Se isso foi feito com um mixin, as propriedades
+   seriam duplicadas para cada declaração que
+   chamou o mixin. Embora isso não afete o seu fluxo de trabalho,
+   adicione o inchaço desnecessário aos arquivos criados pelo compilador Less. */
+
+
+
+/* Parciais e Importações
+==============================*/
+
+
+/* Less permite criar arquivos parciais. Isso pode ajudar a manter o seu
+   código Less modularizado. Arquivos parciais convencionalmente começam com um '_',
+   por exemplo. _reset.less. e são importados para um arquivo less principal que recebe
+   o css compilado. */
+
+/* Considere o seguinte CSS que vamos colocar em um arquivo chamado _reset.less */
+
+html,
+body,
+ul,
+ol {
+  margin: 0;
+  padding: 0;
+}
+
+/* Less disponibiliza @import que podem ser usadas para importar parciais em um arquivo.
+   Isso difere da declaração tradicional CSS @import que faz
+   outra solicitação HTTP para buscar o arquivo importado. Less leva o
+   arquivo importado e combina com o código compilado. */
+
+@import 'reset';
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+/* Compila para: */
+
+html, body, ul, ol {
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-size: 16px;
+  font-family: Helvetica, Arial, Sans-serif;
+}
+
+
+
+/* Operações Matemáticas
+==============================*/
+
+
+/* Less fornece os seguintes operadores: +, -, *, / e %. Estes podem
+   ser úteis para calcular valores diretamente nos seus arquivos Less
+   para usar valores que você já calculou manualmente. Abaixo está um exemplo
+   de como configurar um design simples de duas colunas. */
+
+@content-area: 960px;
+@main-content: 600px;
+@sidebar-content: 300px;
+
+@main-size: @main-content / @content-area * 100%;
+@sidebar-size: @sidebar-content / @content-area * 100%;
+@gutter: 100% - (@main-size + @sidebar-size);
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: @main-size;
+}
+
+.sidebar {
+  width: @sidebar-size;
+}
+
+.gutter {
+  width: @gutter;
+}
+
+/* Compila para: */
+
+body {
+  width: 100%;
+}
+
+.main-content {
+  width: 62.5%;
+}
+
+.sidebar {
+  width: 31.25%;
+}
+
+.gutter {
+  width: 6.25%;
+}
+
+
+```
+
+## Pratique Less
+
+Se você quiser praticar com Less no seu navegador, confira: * [Codepen](http://codepen.io/) * [LESS2CSS](http://lesscss.org/less-preview/)
+
+## Compatibilidade
+
+Less pode ser usado em qualquer projeto, desde que você tenha um programa para compilá-lo em CSS. Você deseja verificar
+se o CSS que você está usando é compatível com seus navegadores de destino.
+
+[QuirksMode CSS](http://www.quirksmode.org/css/) e [CanIUse](http://caniuse.com) são ótimos recursos para verificar a compatibilidade.
+
+## Leitura adicional
+* [Documentação Oficial](http://lesscss.org/features/)
+* [Less CSS - Guia do iniciante](http://www.hongkiat.com/blog/less-basic/)
diff --git a/pt-br/make-pt.html.markdown b/pt-br/make-pt.html.markdown
new file mode 100644
index 00000000..cbdebde7
--- /dev/null
+++ b/pt-br/make-pt.html.markdown
@@ -0,0 +1,243 @@
+---

+category: tool

+tool: make

+contributors:

+    - ["Robert Steed", "https://github.com/robochat"]

+    - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]

+filename: Makefile

+

+lang: pt-br

+---

+

+Um Makefile define um gráfico de regras para criar um alvo (ou alvos). Sua finalidade é fazer o mínimo de trabalho necessário para atualizar um alvo para a versão mais recente da fonte. Famosamente escrito ao longo de um fim de semana por Stuart Feldman em 1976, ainda é amplamente usada (particularmente no Unix e no Linux) apesar de muitos concorrentes e críticas.

+

+Existem muitas variedades de make na existência, no entanto, este artigo pressupõe que estamos usando o GNU make, que é o padrão no Linux.

+

+```make

+

+# Comentários podem ser escritos assim.

+

+# O arquivo deve ser nomeado Makefile e então pode ser executado como `make <alvo>`.

+# Caso contrário, nós usamos `make -f "nome-do-arquivo" <alvo>`.

+

+# Aviso - use somente TABS para identar em Makefiles, nunca espaços!

+

+#-----------------------------------------------------------------------

+# Noções básicas

+#-----------------------------------------------------------------------

+

+# Regras são do formato

+# alvo: <pré-requisito>

+# onde os pré-requisitos são opcionais.

+

+# Uma regra - esta regra só será executada se o arquivo0.txt não existir.

+arquivo0.txt:

+	echo "foo" > arquivo0.txt

+	# Mesmo os comentários nestas seções da 'receita' são passados ​​para o shell.

+	# Experimentar `make arquivo0.txt` or simplyou simplesmente `make` - primeira regra é o padrão.

+

+# Esta regra só será executada se arquivo0.txt for mais recente que arquivo1.txt.

+arquivo1.txt: arquivo0.txt

+	cat arquivo0.txt > arquivo1.txt

+	# se as mesmas regras de citação do shell.

+	@cat arquivo0.txt >> arquivo1.txt

+	# @ pára o comando de ser ecoado para stdout.

+	-@echo 'hello'

+	# - significa que make continuará em caso de erro.

+	# Experimentar `make arquivo1.txt` na linha de comando.

+

+# Uma regra pode ter vários alvos e vários pré-requisitos

+arquivo2.txt arquivo3.txt: arquivo0.txt arquivo1.txt

+	touch arquivo2.txt

+	touch arquivo3.txt

+

+# Make vai reclamar sobre várias receitas para a mesma regra. Esvaziar

+# receitas não contam e podem ser usadas para adicionar novas dependências.

+

+#-----------------------------------------------------------------------

+# Alvos falsos

+#-----------------------------------------------------------------------

+

+# Um alvo falso. Qualquer alvo que não seja um arquivo.

+# Ele nunca será atualizado, portanto, o make sempre tentará executá-lo.

+all: maker process

+

+# Podemos declarar as coisas fora de ordem.

+maker:

+	touch ex0.txt ex1.txt

+

+# Pode evitar quebrar regras falsas quando um arquivo real tem o mesmo nome

+.PHONY: all maker process

+# Este é um alvo especial. Existem vários outros.

+

+# Uma regra com dependência de um alvo falso sempre será executada

+ex0.txt ex1.txt: maker

+

+# Alvos falsos comuns são: todos fazem instalação limpa ...

+

+#-----------------------------------------------------------------------

+# Variáveis ​​Automáticas e Curingas

+#-----------------------------------------------------------------------

+

+process: Arquivo*.txt	# Usando um curinga para corresponder nomes de arquivos

+	@echo $^	# $^ é uma variável que contém a lista de pré-requisitos

+	@echo $@	# imprime o nome do alvo

+	#(fpara várias regras alvo, $@ é o que causou a execução da regra)

+	@echo $<	# o primeiro pré-requisito listado

+	@echo $?	# somente as dependências que estão desatualizadas

+	@echo $+	# todas as dependências, incluindo duplicadas (ao contrário do normal)

+	#@echo $|	# todos os pré-requisitos 'somente pedidos'

+

+# Mesmo se dividirmos as definições de dependência de regra, $^ vai encontrá-los

+process: ex1.txt arquivo0.txt

+# ex1.txt será encontrado, mas arquivo0.txt será desduplicado.

+

+#-----------------------------------------------------------------------

+# Padrões

+#-----------------------------------------------------------------------

+

+# Pode ensinar make a converter certos arquivos em outros arquivos.

+

+%.png: %.svg

+	inkscape --export-png $^

+

+# As regras padrões só farão qualquer coisa se decidirem criar o alvo.

+

+# Os caminhos de diretório são normalmente ignorados quando as regras de

+# padrões são correspondentes. Mas make tentará usar a regra mais

+# apropriada disponível.

+small/%.png: %.svg

+	inkscape --export-png --export-dpi 30 $^

+

+# make utilizará a última versão para uma regra de padrão que encontrar.

+%.png: %.svg

+	@echo esta regra é escolhida

+

+# No entanto, o make usará a primeira regra padrão que pode se tornar o alvo

+%.png: %.ps

+	@echo esta regra não é escolhida se *.svg and *.ps estão ambos presentes

+

+# make já tem algumas regras padrões embutidas. Por exemplo, ele sabe

+# como transformar arquivos *.c em arquivos *.o.

+

+# Makefiles antigos podem usar regras de sufixo em vez de regras padrões

+.png.ps:

+	@echo essa regra é semelhante a uma regra de padrão.

+

+# make sobre a regra de sufixo

+.SUFFIXES: .png

+

+#-----------------------------------------------------------------------

+# Variáveis

+#-----------------------------------------------------------------------

+# aka. macros

+

+# As variáveis ​​são basicamente todos os tipos de string

+

+name = Ted

+name2="Sarah"

+

+echo:

+	@echo $(name)

+	@echo ${name2}

+	@echo $name    # Isso não funcionará, tratado como $ (n)ame.

+	@echo $(name3) # Variáveis ​​desconhecidas são tratadas como strings vazias.

+

+# Existem 4 lugares para definir variáveis.

+# Em ordem de prioridade, do maior para o menor:

+# 1: argumentos de linha de comando

+# 2: Makefile

+# 3: variáveis ​​de ambiente do shell - faça importações automaticamente.

+# 4: make tem algumas variáveis ​​predefinidas

+

+name4 ?= Jean

+# Somente defina a variável se a variável de ambiente ainda não estiver definida.

+

+override name5 = David

+# Pára os argumentos da linha de comando de alterar essa variável.

+

+name4 +=grey

+# Anexar valores à variável (inclui um espaço).

+

+# Valores variáveis ​​específicos de padrões (extensão GNU).

+echo: name2 = Sara # Verdadeiro dentro da regra de correspondência

+	# e também dentro de suas recursivas dependências

+	# (exceto que ele pode quebrar quando seu gráfico ficar muito complicado!)

+

+# Algumas variáveis ​​definidas automaticamente pelo make

+echo_inbuilt:

+	echo $(CC)

+	echo ${CXX}

+	echo $(FC)

+	echo ${CFLAGS}

+	echo $(CPPFLAGS)

+	echo ${CXXFLAGS}

+	echo $(LDFLAGS)

+	echo ${LDLIBS}

+

+#-----------------------------------------------------------------------

+# Variáveis 2

+#-----------------------------------------------------------------------

+

+# O primeiro tipo de variáveis ​​é avaliado a cada vez que elas são usadas.

+# TIsso pode ser caro, então existe um segundo tipo de variável que é

+# avaliado apenas uma vez. (Esta é uma extensão do GNU make)

+

+var := hello

+var2 ::=  $(var) hello

+#:= e ::= são equivalentes.

+

+# Essas variáveis ​​são avaliadas procedimentalmente (na ordem em que

+# aparecem), quebrando assim o resto da línguagem!

+

+# Isso não funciona

+var3 ::= $(var4) and good luck

+var4 ::= good night

+

+#-----------------------------------------------------------------------

+# Funções

+#-----------------------------------------------------------------------

+

+# make tem muitas funções disponíveis.

+

+sourcefiles = $(wildcard *.c */*.c)

+objectfiles = $(patsubst %.c,%.o,$(sourcefiles))

+

+# O formato é $(func arg0,arg1,arg2...)

+

+# Alguns exemplos

+ls:	* src/*

+	@echo $(filter %.txt, $^)

+	@echo $(notdir $^)

+	@echo $(join $(dir $^),$(notdir $^))

+

+#-----------------------------------------------------------------------

+# Diretivas

+#-----------------------------------------------------------------------

+

+# Inclua outros makefiles, úteis para código específico da plataforma

+include foo.mk

+

+sport = tennis

+# Compilação condicional

+report:

+ifeq ($(sport),tennis)

+	@echo 'game, set, match'

+else

+	@echo "They think it's all over; it is now"

+endif

+

+# Há também ifneq, ifdef, ifndef

+

+foo = true

+

+ifdef $(foo)

+bar = 'hello'

+endif

+```

+

+### More Resources

+

++ [documentação gnu make](https://www.gnu.org/software/make/manual/)

++ [tutorial de carpintaria de software](http://swcarpentry.github.io/make-novice/)

++ aprenda C da maneira mais difícil [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html)

diff --git a/pt-br/markdown-pt.html.markdown b/pt-br/markdown-pt.html.markdown
index f22093f9..1a26e406 100644
--- a/pt-br/markdown-pt.html.markdown
+++ b/pt-br/markdown-pt.html.markdown
@@ -4,6 +4,7 @@ contributors:
     - ["Dan Turkel", "http://danturkel.com/"]
 translators:
     - ["Miguel Araújo", "https://github.com/miguelarauj1o"]
+    - ["Monique Baptista", "https://github.com/bfmonique"]
 lang: pt-br    
 filename: learnmarkdown-pt.md
 ---
@@ -14,20 +15,20 @@ escrever sintaxe que converte facilmente em HTML (hoje, suporta outros formatos
 Dê-me feedback tanto quanto você quiser! / Sinta-se livre para a garfar (fork) e 
 puxar o projeto (pull request)
 
-```markdown
-<!-- Markdown é um superconjunto do HTML, de modo que qualquer arvquivo HTML é 
-um arquivo Markdown válido, isso significa que nós podemos usar elementos HTML 
+```md
+<!-- Markdown é um superconjunto do HTML, de modo que qualquer arquivo HTML é 
+um arquivo Markdown válido. Isso significa que nós podemos usar elementos HTML 
 em Markdown, como o elemento de comentário, e eles não serão afetados pelo analisador
 de remarcação. No entanto, se você criar um elemento HTML em seu arquivo Markdown, você
-não pode usar sintaxe remarcação dentro desse conteúdo do elemento.-->
+não pode usar sintaxe de remarcação dentro desse conteúdo do elemento.-->
 
-<!--Markdown também varia de implementação de um analisador para uma próxima.
+<!--A maneira como o Markdown é analisado varia de software para software.
 Este guia vai tentar esclarecer quando as características são universais, ou quando eles são 
-específico para um determinado parser -->
+específico para um determinado interpretador -->
 
 <!-- Cabeçalhos -->
 <!-- Você pode criar elementos HTML <h1> até <h6> facilmente antecedendo o texto
-que deseja estar nesse elemento por um número de hashes (#) -->
+que deseja estar nesse elemento por um número de cerquilhas (#) -->
 # Isto é um cabeçalho <h1>
 ## Isto é um cabeçalho <h2>
 ### Isto é um cabeçalho <h3>
@@ -65,7 +66,7 @@ uma ou múltiplas linhas em branco. -->
 
 Este é um parágrafo. Eu estou digitando em um parágrafo, não é legal?
 
-Agora, eu estou no parágrado 2.
+Agora, eu estou no parágrafo 2.
 ... Ainda continuo no parágrafo 2! :)
 
 Eu estou no parágrafo três.
@@ -111,7 +112,7 @@ ou
 
 1. Item um
 2. Item dois
-3. Tem três
+3. Item três
 
 <!-- Você não tem poder para rotular os itens corretamente e a remarcação será ainda
 tornar os números em ordem, mas isso pode não ser uma boa idéia -->
diff --git a/pt-br/matlab-pt.html.markdown b/pt-br/matlab-pt.html.markdown
index eb660d4c..5ed6b7ba 100644
--- a/pt-br/matlab-pt.html.markdown
+++ b/pt-br/matlab-pt.html.markdown
@@ -206,8 +206,7 @@ size(A) % Resposta = 3 3
 A(1, :) =[] % Remove a primeira linha da matriz
 A(:, 1) =[] % Remove a primeira coluna da matriz
 
-transpose(A) % Transposta a matriz, que é o mesmo de:
-A one
+transpose(A) % Transposta a matriz, que é o mesmo de: A.'
 ctranspose(A) % Transposta a matriz
 % (a transposta, seguida pelo conjugado complexo de cada elemento)
 
diff --git a/pt-br/paren-pt.html.markdown b/pt-br/paren-pt.html.markdown
index 464a69d2..92414ba3 100644
--- a/pt-br/paren-pt.html.markdown
+++ b/pt-br/paren-pt.html.markdown
@@ -182,8 +182,8 @@ a ; => (3 2)
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Macros lhe permitem estender a sintaxe da linguagem.
-;; Os macros no Paren são fáceis.
-;; Na verdade, (defn) é um macro.
+;; As macros no Paren são fáceis.
+;; Na verdade, (defn) é uma macro.
 (defmacro setfn (nome ...) (set nome (fn ...)))
 (defmacro defn (nome ...) (def nome (fn ...)))
 
@@ -191,6 +191,6 @@ a ; => (3 2)
 (defmacro infix (a op ...) (op a ...))
 (infix 1 + 2 (infix 3 * 4)) ; => 15
 
-;; Macros não são higiênicos, você pode sobrescrever as variáveis já existentes!
-;; Eles são transformações de códigos.
+;; Macros não são higiênicas, você pode sobrescrever as variáveis já existentes!
+;; Elas são transformações de códigos.
 ```
diff --git a/pt-br/pascal-pt.html.markdown b/pt-br/pascal-pt.html.markdown
new file mode 100644
index 00000000..3a37271a
--- /dev/null
+++ b/pt-br/pascal-pt.html.markdown
@@ -0,0 +1,253 @@
+---
+language: Pascal
+filename: learnpascal-pt.pas
+contributors:
+    - ["Ganesha Danu", "https://github.com/blinfoldking"]
+    - ["Keith Miyake", "https//github.com/kaymmm"]
+translators:
+    - ["Raul Almeida", "https://github.com/almeidaraul"]
+lang: pt-br
+---
+
+
+>Pascal é uma linguagem de programação estruturada, que recebeu este nome em homenagem ao matemático e físico Blaise Pascal. Foi criada em 1970 pelo suíço Niklaus Wirth,tendo em mente encorajar o uso de código estruturado. 
+fonte : [wikipédia](https://pt.wikipedia.org/wiki/Pascal_(linguagem_de_programa%C3%A7%C3%A3o))
+
+
+
+Para compilar e executar um programa em Pascal, você pode usar o freepascal, 
+um compilador gratuito. [Faça o download aqui](https://www.freepascal.org/)
+
+```pascal
+//Corpo de um programa em Pascal
+//isso é um comentário
+{
+    isso também é um comentário,
+    mas com várias linhas
+}
+
+//cabeçalho do programa
+PROGRAM aprendendo_pascal; //<-- não esqueça o ponto e vírgula. O nome do 
+programa deve começar com uma letra.
+
+CONST
+    {
+        aqui você declara valores constantes
+    }
+TYPE
+    {
+        aqui você declara tipos não nativos
+    }
+VAR
+    {
+        aqui você declara variáveis
+    }
+
+//programa de fato
+BEGIN
+    80
+        aqui ficam todas as instruções que não pertencem nem a funções 
+		nem a procedimentos 
+		
+		blocos de código começam com BEGIN e terminam com END 
+		(como as chaves em C)
+    }
+END. //o "end" no final do programa requer um ponto final.
+```
+
+```pascal
+//formas de declarar uma variável
+VAR a:INTEGER;
+VAR b:INTEGER;
+
+VAR 
+    a : INTEGER;
+    b : INTEGER;
+
+VAR a,b : INTEGER;
+```
+
+```pascal
+PROGRAM Learn_More;
+//agora, mais sobre tipos de dados e operações
+
+CONST
+    PI = 3.141592654;
+    GNU = 'GNU''s Not Unix';
+        { a convenção é usar caixa alta para constantes
+          
+		  constantes têm valores fixos que só podem ser alterados 
+		  antes da compilação
+          
+		  constantes podem ser de qualquer tipo nativo (integer, real, boolean, 
+		  char, string)
+
+TYPE
+    vet_char : array [0..255] of CHAR;
+        // isso declara um novo tipo de variável, vet_char, com 256 caracteres
+    vet_multd : array of array of INTEGER;
+        // vetores de vetores são vetores multidimensionais
+        // use vetores de tamanho 0 (daí, usa-se alocação dinâmica)
+        // vetores do tipo vet_multd são de duas dimensões
+
+//declarando variáveis
+VAR
+    int, c, d  : INTEGER;
+           // três variáveis que guardam valores inteiros
+           // inteiros têm 16 bits (vão de -32768 a 32767)
+    r    : REAL;
+           // uma variável que guarda um valor real
+           // reais vão de 3.4E-38 a 3.4E38
+    bool : BOOLEAN;
+           // uma variável que guarda um valor booleano (verdadeiro ou falso)
+    ch   : CHAR;
+           // uma variável que guarda um caractere
+           // caracteres têm 8 bits 
+    str  : STRING;
+           // STRING não é um tipo padrão, mas vem na maioria dos compiladores
+           // string é um vetor de caracteres com tamanho padrão de 255 elementos
+    s    : STRING[50];
+           // especificar o tamanho de uma string assim otimiza o uso de memória
+    my_str: vet_char;
+           // aqui, uma variável de um tipo personalizado declarado acima
+    my_2d : vet_multd;
+           // defina o tamanho de vetores dinâmicos antes de usá-los
+
+// outros tipos de dados (pascal é uma linguagem fortemente tipada)
+
+    // tipos adicionais de inteiros
+    b    : BYTE;     // faixa [0..255]
+    shi  : SHORTINT; // faixa [-128..127]
+    smi  : SMALLINT; // faixa [-32,768..32,767] (inteiro padrão)
+    w    : WORD;     // faixa [0..65,535]
+    li   : LONGINT;  // faixa [-2,147,483,648..2,147,483,647]
+    lw   : LONGWORD; // faixa [0..4,294,967,295]
+    c    : CARDINAL; // longword
+    i64  : INT64;    // faixa [-9223372036854775808..9223372036854775807]
+    qw   : QWORD;    // faixa [0..18,446,744,073,709,551,615]
+
+    // tipos adicionais de reais
+    rr   : REAL;     // faixa depende da plataforma (8 bits, 16 bits, etc)
+    rs   : SINGLE;   // faixa [1.5E-45..3.4E38]
+    rd   : DOUBLE;   // faixa [5.0E-324 .. 1.7E308]
+    re   : EXTENDED; // faixa [1.9E-4932..1.1E4932]
+    rc   : COMP;     // faixa [-2E64+1 .. 2E63-1]
+
+BEGIN
+    int := 1;// usa-se := para atribuir valores a variáveis
+    r   := 3.14; 
+    ch  := 'a';
+    str := 'apple';
+    bool := true;
+    //pascal não é case-sensitive (não diferencia maiúsculas de minúsculas)
+	// uma opção de organização é usar maiúsculas para termos da linguagem 
+	// (BEGIN, END, INTEGER, etc) e constantes
+    // aritmética
+    int := 1 + 1; // int deixa de ser 1 e passa a ser 2
+    int := int + 1; // int = 2 + 1 = 3;
+    int := 4 DIV 2; //int = 2 (DIV é uma divisão inteira - ignora o resto) 
+    int := 3 DIV 2; //int = 1
+    int := 1 DIV 2; //int = 0
+
+    bool := true OR false; // bool = true
+    bool := false AND true; // bool = false
+    bool := true XOR true; // bool = false
+
+    r := 3 / 2; // usa-se a "/" para divisões entre inteiros
+    r := int; // um real pode receber um valor inteiro (mas não o contrário)
+
+    c := str[1]; //acessando elementos de um vetor: vetor[índice do elemento]
+    str := 'hello' + 'world'; //concatenção de strings
+
+    my_str[0] := 'a'; { só se pode atribuir valores a vetores elemento 
+						por elemento (não o vetor inteiro de uma vez) }
+
+    // LAÇOS
+	WHILE (ch != 'a') DO
+		BEGIN
+			writeln('ch é diferente de a');
+			IF (ch = 'c') THEN
+				writeln('ch é igual a c');
+		END;
+	
+	SETLENGTH(my_2d,10,10); 
+	// inicialização de um vetor com alocação dinâmica; my_2d vira um 10x10 
+    FOR c := 0 to 9 DO 
+		{ vetores começam em 0 e terminam em tamanho-1
+		  (exceto se, declarando o tipo, forem especificados valores diferentes) }
+        FOR d := 0 to 9 DO 
+			// a variável usada em um laço FOR deve ter sido declarada no cabeçalho
+        my_2d[c,d] := c * d; 
+			// acessam-se elementos de vetores multidimensionais com [d1, d2, d3...]
+	
+
+END.
+```
+
+```pascal
+PROGRAM programacao_com_funcoes;
+
+VAR
+    i, inutil : INTEGER;
+
+{ OBS: diferença entre procedimento e função
+	função: realiza operações e retorna valor
+	procedimento: só realiza operações
+} 
+//declarando e descrevendo uma função
+FUNCTION fatorial_recursiva(CONST a: INTEGER) : INTEGER;
+{ calcula a! recursivamente }
+
+// pode-se declarar variáveis locais para funções e procedimentos
+// exemplo:
+// VAR
+//    local_a : INTEGER;
+
+BEGIN
+	{ O bloco ELSE só funciona se não houver ponto e vírgula no bloco do IF 
+	  exemplo: 
+	  	IF a THEN
+			writeln('a'); 
+		ELSE 
+			writeln('b'); 
+		Isso não permitiria que o programa compilasse }
+
+    IF a >= 1 THEN
+    // o valor de retorno é atribuído como se a função fosse uma variável
+        fatorial_recursiva := a * fatorial_recursiva(a-1)
+    ELSE
+        fatorial_recursiva := 1;
+END; // o END de funções e procedimentos recebe ponto e vírgula
+
+//declarando e descrevendo um procedimento 
+PROCEDURE salvainteiro(VAR i : INTEGER; inutil : INTEGER);
+{ recebe entrada do usuário e salva na variável i
+  passagem de valor:
+
+	POR REFERÊNCIA - "VAR i: integer"; implica que alterações na variável i
+	dentro da função são guardadas para o escopo de todo o programa
+
+	POR VALOR - "inutil: integer"; implica que o valor do argumento é copiado 
+	e alterações na variável inutil não são guardadas
+}
+
+BEGIN
+    WRITE('Insira um inteiro: '); //escreve sem quebrar linha
+    READLN(i); //lê i com quebra de linha
+    inutil := 4; // inutil não terá seu valor alterado fora do procedimento. 
+END;
+
+BEGIN // programa principal
+    inutil := 3;
+    salvainteiro(i, inutil);
+
+	// escrevendo i! 
+    WRITELN(i, '! = ', factorial_recursion(i)); // escreve e quebra linha
+	// valores numéricos são automaticamente convertidos para texto na escrita
+
+    // escrever valor de inutil (sempre 3, já que salvainteiro não a altera)
+    WRITELN('inutil = ', inutil); 
+END.
+
+```
+
diff --git a/pt-br/pyqt-pt.html.markdown b/pt-br/pyqt-pt.html.markdown
index 10d55784..40fe82d5 100644
--- a/pt-br/pyqt-pt.html.markdown
+++ b/pt-br/pyqt-pt.html.markdown
@@ -10,7 +10,7 @@ lang: pt-br
 ---
 
 **Qt** é amplamente conhecido como um framework para desenvolvimento de
-software multi-plataforma que pode rodar em vários outras plataformas de
+software multi-plataforma que pode rodar em várias outras plataformas de
 softwares e hardwares com pouca ou nenhuma alteração no código, enquanto mantém
 o poder e a velocidade de uma aplicação nativa. Embora o **Qt** tenha sido
 originalmente escrito em *C++*.
diff --git a/pt-br/python-pt.html.markdown b/pt-br/python-pt.html.markdown
index 5afd46d0..82b70117 100644
--- a/pt-br/python-pt.html.markdown
+++ b/pt-br/python-pt.html.markdown
@@ -464,7 +464,7 @@ Humano.ronca() #=> "*arrrrrrr*"
 
 # Você pode importar módulos
 import math
-print math.sqrt(16) #=> 4
+print math.sqrt(16) #=> 4.0
 
 # Você pode importar funções específicas de um módulo
 from math import ceil, floor
diff --git a/pt-br/python3-pt.html.markdown b/pt-br/python3-pt.html.markdown
index 9b6bd1b6..bc5f801c 100644
--- a/pt-br/python3-pt.html.markdown
+++ b/pt-br/python3-pt.html.markdown
@@ -7,15 +7,16 @@ contributors:
     - ["Zachary Ferguson", "http://github.com/zfergus2"]
 translators:
     - ["Paulo Henrique Rodrigues Pinheiro", "http://www.sysincloud.it"]
+    - ["Monique Baptista", "https://github.com/bfmonique"]
 lang: pt-br
 filename: learnpython3-pt.py
 ---
 
-Python foi criado por Guido Van Rossum nos anos 1990. Ele é atualmente uma
-das mais populares linguagens em existência. Eu fiquei morrendo de amor
-pelo Python por sua clareza sintática. É praticamente pseudocódigo executável.
+Python foi criada por Guido Van Rossum nos anos 1990. Ela é atualmente uma
+das linguagens mais populares existentes. Eu me apaixonei por
+Python por sua clareza sintática. É praticamente pseudocódigo executável.
 
-Suas opiniões são grandemente apreciadas. Você pode encontrar-me em
+Opniões são muito bem vindas. Você pode encontrar-me em
 [@louiedinh](http://twitter.com/louiedinh) ou louiedinh [em]
 [serviço de e-mail do google].
 
@@ -44,7 +45,7 @@ aprender o velho Python 2.7.
 8 - 1   # => 7
 10 * 2  # => 20
 
-# Números inteiros por padrão, exceto na divisão, que retorna número
+# Números são inteiros por padrão, exceto na divisão, que retorna número
 # de ponto flutuante (float).
 35 / 5  # => 7.0
 
@@ -64,7 +65,7 @@ aprender o velho Python 2.7.
 # Exponenciação (x**y, x elevado à potência y)
 2**4  # => 16
 
-# Determine a precedência usando parêntesis
+# Determine a precedência usando parênteses
 (1 + 3) * 2  # => 8
 
 # Valores lógicos são primitivos (Atenção à primeira letra maiúscula)
@@ -105,9 +106,8 @@ False or True   # => True
 1 < 2 < 3  # => True
 2 < 3 < 2  # => False
 
-# (operador 'is' e operador '==') is verifica se duas referenciam um
-# mesmo objeto, mas == verifica se as variáveis apontam para o
-# mesmo valor.
+# 'is' verifica se duas variáveis representam o mesmo endereço
+# na memória; '==' verifica se duas variáveis têm o mesmo valor
 a = [1, 2, 3, 4]  # Referência a uma nova lista, [1, 2, 3, 4]
 b = a             # b referencia o que está referenciado por a
 b is a            # => True, a e b referenciam o mesmo objeto
@@ -174,7 +174,7 @@ input_string_var = input("Digite alguma coisa: ") # Retorna o que foi digitado e
 # Observação: Em versões antigas do Python, o método input() era chamado raw_input()
 
 # Não é necessário declarar variáveis antes de iniciá-las
-# È uma convenção usar letras_minúsculas_com_sublinhados
+# É uma convenção usar letras_minúsculas_com_sublinhados
 alguma_variavel = 5
 alguma_variavel  # => 5
 
@@ -182,31 +182,31 @@ alguma_variavel  # => 5
 # Veja Controle de Fluxo para aprender mais sobre tratamento de exceções.
 alguma_variavel_nao_inicializada  # Gera a exceção NameError
 
-# Listas armazenam sequencias
+# Listas armazenam sequências
 li = []
-# Você pode iniciar com uma lista com alguns valores
+# Você pode iniciar uma lista com valores
 outra_li = [4, 5, 6]
 
-# Adicionar conteúdo ao fim da lista com append
+# Adicione conteúdo ao fim da lista com append
 li.append(1)    # li agora é [1]
 li.append(2)    # li agora é [1, 2]
 li.append(4)    # li agora é [1, 2, 4]
 li.append(3)    # li agora é [1, 2, 4, 3]
-# Remover do final da lista com pop
+# Remova do final da lista com pop
 li.pop()        # => 3 e agora li é [1, 2, 4]
 # Vamos colocá-lo lá novamente!
 li.append(3)    # li agora é [1, 2, 4, 3] novamente.
 
-# Acessar uma lista da mesma forma que você faz com um array
+# Acesse uma lista da mesma forma que você faz com um array
 li[0]   # => 1
-# Acessa o último elemento
+# Acessando o último elemento
 li[-1]  # => 3
 
-# Acessando além dos limites gera um IndexError
+# Acessar além dos limites gera um IndexError
 li[4]  # Gera o IndexError
 
 # Você pode acessar vários elementos com a sintaxe de limites
-# (É um limite fechado, aberto pra você que gosta de matemática.)
+# Inclusivo para o primeiro termo, exclusivo para o segundo
 li[1:3]   # => [2, 4]
 # Omitindo o final
 li[2:]    # => [4, 3]
@@ -647,7 +647,7 @@ Human.grunt()    # => "*grunt*"
 
 # Você pode importar módulos
 import math
-print(math.sqrt(16))  # => 4
+print(math.sqrt(16))  # => 4.0
 
 # Você pode importar apenas funções específicas de um módulo
 from math import ceil, floor
diff --git a/pt-br/ruby-pt.html.markdown b/pt-br/ruby-pt.html.markdown
index 1078f6c5..7ae28ac2 100644
--- a/pt-br/ruby-pt.html.markdown
+++ b/pt-br/ruby-pt.html.markdown
@@ -71,7 +71,7 @@ false.class #=> FalseClass
 2 <= 2 #=> true
 2 >= 2 #=> true
 
-# Strings são objects
+# Strings são objetos
 
 'Eu sou uma string'.class #=> String
 "Eu também sou uma string".class #=> String
diff --git a/pt-br/rust-pt.html.markdown b/pt-br/rust-pt.html.markdown
index 8134d3c5..b2bab214 100644
--- a/pt-br/rust-pt.html.markdown
+++ b/pt-br/rust-pt.html.markdown
@@ -11,7 +11,7 @@ Rust é uma linguagem de programação desenvolvida pelo Mozilla Research. Rust
 combina controle de baixo nível sobre o desempenho com facilidades de alto
 nível e garantias de segurança.
 
-Ele atinge esse objetico sem necessitar de um coletor de lixo ou um processo
+Ele atinge esse objetivo sem necessitar de um coletor de lixo ou um processo
 *runtime*, permitindo que se use bibliotecas Rust em substituição a bibliotecas 
 em C.
 
@@ -27,7 +27,7 @@ noite. Rust adotou um modelo de versões *train-based* com novas versões
 regularmente liberadas a cada seis semanas. A versão 1.1 beta de Rust foi
 disponibilizada ao mesmo tempo que a versão 1.0.
 
-Apesar de Rust ser uma linguagem mais e baixo nível, Rust tem alguns conceitos
+Apesar de Rust ser uma linguagem mais de baixo nível, Rust tem alguns conceitos
 funcionais geralmente encontradas em linguagens de alto nível. Isso faz Rust
 não apenas rápido, mas também fácil e eficiente para programar.
 
@@ -68,7 +68,7 @@ fn main() {
     // Em geral, o compilador Rust consegue inferir qual o tipo de uma 
     // variável, então você não tem que escrever uma anotação explícita de tipo.
     // Ao longo desse tutorial, os tipos serão explicitamente anotados em 
-    // muitos lugares, mas apenas com propóstico demonstrativo. A inferência de 
+    // muitos lugares, mas apenas com propósito demonstrativo. A inferência de 
     // tipos pode gerenciar isso na maioria das vezes.
     let implicit_x = 1;
     let implicit_f = 1.3;
diff --git a/pt-br/solidity-pt.html.markdown b/pt-br/solidity-pt.html.markdown
index 37d15bf2..d4555fa7 100644
--- a/pt-br/solidity-pt.html.markdown
+++ b/pt-br/solidity-pt.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: Solidity
-filename: learnSolidity.sol
+filename: learnSolidity-br.sol
 contributors:
   - ["Nemil Dalal", "https://www.nemil.com"]
   - ["Joseph Chow", ""]
diff --git a/pt-br/stylus-pt.html.markdown b/pt-br/stylus-pt.html.markdown
new file mode 100755
index 00000000..804fa806
--- /dev/null
+++ b/pt-br/stylus-pt.html.markdown
@@ -0,0 +1,228 @@
+---
+language: stylus
+filename: learnStylus-pt.styl
+contributors:
+  - ["Salomão Neto", "https://github.com/salomaosnff"]
+  - ["Isaac Henrique", "https://github.com/Isaachi1"]
+lang: pt-br
+---
+
+Stylus tem como propósito, adicionar funcionalidades às suas folhas de estilos CSS que te ajudam no desenvolvimento, sem que haja a quebra de compartibilidade entre os navegadores Web.
+Entre elas estão variáveis, aninhamento, mixins, funções e muito mais.
+
+A sintaxe do Stylus é muito flexivel podendo utilizar a sintaxe padrão do CSS e deixando opcional o ponto e vírgula (;), dois pontos (:) e até mesmo as chaves ({ e }), tornando assim o seu código ainda mais legível.
+
+Stylus não fornece novas opções de estilos, mas dá funcionalidades que permitem deixar seu CSS muito mais dinâmico.
+
+
+```scss
+
+/* Estilo de código
+==============================*/
+
+/* As chaves, ponto e vírgula, e dois pontos são opcionais no Stylus. */
+
+body {
+  background: #000;
+}
+
+body {
+  background: #000
+}
+
+body {
+  background #000
+}
+
+body
+  background #000
+
+body
+  background: #000;
+
+body
+  background: #000
+
+
+// Comentários de linha única são removidos quando Stylus é compilado para CSS.
+
+/* Comentários multi-line são preservados. */
+
+
+/* Seletores
+==============================*/
+
+/* Selecionando elementos dentro de outro elemento */
+body {
+  background: #000000;
+  h1 {
+    color: #FF0000;
+  }
+}
+
+/* Ou se preferir... */
+body
+  background #000000
+  h1
+    color #FF0000
+
+
+/* Obtendo a referência do elemento pai
+==============================*/
+a {
+  color: #0088dd;
+  &:hover {
+    color: #DD8800;
+  }
+}
+
+
+/*Variáveis
+==============================*/
+
+
+/* 
+  É possível armazenar um valor CSS (tais como a cor) de uma variável.
+  Embora seja opcional, é recomendado adicionar $ antes de um nome de variável 
+  para que você possa distinguir uma variável de outro valor CSS.
+*/
+
+$primary-color = #A3A4FF
+$secondary-color = #51527F
+$body-font = 'Roboto', sans-serif
+
+/* Você pode usar as variáveis em toda a sua folha de estilo.
+Agora, se você quer mudar a cor, você só tem que fazer a mudança uma vez. */
+
+body
+	background-color $primary-color
+	color $secondary-color
+	font-family $body-font
+
+/* Quando compilar ficaria assim: */
+body {
+	background-color: #A3A4FF;
+	color: #51527F;
+	font-family: 'Roboto', sans-serif;
+}
+
+/ * 
+Este é muito mais fácil de manter do que ter de mudar a cor
+cada vez que aparece em toda a sua folha de estilo. 
+* /
+
+
+
+/*Mixins
+==============================*/
+
+/* Se você achar que você está escrevendo o mesmo código para mais de um
+elemento, você pode querer armazenar esse código em um mixin.
+
+center()
+  display block
+	margin-left auto
+	margin-right auto
+	left 0
+	right 0
+
+/* Utilizando um mixin */
+body {
+  center()
+  background-color: $primary-color
+}
+
+/* Apoś compilar ficaria assim: */
+div {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+	background-color: #A3A4FF;
+}
+
+/* Você pode usar mixins para criar uma propriedade estenográfica. */
+
+size($width, $height)
+  width $width
+  height $height
+
+.rectangle
+  size(100px, 60px)
+
+.square
+	size(40px, 40px)
+
+/* Você pode usar um mixin como uma propriedade CSS. */
+circle($ratio)
+  width $ratio * 2
+  height $ratio * 2
+  border-radius $ratio
+
+.ball
+  circle 25px
+
+
+/* Interpolação
+==============================*/
+
+vendor(prop, args)
+  -webkit-{prop} args
+  -moz-{prop} args
+  {prop} args
+
+border-radius()
+  vendor('border-radius', arguments)
+
+box-shadow()
+  vendor('box-shadow', arguments)
+
+button
+  border-radius 1px 2px / 3px 4px
+
+/* Funções
+==============================*/
+
+/* Funções no Stylus permitem fazer uma variedade de tarefas, como por exemplo, menipular algum dado. */
+
+body {
+  background darken(#0088DD, 50%) // Escurece a cor #0088DD em 50%
+}
+
+/** Criando sua própria função */
+somar(a, b)
+  a + b
+
+body
+  padding somar(10px, 5)
+
+/* Condições
+==============================*/
+comparar(a, b)
+  if a > b
+    maior
+  else if a < b
+    menor
+  else
+    igual
+
+comparar(5, 2)   // => maior
+comparar(1, 5)   // => menor
+comparar(10, 10) // => igual
+
+/* Iterações
+==============================*/
+
+/**
+Sintaxe de laço de repetição for:
+for <val-name> [, <key-name>] in <expression>
+**/
+
+for $item in (1..2) /* Repete o bloco 12 vezes */
+  .col-{$item}
+    width ($item / 12) * 100% /* Calcula a largula pelo número da coluna*
+
+```
+
+Agora que você conhece um pouco sobre esse poderoso pré-processador de CSS, você está pronto para criar folhas de estilos mais dinâmicas. Para aprofundar seus conhecimentos visite a documentação oficial do stylus em http://stylus-lang.com.
diff --git a/pt-br/typescript-pt.html.markdown b/pt-br/typescript-pt.html.markdown
index f072b257..077aa2cc 100644
--- a/pt-br/typescript-pt.html.markdown
+++ b/pt-br/typescript-pt.html.markdown
@@ -8,13 +8,6 @@ translators:
 lang: pt-br
 ---
 
-TypeScript is a language that aims at easing development of large scale applications written in JavaScript.
-TypeScript adds common concepts such as classes, modules, interfaces, generics and (optional) static typing to JavaScript.
-It is a superset of JavaScript: all JavaScript code is valid TypeScript code so it can be added seamlessly to any project. The TypeScript compiler emits JavaScript.
-
-This article will focus only on TypeScript extra syntax, as opposed to [JavaScript] (../javascript/).
-
-
 Typescript é uma linguagem que visa facilitar o desenvolvimento de aplicações em grande escala escritos em JavaScript.
 Typescript acrescenta conceitos comuns como classes, módulos, interfaces, genéricos e (opcional) tipagem estática para JavaScript.
 É um super conjunto de JavaScript: todo o código JavaScript é o código do texto dactilografado válido para que possa ser adicionados diretamente a qualquer projeto. O compilador emite typescript JavaScript.
diff --git a/pt-br/vim-pt.html.markdown b/pt-br/vim-pt.html.markdown
index 51eddb48..d7617bbe 100644
--- a/pt-br/vim-pt.html.markdown
+++ b/pt-br/vim-pt.html.markdown
@@ -13,7 +13,7 @@ filename: LearnVim-pt.txt
 [Vim](http://www.vim.org)
 (Vi IMproved - Vi Melhorado) é um clone do editor vi para Unix. Ele é um
 editor de texto projetado para ter velocidade e produtividade, e está presente
-na maioria dos systemas UNIX. O editor tem um grande número de atalhos de teclado
+na maioria dos sistemas UNIX. O editor tem um grande número de atalhos de teclado
 para agilizar a navegação para pontos específicos no arquivo, além de edição rápida.
 
 ## Navegação do Vim: o básico
@@ -25,7 +25,7 @@ para agilizar a navegação para pontos específicos no arquivo, além de ediç�
     :wq              # Salva o arquivo e fecha o vim
     :q!              # Fecha o vim e descarta as alterações no arquivo
                      # ! *força* :q a executar, fechando o vim sem salvar antes
-    :x               # Salvar o arquivo e fechao vim (atalho para :wq)
+    :x               # Salva o arquivo e fecha o vim (atalho para :wq)
 
     u                # Desfazer
     CTRL+R           # Refazer
@@ -62,7 +62,7 @@ para agilizar a navegação para pontos específicos no arquivo, além de ediç�
     
     # Movendo por palavras
 
-    w                # Move o cursor uma palavra a diante
+    w                # Move o cursor uma palavra adiante
     b                # Move o cursor uma palavra atrás
     e                # Move o cursor ao fim da palavra atual
 
diff --git a/pt-br/visualbasic-pt.html.markdown b/pt-br/visualbasic-pt.html.markdown
index b94ab609..2a7205cd 100644
--- a/pt-br/visualbasic-pt.html.markdown
+++ b/pt-br/visualbasic-pt.html.markdown
@@ -8,7 +8,7 @@ lang: pt-br
 filename: learnvisualbasic-pt.vb
 ---
 
-```vb
+```
 Module Module1
 
 module Module1
diff --git a/pt-br/whip-pt.html.markdown b/pt-br/whip-pt.html.markdown
index 989bae05..7bdeec25 100644
--- a/pt-br/whip-pt.html.markdown
+++ b/pt-br/whip-pt.html.markdown
@@ -15,13 +15,13 @@ Whip é um dialeto de Lisp feito para construir scripts e trabalhar com
 conceitos mais simples.
 Ele também copia muitas funções e sintaxe de Haskell (uma linguagem não correlata)
 
-Esse documento foi escrito pelo próprio  autor da linguagem. Então é isso.
+Esse documento foi escrito pelo próprio autor da linguagem. Então é isso.
 
 ```scheme
 ; Comentário são como em Lisp. Pontos-e-vírgulas...
 
 ; A maioria das declarações de primeiro nível estão dentro de "listas"
-; que nada mais são que coisas entre parêntesis separadas por espaços em branco
+; que nada mais são que coisas entre parênteses separadas por espaços em branco
 nao_é_uma_lista
 (uma lista)
 
@@ -64,7 +64,7 @@ false
 (not false) ; => true
 
 ; Mas a maioria das funções não-haskell tem atalhos
-; o não atalho é um '!'.
+; o atalho para "não" é um '!'.
 (! (! true)) ; => true
 
 ; Igualdade é `equal` ou `=`.
@@ -114,7 +114,7 @@ undefined ; usada para indicar que um valor não foi informado
 (1 2 3) ; => [1, 2, 3] (sintaxe JavaScript)
 
 ; Dicionários em Whip são o equivalente a 'object' em JavaScript ou
-; 'dict' em python ou 'hash' em Ruby: eles s]ão uma coleção desordenada
+; 'dict' em python ou 'hash' em Ruby: eles são uma coleção desordenada
 de pares chave-valor.
 {"key1" "value1" "key2" 2 3 3}
 
@@ -222,7 +222,7 @@ linguagens imperativas.
 (take 1 (1 2 3 4)) ; (1 2)
 ; Contrário de `take`
 (drop 1 (1 2 3 4)) ; (3 4)
-; Menos valor em uma lista
+; Menor valor em uma lista
 (min (1 2 3 4)) ; 1
 ; Maior valor em uma lista
 (max (1 2 3 4)) ; 4
diff --git a/pt-br/xml-pt.html.markdown b/pt-br/xml-pt.html.markdown
index f347f8ef..6710b387 100644
--- a/pt-br/xml-pt.html.markdown
+++ b/pt-br/xml-pt.html.markdown
@@ -10,8 +10,7 @@ lang: pt-br
 
 XML é uma linguagem de marcação projetada para armazenar e transportar dados.
 
-Ao contrário de HTML, XML não especifica como exibir ou formatar os dados, 
-basta carregá-lo.
+Ao contrário de HTML, XML não especifica como exibir ou formatar os dados, apenas o transporta.
 
 * Sintaxe XML
 
diff --git a/pt-br/yaml-pt.html.markdown b/pt-br/yaml-pt.html.markdown
index 341ae675..0b71877e 100644
--- a/pt-br/yaml-pt.html.markdown
+++ b/pt-br/yaml-pt.html.markdown
@@ -11,9 +11,7 @@ lang: pt-br
 YAML é uma linguagem de serialização de dados projetado para ser diretamente gravável e
 legível por seres humanos.
 
-É um estrito subconjunto de JSON, com a adição de sintaticamente
-novas linhas e recuo significativos, como Python. Ao contrário de Python, no entanto,
-YAML não permite caracteres de tabulação literais em tudo.
+É um superconjunto de JSON, com a adição de indentação e quebras de linhas sintaticamente significativas, como Python. Ao contrário de Python, entretanto, YAML não permite o caracter literal tab para identação.
 
 ```yaml
 # Commentários em YAML são como este.
diff --git a/pug.html.markdown b/pug.html.markdown
new file mode 100644
index 00000000..0187f1e0
--- /dev/null
+++ b/pug.html.markdown
@@ -0,0 +1,204 @@
+---
+language: Pug
+contributors:
+  - ["Michael Warner", "https://github.com/MichaelJGW"]
+filename: index.pug
+---
+
+## Getting Started with Pug
+
+Pug is a little language that compiles into the HTML. It has cleaner syntax 
+with additional features like if statements and loops. It can also be used 
+as a server side templating language for server languages like NodeJS.
+
+### The Language
+```pug
+
+//- Single Line Comment
+
+//- Multi Line
+    Comment
+
+//- ---TAGS---
+//- Basic
+div
+//- <div></div>
+h1
+//- <h1></h1>
+my-customTag
+//- <my-customTag></my-customTag>
+
+//- Sibling
+div
+div
+//- <div></div>
+    <div></div>
+
+//- Child
+div
+  div
+//- <div>
+      <div></div>
+    </div>
+
+//- Text
+h1 Hello there
+//- <h1>Hello there</h1>
+
+//- Multi Line Text
+div.
+  Hello
+  There
+//- <div>
+      Hello
+      There
+    </div>
+
+//- ---ATTRIBUTES---
+div(class="my-class" id="my-id" my-custom-attrs="data" enabled)
+//- <div class="my-class" id="my-id" my-custom-attrs="data" enabled></div>
+
+//- Short Hand
+span.my-class
+//- <span class="my-class"></span>
+.my-class
+//- <div class="my-class"></div>
+div#my-id
+//- <div id="my-id"></div>
+div#my-id.my-class
+//- <div class="my-class" id="my-id"></div>
+
+
+//- ---JS---
+- const lang = "pug";
+
+//- Multi Line JS
+-
+  const lang = "pug";
+  const awesome = true;
+
+//- JS Classes
+- const myClass = ['class1', 'class2', 'class3']
+div(class=myClass)
+//- <div class="class1 class2 class3"></div>
+
+//- JS Styles
+- const myStyles = {'color':'white', 'background-color':'blue'}
+div(styles=myStyles)
+//- <div styles="{&quot;color&quot;:&quot;white&quot;,&quot;background-color&quot;:&quot;blue&quot;}"></div>
+
+//- JS Attributes
+- const myAttributes = {"src": "photo.png", "alt": "My Photo"}
+img&attributes(myAttributes)
+//- <img src="photo.png" alt="My Photo">
+- let disabled = false
+input(type="text" disabled=disabled)
+//- <input type="text">
+- disabled = true
+input(type="text" disabled=disabled)
+//- <input type="text" disabled>
+
+//- JS Templating
+- const name = "Bob";
+h1 Hi #{name}
+h1= name
+//- <h1>Hi Bob</h1>
+//- <h1>Bob</h1>
+
+//- ---LOOPS---
+
+//- 'each' and 'for' do the same thing we will use 'each' only.
+
+each value, i in [1,2,3]
+  p=value
+//-
+  <p>1</p>
+  <p>2</p>
+  <p>3</p>
+
+each value, index in [1,2,3]
+  p=value + '-' + index
+//-
+  <p>1-0</p>
+  <p>2-1</p>
+  <p>3-2</p>
+
+each value in []
+  p=value
+//- 
+
+each value in []
+  p=value
+else
+  p No Values are here
+
+//- <p>No Values are here</p>
+
+//- ---CONDITIONALS---
+
+- const number = 5
+if number < 5
+  p number is less then 5
+else if number > 5
+  p number is greater then 5
+else
+  p number is 5
+//- <p>number is 5</p>
+
+- const orderStatus = "Pending";
+case orderStatus
+  when "Pending"
+    p.warn Your order is pending
+  when "Completed"
+    p.success Order is Completed.
+  when -1
+    p.error Error Occurred
+  default
+    p No Order Record Found
+//- <p class="warn">Your order is pending</p>
+
+//- --INCLUDE--
+//- File path -> "includes/nav.png"
+h1 Company Name
+nav
+  a(href="index.html") Home
+  a(href="about.html") About Us
+
+//- File path -> "index.png"
+html
+  body
+    include includes/nav.pug
+//-
+  <html>
+    <body>
+      <h1>Company Name</h1>
+      <nav><a href="index.html">Home</a><a href="about.html">About Us</a></nav>
+    </body>
+  </html>
+
+//- Importing JS and CSS
+script
+  include scripts/index.js
+style
+  include styles/theme.css
+
+//- ---MIXIN---
+mixin basic()
+  div Hello
++basic("Bob")
+//- <div>Hello</div>
+
+mixin comment(name, comment)
+  div
+    span.comment-name= name
+    div.comment-text= comment
++comment("Bob", "This is Awesome")
+//- <div>Hello</div>
+
+```
+
+
+### Additional Resources
+- [The Site](https://pugjs.org/)
+- [The Docs](https://pugjs.org/api/getting-started.html)
+- [Github Repo](https://github.com/pugjs/pug)
diff --git a/purescript.html.markdown b/purescript.html.markdown
index df0cb66e..6b74ac64 100644
--- a/purescript.html.markdown
+++ b/purescript.html.markdown
@@ -71,7 +71,8 @@ world""" -- "Hello\nworld"
 --
 -- 2. Arrays are Javascript arrays, but must be homogeneous
 
-[1,1,2,3,5,8] :: Array Number -- [1,1,2,3,5,8]
+[1,1,2,3,5,8] :: Array Int -- [1,1,2,3,5,8]
+[1.2,2.0,3.14] :: Array Number -- [1.2,2.0,3.14]
 [true, true, false] :: Array Boolean -- [true,true,false]
 -- [1,2, true, "false"] won't work
 -- `Cannot unify Prim.Int with Prim.Boolean`
diff --git a/python.html.markdown b/python.html.markdown
index df1ca6f2..0cc33a80 100644
--- a/python.html.markdown
+++ b/python.html.markdown
@@ -328,7 +328,8 @@ filled_dict["four"] = 4  # now, filled_dict["four"] => 4
 filled_dict.setdefault("five", 5)  # filled_dict["five"] is set to 5
 filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5
 
-# Sets store ... well sets (which are like lists but can contain no duplicates)
+# You can declare sets (which are like unordered lists that cannot contain
+# duplicate values) using the set object.
 empty_set = set()
 # Initialize a "set()" with a bunch of values
 some_set = set([1, 2, 2, 3, 4])  # some_set is now set([1, 2, 3, 4])
@@ -661,7 +662,7 @@ i.age  # => raises an AttributeError
 # You can import modules
 import math
 
-print math.sqrt(16)  # => 4
+print math.sqrt(16)  # => 4.0
 
 # You can get specific functions from a module
 from math import ceil, floor
diff --git a/python3.html.markdown b/python3.html.markdown
index 019934cb..d09c2819 100644
--- a/python3.html.markdown
+++ b/python3.html.markdown
@@ -7,6 +7,8 @@ contributors:
     - ["Zachary Ferguson", "http://github.com/zfergus2"]
     - ["evuez", "http://github.com/evuez"]
     - ["Rommel Martinez", "https://ebzzry.io"]
+    - ["Roberto Fernandez Diaz", "https://github.com/robertofd1995"]
+    - ["caminsha", "https://github.com/caminsha"]
 filename: learnpython3.py
 ---
 
@@ -40,10 +42,10 @@ Note: This article applies to Python 3 specifically. Check out [here](http://lea
 10 * 2  # => 20
 35 / 5  # => 7.0
 
-# Result of integer division truncated down both for positive and negative.
+# Integer division rounds down for both positive and negative numbers.
 5 // 3       # => 1
-5.0 // 3.0   # => 1.0 # works on floats too
 -5 // 3      # => -2
+5.0 // 3.0   # => 1.0 # works on floats too
 -5.0 // 3.0  # => -2.0
 
 # The result of division is always a float
@@ -71,15 +73,24 @@ not False  # => True
 True and False  # => False
 False or True   # => True
 
-# Note using Bool operators with ints
-# False is 0 and True is 1
+# True and False are actually 1 and 0 but with different keywords
+True + True # => 2
+True * 8    # => 8
+False - 5   # => -5
+
+# Comparison operators look at the numerical value of True and False
+0 == False  # => True
+1 == True   # => True
+2 == True   # => False
+-5 != False # => True
+
+# Using boolean logical operators on ints casts them to booleans for evaluation, but their non-cast value is returned
 # Don't mix up with bool(ints) and bitwise and/or (&,|)
+bool(0)     # => False
+bool(4)     # => True
+bool(-6)    # => True
 0 and 2     # => 0
 -5 or 0     # => -5
-0 == False  # => True
-2 == True   # => False
-1 == True   # => True
--5 != False != True #=> True
 
 # Equality is ==
 1 == 1  # => True
@@ -95,7 +106,10 @@ False or True   # => True
 2 <= 2  # => True
 2 >= 2  # => True
 
-# Comparisons can be chained!
+# Seeing whether a value is in a range
+1 < 2 and 2 < 3  # => True
+2 < 3 and 3 < 2  # => False
+# Chaining makes this look nicer
 1 < 2 < 3  # => True
 2 < 3 < 2  # => False
 
@@ -138,6 +152,12 @@ len("This is a string")  # => 16
 # still use the old style of formatting:
 "%s can be %s the %s way" % ("Strings", "interpolated", "old")  # => "Strings can be interpolated the old way"
 
+# You can also format using f-strings or formatted string literals (in Python 3.6+)
+name = "Reiko"
+f"She said her name is {name}." # => "She said her name is Reiko"
+# You can basically put any Python statement inside the braces and it will be output in the string.
+f"{name} is {len(name)} characters long." # => "Reiko is 5 characters long."
+
 
 # None is an object
 None  # => None
@@ -209,15 +229,11 @@ li[4]  # Raises an IndexError
 # You can look at ranges with slice syntax.
 # The start index is included, the end index is not
 # (It's a closed/open range for you mathy types.)
-li[1:3]   # => [2, 4]
-# Omit the beginning and return the list
-li[2:]    # => [4, 3]
-# Omit the end and return the list
-li[:3]    # => [1, 2, 4]
-# Select every second entry
-li[::2]   # =>[1, 4]
-# Return a reversed copy of the list
-li[::-1]  # => [3, 4, 2, 1]
+li[1:3]   # Return list from index 1 to 3 => [2, 4]
+li[2:]    # Return list starting from index 2 => [4, 3]
+li[:3]    # Return list from beginning until index 3  => [1, 2, 4]
+li[::2]   # Return list selecting every second entry => [1, 4]
+li[::-1]  # Return list in reverse order => [3, 4, 2, 1]
 # Use any combination of these to make advanced slices
 # li[start:end:step]
 
@@ -274,7 +290,8 @@ a, b, c = (1, 2, 3)  # a is now 1, b is now 2 and c is now 3
 # You can also do extended unpacking
 a, *b, c = (1, 2, 3, 4)  # a is now 1, b is now [2, 3] and c is now 4
 # Tuples are created by default if you leave out the parentheses
-d, e, f = 4, 5, 6
+d, e, f = 4, 5, 6  # tuple 4, 5, 6 is unpacked into variables d, e and f
+# respectively such that d = 4, e = 5 and f = 6
 # Now look how easy it is to swap two values
 e, d = d, e  # d is now 5 and e is now 4
 
@@ -294,16 +311,19 @@ valid_dict = {(1,2,3):[1,2,3]}   # Values can be of any type, however.
 filled_dict["one"]  # => 1
 
 # Get all keys as an iterable with "keys()". We need to wrap the call in list()
-# to turn it into a list. We'll talk about those later.  Note - Dictionary key
-# ordering is not guaranteed. Your results might not match this exactly.
-list(filled_dict.keys())  # => ["three", "two", "one"]
+# to turn it into a list. We'll talk about those later.  Note - for Python
+# versions <3.7, dictionary key ordering is not guaranteed. Your results might
+# not match the example below exactly. However, as of Python 3.7, dictionary
+# items maintain the order at which they are inserted into the dictionary.
+list(filled_dict.keys())  # => ["three", "two", "one"] in Python <3.7
+list(filled_dict.keys())  # => ["one", "two", "three"] in Python 3.7+
 
 
 # Get all values as an iterable with "values()". Once again we need to wrap it
 # in list() to get it out of the iterable. Note - Same as above regarding key
 # ordering.
-list(filled_dict.values())  # => [3, 2, 1]
-
+list(filled_dict.values())  # => [3, 2, 1]  in Python <3.7
+list(filled_dict.values())  # => [1, 2, 3] in Python 3.7+
 
 # Check for existence of keys in a dictionary with "in"
 "one" in filled_dict  # => True
@@ -348,6 +368,8 @@ valid_set = {(1,), 1}
 # Add one more item to the set
 filled_set = some_set
 filled_set.add(5)  # filled_set is now {1, 2, 3, 4, 5}
+# Sets do not have duplicate elements
+filled_set.add(5)  # it remains as before {1, 2, 3, 4, 5}
 
 # Do set intersection with &
 other_set = {3, 4, 5, 6}
@@ -437,8 +459,19 @@ prints:
 """
 for i in range(4, 8, 2):
     print(i)
+
+"""
+To loop over a list, and retrieve both the index and the value of each item in the list
+prints:
+    0 dog
+    1 cat
+    2 mouse
 """
+list = ["dog", "cat", "mouse"]
+for i, value in enumerate(list):
+    print(i, value)
 
+"""
 While loops go until a condition is no longer met.
 prints:
     0
@@ -469,6 +502,26 @@ with open("myfile.txt") as f:
     for line in f:
         print(line)
 
+# Writing to a file
+contents = {"aa": 12, "bb": 21}
+with open("myfile1.txt", "w+") as file:
+    file.write(str(contents))        # writes a string to a file
+
+with open("myfile2.txt", "w+") as file:
+    file.write(json.dumps(contents)) # writes an object to a file
+
+# Reading from a file
+with open('myfile1.txt', "r+") as file:
+    contents = file.read()           # reads a string from a file
+print(contents)
+# print: {"aa": 12, "bb": 21}
+
+with open('myfile2.txt', "r+") as file:
+    contents = json.load(file)       # reads a json object from a file
+print(contents)     
+# print: {"aa": 12, "bb": 21}
+
+
 # Python offers a fundamental abstraction called the Iterable.
 # An iterable is an object that can be treated as a sequence.
 # The object returned by the range function, is an iterable.
@@ -498,8 +551,14 @@ next(our_iterator)  # => "three"
 # After the iterator has returned all of its data, it raises a StopIteration exception
 next(our_iterator)  # Raises StopIteration
 
-# You can grab all the elements of an iterator by calling list() on it.
-list(filled_dict.keys())  # => Returns ["one", "two", "three"]
+# We can also loop over it, in fact, "for" does this implicitly!
+our_iterator = iter(our_iterable)
+for i in our_iterator:
+    print(i)  # Prints one, two, three
+
+# You can grab all the elements of an iterable or iterator by calling list() on it.
+list(our_iterable)  # => Returns ["one", "two", "three"]
+list(our_iterator)  # => Returns [] because state is saved
 
 
 ####################################################
@@ -783,6 +842,7 @@ class Superhero(Human):
         # add additional class attributes:
         self.fictional = True
         self.movie = movie
+        # be aware of mutable default values, since defaults are shared
         self.superpowers = superpowers
 
         # The "super" function lets you access the parent class's methods
diff --git a/pythonstatcomp.html.markdown b/pythonstatcomp.html.markdown
index 6dde1cf0..4cff3535 100644
--- a/pythonstatcomp.html.markdown
+++ b/pythonstatcomp.html.markdown
@@ -38,18 +38,16 @@ r.text  # raw page source
 print(r.text)  # prettily formatted
 # save the page source in a file:
 os.getcwd()  # check what's the working directory
-f = open("learnxinyminutes.html", "wb")
-f.write(r.text.encode("UTF-8"))
-f.close()
+with open("learnxinyminutes.html", "wb") as f:
+    f.write(r.text.encode("UTF-8"))
 
 # downloading a csv
 fp = "https://raw.githubusercontent.com/adambard/learnxinyminutes-docs/master/"
 fn = "pets.csv"
 r = requests.get(fp + fn)
 print(r.text)
-f = open(fn, "wb")
-f.write(r.text.encode("UTF-8"))
-f.close()
+with open(fn, "wb") as f:
+    f.write(r.text.encode("UTF-8"))
 
 """ for more on the requests module, including APIs, see
     http://docs.python-requests.org/en/latest/user/quickstart/
@@ -71,8 +69,8 @@ pets
 # 1  vesuvius    6      23    fish
 # 2       rex    5      34     dog
 
-""" R users: note that Python, like most normal programming languages, starts
-    indexing from 0. R is the unusual one for starting from 1.
+""" R users: note that Python, like most C-influenced programming languages, starts
+    indexing from 0. R starts indexing at 1 due to Fortran influence.
 """
 
 # two different ways to print out a column
@@ -148,7 +146,7 @@ ggplot(aes(x="age",y="weight"), data=pets) + geom_point() + labs(title="pets")
 """
 
 # load some data on Holy Roman Emperors
-url = "https://raw.githubusercontent.com/e99n09/R-notes/master/data/hre.csv"
+url = "https://raw.githubusercontent.com/adambard/learnxinyminutes-docs/master/hre.csv"
 r = requests.get(url)
 fp = "hre.csv"
 with open(fp, "wb") as f:
@@ -158,26 +156,19 @@ hre = pd.read_csv(fp)
 
 hre.head()
 """
-   Ix      Dynasty        Name        Birth             Death Election 1
-0 NaN  Carolingian   Charles I  2 April 742    28 January 814        NaN
-1 NaN  Carolingian     Louis I          778       20 June 840        NaN
-2 NaN  Carolingian   Lothair I          795  29 September 855        NaN
-3 NaN  Carolingian    Louis II          825     12 August 875        NaN
-4 NaN  Carolingian  Charles II  13 June 823     6 October 877        NaN
-
-  Election 2      Coronation 1   Coronation 2 Ceased to be Emperor
-0        NaN   25 December 800            NaN       28 January 814
-1        NaN  11 September 813  5 October 816          20 June 840
-2        NaN       5 April 823            NaN     29 September 855
-3        NaN        Easter 850     18 May 872        12 August 875
-4        NaN   29 December 875            NaN        6 October 877
-
-  Descent from whom 1 Descent how 1 Descent from whom 2 Descent how 2
-0                 NaN           NaN                 NaN           NaN
-1           Charles I           son                 NaN           NaN
-2             Louis I           son                 NaN           NaN
-3           Lothair I           son                 NaN           NaN
-4             Louis I           son                 NaN           NaN
+   Ix      Dynasty        Name        Birth             Death
+0 NaN  Carolingian   Charles I  2 April 742    28 January 814
+1 NaN  Carolingian     Louis I          778       20 June 840
+2 NaN  Carolingian   Lothair I          795  29 September 855
+3 NaN  Carolingian    Louis II          825     12 August 875
+4 NaN  Carolingian  Charles II  13 June 823     6 October 877
+
+       Coronation 1   Coronation 2 Ceased to be Emperor
+0   25 December 800            NaN       28 January 814
+1  11 September 813  5 October 816          20 June 840
+2       5 April 823            NaN     29 September 855
+3        Easter 850     18 May 872        12 August 875
+4   29 December 875            NaN        6 October 877
 """
 
 # clean the Birth and Death columns
@@ -195,6 +186,8 @@ rx = re.compile(r'\d+$')  # match trailing digits
       - http://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.html
 """
 
+from functools import reduce
+
 def extractYear(v):
     return(pd.Series(reduce(lambda x, y: x + y, map(rx.findall, v), [])).astype(int))
 
@@ -205,7 +198,7 @@ hre["DeathY"] = extractYear(hre.Death)
 hre["EstAge"] = hre.DeathY.astype(int) - hre.BirthY.astype(int)
 
 # simple scatterplot, no trend line, color represents dynasty
-sns.lmplot("BirthY", "EstAge", data=hre, hue="Dynasty", fit_reg=False);
+sns.lmplot("BirthY", "EstAge", data=hre, hue="Dynasty", fit_reg=False)
 
 # use scipy to run a linear regression
 from scipy import stats
@@ -222,7 +215,7 @@ rval**2  # 0.020363950027333586
 pval  # 0.34971812581498452
 
 # use seaborn to make a scatterplot and plot the linear regression trend line
-sns.lmplot("BirthY", "EstAge", data=hre);
+sns.lmplot("BirthY", "EstAge", data=hre)
 
 """ For more information on seaborn, see
       - http://web.stanford.edu/~mwaskom/software/seaborn/
diff --git a/r.html.markdown b/r.html.markdown
index e7486e60..3e855602 100644
--- a/r.html.markdown
+++ b/r.html.markdown
@@ -664,7 +664,7 @@ require(plyr)
 # "pets.csv" is a file on the internet
 # (but it could just as easily be a file on your own computer)
 require(RCurl)
-pets <- read.csv(textConnection(getURL("http://learnxinyminutes.com/docs/pets.csv")))
+pets <- read.csv(textConnection(getURL("https://learnxinyminutes.com/docs/pets.csv")))
 pets
 head(pets, 2) # first two rows
 tail(pets, 1) # last row
@@ -789,7 +789,7 @@ install.packages("ggplot2")
 require(ggplot2)
 ?ggplot2
 pp <- ggplot(students, aes(x=house))
-pp + geom_histogram()
+pp + geom_bar()
 ll <- as.data.table(list1)
 pp <- ggplot(ll, aes(x=time,price))
 pp + geom_point()
diff --git a/racket.html.markdown b/racket.html.markdown
index c6b1deba..60a895e0 100644
--- a/racket.html.markdown
+++ b/racket.html.markdown
@@ -249,7 +249,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- no `d'
 (hash-remove m 'a) ; => '#hash((b . 2) (c . 3))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 3. Functions
+;; 4. Functions
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Use `lambda' to create functions.
@@ -319,7 +319,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- no `d'
                                          ; => "Hi Finn, 6 extra args"
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 4. Equality
+;; 5. Equality
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; for numbers use `='
@@ -369,7 +369,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- no `d'
 (equal? (list 3) (list 3))                                       ; => #t
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 5. Control Flow
+;; 6. Control Flow
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;;; Conditionals
@@ -505,7 +505,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- no `d'
   (+ 1 (raise 2))) ; => 2
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 6. Mutation
+;; 7. Mutation
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Use `set!' to assign a new value to an existing variable
@@ -541,7 +541,7 @@ vec ; => #(1 2 3 4)
 (hash-remove! m3 'a)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 7. Modules
+;; 8. Modules
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Modules let you organize code into multiple files and reusable
@@ -568,7 +568,7 @@ vec ; => #(1 2 3 4)
 ; (show "~a" 1 #\A) ; => error, `show' was not exported
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 8. Classes and Objects
+;; 9. Classes and Objects
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Create a class fish% (-% is idiomatic for class bindings)
@@ -609,7 +609,7 @@ vec ; => #(1 2 3 4)
 (send (new (add-color fish%) [size 10] [color 'red]) get-color)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 9. Macros
+;; 10. Macros
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Macros let you extend the syntax of the language
@@ -651,7 +651,7 @@ vec ; => #(1 2 3 4)
 ;; it, the compiler will get in an infinite loop
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 10. Contracts
+;; 11. Contracts
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Contracts impose constraints on values exported from modules
@@ -678,7 +678,7 @@ vec ; => #(1 2 3 4)
 ;; more details....
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; 11. Input & output
+;; 12. Input & output
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 ;; Racket has this concept of "port", which is very similar to file
diff --git a/reason.html.markdown b/reason.html.markdown
new file mode 100644
index 00000000..b8a2215d
--- /dev/null
+++ b/reason.html.markdown
@@ -0,0 +1,544 @@
+---
+language: reason
+filename: reason.re
+contributors:
+  - ["Seth Corker", "https://sethcorker.com"]
+---
+
+Reason is a syntax over OCaml that is easier to get started for programmers who are familiar with C-style syntax like JavaScript. BuckleScript is part of the toolchain which compiles Reason to JavaScript so you can write statically typed code for anywhere that JavaScript runs.
+
+```javascript
+/* Comments start with slash-star, and end with star-slash */
+
+/*----------------------------------------------
+ * Variable and function declaration
+ *----------------------------------------------
+ * Variables and functions use the let keyword and end with a semi-colon
+ * `let` bindings are immutable
+ */
+
+let x = 5;
+/* - Notice we didn't add a type, Reason will infer x is an int */
+
+/* A function like this, take two arguments and add them together */
+let add = (a, b) => a + b;
+/* - This doesn't need a type annotation either! */
+
+/*----------------------------------------------
+ * Type annotation
+ *----------------------------------------------
+ * Types don't need to be explicitly annotated in most cases but when you need
+ * to, you can add the type after the name
+ */
+
+/* A type can be explicitly written like so */
+let x: int = 5;
+
+/* The add function from before could be explicitly annotated too */
+let add2 = (a: int, b: int): int => a + b;
+
+/* A type can be aliased using the type keyword */
+type companyId = int;
+let myId: companyId = 101;
+
+/* Mutation is not encouraged in Reason but it's there if you need it
+   If you need to mutate a let binding, the value must be wrapped in a `ref()`*/
+let myMutableNumber = ref(120);
+
+/* To access the value (and not the ref container), use `^` */
+let copyOfMyMutableNumber = myMutableNumber^;
+
+/* To assign a new value, use the `:=` operator */
+myMutableNumber := 240;
+
+/*----------------------------------------------
+ * Basic types and operators
+ *----------------------------------------------
+ */
+
+/* > String */
+
+/* Use double quotes for strings */
+let greeting = "Hello world!";
+
+/* A string can span multiple lines */
+let aLongerGreeting = "Look at me,
+I'm a multi-line string
+";
+
+/* A quoted string can be used for string interpolation and special chars
+   Use the `js` annotation for unicode */
+let world = {js|🌍|js};
+
+/* The `j` annotation is used for string interpolation */
+let helloWorld = {j|hello, $world|j};
+
+/* Concatenate strings with ++ */
+let name = "John " ++ "Wayne";
+let emailSubject = "Hi " ++ name ++ ", you're a valued customer";
+
+/* > Char */
+
+/* Use a single character for the char type */
+let lastLetter = 'z';
+/* - Char doesn't support Unicode or UTF-8 */
+
+/* > Boolean */
+
+/* A boolean can be either true or false */
+let isLearning = true;
+
+true && false;  /* - : bool = false;  Logical and */
+true || true;   /* - : bool = true;   Logical or  */
+!true;          /* - : bool = false;  Logical not */
+
+/* Greater than `>`, or greater than or equal to `>=` */
+'a' > 'b'; /* - bool : false */
+
+/* Less than `<`, or less than or equal to `<=` */
+1 < 5; /* - : bool = true */
+
+/* Structural equal */
+"hello" == "hello"; /* - : bool = true */
+
+/* Referential equal */
+"hello" === "hello"; /* - : bool = false */
+/* - This is false because they are two different "hello" string literals */
+
+/* Structural unequal */
+lastLetter != 'a'; /* -: bool = true */
+
+/* Referential unequal */
+lastLetter !== lastLetter; /* - : bool = false */
+
+/* > Integer */
+/* Perform math operations on integers */
+
+1 + 1;          /* - : int = 2  */
+25 - 11;        /* - : int = 11 */
+5 * 2 * 3;      /* - : int = 30 */
+8 / 2;          /* - : int = 4  */
+
+/* > Float */
+/* Operators on floats have a dot after them */
+
+1.1 +. 1.5;     /* - : float = 2.6  */
+18.0 -. 24.5;   /* - : float = -6.5 */
+2.5 *. 2.0;     /* - : float = 5.   */
+16.0 /. 4.0;    /* - : float = 4.   */
+
+/* > Tuple
+ * Tuples have the following attributes
+  - immutable
+  - ordered
+  - fix-sized at creation time
+  - heterogeneous (can contain different types of values)
+ A tuple is 2 or more values */
+
+let teamMember = ("John", 25);
+
+/* Type annotation matches the values */
+let position2d: (float, float) = (9.0, 12.0);
+
+/* Pattern matching is a great tool to retrieve just the values you care about
+   If we only want the y value, let's use `_` to ignore the value */
+let (_, y) = position2d;
+y +. 1.0; /* - : float = 13. */
+
+/* > Record */
+
+/* A record has to have an explicit type */
+type trainJourney = {
+  destination: string,
+  capacity: int,
+  averageSpeed: float,
+};
+
+/* Once the type is declared, Reason can infer it whenever it comes up */
+let firstTrip = {destination: "London", capacity: 45, averageSpeed: 120.0};
+
+/* Access a property using dot notation */
+let maxPassengers = firstTrip.capacity;
+
+/* If you define the record type in a different file, you have to reference the
+   filename, if trainJourney was in a file called Trips.re */
+let secondTrip: Trips.trainJourney = {
+  destination: "Paris",
+  capacity: 50,
+  averageSpeed: 150.0,
+};
+
+/* Records are immutable by default */
+/* But the contents of a record can be copied using the spread operator */
+let newTrip = {...secondTrip, averageSpeed: 120.0};
+
+/* A record property can be mutated explicitly with the `mutable` keyword */
+type breakfastCereal = {
+  name: string,
+  mutable amount: int,
+};
+
+let tastyMuesli = {name: "Tasty Muesli TM", amount: 500};
+
+tastyMuesli.amount = 200;
+/* - tastyMuesli now has an amount of 200 */
+
+/* Punning is used to avoid redundant typing */
+let name = "Just As Good Muesli";
+let justAsGoodMuesli = {name, amount: 500};
+/* - justAsGoodMuesli.name is now "Just As Good Muesli", it's equivalent
+   to { name: name, amount: 500 } */
+
+/* > Variant
+   Mutually exclusive states can be expressed with variants */
+
+type authType =
+  | GitHub
+  | Facebook
+  | Google
+  | Password;
+/* - The constructors must be capitalized like so */
+/* - Like records, variants should be named if declared in a different file */
+
+let userPreferredAuth = GitHub;
+
+/* Variants work great with a switch statement */
+let loginMessage =
+  switch (userPreferredAuth) {
+  | GitHub => "Login with GitHub credentials."
+  | Facebook => "Login with your Facebook account."
+  | Google => "Login with your Google account"
+  | Password => "Login with email and password."
+  };
+
+/* > Option
+   An option can be None or Some('a) where 'a is the type */
+
+let userId = Some(23);
+
+/* A switch handles the two cases */
+let alertMessage =
+  switch (userId) {
+  | Some(id) => "Welcome, your ID is" ++ string_of_int(id)
+  | None => "You don't have an account!"
+  };
+/* - Missing a case, `None` or `Some`, would cause an error */
+
+/* > List
+  * Lists have the following attributes
+   - immutable
+   - ordered
+   - fast at prepending items
+   - fast at splitting
+
+  * Lists in Reason are linked lists
+ */
+
+/* A list is declared with square brackets */
+let userIds = [1, 4, 8];
+
+/* The type can be explicitly set with list('a) where 'a is the type */
+type idList = list(int);
+type attendanceList = list(string);
+
+/* Lists are immutable */
+/* But the contents of a list can be copied using the spread operator */
+let newUserIds = [101, 102, ...userIds];
+
+/* > Array
+ * Arrays have the following attributes
+  - mutable
+  - fast at random access & updates */
+
+/* An array is declared with `[|` and ends with `|]` */
+let languages = [|"Reason", "JavaScript", "OCaml"|];
+
+/*----------------------------------------------
+ * Function
+ *----------------------------------------------
+ */
+
+/* Reason functions use the arrow syntax, the expression is returned */
+let signUpToNewsletter = email => "Thanks for signing up " ++ email;
+
+/* Call a function like this */
+signUpToNewsletter("hello@reason.org");
+
+/* For longer functions, use a block */
+let getEmailPrefs = email => {
+  let message = "Update settings for " ++ email;
+  let prefs = ["Weekly News", "Daily Notifications"];
+
+  (message, prefs);
+};
+/* - the final tuple is implicitly returned */
+
+/* > Labeled Arguments */
+
+/* Arguments can be labeled with the ~ symbol */
+let moveTo = (~x, ~y) => {/* Move to x,y */};
+
+moveTo(~x=7.0, ~y=3.5);
+
+/* Labeled arguments can also have a name used within the function */
+let getMessage = (~message as msg) => "==" ++ msg ++ "==";
+
+getMessage(~message="You have a message!");
+/* - The caller specifies ~message but internally the function can make use */
+
+/* The following function also has explicit types declared */
+let showDialog = (~message: string): unit => {
+  () /* Show the dialog */;
+};
+/* - The return type is `unit`, this is a special type that is equivalent to
+   specifying that this function doesn't return a value
+   the `unit` type can also be represented as `()` */
+
+/* > Currying
+   Functions can be curried and are partially called, allowing for easy reuse */
+
+let div = (denom, numr) => numr / denom;
+let divBySix = div(6);
+let divByTwo = div(2);
+
+div(3, 24);     /* - : int = 8  */
+divBySix(128);  /* - : int = 21 */
+divByTwo(10);   /* - : int = 5  */
+
+/* > Optional Labeled Arguments */
+
+/* Use `=?` syntax for optional labeled arguments */
+let greetPerson = (~name, ~greeting=?, ()) => {
+  switch (greeting) {
+  | Some(greet) => greet ++ " " ++ name
+  | None => "Hi " ++ name
+  };
+};
+/* - The third argument, `unit` or `()` is required because if we omitted it,
+   the function would be curried so greetPerson(~name="Kate") would create
+   a partial function, to fix this we add `unit` when we declare and call it */
+
+/* Call greetPerson without the optional labeled argument */
+greetPerson(~name="Kate", ());
+
+/* Call greetPerson with all arguments */
+greetPerson(~name="Marco", ~greeting="How are you today,");
+
+/* > Pipe */
+/* Functions can be called with the pipeline operator */
+
+/* Use `->` to pass in the first argument (pipe-first) */
+3->div(24);     /* - : int = 8 */
+/* - This is equivalent to div(3, 24); */
+
+36->divBySix;   /* - : int = 6 */
+/* - This is equivalent to divBySix(36); */
+
+/* Use `|>` to pass in the last argument (pipe-last) */
+24 |> div(3);   /* - : int = 8 */
+/* - This is equivalent to div(3, 24); */
+
+36 |> divBySix; /* - : int = 6 */
+/* - This is equivalent to divBySix(36); */
+
+/* Pipes make it easier to chain code together */
+let addOne = a => a + 1;
+let divByTwo = a => a / 2;
+let multByThree = a => a * 3;
+
+let pipedValue = 3->addOne->divByTwo->multByThree; /* - : int = 6 */
+
+/*----------------------------------------------
+ * Control Flow & Pattern Matching
+ *----------------------------------------------
+ */
+
+/* > If-else */
+/* In Reason, `If` is an expression when evaluate will return the result */
+
+/* greeting will be "Good morning!" */
+let greeting = if (true) {"Good morning!"} else {"Hello!"};
+
+/* Without an else branch the expression will return `unit` or `()` */
+if (false) {
+  showDialog(~message="Are you sure you want to leave?");
+};
+/* - Because the result will be of type `unit`, both return types should be of
+   the same type if you want to assign the result. */
+
+/* > Destructuring */
+/* Extract properties from data structures easily */
+
+let aTuple = ("Teacher", 101);
+
+/* We can extract the values of a tuple */
+let (name, classNum) = aTuple;
+
+/* The properties of a record can be extracted too */
+type person = {
+  firstName: string,
+  age: int,
+};
+let bjorn = {firstName: "Bjorn", age: 28};
+
+/* The variable names have to match with the record property names */
+let {firstName, age} = bjorn;
+
+/* But we can rename them like so */
+let {firstName: bName, age: bAge} = bjorn;
+
+let {firstName: cName, age: _} = bjorn;
+
+/* > Switch
+   Pattern matching with switches is an important tool in Reason
+   It can be used in combination with destructuring for an expressive and
+   concise tool */
+
+/* Lets take a simple list */
+let firstNames = ["James", "Jean", "Geoff"];
+
+/* We can pattern match on the names for each case we want to handle */
+switch (firstNames) {
+| [] => "No names"
+| [first] => "Only " ++ first
+| [first, second] => "A couple of names " ++ first ++ "," ++ second
+| [first, second, third] =>
+  "Three names, " ++ first ++ ", " ++ second ++ ", " ++ third
+| _ => "Lots of names"
+};
+/* - The `_` is a catch all at the end, it signifies that we don't care what
+   the value is so it will match every other case */
+
+/* > When clause */
+
+let isJohn = a => a == "John";
+let maybeName = Some("John");
+
+/* When can add more complex logic to a simple switch */
+let aGreeting =
+  switch (maybeName) {
+  | Some(name) when isJohn(name) => "Hi John! How's it going?"
+  | Some(name) => "Hi " ++ name ++ ", welcome."
+  | None => "No one to greet."
+  };
+
+/* > Exception */
+
+/* Define a custom exception */
+exception Under_Age;
+
+/* Raise an exception within a function */
+let driveToTown = (driver: person) =>
+  if (driver.age >= 15) {
+    "We're in town";
+  } else {
+    raise(Under_Age);
+  };
+
+let evan = {firstName: "Evan", age: 14};
+
+/* Pattern match on the exception Under_Age */
+switch (driveToTown(evan)) {
+| status => print_endline(status)
+| exception Under_Age =>
+  print_endline(evan.firstName ++ " is too young to drive!")
+};
+
+/* Alternatively, a try block can be used */
+/* - With Reason exceptions can be avoided with optionals and are seldom used */
+let messageToEvan =
+  try (driveToTown(evan)) {
+  | Under_Age => evan.firstName ++ " is too young to drive!"
+  };
+
+/*----------------------------------------------
+ * Object
+ *----------------------------------------------
+ * Objects are similar to Record types but aren't as rigid
+ * An object resembles a class
+ */
+
+/* An object may be typed like a record but contains a dot */
+type surfaceComputer = {
+  .
+  color: string,
+  capacity: int,
+};
+/* - A single dot signifies a closed object, an object that uses this type
+   must have the exact shape */
+
+let surfaceBook: surfaceComputer = {pub color = "blue"; pub capacity = 512};
+
+/* But an object doesn't require a type */
+let house = {
+  /* A private property */
+  val temp = ref(18.0);
+  /* Public properties */
+  pub temperature = temp;
+  /* A private method only accessible from within house */
+  pri setThermostat = v => temp := v;
+  /* A public method that calls the private setThermostat method */
+  pub arriveHome = () => this#setThermostat(22.0)
+};
+
+house#temperature; /* - : float = 18. */
+house#arriveHome();
+house#temperature; /* - : float = 22. */
+
+/*----------------------------------------------
+ * Module
+ *----------------------------------------------
+ * Modules are used to organize your code and provide namespacing.
+ * Each file is a module by default
+ */
+
+/* Create a module */
+module Staff = {
+  type role =
+    | Delivery
+    | Sales
+    | Other;
+  type member = {
+    name: string,
+    role,
+  };
+
+  let getRoleDirectionMessage = staff =>
+    switch (staff.role) {
+    | Delivery => "Deliver it like you mean it!"
+    | Sales => "Sell it like only you can!"
+    | Other => "You're an important part of the team!"
+    };
+};
+
+/* A module can be accessed with dot notation */
+let newEmployee: Staff.member = {name: "Laura", role: Staff.Delivery};
+
+/* Using the module name can be tiresome so the module's contents can be opened
+   into the current scope with `open` */
+open Staff;
+
+let otherNewEmployee: member = {name: "Fred", role: Other};
+
+/* A module can be extended using the `include` keyword, include copies
+   the contents of the module into the scope of the new module */
+module SpecializedStaff = {
+  include Staff;
+
+  /* `member` is included so there's no need to reference it explicitly */
+  let ceo: member = {name: "Reggie", role: Other};
+
+  let getMeetingTime = staff =>
+    switch (staff) {
+    | Other => 11_15 /* - : int = 1115; Underscores are for formatting only  */
+    | _ => 9_30
+    };
+};
+```
+
+## Further Reading
+
+- [Official Reason Docs](https://reasonml.github.io/docs/en/what-and-why)
+- [Official BuckleScript Docs](https://bucklescript.github.io/docs/en/what-why)
+- [Try Reason](https://reasonml.github.io/en/try)
+- [Get Started with Reason by Nik Graf](https://egghead.io/courses/get-started-with-reason)
diff --git a/red.html.markdown b/red.html.markdown
index 3575032f..74538bd7 100644
--- a/red.html.markdown
+++ b/red.html.markdown
@@ -103,7 +103,8 @@ type? my-integer
 integer!
 
 ; A variable can be initialized using another variable that gets initialized
-; at the same time.
+; at the same time. Initialize here refers to both declaring a variable and
+; assigning a value to it.
 i2: 1 + i1: 1
 
 ; Arithmetic is straightforward
@@ -113,12 +114,12 @@ i2 * i1 ; result 2
 i1 / i2 ; result 0 (0.5, but truncated towards 0)
 
 ; Comparison operators are probably familiar, and unlike in other languages
-; you only need a single '=' sign for comparison.
+; you only need a single '=' sign for comparison. Inequality is '<>' like in Pascal.
 ; There is a boolean like type in Red. It has values true and false, but also
 ; the values on/off or yes/no can be used
 
 3 = 2 ; result false
-3 != 2 ; result true
+3 <> 2 ; result true
 3 > 2 ; result true
 3 < 2 ; result false
 2 <= 2 ; result true
@@ -128,8 +129,8 @@ i1 / i2 ; result 0 (0.5, but truncated towards 0)
 ; Control Structures
 ;
 ; if
-; Evaluate a block of code if a given condition is true. IF does not return
-; any value, so cannot be used in an expression.
+; Evaluate a block of code if a given condition is true. IF returns
+; the resulting value of the block or 'none' if the condition was false.
 if a < 0 [print "a is negative"]
 
 ; either
@@ -164,7 +165,7 @@ print ["a is " msg lf]
 
 ; until
 ; Loop over a block of code until the condition at end of block, is met.
-; UNTIL does not return any value, so it cannot be used in an expression.
+; UNTIL always returns the 'true' value from the final evaluation of the last expression.
 c: 5
 until [
    prin "o"
diff --git a/ro-ro/elixir-ro.html.markdown b/ro-ro/elixir-ro.html.markdown
new file mode 100644
index 00000000..10fec3c5
--- /dev/null
+++ b/ro-ro/elixir-ro.html.markdown
@@ -0,0 +1,459 @@
+---
+language: elixir
+contributors:
+    - ["Joao Marques", "http://github.com/mrshankly"]
+    - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+    - ["Ryan Plant", "https://github.com/ryanplant-au"]
+    - ["Ev Bogdanov", "https://github.com/evbogdanov"]
+translators:
+    - ["Vitalie Lazu", "https://github.com/vitaliel"]
+lang: ro-ro
+filename: learnelixir-ro.ex
+---
+
+Elixir este un limbaj funcțional modern construit pe baza mașinii virtuale Erlang.
+E total compatibil cu Erlang, dar are o sintaxă mai prietenoasă și propune mai multe
+posibilități.
+
+```elixir
+
+# Comentariile de o linie încep cu simbolul diez.
+
+# Pentru comentarii pe mai multe linii nu există sintaxă separată,
+# de aceea folosiți mai multe linii cu comentarii.
+
+# Pentru a folosi shell-ul elixir utilizați comanda `iex`.
+# Compilați modulele cu comanda `elixirc`.
+
+# Ambele comenzi vor lucra în terminal, dacă ați instalat Elixir corect.
+
+## ---------------------------
+## -- Tipuri de bază
+## ---------------------------
+
+# Numere
+3    # număr întreg
+0x1F # număr întreg
+3.0  # număr cu virgulă mobilă
+
+# Atomii, sunt constante nenumerice. Ei încep cu `:`.
+:salut # atom
+
+# Tuplele sunt păstrate în memorie consecutiv.
+{1,2,3} # tuple
+
+# Putem accesa elementul tuplelui folosind funcția `elem`:
+elem({1, 2, 3}, 0) #=> 1
+
+# Listele sunt implementate ca liste înlănțuite.
+[1,2,3] # listă
+
+# Fiecare listă ne vidă are cap (primul element al listei)
+# și coadă (restul elementelor).
+# Putem accesa capul și coada listei cum urmează:
+[cap | coadă] = [1,2,3]
+cap   #=> 1
+coadă #=> [2, 3]
+
+# În Elixir, ca și în Erlang, simbolul `=` denotă potrivirea șabloanelor și
+# nu atribuire.
+#
+# Aceasta înseamnă că expresia din stînga (șablonul) se potrivește cu
+# expresia din dreaptă.
+#
+# În modul acesta exemplul de mai sus lucrează accesînd capul și coada unei liste.
+
+# Potrivirea șablonului va da eroare cînd expresiile din stînga și dreapta nu se
+# potrivesc, în exemplu acesta tuplele au lungime diferită.
+{a, b, c} = {1, 2} #=> ** (MatchError)
+
+# Există și date binare
+<<1,2,3>>
+
+# Sunt două tipuri de șiruri de caractere
+"salut" # șir de caractere Elixir
+'salut' # listă de caractere Erlang
+
+# Șir de caractere pe mai multe linii
+"""
+Sunt un șir de caractere
+pe mai multe linii.
+"""
+#=> "Sunt un șir de caractere\npe mai multe linii..\n"
+
+# Șirurile de caractere sunt codificate în UTF-8:
+"Bună dimineața" #=> "Bună dimineața"
+
+# Șirurile de caractere sunt date binare, listele de caractere doar liste.
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c]   #=> 'abc'
+
+# `?a` în Elixir întoarce codul ASCII pentru litera `a`
+?a #=> 97
+
+# Pentru a concatena listele folosiți `++`, pentru date binare - `<>`
+[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
+'Salut ' ++ 'lume'  #=> 'Salut lume'
+
+<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
+"Salut " <> "lume"  #=> "Salut lume"
+
+# Diapazoanele sunt reprezentate ca `început..sfîrșit` (inclusiv)
+1..10 #=> 1..10
+început..sfîrșit = 1..10 # Putem folosi potrivirea șabloanelor cu diapazoane de asemenea
+[început, sfîrșit] #=> [1, 10]
+
+# Dicţionarele stochează chei şi o valoare pentru fiecare cheie
+genuri = %{"Ion" => "bărbat", "Maria" => "femeie"}
+genuri["Ion"] #=> "bărbat"
+
+# Dicționare cu chei de tip atom au sintaxă specială
+genuri = %{ion: "bărbat", maria: "femeie"}
+genuri.ion #=> "bărbat"
+
+## ---------------------------
+## -- Operatori
+## ---------------------------
+
+# Operații matematice
+1 + 1  #=> 2
+10 - 5 #=> 5
+5 * 2  #=> 10
+10 / 2 #=> 5.0
+
+# În Elixir operatorul `/` întotdeauna întoarce un număr cu virgulă mobilă.
+
+# Folosiți `div` pentru împărțirea numerelor întregi
+div(10, 2) #=> 5
+
+# Pentru a obține restul de la împărțire utilizați `rem`
+rem(10, 3) #=> 1
+
+# Există și operatori booleni: `or`, `and` and `not`.
+# Acești operatori așteaptă ca primul argument o expresie booleană.
+true and true #=> true
+false or true #=> true
+1 and true    #=> ** (BadBooleanError)
+
+# Elixir de asemenea  oferă `||`, `&&` și `!` care acceptă argumente de orice tip.
+# Toate valorile în afară de `false` și `nil` se vor evalua ca `true`.
+1 || true  #=> 1
+false && 1 #=> false
+nil && 20  #=> nil
+!true #=> false
+
+# Operatori de comparație: `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` și `>`
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2  #=> true
+
+# `===` și `!==` au strictețe mai mare cînd comparăm numere întregi și reale:
+1 == 1.0  #=> true
+1 === 1.0 #=> false
+
+# Putem compara de asemenea și date de diferite tipuri:
+1 < :salut #=> true
+
+# La compararea diferitor tipuri folosiți următoare prioritate:
+# număr < atom < referință < funcție < port < proces < tuple < listă < șir de caractere
+
+# Cităm pe Joe Armstrong în acest caz: "Ordinea actuală nu e importantă,
+dar că ordinea totală este bine definită este important."
+
+## ---------------------------
+## -- Ordinea execuției
+## ---------------------------
+
+# expresia `if`
+if false do
+  "Aceasta nu veți vedea niciodată"
+else
+  "Aceasta veți vedea"
+end
+
+# expresia opusă `unless`
+unless true do
+  "Aceasta nu veți vedea niciodată"
+else
+  "Aceasta veți vedea"
+end
+
+# Țineți minte potrivirea șabloanelor? Multe structuri în Elixir se bazează pe ea.
+
+# `case` ne permite să comparăm o valoare cu multe șabloane:
+case {:unu, :doi} do
+  {:patru, :cinci} ->
+    "Aceasta nu se potrivește"
+  {:unu, x} ->
+    "Aceasta se potrivește și atribuie lui `x` `:doi` în acest bloc"
+  _ ->
+    "Aceasta se va potrivi cu orice valoare"
+end
+
+# Simbolul `_` se numește variabila anonimă.
+# Folosiți-l pentru valori ce nu vă interesează.
+# De exemplu, dacă doar capul listei ne intereseaza:
+[cap | _] = [1,2,3]
+cap #=> 1
+
+# Pentru o citire mai bună putem scri:
+[cap | _coadă] = [:a, :b, :c]
+cap #=> :a
+
+# `cond` ne permite să verificăm multe condiții de odată.
+# Folosiți `cond` în schimbul la multe expresii `if`.
+cond do
+  1 + 1 == 3 ->
+    "Aceasta nu veți vedea niciodată"
+  2 * 5 == 12 ->
+    "Pe mine la fel"
+  1 + 2 == 3 ->
+    "Aceasta veți vedea"
+end
+
+# Este obușnuit de setat ultima condiție cu `true`, care se va potrivi întotdeauna.
+cond do
+  1 + 1 == 3 ->
+    "Aceasta nu veți vedea niciodată"
+  2 * 5 == 12 ->
+    "Pe mine la fel"
+  true ->
+    "Aceasta veți vedea (este else în esență)"
+end
+
+# Blocul `try/catch` se foloște pentru prelucrarea excepțiilor.
+# Elixir suportă blocul `after` care se execută în orice caz.
+try do
+  throw(:salut)
+catch
+  mesaj -> "Am primit #{mesaj}."
+after
+  IO.puts("Sunt în blocul after.")
+end
+#=> Sunt în blocul after.
+# "Am primit salut"
+
+## ---------------------------
+## -- Module și Funcții
+## ---------------------------
+
+# Funcții anonime (atenție la punct la apelarea funcției)
+square = fn(x) -> x * x end
+square.(5) #=> 25
+
+# Ele de asemenea aceptă multe clauze și expresii de gardă.
+# Expresiile de gardă vă permit să acordați potrivirea șabloanelor,
+# ele sunt indicate după cuvîntul cheie `when`:
+f = fn
+  x, y when x > 0 -> x + y
+  x, y -> x * y
+end
+
+f.(1, 3)  #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir de asemenea oferă multe funcții incorporate.
+# Ele sunt accesibile în scopul curent.
+is_number(10)    #=> true
+is_list("salut") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# Puteți grupa cîteva funcții într-un modul. În interiorul modulului folosiți `def`
+# pentru a defini funcțiile necesare.
+defmodule Math do
+  def sum(a, b) do
+    a + b
+  end
+
+  def square(x) do
+    x * x
+  end
+end
+
+Math.sum(1, 2)  #=> 3
+Math.square(3)  #=> 9
+
+# Pentru a compila modulul nostru simplu Math îl salvăm ca `math.ex` și utilizăm `elixirc`.
+# în terminal: elixirc math.ex
+
+# În interiorul modulului putem defini funcții cu `def` și funcții private cu `defp`.
+defmodule PrivateMath do
+  # O funcție definită cu `def` este accesibilă pentru apelare din alte module,
+  def sum(a, b) do
+    do_sum(a, b)
+  end
+
+  # O funcție privată poate fi apelată doar local.
+  defp do_sum(a, b) do
+    a + b
+  end
+end
+
+PrivateMath.sum(1, 2)    #=> 3
+PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
+
+# Declarația funcției de asemenea suportă expresii de gardă și multe clauze:
+defmodule Geometry do
+  def area({:rectangle, w, h}) do
+    w * h
+  end
+
+  def area({:circle, r}) when is_number(r) do
+    3.14 * r * r
+  end
+end
+
+Geometry.area({:rectangle, 2, 3}) #=> 6
+Geometry.area({:circle, 3})       #=> 28.25999999999999801048
+Geometry.area({:circle, "not_a_number"}) #=> ** (FunctionClauseError)
+
+# Din cauza variabilelor imutabile, un rol important îl ocupă funcțiile recursive
+defmodule Recursion do
+  def sum_list([head | tail], acc) do
+    sum_list(tail, acc + head)
+  end
+
+  def sum_list([], acc) do
+    acc
+  end
+end
+
+Recursion.sum_list([1,2,3], 0) #=> 6
+
+# Modulele în Elixir suportă atribute, există atribute incorporate și
+# puteți adăuga altele.
+defmodule MyMod do
+  @moduledoc """
+  Este un atribut incorporat
+  """
+
+  @my_data 100 # Acesta e atributul nostru
+  IO.inspect(@my_data) #=> 100
+end
+
+# Operatorul |> permite transferarea rezultatului unei expresii din stînga
+# ca primul argument al unei funcții din dreapta.
+Range.new(1,10)
+|> Enum.map(fn x -> x * x end)
+|> Enum.filter(fn x -> rem(x, 2) == 0 end)
+#=> [4, 16, 36, 64, 100]
+
+## ---------------------------
+## -- Structuri și Excepții
+## ---------------------------
+
+# Structurile sunt extensii a dicționarelor ce au valori implicite,
+# verificări în timpul compilării și polimorfism
+defmodule Person do
+  defstruct name: nil, age: 0, height: 0
+end
+
+joe_info = %Person{ name: "Joe", age: 30, height: 180 }
+#=> %Person{age: 30, height: 180, name: "Joe"}
+
+# Acesarea cîmpului din structură
+joe_info.name #=> "Joe"
+
+# Actualizarea valorii cîmpului
+older_joe_info = %{ joe_info | age: 31 }
+#=> %Person{age: 31, height: 180, name: "Joe"}
+
+# Blocul `try` cu cuvîntul cheie `rescue` e folosit pentru a prinde excepții
+try do
+  raise "o eroare"
+rescue
+  RuntimeError -> "a fost prinsă o eroare runtime"
+  _error -> "aici vor fi prinse toate erorile"
+end
+#=> "a fost prinsă o eroare runtime"
+
+# Toate excepțiile au un mesaj
+try do
+  raise "o eroare"
+rescue
+  x in [RuntimeError] ->
+    x.message
+end
+#=> "o eroare"
+
+## ---------------------------
+## -- Concurența
+## ---------------------------
+
+# Concurența în Elixir se bazează pe modelul actor. Pentru a scrie programe
+# concurente avem nevoie de trei lucruri:
+# 1. Crearea proceselor
+# 2. Trimiterea mesajelor
+# 3. Primirea mesajelor
+
+# Un nou proces se crează folosind funcția `spawn`, care primește o funcție
+# ca argument.
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+spawn(f) #=> #PID<0.40.0>
+
+# `spawn` întoarce identificatorul procesului pid, îl puteți folosi pentru
+# a trimite mesaje procesului. Mesajele se transmit folosind operatorul `send`.  
+# Pentru primirea mesajelor se folosește mecanismul `receive`:
+
+# Blocul `receive do` este folosit pentru așteptarea mesajelor și prelucrarea lor
+# cînd au fost primite. Blocul `receive do` va procesa doar un singur mesaj primit.
+# Pentru a procesa mai multe mesaje, funcția cu blocul `receive do` trebuie
+# recursiv să se auto apeleze.
+
+defmodule Geometry do
+  def area_loop do
+    receive do
+      {:rectangle, w, h} ->
+        IO.puts("Aria = #{w * h}")
+        area_loop()
+      {:circle, r} ->
+        IO.puts("Aria = #{3.14 * r * r}")
+        area_loop()
+    end
+  end
+end
+
+# Compilați modulul și creați un proces
+pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
+# Un alt mod
+pid = spawn(Geometry, :area_loop, [])
+
+# Trimiteți un mesaj către `pid` care se va potrivi cu un șablon din blocul `receive`
+send pid, {:rectangle, 2, 3}
+#=> Aria = 6
+#   {:rectangle,2,3}
+
+send pid, {:circle, 2}
+#=> Aria = 12.56000000000000049738
+#   {:circle,2}
+
+# Interpretatorul este de asemenea un proces, puteți folosi `self` 
+# pentru a primi identificatorul de proces: 
+self() #=> #PID<0.27.0>
+
+## ---------------------------
+## -- Agenții
+## ---------------------------
+
+# Un agent este un proces care urmărește careva valori ce se schimbă.
+
+# Creați un agent cu `Agent.start_link`, transmițînd o funcție.
+# Stare inițială a agentului va fi rezultatul funcției.
+{ok, my_agent} = Agent.start_link(fn -> ["roșu", "verde"] end)
+
+# `Agent.get` primește numele agentului și o `fn` care primește starea curentă
+# Orice va întoarce `fn` este ceea ce veți primi înapoi: 
+Agent.get(my_agent, fn colors -> colors end) #=> ["roșu", "verde"]
+
+# Actualizați starea agentului în acelaș mod:
+Agent.update(my_agent, fn colors -> ["albastru" | colors] end)
+```
+
+## Link-uri utile
+
+* [Primii pași](http://elixir-lang.org/getting-started/introduction.html) de pe [situl Elixir](http://elixir-lang.org)
+* [Documentația oficială Elixir](http://elixir-lang.org/docs/master/)
+* [Un mic conspect pe Elixir](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
+* [Cartea "Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) de Dave Thomas
+* [Cartea "Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) de Fred Hebert
+* [Cartea "Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) de Joe Armstrong
diff --git a/ro-ro/python-ro.html.markdown b/ro-ro/python-ro.html.markdown
index c96e30dc..ada0c034 100644
--- a/ro-ro/python-ro.html.markdown
+++ b/ro-ro/python-ro.html.markdown
@@ -449,7 +449,7 @@ Om.exclama() #=> "*Aaaaaah*"
 
 # Pentru a folosi un modul, trebuie importat 
 import math
-print math.sqrt(16) #=> 4
+print math.sqrt(16) #=> 4.0
 
 # Putem importa doar anumite funcţii dintr-un modul 
 from math import ceil, floor
diff --git a/rst.html.markdown b/rst.html.markdown
index 65f848ed..2423622e 100644
--- a/rst.html.markdown
+++ b/rst.html.markdown
@@ -47,22 +47,27 @@ Title are underlined with equals signs too
 Subtitles with dashes
 ---------------------
 
-And sub-subtitles with tildes
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+You can put text in *italic* or in **bold**, you can "mark" text as code with double backquote ``print()``.
 
-You can  put text in *italic* or in **bold**, you can "mark" text as code with double backquote ``: ``print()``.
+Lists are similar to Markdown, but a little more involved.
 
-Lists are as simple as in Markdown:
+Remember to line up list symbols (like - or *) with the left edge of the previous text block, and remember to use blank lines to separate new lists from parent lists:    
 
 - First item
 - Second item
-    - Sub item
+
+  - Sub item
+    
+- Third item
 
 or
 
 * First item
 * Second item
-    * Sub item
+    
+  * Sub item
+
+* Third item
 
 Tables are really easy to write:
 
@@ -73,7 +78,7 @@ France      Paris
 Japan       Tokyo
 =========== ========
 
-More complex tabless can be done easily (merged columns and/or rows) but I suggest you to read the complete doc for this :)
+More complex tables can be done easily (merged columns and/or rows) but I suggest you to read the complete doc for this :)
 
 There are multiple ways to make links:
 
diff --git a/ru-ru/asymptotic-notation-ru.html.markdown b/ru-ru/asymptotic-notation-ru.html.markdown
index 73ad80ba..7fd02c47 100644
--- a/ru-ru/asymptotic-notation-ru.html.markdown
+++ b/ru-ru/asymptotic-notation-ru.html.markdown
@@ -1,225 +1,225 @@
----
-category: Algorithms & Data Structures
-name: Asymptotic Notation
-contributors:
-    - ["Jake Prather", "http://github.com/JakeHP"]
-    - ["Divay Prakash", "http://github.com/divayprakash"]
-translators:
-    - ["pru-mike", "http://gihub.com/pru-mike"]
-lang: ru-ru
----
-
-# О-cимволика
-
-## Что это такое?
-
-О-cимволика или асимптотическая запись это система символов позволяющая оценить
-время выполнения алгоритма, устанавливая зависимость времени выполнения от
-увеличения объема входных данных, так же известна как оценка
-сложности алгоритмов. Быстро-ли алгоритм станет невероятно медленным, когда
-объем входных данных увеличится? Будет-ли алгоритм выполняться достаточно быстро,
-если объем входных данных возрастет? О-символика позволяет ответить на эти
-вопросы.
-
-## Можно-ли по-другому найти ответы на эти вопросы?
-
-Один способ это подсчитать число элементарных операций в зависимости от
-различных объемов входных данных. Хотя это и приемлемое решение, тот объем
-работы которого оно потребует, даже для простых алгоритмов, делает его 
-использование неоправданным.
-
-Другой способ это измерить какое время алгоритм потребует для завершения на
-различных объемах входных данных. В тоже время, точность и относительность
-(полученное время будет относиться только к той машине на которой оно
-вычислено) этого метода зависит от среды выполнения: компьютерного аппаратного
-обеспечения, мощности процессора и т.д.
-
-## Виды О-символики
-
-В первом разделе этого документа мы определили, что О-символика
-позволяет оценивать алгоритмы в зависимости от изменения размера входных
-данных. Представим что алгоритм это функция f, n размер входных данных и 
-f(n) время выполнения. Тогда для данного алгоритма f c размером входных
-данных n получим какое-то результирующее время выполнения f(n).
-Из этого можно построить график, где ось Y время выполнения, ось X размер входных
-данных и точки на графике это время выполнения для заданного размера входных
-данных.
-
-С помощью О-символики можно оценить функцию или алгоритм
-несколькими различными способами. Например можно оценить алгоритм исходя
-из нижней оценки, верхней оценки, тождественной оценки. Чаще всего встречается
-анализ на основе верхней оценки. Как правило не используется нижняя оценка,
-потому что она не подходит под планируемые условия. Отличный пример алгоритмы
-сортировки, особенно добавление элементов в древовидную структуру. Нижняя оценка
-большинства таких алгоритмов может быть дана как одна операция. В то время как в
-большинстве случаев, добавляемые элементы должны быть отсортированы
-соответствующим образом при помощи дерева, что может потребовать обхода целой
-ветви. Это и есть худший случай, для которого планируется верхняя оценка.
-
-### Виды функций, пределы и упрощения
-
-```
-Логарифмическая функция - log n
-Линейная функция - an + b
-Квадратическая функция - an^2 + bn +c
-Полиномиальная функция - an^z + . . . + an^2 + a*n^1 + a*n^0, где z константа
-Экспоненциальная функция - a^n, где a константа
-```
-
-Приведены несколько базовых функций используемых при определении сложности в
-различных оценках. Список начинается с самой медленно возрастающей функции
-(логарифм, наиболее быстрое время выполнения) и следует до самой быстро
-возрастающей функции (экспонента, самое медленное время выполнения). Отметим,
-что в то время как 'n' или размер входных данных, возрастает в каждой из этих функций,
-результат намного быстрее возрастает в квадратической, полиномиальной
-и экспоненциальной по сравнению с логарифмической и линейной.
-
-Крайне важно понимать, что при использовании описанной далее нотации необходимо
-использовать упрощенные выражения.
-Это означает, что необходимо отбрасывать константы и слагаемые младших порядков,
-потому что если размер входных данных (n в функции f(n) нашего примера)
-увеличивается до бесконечности (в пределе), тогда слагаемые младших порядков
-и константы становятся пренебрежительно малыми. Таким образом, если есть
-константа например размера 2^9001 или любого другого невообразимого размера,
-надо понимать, что её упрощение внесёт значительные искажения в точность
-оценки.
-
-Т.к. нам нужны упрощенные выражения, немного скорректируем нашу таблицу...
-
-```
-Логарифм - log n
-Линейная функция - n
-Квадратическая функция - n^2
-Полиномиальная функция - n^z, где z константа
-Экспонента - a^n, где a константа
-```
-
-### О-Большое
-О-Большое, записывается как **О**, это асимптотическая запись для оценки худшего
-случая или для ограничения заданой функции сверху. Это позволяет сделать 
-_**асимптотическую оценку верхней границы**_ скорости роста времени выполнения 
-алгоритма. Допустим `f(n)` время выполнения алгоритма и `g(n)` заданная временная
-сложность которая проверяется для алгоритма. Тогда `f(n)` это O(g(n)), если
-существуют действительные константы с (с > 0) и n<sub>0</sub>, такие
-что `f(n)` <= `c g(n)` выполняется для всех n начиная с некоторого n<sub>0</sub> (n > n<sub>0</sub>).
-
-*Пример 1*
-
-```
-f(n) = 3log n + 100
-g(n) = log n
-```
-
-Является-ли `f(n)` O(g(n))?
-Является-ли `3 log n + 100` O(log n)?
-Посмотрим на определение О-Большого:
-
-```
-3log n + 100 <= c * log n
-```
-
-Существуют-ли константы c, n<sub>0</sub> такие что выражение верно для всех n > n<sub>0</sub>
-
-```
-3log n + 100 <= 150 * log n, n > 2 (неопределенно для n = 1)
-```
-
-Да! По определению О-Большого `f(n)` является O(g(n)).
-
-*Пример 2*
-
-```
-f(n) = 3 * n^2
-g(n) = n
-```
-
-Является-ли `f(n)` O(g(n))?
-Является-ли `3 * n^2` O(n)?
-Посмотрим на определение О-Большого:
-
-```
-3 * n^2 <= c * n
-```
-
-Существуют-ли константы c, n<sub>0</sub> такие что выражение верно для всех n > n<sub>0</sub>?
-Нет, не существуют. `f(n)` НЕ ЯВЛЯЕТСЯ O(g(n)).
-
-### Омега-Большое
-Омега-Большое, записывается как **Ω**, это асимптотическая запись для оценки
-лучшего случая или для ограничения заданой функции снизу. Это позволяет сделать
-_**асимптотическую оценку нижней границы**_ скорости роста времени выполнения 
-алгоритма. 
-
-`f(n)` принадлежит Ω(g(n)), если существуют действительные константы
-с (с > 0) и <sub>0</sub> (n<sub>0</sub> > 0), такие что `f(n)` >= `c g(n)` для всех n > n<sub>0</sub>.
-
-### Примечание
-
-Асимптотические оценки сделаные при помощи О-Большое и Омега-Большое могут
-как быть так и не быть точными. Для того что бы обозначить что границы не
-являются асимптотически точными используются записи о-малое и омега-малое.
-
-### О-Малое
-O-Малое, записывается как **о**, это асимптотическая запись для оценки верхней
-границы времени выполнения алгоритма, при условии что граница не является
-асимптотически точной.
-
-`f(n)` является o(g(n)), если можно подобрать такие действительные константы,
-что для всех c (c > 0) найдется n<sub>0</sub> (n<sub>0</sub> > 0), так
-что `f(n)` < `c g(n)` выполняется для всех n (n > n<sub>0</sub>).
-
-Определения О-символики для О-Большое и О-Малое похожи. Главное отличие в том,
-что если f(n) = O(g(n)), тогда условие f(n) <= c g(n) выполняется если _**существует**_
-константа c > 0, но если f(n) = o(g(n)), тогда условие f(n) < c g(n) выполняется
-для _**всех**_ констант с > 0.
-
-### Омега-малое
-Омега-малое, записывается как **ω**, это асимптотическая запись для оценки
-верней границы времени выполнения алгоритма, при условии что граница не является
-асимптотически точной.
-
-`f(n)` является ω(g(n)), если можно подобрать такие действительные константы,
-что для всех c (c > 0) найдется n<sub>0</sub> (n<sub>0</sub> > 0), так
-что `f(n)` > `c g(n)` выполняется для всех n (n > n<sub>0</sub>)
-
-Определения Ω-символики и ω-символики похожи. Главное отличие в том, что
-если f(n) = Ω(g(n)), тогда условие f(n) >= c g(n) выполняется если _**существует**_
-константа c > 0, но если f(n) = ω(g(n)), тогда условие f(n) > c g(n)
-выполняется для _**всех**_ констант с > 0.
-
-### Тета
-Тета, записывается как **Θ**, это асимптотическая запись для оценки
-_***асимптотически точной границы***_ времени выполнения алгоритма.
-
-`f(n)` является Θ(g(n)), если для некоторых действительных
-констант c1, c2 и n<sub>0</sub> (c1 > 0, c2 > 0, n<sub>0</sub> > 0),
-`c1 g(n)` < `f(n)` < `c2 g(n)` для всех n (n > n<sub>0</sub>).
-
-∴ `f(n)` является Θ(g(n)) означает что `f(n)` является O(g(n))
-и `f(n)` является Ω(g(n)).
-
-О-Большое основной инструмент для анализа сложности алгоритмов.
-Так же смотрите примеры по ссылкам.
-
-### Заключение
-Такую тему сложно изложить кратко, поэтому обязательно стоит пройти по ссылкам и
-посмотреть дополнительную литературу. В них дается более глубокое описание с
-определениями и примерами.
-
-
-## Дополнительная литература
-
-* [Алгоритмы на Java](https://www.ozon.ru/context/detail/id/18319699/)
-* [Алгоритмы. Построение и анализ](https://www.ozon.ru/context/detail/id/33769775/)
-
-## Ссылки
-
-* [Оценки времени исполнения. Cимвол O()](http://algolist.manual.ru/misc/o_n.php)
-* [Асимптотический анализ и теория вероятностей](https://www.lektorium.tv/course/22903)
-
-## Ссылки (Eng)
-
-* [Algorithms, Part I](https://www.coursera.org/learn/algorithms-part1)
-* [Cheatsheet 1](http://web.mit.edu/broder/Public/asymptotics-cheatsheet.pdf)
-* [Cheatsheet 2](http://bigocheatsheet.com/)
-
+---

+category: Algorithms & Data Structures

+name: Asymptotic Notation

+contributors:

+    - ["Jake Prather", "http://github.com/JakeHP"]

+    - ["Divay Prakash", "http://github.com/divayprakash"]

+translators:

+    - ["pru-mike", "http://github.com/pru-mike"]

+lang: ru-ru

+---

+

+# О-символика

+

+## Что это такое?

+

+О-символика, или асимптотическая запись, — это система символов, позволяющая

+оценить время выполнения алгоритма, устанавливая зависимость времени выполнения

+от увеличения объёма входных данных. Она также известна как оценка

+сложности алгоритмов. Станет ли алгоритм невероятно медленным, когда

+объём входных данных увеличится? Будет ли алгоритм выполняться достаточно быстро,

+если объём входных данных возрастёт? О-символика позволяет ответить на эти

+вопросы.

+

+## Можно ли по-другому найти ответы на эти вопросы?

+

+Один способ — это подсчитать число элементарных операций в зависимости от

+различных объёмов входных данных. Хотя это и приемлемое решение, тот объём

+работы, которого оно потребует, даже для простых алгоритмов делает его 

+использование неоправданным.

+

+Другой способ — это измерить, какое время алгоритм потребует для завершения на

+различных объёмах входных данных. В то же время, точность и относительность

+этого метода (полученное время будет относиться только к той машине, на которой 

+оно вычислено) зависит от среды выполнения: компьютерного аппаратного

+обеспечения, мощности процессора и т.д.

+

+## Виды О-символики

+

+В первом разделе этого документа мы определили, что О-символика

+позволяет оценивать алгоритмы в зависимости от изменения размера входных

+данных. Представим, что алгоритм — это функция f, n — размер входных данных и 

+f(n) — время выполнения. Тогда для данного алгоритма f с размером входных

+данных n получим какое-то результирующее время выполнения f(n).

+Из этого можно построить график, где ось y — время выполнения, ось x — размер входных

+данных, а точки на графике — это время выполнения для заданного размера входных

+данных.

+

+С помощью О-символики можно оценить функцию или алгоритм

+несколькими различными способами. Например, можно оценить алгоритм исходя

+из нижней оценки, верхней оценки, тождественной оценки. Чаще всего встречается

+анализ на основе верхней оценки. Как правило не используется нижняя оценка,

+потому что она не подходит под планируемые условия. Отличный пример — алгоритмы

+сортировки, особенно добавление элементов в древовидную структуру. Нижняя оценка

+большинства таких алгоритмов может быть дана как одна операция. В то время как в

+большинстве случаев добавляемые элементы должны быть отсортированы

+соответствующим образом при помощи дерева, что может потребовать обхода целой

+ветви. Это и есть худший случай, для которого планируется верхняя оценка.

+

+### Виды функций, пределы и упрощения

+

+```

+Логарифмическая функция — log n

+Линейная функция — an + b

+Квадратичная функция — an^2 + bn +c

+Степенная функция — an^z + . . . + an^2 + a*n^1 + a*n^0, где z — константа

+Показательная функция — a^n, где a — константа

+```

+

+Приведены несколько базовых функций, используемых при определении сложности в

+различных оценках. Список начинается с самой медленно возрастающей функции

+(логарифм, наиболее быстрое время выполнения) и следует до самой быстро

+возрастающей функции (экспонента, самое медленное время выполнения). Отметим,

+что в то время, как «n», или размер входных данных, возрастает в каждой из этих функций,

+результат намного быстрее возрастает в квадратичной, степенной

+и показательной по сравнению с логарифмической и линейной.

+

+Крайне важно понимать, что при использовании описанной далее нотации необходимо

+использовать упрощённые выражения.

+Это означает, что необходимо отбрасывать константы и слагаемые младших порядков,

+потому что если размер входных данных (n в функции f(n) нашего примера)

+увеличивается до бесконечности (в пределе), тогда слагаемые младших порядков

+и константы становятся пренебрежительно малыми. Таким образом, если есть

+константа, например, размера 2^9001 или любого другого невообразимого размера,

+надо понимать, что её упрощение внесёт значительные искажения в точность

+оценки.

+

+Т.к. нам нужны упрощённые выражения, немного скорректируем нашу таблицу...

+

+```

+Логарифм — log n

+Линейная функция — n

+Квадратичная функция — n^2

+Степенная функция — n^z, где z — константа

+Показательная функция — a^n, где a — константа

+```

+

+### О Большое

+О Большое, записывается как **О**, — это асимптотическая запись для оценки худшего

+случая, или для ограничения заданной функции сверху. Это позволяет сделать 

+_**асимптотическую оценку верхней границы**_ скорости роста времени выполнения 

+алгоритма. Пусть `f(n)` — время выполнения алгоритма, а `g(n)` — заданная временная

+сложность, которая проверяется для алгоритма. Тогда `f(n)` — это O(g(n)), если

+существуют действительные константы c (c > 0) и n<sub>0</sub>, такие,

+что `f(n)` <= `c g(n)` выполняется для всех n, начиная с некоторого n<sub>0</sub> (n > n<sub>0</sub>).

+

+*Пример 1*

+

+```

+f(n) = 3log n + 100

+g(n) = log n

+```

+

+Является ли `f(n)` O(g(n))?

+Является ли `3 log n + 100` O(log n)?

+Посмотрим на определение О Большого:

+

+```

+3log n + 100 <= c * log n

+```

+

+Существуют ли константы c и n<sub>0</sub>, такие, что выражение верно для всех n > n<sub>0</sub>?

+

+```

+3log n + 100 <= 150 * log n, n > 2 (не определенно для n = 1)

+```

+

+Да! По определению О Большого `f(n)` является O(g(n)).

+

+*Пример 2*

+

+```

+f(n) = 3 * n^2

+g(n) = n

+```

+

+Является ли `f(n)` O(g(n))?

+Является ли `3 * n^2` O(n)?

+Посмотрим на определение О Большого:

+

+```

+3 * n^2 <= c * n

+```

+

+Существуют ли константы c и n<sub>0</sub>, такие, что выражение верно для всех n > n<sub>0</sub>?

+Нет, не существуют. `f(n)` НЕ ЯВЛЯЕТСЯ O(g(n)).

+

+### Омега Большое

+Омега Большое, записывается как **Ω**, — это асимптотическая запись для оценки

+лучшего случая, или для ограничения заданной функции снизу. Это позволяет сделать

+_**асимптотическую оценку нижней границы**_ скорости роста времени выполнения 

+алгоритма. 

+

+`f(n)` является Ω(g(n)), если существуют действительные константы

+c (c > 0) и n<sub>0</sub> (n<sub>0</sub> > 0), такие, что `f(n)` >= `c g(n)` для всех n > n<sub>0</sub>.

+

+### Примечание

+

+Асимптотические оценки, сделаные при помощи О Большого и Омега Большого, могут

+как являться, так и не являться точными. Для того, чтобы обозначить, что границы не

+являются асимптотически точными, используются записи О Малое и Омега Малое.

+

+### О Малое

+O Малое, записывается как **о**, — это асимптотическая запись для оценки верхней

+границы времени выполнения алгоритма при условии, что граница не является

+асимптотически точной.

+

+`f(n)` является o(g(n)), если можно подобрать такие действительные константы,

+что для всех c (c > 0) найдётся n<sub>0</sub> (n<sub>0</sub> > 0), так

+что `f(n)` < `c g(n)` выполняется для всех n (n > n<sub>0</sub>).

+

+Определения О-символики для О Большого и О Малого похожи. Главное отличие в том,

+что если f(n) = O(g(n)), тогда условие f(n) <= c g(n) выполняется, если _**существует**_

+константа c > 0, но если f(n) = o(g(n)), тогда условие f(n) < c g(n) выполняется

+для _**всех**_ констант c > 0.

+

+### Омега Малое

+Омега Малое, записывается как **ω**, — это асимптотическая запись для оценки

+верхней границы времени выполнения алгоритма при условии, что граница не является

+асимптотически точной.

+

+`f(n)` является ω(g(n)), если можно подобрать такие действительные константы,

+что для всех c (c > 0) найдётся n<sub>0</sub> (n<sub>0</sub> > 0), так

+что `f(n)` > `c g(n)` выполняется для всех n (n > n<sub>0</sub>).

+

+Определения Ω-символики и ω-символики похожи. Главное отличие в том, что

+если f(n) = Ω(g(n)), тогда условие f(n) >= c g(n) выполняется, если _**существует**_

+константа c > 0, но если f(n) = ω(g(n)), тогда условие f(n) > c g(n)

+выполняется для _**всех**_ констант c > 0.

+

+### Тета

+Тета, записывается как **Θ**, — это асимптотическая запись для оценки

+_***асимптотически точной границы***_ времени выполнения алгоритма.

+

+`f(n)` является Θ(g(n)), если для некоторых действительных

+констант c1, c2 и n<sub>0</sub> (c1 > 0, c2 > 0, n<sub>0</sub> > 0)

+`c1 g(n)` < `f(n)` < `c2 g(n)` для всех n (n > n<sub>0</sub>).

+

+∴ `f(n)` является Θ(g(n)) означает, что `f(n)` является O(g(n))

+и `f(n)` является Ω(g(n)).

+

+О Большое — основной инструмент для анализа сложности алгоритмов.

+Также см. примеры по ссылкам.

+

+### Заключение

+Такую тему сложно изложить кратко, поэтому обязательно стоит пройти по ссылкам и

+посмотреть дополнительную литературу. В ней даётся более глубокое описание с

+определениями и примерами.

+

+

+## Дополнительная литература

+

+* [Алгоритмы на Java](https://www.ozon.ru/context/detail/id/18319699/)

+* [Алгоритмы. Построение и анализ](https://www.ozon.ru/context/detail/id/33769775/)

+

+## Ссылки

+

+* [Оценки времени исполнения. Символ O()](http://algolist.manual.ru/misc/o_n.php)

+* [Асимптотический анализ и теория вероятностей](https://www.lektorium.tv/course/22903)

+

+## Ссылки (англ.)

+

+* [Algorithms, Part I](https://www.coursera.org/learn/algorithms-part1)

+* [Cheatsheet 1](http://web.mit.edu/broder/Public/asymptotics-cheatsheet.pdf)

+* [Cheatsheet 2](http://bigocheatsheet.com/)

+

diff --git a/ru-ru/bash-ru.html.markdown b/ru-ru/bash-ru.html.markdown
index 5e99afc2..ce918340 100644
--- a/ru-ru/bash-ru.html.markdown
+++ b/ru-ru/bash-ru.html.markdown
@@ -11,29 +11,40 @@ contributors:
     - ["Rahil Momin", "https://github.com/iamrahil"]
     - ["Gregrory Kielian", "https://github.com/gskielian"]
     - ["Etan Reisner", "https://github.com/deryni"]
+    - ["Jonathan Wang", "https://github.com/Jonathansw"]   
+    - ["Leo Rudberg", "https://github.com/LOZORD"]
+    - ["Betsy Lorton", "https://github.com/schbetsy"]
+    - ["John Detter", "https://github.com/jdetter"]
+    - ["Harry Mumford-Turner", "https://github.com/harrymt"]
+    - ["Martin Nicholson", "https://github.com/mn113"]
 translators:
     - ["Andrey Samsonov", "https://github.com/kryzhovnik"]
-    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["Andre Polykanine", "https://github.com/Menelion"]
 filename: LearnBash-ru.sh
 lang: ru-ru
 ---
 
-Bash - это командная оболочка unix (unix shell), которая распространялась как оболочка для операционной системы GNU и используется в качестве оболочки по умолчанию для Linux и Mac OS X.
-Почти все нижеприведенные примеры могут быть частью shell-скриптов или исполнены напрямую в shell.
+Bash — это командная оболочка unix, которая распространялась как оболочка
+для операционной системы GNU и используется в качестве оболочки по умолчанию
+для Linux и Mac OS X.
+Почти все нижеприведённые примеры могут быть частью shell-скриптов
+или исполнены напрямую в shell.
 
 [Подробнее.](http://www.gnu.org/software/bash/manual/bashref.html)
 
 ```bash
 #!/bin/bash
-# Первая строка скрипта - это shebang, который сообщает системе, как исполнять
-# этот скрипт: http://en.wikipedia.org/wiki/Shebang_(Unix)
-# Как вы уже поняли, комментарии начинаются с #. Shebang - тоже комментарий.
+# Первая строка скрипта — это шебанг, который сообщает системе, как исполнять
+# этот скрипт: https://ru.wikipedia.org/wiki/Шебанг_(Unix)
+# Как вы уже поняли, комментарии начинаются с «#». Шебанг — тоже комментарий.
 
 # Простой пример hello world:
 echo Hello world!
 
 # Отдельные команды начинаются с новой строки или разделяются точкой с запятой:
 echo 'Это первая строка'; echo 'Это вторая строка'
+# => Это первая строка
+# => Это вторая строка
 
 # Вот так объявляется переменная:
 VARIABLE="Просто строка"
@@ -41,103 +52,234 @@ VARIABLE="Просто строка"
 # но не так:
 VARIABLE = "Просто строка"
 # Bash решит, что VARIABLE - это команда, которую он должен исполнить,
-# и выдаст ошибку, потому что не сможет найти ее.
+# и выдаст ошибку, потому что не сможет найти её.
 
 # и не так:
 VARIABLE= 'Просто строка'
-# Тут Bash решит, что 'Просто строка' - это команда, которую он должен исполнить,
-# и выдаст ошибку, потому что не сможет найти такой команды
+# Тут Bash решит, что 'Просто строка' — это команда, которую он должен
+# исполнить, и выдаст ошибку, потому что не сможет найти такой команды
 # (здесь 'VARIABLE=' выглядит как присвоение значения переменной,
 # но только в контексте исполнения команды 'Просто строка').
 
 # Использование переменой:
-echo $VARIABLE
-echo "$VARIABLE"
-echo '$VARIABLE'
-# Когда вы используете переменную - присваиваете, экспортируете и т.д. -
+echo $VARIABLE # => Просто строка
+echo "$VARIABLE" # => Просто строка
+echo '$VARIABLE' # => $Variable
+# Когда вы используете переменную — присваиваете, экспортируете и т.д. —
 # пишите её имя без $. А для получения значения переменной используйте $.
 # Заметьте, что ' (одинарные кавычки) не раскрывают переменные в них.
 
-# Подстановка строк в переменные
-echo ${VARIABLE/Просто/A}
-# Это выражение заменит первую встреченную подстроку "Просто" на "A"
+# Раскрытие параметров ${ }:
+echo ${Variable} # => Просто строка
+# Это простое использование раскрытия параметров
+# Раскрытие параметров получает значение переменной.
+# Оно «раскрывает», или печатает это значение.
+# ̶Значение можно изменить во время раскрытия.
+# Ниже приведены другие модификации при раскрытии параметров.
+
+# Замена подстрок в переменных
+echo ${Variable/Просто/Это} # => Это строка
+# Заменит первое вхождение «Просто» на «Это»
 
 # Взять подстроку из переменной
 LENGTH=7
-echo ${VARIABLE:0:LENGTH}
-# Это выражение вернет только первые 7 символов переменной VARIABLE
+echo ${VARIABLE:0:LENGTH} # => Просто 
+# Это выражение вернёт только первые 7 символов переменной VARIABLE
+echo ${Variable: -5} # => трока
+# Вернёт последние 5 символов (обратите внимание на пробел перед «-5»)
+
+# Длина строки
+echo ${#Variable} # => 13
 
-# Значение по умолчанию
-echo ${FOO:-"DefaultValueIfFOOIsMissingOrEmpty"}
+# Значение переменной по умолчанию
+echo ${FOO:-"ЗначениеПоУмолчаниюЕслиFooПустаИлиНеНайдена"}
+# => ЗначениеПоУмолчаниюЕслиFooПустаИлиНеНайдена
 # Это сработает при отсутствующем значении (FOO=) и пустой строке (FOO="");
-# ноль (FOO=0) вернет 0.
-# Заметьте, что в любом случае значение самой переменной FOO не изменится.
+# ноль (FOO=0) вернёт 0.
+# Заметьте, что в любом случае это лишь вернёт значение по умолчанию,
+# а значение самой переменной FOO не изменится.
+
+# Объявить массив из 6 элементов
+array0=(один два три четыре пять шесть)
+# Вывести первый элемент
+echo $array0 # => "один"
+# Вывести первый элемент
+echo ${array0[0]} # => "один"
+# Вывести все элементы
+echo ${array0[@]} # => "один два три четыре пять шесть"
+# Вывести число элементов
+echo ${#array0[@]} # => "6"
+# Вывести число символов в третьем элементе
+echo ${#array0[2]} # => "3"
+# Вывести 2 элемента, начиная с четвёртого
+echo ${array0[@]:3:2} # => "четыре пять"
+# Вывести все элементы, каждый на своей строке
+for i in "${array0[@]}"; do
+    echo "$i"
+done
+
+# Раскрытие скобок { }
+# Используется для создания произвольных строк
+echo {1..10} # => 1 2 3 4 5 6 7 8 9 10
+echo {a..z} # => a b c d e f g h i j k l m n o p q r s t u v w x y z
+# Выведет диапазон от начального до конечного значения
 
 # Встроенные переменные:
 # В bash есть полезные встроенные переменные, например
-echo "Последнее возвращенное значение: $?"
-echo "PID скрипта: $$"
-echo "Количество аргументов: $#"
-echo "Аргументы скрипта: $@"
+echo "Значение, возвращённое последней программой: $?"
+echo "Идентификатор процесса скрипта: $$"
+echo "Число аргументов, переданных скрипту: $#"
+echo "Все аргументы, переданные скрипту: $@"
 echo "Аргументы скрипта, распределённые по отдельным переменным: $1 $2..."
 
-# Чтение аргументов из устройста ввода:
+# Теперь, когда мы знаем, как выводить и использовать переменные,
+# давайте изучим некоторые другие основы Bash!
+
+# Текущая директория доступна по команде `pwd`.
+# `pwd` расшифровывается как «print working directory», т.е.
+# «напечатать рабочую директорию».
+# Мы также можем использовать встроенную переменную `$PWD`.
+# Заметьте, следующие выражения эквивалентны:
+echo "Я в $(pwd)" # выполняет `pwd` и раскрывает вывод
+echo "Я в $PWD" # раскрывает переменную
+
+# Если вы получаете слишком много информации в терминале или из скрипта,
+# команда `clear` очистит экран
+clear
+# Очистить экран можно также с помощью Ctrl+L
+
+# Чтение аргументов с устройства ввода:
 echo "Как Вас зовут?"
 read NAME # Обратите внимание, что нам не нужно определять новую переменную
 echo Привет, $NAME!
 
 # У нас есть обычная структура if:
 # наберите 'man test' для получения подробной информации о форматах условия
-if [ $NAME -ne $USER ]
+if [ $NAME != $USER ]
 then
     echo "Имя не совпадает с именем пользователя"
 else
     echo "Имя совпадает с именем пользователя"
 fi
+# Истинно, если значение $Name не совпадает с текущим именем пользователя
 
-# Примечание: если $Name пустой, bash интерпретирует код как:
-if [ -ne $USER ]
+# Примечание: если $Name пуста, bash интерпретирует код так:
+if [ != $USER ]
 # а это ошибочная команда
-# поэтому такие переменные нужно использовать так:
-if [ "$Name" -ne $USER ] ...
-# когда $Name пустой, bash видит код как:
-if [ "" -ne $USER ] ...
+# поэтому «безопасный» способ использовать пустые переменные в Bash таков:
+if [ "$Name" != $USER ] ...
+# при этом, когда $Name пуста, bash видит код так:
+if [ "" != $USER ] ...
 # что работает правильно
 
 # Также есть условное исполнение
 echo "Исполнится всегда" || echo "Исполнится, если первая команда завершится ошибкой"
+# => Исполнится всегда
 echo "Исполнится всегда" && echo "Исполнится, если первая команда выполнится удачно"
+# => Исполнится всегда
+# => Исполнится, если первая команда выполнится удачно
 
-# Можно использовать && и || в выражениях if, когда нужно несколько пар скобок:
-if [ $NAME == "Steve" ] && [ $AGE -eq 15 ]
+
+# Чтобы использовать && и || в выражениях if, нужно несколько пар скобок:
+if [ $NAME == "Стив" ] && [ $AGE -eq 15 ]
+then
+    echo "Исполнится, если $NAME равно Стив И $AGE равно 15."
+fi
+
+if [ $NAME == "Дания" ] || [ $NAME == "Зак" ]
 then
-    echo "Исполнится, если $NAME равно Steve И $AGE равно 15."
+    echo "Исполнится, если $NAME равно Дания ИЛИ Зак."
 fi
 
-if [ $NAME == "Daniya" ] || [ $NAME == "Zach" ]
+# Есть ещё оператор «=~», который проверяет строку
+# на соответствие регулярному выражению:
+Email=me@example.com
+if [[ "$Email" =~ [a-z]+@[a-z]{2,}\.(com|net|org) ]]
 then
-    echo "Исполнится, если $NAME равно Daniya ИЛИ Zach."
+    echo "адрес корректный!"
 fi
+# Обратите внимание, что =~ работает только внутри
+# двойных квадратных скобок [[ ]],
+# которые несколько отличаются от одинарных скобок [ ].
+# Для более подробной информации см. http://www.gnu.org/software/bash/manual/bashref.html#Conditional-Constructs.
+
+# Переопределить команду «ping» как псевдоним для отправки только пяти пакетов
+alias ping='ping -c 5'
+# Экранировать псевдоним и использовать команду под своим именем вместо него
+\ping 192.168.1.1
+# Вывести все псевдонимы
+alias -p
 
 # Выражения обозначаются таким форматом:
-echo $(( 10 + 5 ))
+echo $(( 10 + 5 )) # => 15
 
-# В отличие от других языков программирования, Bash - это командная оболочка,
+# В отличие от других языков программирования, Bash — это командная оболочка,
 # а значит, работает в контексте текущей директории.
 # Вы можете просматривать файлы и директории в текущей директории командой ls:
-ls
+ls # перечисляет файлы и поддиректории в текущей директории
 
-# У этой команды есть опции:
+# У этой команды есть параметры:
 ls -l # Показать каждый файл и директорию на отдельной строке
+ls -t # сортирует содержимое по дате последнего изменения (в обратном порядке)
+ls -R # Рекурсивно выполняет `ls` по данной директории и всем её поддиректориям
 
 # Результат предыдущей команды может быть направлен на вход следующей.
 # Команда grep фильтрует ввод по шаблону.
-# Так мы можем просмотреть только *.txt файлы в текущей директории:
+# Так мы можем просмотреть только *.txt-файлы в текущей директории:
 ls -l | grep "\.txt"
 
+# Для вывода файлов в стандартный поток используйте `cat`:
+cat file.txt
+
+# С помощью `cat` мы также можем читать файлы:
+Contents=$(cat file.txt)
+echo "НАЧАЛО ФАЙЛА\n$Contents\nКОНЕЦ ФАЙЛА" # «\n» выводит символ перевода на новую строку
+# => НАЧАЛО ФАЙЛА
+# => [Содержимое file.txt]
+# => КОНЕЦ ФАЙЛА
+
+# Для копирования файлов и директорий из одного места в другое используйте `cp`.
+# `cp` создаёт новые версии исходных элементов,
+# так что редактирование копии не повлияет на оригинал (и наоборот).
+# Обратите внимание, что команда перезапишет целевой элемент, если он уже существует.
+cp srcFile.txt clone.txt
+cp -r srcDirectory/ dst/ # рекурсивное копирование
+
+# Если вам нужно обмениваться файлами между компьютерами, посмотрите в сторону `scp` или `sftp`.
+# `scp` ведёт себя очень похоже на `cp`.
+# `sftp` более интерактивна.
+
+# Для перемещения файлов и директорий из одного места в другое используйте `mv`.
+# Команда `mv` похожа на `cp`, но она удаляет исходный элемент.
+# `mv` также можно использовать для переименования файлов!
+mv s0urc3.txt dst.txt # Извините, тут были Leet-хакеры...
+
+# Поскольку Bash работает в контексте текущей директории, вам может понадобиться
+# запустить команду в другой директории.
+# Для изменения местоположения у нас есть `cd`:
+cd ~    # Перейти в домашнюю директорию
+cd      # Также переходит в домашнюю директорию
+cd ..   # Перейти на уровень вверх
+        # (например, из /home/username/Downloads в /home/username)
+cd /home/username/Documents   # перейти в указанную директорию
+cd ~/Documents/..    # Всё ещё в домашней директории. Так ведь??
+cd -    # Перейти в последнюю директорию
+# => /home/username/Documents
+
+# Для работы по директориям используйте субоболочки
+(echo "Сначала я здесь: $PWD") && (cd someDir; echo "А теперь я тут: $PWD")
+pwd # всё ещё в первой директории
+
+# Для создания новых директорий используйте `mkdir`.
+mkdir myNewDir
+# Флаг `-p` указывает, что нужно создать все промежуточные директории, если нужно.
+mkdir -p myNewDir/with/intermediate/directories
+# Если промежуточные директории до этого не существовали,
+# вышеприведённая команда без флага `-p` вернёт ошибку
+
 # Вы можете перенаправить ввод и вывод команды (stdin, stdout и stderr).
-# Следующая команда означает: читать из stdin, пока не встретится ^EOF$, и
-# перезаписать hello.py следующим строками (до строки "EOF"):
+# Прочитать из stdin, пока не встретится ^EOF$, и
+# перезаписать hello.py следующими строками (до строки "EOF"):
 cat > hello.py << EOF
 #!/usr/bin/env python
 from __future__ import print_function
@@ -147,23 +289,25 @@ print("#stderr", file=sys.stderr)
 for line in sys.stdin:
     print(line, file=sys.stdout)
 EOF
+# Если первый «EOF» не заключён в кавычки, переменные будут раскрыты
 
 # Запуск hello.py с разными вариантами перенаправления потоков
 # стандартных ввода, вывода и ошибок:
-python hello.py < "input.in"
-python hello.py > "output.out"
-python hello.py 2> "error.err"
-python hello.py > "output-and-error.log" 2>&1
-python hello.py > /dev/null 2>&1
+python hello.py < "input.in" # передать input.in в качестве ввода в скрипт
+python hello.py > "output.out" # передать вывод скрипта в output.out
+python hello.py 2> "error.err" # передать вывод ошибок в error.err
+python hello.py > "output-and-error.log" 2>&1 # передать вывод скрипта и ошибок в output-and-error.log
+python hello.py > /dev/null 2>&1 # передать вывод скрипта и ошибок в «чёрную дыру» /dev/null, т.е., без вывода
 # Поток ошибок перезапишет файл, если этот файл существует,
-# поэтому, если вы хотите дописывать файл, используйте ">>":
+# поэтому, если вы хотите дописывать файл, используйте «>>»:
 python hello.py >> "output.out" 2>> "error.err"
 
-# Переписать output.txt, дописать error.err и сосчитать строки:
+# Перезаписать output.txt, дописать error.err и сосчитать строки:
 info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
 wc -l output.out error.err
 
-# Запустить команду и вывести ее файловый дескриптор (смотрите: man fd)
+# Запустить команду и вывести её файловый дескриптор (например, /dev/fd/123)
+# См. man fd
 echo <(echo "#helloworld")
 
 # Перезаписать output.txt строкой "#helloworld":
@@ -172,40 +316,49 @@ echo "#helloworld" > output.out
 echo "#helloworld" | cat > output.out
 echo "#helloworld" | tee output.out >/dev/null
 
-# Подчистить временные файлы с подробным выводом ('-i' - интерактивый режим)
+# Подчистить временные файлы с подробным выводом ('-i' — интерактивный режим)
+# ВНИМАНИЕ: команду `rm` отменить нельзя
 rm -v output.out error.err output-and-error.log
+rm -r tempDir/ # рекурсивное удаление
 
 # Команды могут быть подставлены в строку с помощью $( ):
 # следующие команды выводят число файлов и директорий в текущей директории.
 echo "Здесь $(ls | wc -l) элементов."
 
-# То же самое можно сделать с использованием обратных кавычек,
+# То же самое можно сделать с использованием обратных кавычек «``»,
 # но они не могут быть вложенными, поэтому предпочтительно использовать $( ).
 echo "Здесь `ls | wc -l` элементов."
 
 # В Bash есть структура case, которая похожа на switch в Java и C++:
 case "$VARIABLE" in 
-    # Перечислите шаблоны для условий, которые хотите отловить
+    # Перечислите шаблоны для условий, которые хотите выполнить
     0) echo "Тут ноль.";;
     1) echo "Тут один.";;
     *) echo "Это не пустое значение.";;
 esac
 
-# Цикл for перебирает элементы переданные в аргументе:
+# Цикл for перебирает элементы по количеству аргументов:
 # Содержимое $VARIABLE будет напечатано три раза.
 for VARIABLE in {1..3}
 do
     echo "$VARIABLE"
 done
+# => 1
+# => 2
+# => 3
+
 
-# Или с использованием "традиционного" синтаксиса цикла for:
+# Или с использованием «традиционного» синтаксиса цикла for:
 for ((a=1; a <= 3; a++))
 do
     echo $a
 done
+# => 1
+# => 2
+# => 3
 
 # Цикл for можно использовать для действий с файлами.
-# Запустим команду 'cat' для файлов file1 и file2
+# Запустим команду «cat» для файлов file1 и file2
 for VARIABLE in file1 file2
 do
     cat "$VARIABLE"
@@ -221,52 +374,89 @@ done
 # Цикл while:
 while [ true ]
 do
-    echo "тело цикла здесь..."
+    echo "Здесь тело цикла..."
     break
 done
+# => Здесь тело цикла...
 
-# Вы можете определять функции
+# Вы также можете определять функции
 # Определение:
 function foo ()
 {
-    echo "Аргументы работают также, как аргументы скрипта: $@"
-    echo "и: $1 $2..."
+    echo "Аргументы работают так же, как и аргументы скрипта: $@"
+    echo "И так: $1 $2..."
     echo "Это функция"
     return 0
 }
+# Вызовем функцию `foo` с двумя аргументами, arg1 и arg2:
+foo arg1 arg2
+# => Аргументы работают так же, как и аргументы скрипта: arg1 arg2
+# => И так: arg1 arg2...
+# => Это функция
 
 # или просто
 bar ()
 {
-    echo "Другой способ определить функцию!"
+    echo "Другой способ определять функции!"
     return 0
 }
+# Вызовем функцию `bar` без аргументов:
+bar # => Другой способ определять функции!
 
 # Вызов функции
-foo "Мое имя" $NAME
+foo "Меня зовут" $NAME
 
 # Есть много полезных команд, которые нужно знать:
 # напечатать последние 10 строк файла file.txt
 tail -n 10 file.txt
+
 # напечатать первые 10 строк файла file.txt
 head -n 10 file.txt
+
 # отсортировать строки file.txt
 sort file.txt
-# отобрать или наоборот пропустить повторяющиеся строки (с опцией -d отбирает)
+
+# отобрать или наоборот пропустить повторяющиеся строки (с параметром `-d` отбирает строки)
 uniq -d file.txt
-# напечатать только первую колонку перед символом ','
+
+# напечатать только первый столбец перед символом «,»
 cut -d ',' -f 1 file.txt
-# заменить каждое 'okay' на 'great' в файле file.txt (regex поддерживается)
-sed -i 's/okay/great/g' file.txt
-# вывести в stdout все строки из file.txt, совпадающие с шаблоном regex;
-# этот пример выводит строки, которые начинаются на "foo" и оканчиваются "bar"
+
+# заменить каждое вхождение «хорошо» на «прекрасно» в файле file.txt
+# (поддерживаются регулярные выражения)
+sed -i 's/хорошо/прекрасно/g' file.txt
+
+# вывести в stdout все строки из file.txt, соответствующие регулярному выражению
+# этот пример выводит строки, которые начинаются на «foo» и оканчиваются на «bar»
 grep "^foo.*bar$" file.txt
-# передайте опцию -c чтобы вывести число строк, в которых совпал шаблон
+
+# Передайте параметр `-c`, чтобы вывести лишь число строк,
+# соответствующих регулярному выражению
 grep -c "^foo.*bar$" file.txt
-# чтобы искать по строке, а не шаблону regex, используйте fgrep (или grep -F)
+
+# Ниже приведены другие полезные параметры:
+grep -r "^foo.*bar$" someDir/ # рекурсивный `grep`
+grep -n "^foo.*bar$" file.txt # задаются номера строк
+grep -rI "^foo.*bar$" someDir/ # рекурсивный `grep` с игнорированием двоичных файлов
+
+# Выполнить тот же изначальный поиск, но удалив строки, содержащие «baz»
+grep "^foo.*bar$" file.txt | grep -v "baz"
+
+# чтобы искать непосредственно по строке, а не в соответствии 
+# с регулярным выражением, используйте fgrep (или grep -F):
 fgrep "^foo.*bar$" file.txt 
 
-# Читайте встроенную документацию оболочки Bash командой 'help':
+# Команда `trap` позволяет выполнить некую команду, когда ваш скрипт
+# принимает определённый Posix-сигнал. В следующем примере `trap` выполнит `rm`,
+# если скрипт примет один из трёх перечисленных сигналов.
+trap "rm $TEMP_FILE; exit" SIGHUP SIGINT SIGTERM
+
+# `sudo` используется для выполнения команд с правами суперпользователя
+NAME1=$(whoami)
+NAME2=$(sudo whoami)
+echo "Был $NAME1, затем стал более мощным $NAME2"
+
+# Читайте встроенную документацию оболочки Bash командой `help`:
 help
 help help
 help for
@@ -274,18 +464,18 @@ help return
 help source
 help .
 
-# Читайте Bash man-документацию
+# Читайте man-документацию Bash командой `man`:
 apropos bash
 man 1 bash
 man bash
 
-# Читайте документацию info (? для помощи)
+# Читайте документацию info (? для справки)
 apropos info | grep '^info.*('
 man info
 info info
 info 5 info
 
-# Читайте bash info документацию:
+# Читайте info-документацию Bash:
 info bash
 info bash 'Bash Features'
 info bash 6
diff --git a/ru-ru/c++-ru.html.markdown b/ru-ru/c++-ru.html.markdown
index b9704fc3..c6ac5694 100644
--- a/ru-ru/c++-ru.html.markdown
+++ b/ru-ru/c++-ru.html.markdown
@@ -471,6 +471,7 @@ int main() {
 // членам\методам без открытых или защищенных методов для этого.
 class OwnedDog : public Dog {
 
+public:
     void setOwner(const std::string& dogsOwner);
 
     // Переопределяем поведение функции печати для всех OwnedDog. Смотрите
@@ -582,10 +583,10 @@ public:
 
 // Во время компиляции компилятор фактически генерирует копии каждого шаблона
 // с замещенными параметрами, поэтому полное определение класса должно присутствовать
-// при каждом вызове. Именно поэтому классы шаблонов полностью определены в
+// при каждом вызове. Именно поэтому шаблоны классов полностью определены в
 // заголовочных файлах.
 
-// Чтобы создать экземпляр класса шаблона на стеке:
+// Чтобы создать экземпляр шаблона класса на стеке:
 Box<int> intBox;
 
 // и вы можете использовать его, как и ожидалось:
@@ -605,7 +606,7 @@ boxOfBox.insert(intBox);
 //   http://en.wikipedia.org/wiki/Typename
 // (да-да, это ключевое слово имеет собственную страничку на вики).
 
-// Аналогичным образом, шаблонная функция:
+// Аналогичным образом, шаблон функции:
 template<class T>
 void barkThreeTimes(const T& input)
 {
@@ -622,7 +623,7 @@ Dog fluffy;
 fluffy.setName("Fluffy");
 barkThreeTimes(fluffy); // Печатает "Fluffy barks" три раза.
 
-//Параметры шаблона не должны быть классами:
+// Параметры шаблона не должны быть классами:
 template<int Y>
 void printMessage() {
   cout << "Learn C++ in " << Y << " minutes!" << endl;
@@ -680,7 +681,7 @@ catch (...)
 // некоторого ресурса неразрывно совмещается с инициализацией, а освобождение -
 // с уничтожением объекта.
 
-// Чтобы понять, на сколько это полезно,
+// Чтобы понять, насколько это полезно,
 // рассмотрим функцию, которая использует обработчик файлов в С:
 void doSomethingWithAFile(const char* filename)
 {
@@ -886,7 +887,6 @@ v.swap(vector<Foo>());
 ```
 ## Дальнейшее чтение:
 
-Наиболее полное и обновленное руководство по С++ можно найти на
-<http://cppreference.com/w/cpp>
-
-Дополнительные ресурсы могут быть найдены на <http://cplusplus.com>
+* Наиболее полное и обновленное руководство по С++ можно найти на [CPP Reference](http://cppreference.com/w/cpp).
+* Дополнительные ресурсы могут быть найдены на [CPlusPlus](http://cplusplus.com).
+* Учебник, посвященный основам языка и настройке среды кодирования, доступен в [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb).
diff --git a/ru-ru/clojure-ru.html.markdown b/ru-ru/clojure-ru.html.markdown
index 356d1cc0..19233d23 100644
--- a/ru-ru/clojure-ru.html.markdown
+++ b/ru-ru/clojure-ru.html.markdown
@@ -8,9 +8,9 @@ translators:
 lang: ru-ru
 ---
 
-Clojure, это представитель семейства Lisp-подобных языков, разработанный
+Clojure — это представитель семейства Lisp-подобных языков, разработанный
 для Java Virtual Machine. Язык идейно гораздо ближе к чистому
-[функциональному программированию](https://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) чем его прародитель Common Lisp, но в то же время обладает набором инструментов для работы с состоянием,
+[функциональному программированию](https://ru.wikipedia.org/wiki/%D0%A4%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D0%BE%D0%BD%D0%B0%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5), чем его прародитель Common Lisp, но в то же время обладает набором инструментов для работы с состоянием,
 таких как [STM](https://ru.wikipedia.org/wiki/Software_transactional_memory).
 
 Благодаря такому сочетанию технологий в одном языке, разработка программ,
@@ -23,9 +23,9 @@ Clojure, это представитель семейства Lisp-подобн�
 ```clojure
 ; Комментарии начинаются символом ";".
 
-; Код на языке Clojure записывается в виде "форм",
+; Код на языке Clojure записывается в виде «форм»,
 ; которые представляют собой обычные списки элементов, разделенных пробелами,
-; заключённые в круглые скобки
+; заключённые в круглые скобки.
 ;
 ; Clojure Reader (инструмент языка, отвечающий за чтение исходного кода),
 ; анализируя форму, предполагает, что первым элементом формы (т.е. списка)
@@ -76,32 +76,32 @@ Clojure, это представитель семейства Lisp-подобн�
 '(+ 1 2) ; => (+ 1 2)
 ; ("'", это краткая запись формы (quote (+ 1 2))
 
-; "Квотированный" список можно вычислить, передав его функции eval
+; «Квотированный» список можно вычислить, передав его функции eval
 (eval '(+ 1 2)) ; => 3
 
 ; Коллекции и Последовательности
 ;;;;;;;;;;;;;;;;;;;
 
-; Списки (Lists) в clojure структурно представляют собой "связанные списки",
+; Списки (Lists) в clojure структурно представляют собой «связанные списки»,
 ; тогда как Векторы (Vectors), устроены как массивы.
 ; Векторы и Списки тоже являются классами Java!
 (class [1 2 3]); => clojure.lang.PersistentVector
 (class '(1 2 3)); => clojure.lang.PersistentList
 
-; Список может быть записан, как (1 2 3), но в этом случае
+; Список может быть записан как (1 2 3), но в этом случае
 ; он будет воспринят reader`ом, как вызов функции.
 ; Есть два способа этого избежать:
 ; '(1 2 3)     - квотирование,
 ; (list 1 2 3) - явное конструирование списка с помощью функции list.
 
-; "Коллекции", это некие наборы данных
+; «Коллекции» — это некие наборы данных.
 ; И списки, и векторы являются коллекциями:
 (coll? '(1 2 3)) ; => true
 (coll? [1 2 3]) ; => true
 
-; "Последовательности" (seqs), это абстракция над наборами данных,
+; «Последовательности» (seqs) — это абстракция над наборами данных,
 ; элементы которых "упакованы" последовательно.
-; Списки - последовательности, а вектора - нет.
+; Списки — последовательности, а векторы — нет.
 (seq? '(1 2 3)) ; => true
 (seq? [1 2 3]) ; => false
 
@@ -119,7 +119,7 @@ Clojure, это представитель семейства Lisp-подобн�
 
 ; Функция conj добавляет элемент в коллекцию
 ; максимально эффективным для неё способом.
-; Для списков эффективно добавление в начло, а для векторов - в конец.
+; Для списков эффективно добавление в начло, а для векторов — в конец.
 (conj [1 2 3] 4) ; => [1 2 3 4]
 (conj '(1 2 3) 4) ; => (4 1 2 3)
 
@@ -130,7 +130,7 @@ Clojure, это представитель семейства Lisp-подобн�
 (map inc [1 2 3]) ; => (2 3 4)
 (filter even? [1 2 3]) ; => (2)
 
-; reduce поможет "свернуть" коллекцию
+; reduce поможет «свернуть» коллекцию
 (reduce + [1 2 3 4])
 ; = (+ (+ (+ 1 2) 3) 4)
 ; => 10
@@ -144,12 +144,12 @@ Clojure, это представитель семейства Lisp-подобн�
 ;;;;;;;;;;;;;;;;;;;;;
 
 ; Функция создается специальной формой fn.
-; "Тело" функции может состоять из нескольких форм,
+; «Тело» функции может состоять из нескольких форм,
 ; но результатом вызова функции всегда будет результат вычисления
 ; последней из них.
 (fn [] "Hello World") ; => fn
 
-; (Вызов функции требует "оборачивания" fn-формы в форму вызова)
+; (Вызов функции требует «оборачивания» fn-формы в форму вызова)
 ((fn [] "Hello World")) ; => "Hello World"
 
 ; Назначить значению имя можно специальной формой def
@@ -160,7 +160,7 @@ x ; => 1
 (def hello-world (fn [] "Hello World"))
 (hello-world) ; => "Hello World"
 
-; Поскольку именование функций - очень частая операция,
+; Поскольку именование функций — очень частая операция,
 ; clojure позволяет, сделать это проще:
 (defn hello-world [] "Hello World")
 
@@ -211,7 +211,7 @@ x ; => 1
 
 ; Отображения могут использовать в качестве ключей любые хэшируемые значения,
 ; однако предпочтительными являются ключи,
-; являющиеся "ключевыми словами" (keywords)
+; являющиеся «ключевыми словами» (keywords)
 (class :a) ; => clojure.lang.Keyword
 
 (def stringmap {"a" 1, "b" 2, "c" 3})
@@ -263,7 +263,7 @@ keymap ; => {:a 1, :b 2, :c 3} - оригинал не был затронут
 ; Исключаются - посредством disj
 (disj #{1 2 3} 1) ; => #{2 3}
 
-; Вызов множества, как функции, позволяет проверить
+; Вызов множества как функции позволяет проверить
 ; принадлежность элемента этому множеству:
 (#{1 2 3} 1) ; => 1
 (#{1 2 3} 4) ; => nil
@@ -274,8 +274,8 @@ keymap ; => {:a 1, :b 2, :c 3} - оригинал не был затронут
 ; Полезные формы
 ;;;;;;;;;;;;;;;;;
 
-; Конструкции ветвления в clojure, это обычные макросы
-; и подобны их собратьям в других языках:
+; Конструкции ветвления в clojure — это обычные макросы,
+; они подобны своим собратьям в других языках:
 (if false "a" "b") ; => "b"
 (if false "a") ; => nil
 
@@ -285,7 +285,7 @@ keymap ; => {:a 1, :b 2, :c 3} - оригинал не был затронут
 (let [a 1 b 2]
   (> a b)) ; => false
 
-; Несколько форм можно объединить в одну форму посредством do
+; Несколько форм можно объединить в одну форму посредством do.
 ; Значением do-формы будет значение последней формы из списка вложенных в неё:
 (do
   (print "Hello")
@@ -298,7 +298,7 @@ keymap ; => {:a 1, :b 2, :c 3} - оригинал не был затронут
   (str "Hello " name))
 (print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff")
 
-; Ещё один пример - let:
+; Ещё один пример — let:
 (let [name "Urkel"]
   (print "Saying hello to " name)
   (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
@@ -306,7 +306,7 @@ keymap ; => {:a 1, :b 2, :c 3} - оригинал не был затронут
 ; Модули
 ;;;;;;;;;
 
-; Форма "use" позволяет добавить в текущее пространство имен
+; Форма use позволяет добавить в текущее пространство имен
 ; все имена (вместе со значениями) из указанного модуля:
 (use 'clojure.set)
 
@@ -392,7 +392,7 @@ keymap ; => {:a 1, :b 2, :c 3} - оригинал не был затронут
 my-atom  ;=> Atom<#...> (Возвращает объект типа Atom)
 @my-atom ; => {:a 1 :b 2}
 
-; Пример реализации счётчика на атоме
+; Пример реализации счётчика на атоме:
 (def counter (atom 0))
 (defn inc-counter []
   (swap! counter inc))
@@ -414,13 +414,13 @@ my-atom  ;=> Atom<#...> (Возвращает объект типа Atom)
 
 Это руководство не претендует на полноту, но мы смеем надеяться, способно вызвать интерес к дальнейшему изучению языка.
 
-Clojure.org - сайт содержит большое количество статей по языку:
+Сайт Clojure.org содержит большое количество статей по языку:
 [http://clojure.org/](http://clojure.org/)
 
-Clojuredocs.org - сайт документации языка с примерами использования функций:
+Clojuredocs.org — сайт документации языка с примерами использования функций:
 [http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
 
-4Clojure - отличный способ закрепить навыки программирования на clojure, решая задачи вместе с коллегами со всего мира:
+4Clojure — отличный способ закрепить навыки программирования на clojure, решая задачи вместе с коллегами со всего мира:
 [http://www.4clojure.com/](http://www.4clojure.com/)
 
 Clojure-doc.org (да, именно) неплохой перечень статей для начинающих:
diff --git a/ru-ru/common-lisp-ru.html.markdown b/ru-ru/common-lisp-ru.html.markdown
new file mode 100644
index 00000000..d5f9bf0e
--- /dev/null
+++ b/ru-ru/common-lisp-ru.html.markdown
@@ -0,0 +1,704 @@
+---
+
+language: "Common Lisp"
+filename: commonlisp.lisp
+contributors:
+  - ["Paul Nathan", "https://github.com/pnathan"]
+  - ["Rommel Martinez", "https://ebzzry.io"]
+translators:
+  - ["Michael Filonenko", "https://github.com/filonenko-mikhail"]
+lang: ru-ru
+---
+
+Common Lisp - мультипарадигменный язык программирования общего назначения, подходящий для широкого
+спектра задач.
+Его частенько называют программируемым языком программирования.
+
+Идеальная отправная точка - книга [Common Lisp на практике (перевод)](http://lisper.ru/pcl/).
+Ещё одна популярная книга [Land of Lisp](http://landoflisp.com/).
+И одна из последних книг [Common Lisp Recipes](http://weitz.de/cl-recipes/) вобрала в себя лучшие
+архитектурные решения на основе опыта коммерческой работки автора.
+
+
+
+```common-lisp
+
+;;;-----------------------------------------------------------------------------
+;;; 0. Синтаксис
+;;;-----------------------------------------------------------------------------
+
+;;; Основные формы
+
+;;; Существует два фундамента CL: АТОМ и S-выражение.
+;;; Как правило, сгруппированные S-выражения называют `формами`.
+
+10            ; атом; вычисляется в самого себя
+:thing        ; другой атом; вычисляется в символ :thing
+t             ; ещё один атом, обозначает `истину` (true)
+(+ 1 2 3 4)   ; s-выражение
+'(4 :foo t)   ; ещё одно s-выражение
+
+;;; Комментарии
+
+;;; Однострочные комментарии начинаются точкой с запятой. Четыре знака подряд
+;;; используют для комментария всего файла, три для раздела, два для текущего
+;;; определения; один для текущей строки. Например:
+
+;;;; life.lisp
+
+;;; То-сё - пятое-десятое. Оптимизировано для максимального бадабума и ччччч.
+;;; Требуется для функции PoschitatBenzinIsRossiiVBelarus
+
+(defun meaning (life)
+  "Возвращает смысл Жизни"
+  (let ((meh "abc"))
+    ;; Вызывает бадабум
+    (loop :for x :across meh
+       :collect x)))                    ; сохранить значения в x, и потом вернуть
+
+;;; А вот целый блок комментария можно использовать как угодно.
+;;; Для него используются #| и |#
+
+#| Целый блок комментария, который размазан
+   на несколько строк
+    #|
+       которые могут быть вложенными!
+    |#
+|#
+
+;;; Чем пользоваться
+
+;;; Существует несколько реализаций: и коммерческих, и открытых.
+;;; Все они максимально соответствуют стандарту языка.
+;;; SBCL, например, добротен. А за дополнительными библиотеками
+;;; нужно ходить в Quicklisp
+
+;;; Обычно разработка ведется в текстовом редакторе с запущенным в цикле
+;;; интерпретатором (в CL это Read Eval Print Loop). Этот цикл (REPL)
+;;; позволяет интерактивно выполнять части программы вживую сразу наблюдая
+;;; результат.
+
+;;;-----------------------------------------------------------------------------
+;;; 1. Базовые типы и операторы
+;;;-----------------------------------------------------------------------------
+
+;;; Символы
+
+'foo ; => FOO Символы автоматически приводятся к верхнему регистру.
+
+;;; INTERN создаёт символ из строки.
+
+(intern "AAAA")        ; => AAAA
+(intern "aaa")         ; => |aaa|
+
+;;; Числа
+
+9999999999999999999999 ; целые
+#b111                  ; двоичные => 7
+#o111                  ; восьмеричные => 73
+#x111                  ; шестнадцатиричные => 273
+3.14159s0              ; с плавающей точкой
+3.14159d0              ; с плавающей точкой с двойной точностью
+1/2                    ; рациональные)
+#C(1 2)                ; комплексные
+
+;;; Вызов функции пишется как s-выражение (f x y z ....), где f это функция,
+;;; x, y, z, ... аругменты.
+
+(+ 1 2)                ; => 3
+
+;;; Если вы хотите просто представить код как данные, воспользуйтесь формой QUOTE
+;;; Она не вычисляет аргументы, а возвращает их как есть.
+;;; Она даёт начало метапрограммированию
+
+(quote (+ 1 2))        ; => (+ 1 2)
+(quote a)              ; => A
+
+;;; QUOTE можно сокращенно записать знаком '
+
+'(+ 1 2)               ; => (+ 1 2)
+'a                     ; => A
+
+;;; Арифметические операции
+
+(+ 1 1)                ; => 2
+(- 8 1)                ; => 7
+(* 10 2)               ; => 20
+(expt 2 3)             ; => 8
+(mod 5 2)              ; => 1
+(/ 35 5)               ; => 7
+(/ 1 3)                ; => 1/3
+(+ #C(1 2) #C(6 -4))   ; => #C(7 -2)
+
+;;; Булевые
+
+t                      ; истина; любое не-NIL значение `истинно`
+nil                    ; ложь; а ещё пустой список () тоже `ложь`
+(not nil)              ; => T
+(and 0 t)              ; => T
+(or 0 nil)             ; => 0
+
+;;; Строковые символы
+
+#\A                    ; => #\A
+#\λ                    ; => #\GREEK_SMALL_LETTER_LAMDA
+#\u03BB                ; => #\GREEK_SMALL_LETTER_LAMDA
+
+;;; Строки это фиксированные массивы символов
+
+"Hello, world!"
+"Тимур \"Каштан\" Бадтрудинов"   ; экранировать двойную кавычку обратным слешом
+
+;;; Строки можно соединять
+
+(concatenate 'string "ПРивет, " "мир!") ; => "ПРивет, мир!"
+
+;;; Можно пройтись по строке как по массиву символов
+
+(elt "Apple" 0) ; => #\A
+
+;;; Для форматированного вывода используется FORMAT. Он умеет выводить, как просто значения,
+;;; так и производить циклы и учитывать условия. Первый агрумент указывает куда отправить
+;;; результат. Если NIL, FORMAT вернет результат как строку, если T результат отправиться
+;;; консоль вывода а форма вернет NIL.
+
+(format nil "~A, ~A!" "Привет" "мир")   ; => "Привет, мир!"
+(format t "~A, ~A!" "Привет" "мир")     ; => NIL
+
+
+;;;-----------------------------------------------------------------------------
+;;; 2. Переменные
+;;;-----------------------------------------------------------------------------
+
+;;; С помощью DEFVAR и DEFPARAMETER вы можете создать глобальную (динамческой видимости)
+;;; переменную.
+;;; Имя переменной может состоять из любых символов кроме: ()",'`;#|\
+
+;;; Разница между DEFVAR и DEFPARAMETER в том, что повторное выполнение DEFVAR
+;;; переменную не поменяет. А вот DEFPARAMETER меняет переменную при каждом вызове.
+
+;;; Обычно глобальные (динамически видимые) переменные содержат звездочки в имени.
+
+(defparameter *some-var* 5)
+*some-var* ; => 5
+
+;;; Можете использовать unicode.
+(defparameter *КУКУ* nil)
+
+;;; Доступ к необъявленной переменной - это непредсказуемое поведение. Не делайте так.
+
+;;; С помощью LET можете сделать локальное связывание.
+;;; В следующем куске кода, `я` связывается с "танцую с тобой" только
+;;; внутри формы (let ...). LET всегда возвращает значение последней формы.
+
+(let ((я "танцую с тобой")) я) ; => "танцую с тобой"
+
+
+;;;-----------------------------------------------------------------------------;
+;;; 3. Структуры и коллекции
+;;;-----------------------------------------------------------------------------;
+
+
+;;; Структуры
+
+(defstruct dog name breed age)
+(defparameter *rover*
+    (make-dog :name "rover"
+              :breed "collie"
+              :age 5))
+*rover*            ; => #S(DOG :NAME "rover" :BREED "collie" :AGE 5)
+(dog-p *rover*)    ; => T
+(dog-name *rover*) ; => "rover"
+
+;;; DEFSTRUCT автоматически создала DOG-P, MAKE-DOG, и DOG-NAME
+
+
+;;; Пары (cons-ячейки)
+
+;;; CONS создаёт пары. CAR и CDR возвращают начало и конец CONS-пары.
+
+(cons 'SUBJECT 'VERB)         ; => '(SUBJECT . VERB)
+(car (cons 'SUBJECT 'VERB))   ; => SUBJECT
+(cdr (cons 'SUBJECT 'VERB))   ; => VERB
+
+
+;;; Списки
+
+;;; Списки это связанные CONS-пары, в конце самой последней из которых стоит NIL
+;;; (или '() ).
+
+(cons 1 (cons 2 (cons 3 nil)))     ; => '(1 2 3)
+
+;;; Списки с произвольным количеством элементов удобно создавать с помощью LIST
+
+(list 1 2 3)                       ; => '(1 2 3)
+
+;;; Если первый аргумент для CONS это атом и второй аргумент список, CONS
+;;; возвращает новую CONS-пару, которая представляет собой список
+
+(cons 4 '(1 2 3))                  ; => '(4 1 2 3)
+
+;;; Чтобы объединить списки, используйте APPEND
+
+(append '(1 2) '(3 4))             ; => '(1 2 3 4)
+
+;;; Или CONCATENATE
+
+(concatenate 'list '(1 2) '(3 4))  ; => '(1 2 3 4)
+
+;;; Списки это самый используемый элемент языка. Поэтому с ними можно делать
+;;; многие вещи. Вот несколько примеров:
+
+(mapcar #'1+ '(1 2 3))             ; => '(2 3 4)
+(mapcar #'+ '(1 2 3) '(10 20 30))  ; => '(11 22 33)
+(remove-if-not #'evenp '(1 2 3 4)) ; => '(2 4)
+(every #'evenp '(1 2 3 4))         ; => NIL
+(some #'oddp '(1 2 3 4))           ; => T
+(butlast '(subject verb object))   ; => (SUBJECT VERB)
+
+
+;;; Вектора
+
+;;; Вектора заданные прямо в коде - это массивы с фиксированной длинной.
+
+#(1 2 3) ; => #(1 2 3)
+
+;;; Для соединения векторов используйте CONCATENATE
+
+(concatenate 'vector #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6)
+
+
+;;; Массивы
+
+;;; И вектора и строки это подмножества массивов.
+
+;;; Двухмерные массивы
+
+(make-array (list 2 2))         ; => #2A((0 0) (0 0))
+(make-array '(2 2))             ; => #2A((0 0) (0 0))
+(make-array (list 2 2 2))       ; => #3A(((0 0) (0 0)) ((0 0) (0 0)))
+
+;;; Внимание: значение по-умолчанию элемента массива зависит от реализации.
+;;; Лучше явно указывайте:
+
+(make-array '(2) :initial-element 'unset)  ; => #(UNSET UNSET)
+
+;;; Для доступа к элементу в позиции 1, 1, 1:
+
+(aref (make-array (list 2 2 2)) 1 1 1)     ;  => 0
+
+
+;;; Вектора с изменяемой длиной
+
+;;; Вектора с изменяемой длиной при выводе на консоль выглядят также,
+;;; как и вектора, с константной длиной
+
+(defparameter *adjvec* (make-array '(3) :initial-contents '(1 2 3)
+                                   :adjustable t :fill-pointer t))
+*adjvec* ; => #(1 2 3)
+
+;;; Добавление новых элементов
+
+(vector-push-extend 4 *adjvec*)   ; => 3
+*adjvec*                          ; => #(1 2 3 4)
+
+
+;;; Множества, это просто списки:
+
+(set-difference '(1 2 3 4) '(4 5 6 7))   ; => (3 2 1)
+(intersection '(1 2 3 4) '(4 5 6 7))     ; => 4
+(union '(1 2 3 4) '(4 5 6 7))            ; => (3 2 1 4 5 6 7)
+(adjoin 4 '(1 2 3 4))                    ; => (1 2 3 4)
+
+;;; Несмотря на все, для действительно больших объемов данных, вам нужно что-то
+;;; лучше, чем просто связанные списки
+
+;;; Словари представлены хеш таблицами.
+
+;;; Создание хеш таблицы:
+
+(defparameter *m* (make-hash-table))
+
+;;; Установка пары ключ-значение
+
+(setf (gethash 'a *m*) 1)
+
+;;; Возврат значения по ключу
+
+(gethash 'a *m*) ; => 1, T
+
+;;; CL выражения умеют возвращать сразу несколько значений.
+
+(values 1 2) ; => 1, 2
+
+;;; которые могут быть распределены по переменным с помощью MULTIPLE-VALUE-BIND
+
+(multiple-value-bind (x y)
+    (values 1 2)
+  (list y x))
+
+; => '(2 1)
+
+;;; GETHASH как раз та функция, которая возвращает несколько значений. Первое
+;;; значение - это значение по ключу в хеш таблицу. Если ключ не был найден,
+;;; возвращает NIL.
+
+;;; Второе возвращаемое значение, указывает был ли ключ в хеш таблице. Если ключа
+;;; не было, то возвращает NIL. Таким образом можно проверить, это значение
+;;; NIL, или ключа просто не было.
+
+;;; Вот возврат значений, в случае когда ключа в хеш таблице не было:
+
+(gethash 'd *m*) ;=> NIL, NIL
+
+;;; Можете задать значение по умолчанию.
+
+(gethash 'd *m* :not-found) ; => :NOT-FOUND
+
+;;; Давайте обработаем возврат несколько значений.
+
+(multiple-value-bind (a b)
+    (gethash 'd *m*)
+  (list a b))
+; => (NIL NIL)
+
+(multiple-value-bind (a b)
+    (gethash 'a *m*)
+  (list a b))
+; => (1 T)
+
+
+;;;-----------------------------------------------------------------------------
+;;; 3. Функции
+;;;-----------------------------------------------------------------------------
+
+;;; Для создания анонимных функций используйте LAMBDA. Функций всегда возвращают
+;;; значение последнего своего выражения. Как выглядит функция при выводе в консоль
+;;; зависит от реализации.
+
+(lambda () "Привет Мир") ; => #<FUNCTION (LAMBDA ()) {1004E7818B}>
+
+;;; Для вызова анонимной функции пользуйтесь FUNCALL
+
+(funcall (lambda () "Привет Мир"))   ; => "Привет мир"
+(funcall #'+ 1 2 3)                   ; => 6
+
+;;; FUNCALL сработает и тогда, когда анонимная функция стоит в начале
+;;; неэкранированного списка
+
+((lambda () "Привет Мир"))           ; => "Привет Мир"
+((lambda (val) val) "Привет Мир")    ; => "Привет Мир"
+
+;;; FUNCALL используется, когда аргументы заранее известны.
+;;; В противном случае используйте APPLY
+
+(apply #'+ '(1 2 3))   ; => 6
+(apply (lambda () "Привет Мир") nil) ; => "Привет Мир"
+
+;;; Для обычной функции с именем используйте DEFUN
+
+(defun hello-world () "Привет Мир")
+(hello-world) ; => "Привет Мир"
+
+;;; Выше видно пустой список (), это место для определения аргументов
+
+(defun hello (name) (format nil "Hello, ~A" name))
+(hello "Григорий") ; => "Привет, Григорий"
+
+;;; Можно указать необязательные аргументы. По умолчанию они будут NIL
+
+(defun hello (name &optional from)
+  (if from
+      (format t "Приветствие для ~A от ~A" name from)
+      (format t "Привет, ~A" name)))
+
+(hello "Георгия" "Василия")       ; => Приветствие для Георгия от Василия
+
+;;; Можно явно задать значения по умолчанию
+
+(defun hello (name &optional (from "Мира"))
+   (format nil "Приветствие для ~A от ~A" name from))
+
+(hello "Жоры")               ; => Приветствие для Жоры от Мира
+(hello "Жоры" "альпаки")     ; => Приветствие для Жоры от альпаки
+
+;;; Можно также задать именованные параметры
+
+(defun generalized-greeter (name &key (from "Мира") (honorific "Господин"))
+  (format t "Здравствуйте, ~A ~A, от ~A" honorific name from))
+
+(generalized-greeter "Григорий")
+; => Здравствуйте, Господин Григорий, от Мира
+
+(generalized-greeter "Григорий" :from "альпаки" :honorific "гражданин")
+; => Здравствуйте, Гражданин Григорий, от альпаки
+
+
+;;;-----------------------------------------------------------------------------
+;;; 4. Равенство или эквивалентность
+;;;-----------------------------------------------------------------------------
+
+;;; У CL сложная система эквивалентности. Взглянем одним глазом.
+
+;;; Для чисел используйте `='
+(= 3 3.0)               ; => T
+(= 2 1)                 ; => NIL
+
+;;; Для идентичености объектов используйте EQL
+(eql 3 3)               ; => T
+(eql 3 3.0)             ; => NIL
+(eql (list 3) (list 3)) ; => NIL
+
+;;; Для списков, строк, и битовых векторов - EQUAL
+(equal (list 'a 'b) (list 'a 'b)) ; => T
+(equal (list 'a 'b) (list 'b 'a)) ; => NIL
+
+
+;;;-----------------------------------------------------------------------------
+;;; 5. Циклы и ветвления
+;;;-----------------------------------------------------------------------------
+
+;;; Ветвления
+
+(if t                    ; проверямое значение
+    "случилась истина"   ; если, оно было истинно
+    "случилась ложь")    ; иначе, когда оно было ложно
+; => "случилась истина"
+
+;;; В форме ветвления if, все не-NIL значения это `истина`
+
+(member 'Groucho '(Harpo Groucho Zeppo)) ; => '(GROUCHO ZEPPO)
+(if (member 'Groucho '(Harpo Groucho Zeppo))
+    'yep
+    'nope)
+; => 'YEP
+
+;;; COND это цепочка проверок для нахождения искомого
+(cond ((> 2 2) (error "мимо!"))
+      ((< 2 2) (error "опять мимо!"))
+      (t 'ok)) ; => 'OK
+
+;;; TYPECASE выбирает ветку исходя из типа выражения
+(typecase 1
+  (string :string)
+  (integer :int))
+; => :int
+
+
+;;; Циклы
+
+;;; С рекурсией
+
+(defun fact (n)
+  (if (< n 2)
+      1
+    (* n (fact(- n 1)))))
+
+(fact 5) ; => 120
+
+;;; И без
+
+(defun fact (n)
+  (loop :for result = 1 :then (* result i)
+     :for i :from 2 :to n
+     :finally (return result)))
+
+(fact 5) ; => 120
+
+(loop :for x :across "abc" :collect x)
+; => (#\a #\b #\c #\d)
+
+(dolist (i '(1 2 3 4))
+  (format t "~A" i))
+; => 1234
+
+
+;;;-----------------------------------------------------------------------------
+;;; 6. Установка значений в переменные (и не только)
+;;;-----------------------------------------------------------------------------
+
+;;; Для присвоения переменной нового значения используйте SETF. Это уже было
+;;; при работе с хеш таблицами.
+
+(let ((variable 10))
+    (setf variable 2))
+; => 2
+
+;;; Для функционального подхода в программировании, старайтесь избегать измений
+;;; в переменных.
+
+;;;-----------------------------------------------------------------------------
+;;; 7. Классы и объекты
+;;;-----------------------------------------------------------------------------
+
+;;; Никаких больше животных в примерах. Берем устройства приводимые в движение
+;;; мускульной силой человека.
+
+(defclass human-powered-conveyance ()
+  ((velocity
+    :accessor velocity
+    :initarg :velocity)
+   (average-efficiency
+    :accessor average-efficiency
+   :initarg :average-efficiency))
+  (:documentation "Устройство движимое человеческой силой"))
+
+;;; Аргументы DEFCLASS:
+;;; 1. Имя класса
+;;; 2. Список родительских классов
+;;; 3. Список полей
+;;; 4. Необязательная метаинформация
+
+;;; Если родительские классы не заданы, используется "стандартный" класс
+;;; Это можно *изменить*, но хорошенько подумайте прежде. Если все-таки
+;;; решились вам поможет "Art of the Metaobject Protocol"
+
+(defclass bicycle (human-powered-conveyance)
+  ((wheel-size
+    :accessor wheel-size
+    :initarg :wheel-size
+    :documentation "Diameter of the wheel.")
+   (height
+    :accessor height
+    :initarg :height)))
+
+(defclass recumbent (bicycle)
+  ((chain-type
+    :accessor chain-type
+    :initarg :chain-type)))
+
+(defclass unicycle (human-powered-conveyance) nil)
+
+(defclass canoe (human-powered-conveyance)
+  ((number-of-rowers
+    :accessor number-of-rowers
+    :initarg :number-of-rowers)))
+
+;;; Если вызвать DESCRIBE для HUMAN-POWERED-CONVEYANCE то получите следующее:
+
+(describe 'human-powered-conveyance)
+
+; COMMON-LISP-USER::HUMAN-POWERED-CONVEYANCE
+;  [symbol]
+;
+; HUMAN-POWERED-CONVEYANCE names the standard-class #<STANDARD-CLASS
+;                                                    HUMAN-POWERED-CONVEYANCE>:
+;  Documentation:
+;    A human powered conveyance
+;  Direct superclasses: STANDARD-OBJECT
+;  Direct subclasses: UNICYCLE, BICYCLE, CANOE
+;  Not yet finalized.
+;  Direct slots:
+;    VELOCITY
+;      Readers: VELOCITY
+;      Writers: (SETF VELOCITY)
+;    AVERAGE-EFFICIENCY
+;      Readers: AVERAGE-EFFICIENCY
+;      Writers: (SETF AVERAGE-EFFICIENCY)
+
+;;; CL задизайнен как интерактивная система. В рантайме доступна информация о
+;;; типе объектов.
+
+;;; Давайте посчитаем расстояние, которое пройдет велосипед за один оборот колеса
+;;; по формуле C = d * pi
+
+(defmethod circumference ((object bicycle))
+  (* pi (wheel-size object)))
+
+;;; PI - это константа в CL
+
+;;; Предположим мы нашли, что критерий эффективности логарифмически связан
+;;; с гребцами каноэ. Тогда вычисление можем сделать сразу при инициализации.
+
+;;; Инициализируем объект после его создания:
+
+(defmethod initialize-instance :after ((object canoe) &rest args)
+  (setf (average-efficiency object)  (log (1+ (number-of-rowers object)))))
+
+
+;;; Давайте проверим что получилось с этой самой эффективностью...
+
+(average-efficiency (make-instance 'canoe :number-of-rowers 15))
+; => 2.7725887
+
+
+;;;-----------------------------------------------------------------------------
+;;; 8. Макросы
+;;;-----------------------------------------------------------------------------
+
+;;; Макросы позволяют расширить синаксис языка. В CL нет например цикла WHILE,
+;;; но его проще простого реализовать на макросах. Если мы отбросим наши
+;;; ассемблерные (или алгольные) инстинкты, мы взлетим на крыльях:
+
+(defmacro while (condition &body body)
+    "Пока `условие` истинно, выполняется `тело`.
+`Условие` проверяется перед каждым выполнением `тела`"
+    (let ((block-name (gensym)) (done (gensym)))
+        `(tagbody
+           ,block-name
+           (unless ,condition
+               (go ,done))
+           (progn
+           ,@body)
+           (go ,block-name)
+           ,done)))
+
+;;; Взглянем на более высокоуровневую версию этого макроса:
+
+(defmacro while (condition &body body)
+    "Пока `условие` истинно, выполняется `тело`.
+`Условие` проверяется перед каждым выполнением `тела`"
+  `(loop while ,condition
+         do
+         (progn
+            ,@body)))
+
+;;; В современных комиляторах LOOP так же эффективен как и приведенный
+;;; выше код. Поэтому используйте его, его проще читать.
+
+;;; В макросах используются символы ```, `,` и `@`. ``` - это оператор
+;;; квазиквотирования - это значит что форма исполнятся не будет, а вернется
+;;; как данные. Оператаор `,` позволяет исполнить форму внутри
+;;; квазиквотирования. Оператор `@` исполняет форму внутри квазиквотирования
+;;; но полученный список вклеивает по месту.
+
+;;; GENSYM создаёт уникальный символ, который гарантировано больше нигде в
+;;; системе не используется. Так надо потому, что макросы разворачиваются
+;;; во время компиляции и переменные объявленные в макросе могут совпасть
+;;; по имени с переменными в обычном коде.
+
+;;; Дальнйешую информацию о макросах ищите в книгах Practical Common Lisp
+;;; и On Lisp
+```
+
+## Для чтения
+
+На русском
+- [Practical Common Lisp](http://www.gigamonkeys.com/book/)
+
+На английском
+- [Practical Common Lisp](http://www.gigamonkeys.com/book/)
+- [Common Lisp: A Gentle Introduction to Symbolic Computation](https://www.cs.cmu.edu/~dst/LispBook/book.pdf)
+
+
+## Дополнительная информация
+
+На русском
+
+- [Lisper.ru](http://lisper.ru/)
+
+На английском
+
+- [CLiki](http://www.cliki.net/)
+- [common-lisp.net](https://common-lisp.net/)
+- [Awesome Common Lisp](https://github.com/CodyReichert/awesome-cl)
+- [Lisp Lang](http://lisp-lang.org/)
+
+
+## Благодарности в английской версии
+
+Спасибо людям из Scheme за отличную статью, взятую за основу для
+Common Lisp.
+
+
+- [Paul Khuong](https://github.com/pkhuong) за хорошую вычитку.
diff --git a/ru-ru/crystal-ru.html.markdown b/ru-ru/crystal-ru.html.markdown
new file mode 100644
index 00000000..87d12f23
--- /dev/null
+++ b/ru-ru/crystal-ru.html.markdown
@@ -0,0 +1,584 @@
+---
+language: crystal
+filename: learncrystal-ru.cr
+contributors:
+    - ["Vitalii Elenhaupt", "http://veelenga.com"]
+    - ["Arnaud Fernandés", "https://github.com/TechMagister/"]
+translators:
+    - ["Den Patin", "https://github.com/denpatin"]
+lang: ru-ru
+---
+
+```crystal
+# — так начинается комментарий
+
+
+# Всё является объектом
+nil.class  #=> Nil
+100.class  #=> Int32
+true.class #=> Bool
+
+# Возвращают false только nil, false и пустые указатели
+!nil   #=> true  : Bool
+!false #=> true  : Bool
+!0     #=> false : Bool
+
+
+# Целые числа
+
+1.class #=> Int32
+
+# Четыре типа целых чисел со знаком
+1_i8.class  #=> Int8
+1_i16.class #=> Int16
+1_i32.class #=> Int32
+1_i64.class #=> Int64
+
+# Четыре типа целых чисел без знака
+1_u8.class  #=> UInt8
+1_u16.class #=> UInt16
+1_u32.class #=> UInt32
+1_u64.class #=> UInt64
+
+2147483648.class          #=> Int64
+9223372036854775808.class #=> UInt64
+
+# Двоичные числа
+0b1101 #=> 13 : Int32
+
+# Восьмеричные числа
+0o123 #=> 83 : Int32
+
+# Шестнадцатеричные числа
+0xFE012D #=> 16646445 : Int32
+0xfe012d #=> 16646445 : Int32
+
+# Числа с плавающей точкой
+
+1.0.class #=> Float64
+
+# Два типа чисел с плавающей запятой
+1.0_f32.class #=> Float32
+1_f32.class   #=> Float32
+
+1e10.class    #=> Float64
+1.5e10.class  #=> Float64
+1.5e-7.class  #=> Float64
+
+
+# Символьные литералы
+
+'a'.class #=> Char
+
+# Восьмеричный код символа
+'\101' #=> 'A' : Char
+
+# Код символа Unicode
+'\u0041' #=> 'A' : Char
+
+
+# Строки
+
+"s".class #=> String
+
+# Строки неизменяемы
+s = "hello, "  #=> "hello, "        : String
+s.object_id    #=> 134667712        : UInt64
+s += "Crystal" #=> "hello, Crystal" : String
+s.object_id    #=> 142528472        : UInt64
+
+# Поддерживается интерполяция строк
+"sum = #{1 + 2}" #=> "sum = 3" : String
+
+# Поддерживается многострочность
+"This is
+   multiline string"
+
+# Строка с двойными кавычками
+%(hello "world") #=> "hello \"world\""
+
+
+# Символы — константы без значения, определяемые только именем. Часто
+# используются вместо часто используемых строк для лучшей производительности.
+# На внутреннем уровне они представлены как Int32.
+
+:symbol.class #=> Symbol
+
+sentence = :question?     # :"question?" : Symbol
+
+sentence == :question?    #=> true  : Bool
+sentence == :exclamation! #=> false : Bool
+sentence == "question?"   #=> false : Bool
+
+
+# Массивы
+
+[1, 2, 3].class         #=> Array(Int32)
+[1, "hello", 'x'].class #=> Array(Int32 | String | Char)
+
+# При объявлении пустого массива необходимо указать тип его элементов
+[]               # Syntax error: for empty arrays use '[] of ElementType'
+[] of Int32      #=> [] : Array(Int32)
+Array(Int32).new #=> [] : Array(Int32)
+
+# Элементы внутри массива имеют свои индексы
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5] : Array(Int32)
+array[0]                #=> 1               : Int32
+array[10]               # raises IndexError
+array[-6]               # raises IndexError
+array[10]?              #=> nil             : (Int32 | Nil)
+array[-6]?              #=> nil             : (Int32 | Nil)
+
+# Можно получать элементы по индексу с конца
+array[-1] #=> 5
+
+# С начала и с указанием размера итогового массива
+array[2, 3] #=> [3, 4, 5]
+
+# Или посредством указания диапазона
+array[1..3] #=> [2, 3, 4]
+
+# Добавление в массив
+array << 6  #=> [1, 2, 3, 4, 5, 6]
+
+# Удаление элемента из конца массива
+array.pop #=> 6
+array     #=> [1, 2, 3, 4, 5]
+
+# Удаление элемента из начала массива
+array.shift #=> 1
+array       #=> [2, 3, 4, 5]
+
+# Проверка на наличие элемента в массиве
+array.includes? 3 #=> true
+
+# Синтаксический сахар для массива строк и символов
+%w(one two three) #=> ["one", "two", "three"] : Array(String)
+%i(one two three) #=> [:one, :two, :three]    : Array(Symbol)
+
+# Массивоподобный синтаксис используется и для других типов, только если для
+# них определены методы .new и #<<
+set = Set{1, 2, 3} #=> [1, 2, 3]
+set.class          #=> Set(Int32)
+
+# Вышеприведенное эквивалентно следующему
+set = Set(typeof(1, 2, 3)).new
+set << 1
+set << 2
+set << 3
+
+
+# Хэши
+
+{1 => 2, 3 => 4}.class   #=> Hash(Int32, Int32)
+{1 => 2, 'a' => 3}.class #=> Hash(Int32 | Char, Int32)
+
+# При объявлении пустого хэша необходимо указать типы ключа и значения
+{}                     # Syntax error
+{} of Int32 => Int32   # {}
+Hash(Int32, Int32).new # {}
+
+# Значения в хэше легко найти по ключу
+hash = {"color" => "green", "number" => 5}
+hash["color"]        #=> "green"
+hash["no_such_key"]  #=> Missing hash key: "no_such_key" (KeyError)
+hash["no_such_key"]? #=> nil
+
+# Проверка наличия ключа в хэше
+hash.has_key? "color" #=> true
+
+# Синтаксический сахар для символьных и строковых ключей
+{key1: 'a', key2: 'b'}     # {:key1 => 'a', :key2 => 'b'}
+{"key1": 'a', "key2": 'b'} # {"key1" => 'a', "key2" => 'b'}
+
+# Хэшеподобный синтаксис используется и для других типов, только если для них
+# определены методы .new и #[]=
+class MyType
+  def []=(key, value)
+    puts "do stuff"
+  end
+end
+
+MyType{"foo" => "bar"}
+
+# Вышеприведенное эквивалентно следующему
+tmp = MyType.new
+tmp["foo"] = "bar"
+tmp
+
+
+# Диапазоны
+
+1..10                  #=> Range(Int32, Int32)
+Range.new(1, 10).class #=> Range(Int32, Int32)
+
+# Включающий и исключающий диапазоны
+(3..5).to_a  #=> [3, 4, 5]
+(3...5).to_a #=> [3, 4]
+
+# Проверка на вхождение в диапазон
+(1..8).includes? 2 #=> true
+
+
+# Кортежи
+# Неизменяемые последовательности фиксированного размера, содержащие,
+# как правило, элементы разных типов
+
+{1, "hello", 'x'}.class #=> Tuple(Int32, String, Char)
+
+# Доступ к элементам осуществляется по индексу
+tuple = {:key1, :key2}
+tuple[1] #=> :key2
+tuple[2] #=> syntax error : Index out of bound
+
+# Элементы кортежей можно попарно присвоить переменным
+a, b, c = {:a, 'b', "c"}
+a #=> :a
+b #=> 'b'
+c #=> "c"
+
+
+# Процедуры
+# Указатели на функцию с необязательным содержимым (замыкание).
+# Обычно создаётся с помощью специального литерала ->
+
+proc = ->(x : Int32) { x.to_s }
+proc.class # Proc(Int32, String)
+# Или посредством метода .new
+Proc(Int32, String).new { |x| x.to_s }
+
+# Вызываются посредством метода .call
+proc.call 10 #=> "10"
+
+
+# Управляющие операторы
+
+if true
+  "if statement"
+elsif false
+  "else-if, optional"
+else
+  "else, also optional"
+end
+
+puts "if as a suffix" if true
+
+# if как часть выражения
+a = if 2 > 1
+      3
+    else
+      4
+    end
+
+a #=> 3
+
+# Тернарный if
+a = 1 > 2 ? 3 : 4 #=> 4
+
+# Оператор выбора
+cmd = "move"
+
+action = case cmd
+         when "create"
+           "Creating..."
+         when "copy"
+           "Copying..."
+         when "move"
+           "Moving..."
+         when "delete"
+           "Deleting..."
+end
+
+action #=> "Moving..."
+
+
+# Циклы
+
+index = 0
+while index <= 3
+  puts "Index: #{index}"
+  index += 1
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+index = 0
+until index > 3
+  puts "Index: #{index}"
+  index += 1
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+# Но лучше использовать each
+(1..3).each do |index|
+  puts "Index: #{index}"
+end
+# Index: 1
+# Index: 2
+# Index: 3
+
+# Тип переменной зависит от типа выражения
+if a < 3
+  a = "hello"
+else
+  a = true
+end
+typeof a #=> (Bool | String)
+
+if a && b
+  # здесь гарантируется, что и a, и b — не nil
+end
+
+if a.is_a? String
+  a.class #=> String
+end
+
+
+# Методы
+
+def double(x)
+  x * 2
+end
+
+# Методы (а также любые блоки) всегда возвращают значение последнего выражения
+double(2) #=> 4
+
+# Скобки можно опускать, если вызов метода не вносит двусмысленности
+double 3 #=> 6
+
+double double 3 #=> 12
+
+def sum(x, y)
+  x + y
+end
+
+# Параметры методов перечисляются через запятую
+sum 3, 4 #=> 7
+
+sum sum(3, 4), 5 #=> 12
+
+
+# yield
+
+# У всех методов есть неявный необязательный параметр блока, который можно
+# вызвать ключевым словом yield
+
+def surround
+  puts '{'
+  yield
+  puts '}'
+end
+
+surround { puts "hello world" }
+
+# {
+# hello world
+# }
+
+# Методу можно передать блок
+# & — ссылка на переданный блок
+def guests(&block)
+  block.call "some_argument"
+end
+
+# Методу можно передать список параметров, доступ к ним будет как к массиву
+# Для этого используется оператор *
+def guests(*array)
+  array.each { |guest| puts guest }
+end
+
+# Если метод возвращает массив, можно попарно присвоить значение каждого из его
+# элементов переменным
+def foods
+    ["pancake", "sandwich", "quesadilla"]
+end
+breakfast, lunch, dinner = foods
+breakfast #=> "pancake"
+dinner    #=> "quesadilla"
+
+# По соглашению название методов, возвращающих булево значение, должно
+# оканчиваться вопросительным знаком
+5.even? # false
+5.odd?  # true
+
+# Если название метода оканчивается восклицательным знаком, по соглашению это
+# означает, что метод делает что-то необратимое, например изменяет получателя.
+# Некоторые методы имеют две версии: "опасную" версию с !, которая что-то
+# меняет, и "безопасную", которая просто возвращает новое значение
+company_name = "Dunder Mifflin"
+company_name.gsub "Dunder", "Donald"  #=> "Donald Mifflin"
+company_name  #=> "Dunder Mifflin"
+company_name.gsub! "Dunder", "Donald"
+company_name  #=> "Donald Mifflin"
+
+
+# Классы
+# Определяются с помощью ключевого слова class
+
+class Human
+
+  # Переменная класса является общей для всех экземпляров этого класса
+  @@species = "H. sapiens"
+
+  # Объявление типа переменной name экземпляра класса
+  @name : String
+
+  # Базовый конструктор
+  # Значением первого параметра инициализируем переменную @name.
+  # То же делаем и со вторым параметром — переменная @age. В случае, если мы
+  # не передаём второй параметр, для инициализации @age будет взято значение
+  # по умолчанию (в данном случае — 0)
+  def initialize(@name, @age = 0)
+  end
+
+  # Базовый метод установки значения переменной
+  def name=(name)
+    @name = name
+  end
+
+  # Базовый метод получения значения переменной
+  def name
+    @name
+  end
+
+  # Синтаксический сахар одновременно для двух методов выше
+  property :name
+
+  # А также по отдельности
+  getter :name
+  setter :name
+
+  # Метод класса определяется ключевым словом self, чтобы его можно было
+  # различить с методом экземпляра класса. Такой метод можно вызвать только
+  # на уровне класса, а не экземпляра.
+  def self.say(msg)
+    puts msg
+  end
+
+  def species
+    @@species
+  end
+end
+
+
+# Создание экземпляра класса
+jim = Human.new("Jim Halpert")
+
+dwight = Human.new("Dwight K. Schrute")
+
+# Вызов методов экземпляра класса
+jim.species #=> "H. sapiens"
+jim.name #=> "Jim Halpert"
+jim.name = "Jim Halpert II" #=> "Jim Halpert II"
+jim.name #=> "Jim Halpert II"
+dwight.species #=> "H. sapiens"
+dwight.name #=> "Dwight K. Schrute"
+
+# Вызов метода класса
+Human.say("Hi") #=> выведет "Hi" и вернёт nil
+
+# Переменные экземпляра класса (@) видно только в пределах экземпляра
+class TestClass
+  @var = "I'm an instance var"
+end
+
+# Переменные класса (@) видны как в экземплярах класса, так и в самом классе
+class TestClass
+  @@var = "I'm a class var"
+end
+
+# Переменные с большой буквы — это константы
+Var = "I'm a constant"
+Var = "can't be updated" # Error: already initialized constant Var
+
+# Примеры
+
+# Базовый класс
+class Human
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+# Класс-потомок
+class Worker < Human
+end
+
+Human.foo   #=> 0
+Worker.foo  #=> 0
+
+Human.foo = 2 #=> 2
+Worker.foo    #=> 0
+
+Worker.foo = 3 #=> 3
+Human.foo   #=> 2
+Worker.foo  #=> 3
+
+module ModuleExample
+  def foo
+    "foo"
+  end
+end
+
+# Подключение модуля в класс добавляет его методы в экземпляр класса
+# Расширение модуля добавляет его методы в сам класс
+
+class Person
+  include ModuleExample
+end
+
+class Book
+  extend ModuleExample
+end
+
+Person.foo     # => undefined method 'foo' for Person:Class
+Person.new.foo # => 'foo'
+Book.foo       # => 'foo'
+Book.new.foo   # => undefined method 'foo' for Book
+
+
+# Обработка исключений
+
+# Создание пользовательского типа исключения
+class MyException < Exception
+end
+
+# Ещё одного
+class MyAnotherException < Exception; end
+
+ex = begin
+   raise MyException.new
+rescue ex1 : IndexError
+  "ex1"
+rescue ex2 : MyException | MyAnotherException
+  "ex2"
+rescue ex3 : Exception
+  "ex3"
+rescue ex4 # без указания конкретного типа исключения будут "отлавливаться" все
+  "ex4"
+end
+
+ex #=> "ex2"
+
+```
+
+## Дополнительная информация
+
+### На русском
+
+- [Официальная документация](http://ru.crystal-lang.org/docs/)
+
+### На английском
+
+- [Official Documentation](http://crystal-lang.org/)
diff --git a/ru-ru/jquery-ru.html.markdown b/ru-ru/jquery-ru.html.markdown
new file mode 100644
index 00000000..471b4e24
--- /dev/null
+++ b/ru-ru/jquery-ru.html.markdown
@@ -0,0 +1,127 @@
+---
+category: tool
+tool: jquery
+contributors:
+    - ["Sawyer Charles", "https://github.com/xssc"]
+translators:
+    - ["Ev Bogdanov", "https://github.com/evbogdanov"]
+lang: ru-ru
+filename: jquery-ru.js
+---
+
+jQuery — это библиотека JavaScript, которая помогает "делать больше, писать меньше". Она выполняет множество типичных JavaScript-задач, упрощая написание кода. jQuery используется крупными компаниями и разработчиками со всего мира. Она упрощает и ускоряет работу с AJAX, с событиями, с DOM и со многим другим.
+
+Поскольку jQuery является библиотекой JavaScript, вам следует начать с [изучения JavaScript](https://learnxinyminutes.com/docs/ru-ru/javascript-ru/).
+
+```js
+
+
+///////////////////////////////////
+// 1. Селекторы
+
+// Для получения элемента в jQuery используются селекторы
+var page = $(window); // Получить страницу целиком
+
+// В качестве селектора может выступать CSS-селектор
+var paragraph = $('p'); // Получить все <p> элементы
+var table1 = $('#table1'); // Получить элемент с идентификатором 'table1'
+var squares = $('.square'); // Получить все элементы с классом 'square'
+var square_p = $('p.square') // Получить <p> элементы с классом 'square'
+
+
+///////////////////////////////////
+// 2. События и эффекты
+// jQuery прекрасно справляется с обработкой событий
+// Часто используемое событие — это событие документа 'ready'
+// Вы можете использовать метод 'ready', который сработает, как только документ полностью загрузится
+$(document).ready(function(){
+  // Код не выполнится до тех пор, пока документ не будет загружен
+});
+// Обработку события можно вынести в отдельную функцию
+function onAction() {
+  // Код выполнится, когда произойдёт событие
+}
+$('#btn').click(onAction); // Обработчик события сработает при клике
+
+// Другие распространённые события:
+$('#btn').dblclick(onAction); // Двойной клик
+$('#btn').hover(onAction); // Наведение курсора
+$('#btn').focus(onAction); // Фокус
+$('#btn').blur(onAction); // Потеря фокуса
+$('#btn').submit(onAction); // Отправка формы
+$('#btn').select(onAction); // Когда выбрали элемент
+$('#btn').keydown(onAction); // Когда нажали клавишу
+$('#btn').keyup(onAction); // Когда отпустили клавишу
+$('#btn').keypress(onAction); // Когда нажали символьную клавишу (нажатие привело к появлению символа)
+$('#btn').mousemove(onAction); // Когда переместили курсор мыши
+$('#btn').mouseenter(onAction); // Когда навели курсор на элемент
+$('#btn').mouseleave(onAction); // Когда сдвинули курсор с элемента
+
+
+// Вы можете не только обрабатывать события, но и вызывать их
+$('#btn').dblclick(); // Вызвать двойной клик на элементе
+
+// Для одного селектора возможно назначить несколько обработчиков событий
+$('#btn').on(
+  {dblclick: myFunction1} // Обработать двойной клик
+  {blur: myFunction1} // Обработать исчезновение фокуса
+);
+
+// Вы можете перемещать и прятать элементы с помощью методов-эффектов
+$('.table').hide(); // Спрятать элемент(ы)
+
+// Обратите внимание: вызов функции в этих методах всё равно спрячет сам элемент
+$('.table').hide(function(){
+    // Сначала спрятать элемент, затем вызвать функцию
+});
+
+// Вы можете хранить селекторы в переменных
+var tables = $('.table');
+
+// Некоторые основные методы для манипуляций с документом:
+tables.hide(); // Спрятать элемент(ы)
+tables.show(); // Показать элемент(ы)
+tables.toggle(); // Спрятать/показать
+tables.fadeOut(); // Плавное исчезновение
+tables.fadeIn(); // Плавное появление
+tables.fadeToggle(); // Плавное исчезновение или появление
+tables.fadeTo(0.5); // Изменение прозрачности
+tables.slideUp(); // Свернуть элемент
+tables.slideDown(); // Развернуть элемент
+tables.slideToggle(); // Свернуть или развернуть
+
+// Все эти методы принимают скорость (в миллисекундах) и функцию обратного вызова
+tables.hide(1000, myFunction); // Анимация длится 1 секунду, затем вызов функции
+
+// В методе 'fadeTo' вторым параметром обязательно идёт прозрачность
+tables.fadeTo(2000, 0.1, myFunction); // Прозрачность меняется в течение 2 секунд до 0.1, затем вызывается функция
+
+// Метод 'animate' позволяет делать более продвинутую анимацию
+tables.animate({"margin-top": "+=50", height: "100px"}, 500, myFunction);
+
+
+///////////////////////////////////
+// 3. Манипуляции
+
+// Манипуляции похожи на эффекты, но позволяют добиться большего
+$('div').addClass('taming-slim-20'); // Добавить класс 'taming-slim-20' ко всем <div> элементам
+
+// Часто встречающиеся методы манипуляций
+$('p').append('Hello world'); // Добавить в конец элемента
+$('p').attr('class'); // Получить атрибут
+$('p').attr('class', 'content'); // Установить атрибут
+$('p').hasClass('taming-slim-20'); // Проверить наличие класса
+$('p').height(); // Получить или установить высоту элемента
+
+
+// Во многих методах вам доступна информация ТОЛЬКО о первом элементе из выбранных
+$('p').height(); // Вы получите высоту только для первого <p> элемента
+
+// Метод 'each' позволяет это исправить и пройтись по всем выбранным вами элементам
+var heights = [];
+$('p').each(function() {
+  heights.push($(this).height()); // Добавить высоту всех <p> элементов в массив
+});
+
+
+```
diff --git a/ru-ru/kotlin-ru.html.markdown b/ru-ru/kotlin-ru.html.markdown
index 58dab4cd..85f44c96 100644
--- a/ru-ru/kotlin-ru.html.markdown
+++ b/ru-ru/kotlin-ru.html.markdown
@@ -8,7 +8,7 @@ translators:
     - ["Vadim Toptunov", "https://github.com/VadimToptunov"]
 ---
 
-Kotlin - статистически типизированный язык для JVM, Android и браузера. Язык полностью совместим c Java. 
+Kotlin - статически типизированный язык для JVM, Android и браузера. Язык полностью совместим c Java. 
 [Более детальная информация здесь.](https://kotlinlang.org/)
 
 ```kotlin
diff --git a/ru-ru/learnvisualbasic-ru.html.markdown b/ru-ru/learnvisualbasic-ru.html.markdown
new file mode 100644
index 00000000..72e1358c
--- /dev/null
+++ b/ru-ru/learnvisualbasic-ru.html.markdown
@@ -0,0 +1,284 @@
+---
+language: Visual Basic
+contributors:
+    - ["Brian Martin", "http://brianmartin.biz"]
+translators:
+    - ["satory-ra", "https://github.com/satory-ra"]
+filename: learnvisualbasic-ru.vb
+lang: ru-ru
+---
+
+```vbnet
+Module Module1
+
+    Sub Main()
+        'Краткий обзор консольных приложений Visual Basic перед более
+        'глубоким изучением.
+        'Апостроф начинает строку комментария.
+        'Чтобы изучить это руководство в компиляторе Visual Basic,
+        'я создал систему навигации.
+        'Эта система будет объяснена при прохождении этого урока.
+        'Постепенно вы всё поймете.
+        Console.Title = ("Выучи Х за Y минут")
+        Console.WriteLine("НАВИГАЦИЯ") 'Display
+        Console.WriteLine("")
+        Console.ForegroundColor = ConsoleColor.Green
+        Console.WriteLine("1. Вывод данных")
+        Console.WriteLine("2. Ввод данных")
+        Console.WriteLine("3. Расчёт целых чисел")
+        Console.WriteLine("4. Расчёт десятичных дробей")
+        Console.WriteLine("5. Калькулятор")
+        Console.WriteLine("6. Использование циклов Do While")
+        Console.WriteLine("7. Использование циклов For")
+        Console.WriteLine("8. Условные выражения")
+        Console.WriteLine("9. Выберите напиток")
+        Console.WriteLine("50. О приложении")
+        Console.WriteLine("Выберите номер из списка")
+        Dim selection As String = Console.ReadLine
+        '«Case» в операторе Select не является обязательным.
+        'Например, "Select selection" вместо "Select Case selection"
+        'также будет работать.
+        Select Case selection
+            Case "1" 'Вывод данных
+                Console.Clear() 'Очищает окно консоли
+                HelloWorldOutput() 'Открывает приватную подпрограмму.
+            Case "2" 'Ввод данных
+                Console.Clear()
+                HelloWorldInput()
+            Case "3" 'Расчёт целых чисел
+                Console.Clear()
+                CalculatingWholeNumbers()
+            Case "4" 'Расчёт десятичных дробей
+                Console.Clear()
+                CalculatingDecimalNumbers()
+            Case "5" 'Калькулятор
+                Console.Clear()
+                WorkingCalculator()
+            Case "6" 'Использование циклов Do While
+                Console.Clear()
+                UsingDoWhileLoops()
+            Case "7" 'Использование циклов For
+                Console.Clear()
+                UsingForLoops()
+            Case "8" 'Условные выражения
+                Console.Clear()
+                ConditionalStatement()
+            Case "9" 'Выражения If/Else
+                Console.Clear()
+                IfElseStatement() 'Выберите напиток
+            Case "50" 'Окно сообщения «О приложении»
+                Console.Clear()
+                Console.Title = ("Выучи Х за Y минут :: О приложении")
+                MsgBox("Это руководство от Брайана Мартина (@BrianMartinn")
+                Console.Clear()
+                Main()
+                Console.ReadLine()
+
+        End Select
+    End Sub
+
+    'Один - Я использую эти цифры для того, чтобы было проще
+    'соотносить код с системой навигации.
+
+    'Мы используем частные подпрограммы для разделения различных
+    'разделов программы.
+    Private Sub HelloWorldOutput()
+        'Название консольного приложения
+        Console.Title = "Вывод данных | Выучи Х за Y минут"
+        'Используйте Console.Write ("") или Console.WriteLine ("")
+        'для отображения результатов.
+        'Затем следует Console.Read () или Console.Readline ()
+        'Console.ReadLine () показывает вывод в консоли.
+        Console.WriteLine("Hello World")
+        Console.ReadLine()
+    End Sub
+
+    'Два
+    Private Sub HelloWorldInput()
+        Console.Title = "Ввод данных | Выучи Х за Y минут"
+        'Переменная
+        'используется для хранения пользовательских данных.
+        'Объявление переменных начинается с Dim и заканчиваются
+        'As VariableType (тип переменной).
+
+        'В этом уроке мы хотим узнать ваше имя и заставить программу 
+        'реагировать на это.
+        Dim username As String
+        'Мы используем тип «string», так как ваше имя - это текстовая переменная.
+        Console.WriteLine("Привет, как тебя зовут? ") 'Просит ввести имя.
+        username = Console.ReadLine() 'Сохраняет имя в переменной username.
+        Console.WriteLine("Пирвет, " + username) 'Выводит: «Привет, 'имя'»
+        Console.ReadLine() 'Отображает вышеуказанный вывод.
+
+        'Вышеуказанная программа спросит ваше имя и скажет вам привет.
+        'Есть и другие типы переменных, такие как целые числа (Integer),
+        'мы используем Integer для обработки целых чисел.
+    End Sub
+
+    'Три
+    Private Sub CalculatingWholeNumbers()
+        Console.Title = "Расчёт целых чисел | Выучи Х за Y минут"
+        Console.Write("Первое число: ") 'Введите первое целое число: 1, 2, 50, 104 и т.д.
+        Dim a As Integer = Console.ReadLine()
+        Console.Write("Второе число: ") 'Введите второе целое число.
+        Dim b As Integer = Console.ReadLine()
+        Dim c As Integer = a + b
+        Console.WriteLine(c)
+        Console.ReadLine()
+        'Приведенная программа сумирует два целых числа
+    End Sub
+
+    'Четыре
+    Private Sub CalculatingDecimalNumbers()
+        Console.Title = "Расчёт десятичных дробей | Выучи Х за Y минут"
+        'Мы также должны уметь обрабатывать десятичные дроби.
+        'Просто измените тип переменной с Integer на Double.
+
+        'Введите число с плавающей точкой: 1.2, 2.4, 50.1, 104.9 и т.д.
+        Console.Write("Первое число: ")
+        Dim a As Double = Console.ReadLine
+        Console.Write("Второе число: ") 'Введите второе число с плавающей точкой.
+        Dim b As Double = Console.ReadLine
+        Dim c As Double = a + b
+        Console.WriteLine(c)
+        Console.ReadLine()
+        'Приведенный выше код может сложить две десятичных дроби.
+    End Sub
+
+    'Пять
+    Private Sub WorkingCalculator()
+        Console.Title = "Калькулятор | Выучи Х за Y минут"
+        'Но что, если вам нужен калькулятор, который может обрабатывать сложение, 
+        'вычитание, умножение и деление?
+        'Просто скопируйте и вставьте приведенный код.
+        Console.Write("Первое число: ")
+        Dim a As Double = Console.ReadLine
+        Console.Write("Второе число: ")
+        Dim b As Double = Console.ReadLine
+        Dim c As Double = a + b
+        Dim d As Double = a * b
+        Dim e As Double = a - b
+        Dim f As Double = a / b
+
+        'С помощью следующего кода мы можем вывести результат сложения,
+        'вычитания, умножения и деления, рассчитанный выше, на экран.
+        Console.Write(a.ToString() + " + " + b.ToString())
+        'Мы хотим, чтобы в начале ответа было 3 пробела, для этого 
+        'вы можете использовать метод String.PadLeft (3).
+        Console.WriteLine(" = " + c.ToString.PadLeft(3))
+        Console.Write(a.ToString() + " * " + b.ToString())
+        Console.WriteLine(" = " + d.ToString.PadLeft(3))
+        Console.Write(a.ToString() + " - " + b.ToString())
+        Console.WriteLine(" = " + e.ToString.PadLeft(3))
+        Console.Write(a.ToString() + " / " + b.ToString())
+        Console.WriteLine(" = " + f.ToString.PadLeft(3))
+        Console.ReadLine()
+
+    End Sub
+
+    'Шесть
+    Private Sub UsingDoWhileLoops()
+        'Код такой же, как и в предидущей подпрограмме
+        'На этот раз мы спрашиваем, хочет ли пользователь продолжить (да или нет?)
+        'Мы будем использовать цикл Do While, потому что не знаем,
+        'понадобиться ли пользователю калькулятор болше одного раза.
+        Console.Title = "Использование циклов Do While | Выучи Х за Y минут"
+        Dim answer As String
+        'Мы используем тип переменной "String", так как её значение текст.
+        Do 'Мы начаем программу с
+            Console.Write("Первое число: ")
+            Dim a As Double = Console.ReadLine
+            Console.Write("Второе число: ")
+            Dim b As Double = Console.ReadLine
+            Dim c As Double = a + b
+            Dim d As Double = a * b
+            Dim e As Double = a - b
+            Dim f As Double = a / b
+
+            Console.Write(a.ToString() + " + " + b.ToString())
+            Console.WriteLine(" = " + c.ToString.PadLeft(3))
+            Console.Write(a.ToString() + " * " + b.ToString())
+            Console.WriteLine(" = " + d.ToString.PadLeft(3))
+            Console.Write(a.ToString() + " - " + b.ToString())
+            Console.WriteLine(" = " + e.ToString.PadLeft(3))
+            Console.Write(a.ToString() + " / " + b.ToString())
+            Console.WriteLine(" = " + f.ToString.PadLeft(3))
+            Console.ReadLine()
+            'Спросите пользователя, хочет ли он продолжить,
+            'в ответе учитывается регистр букв.
+            Console.Write("Желаете ли вы продолжить? (да / нет)")
+            'Программа берет значение и записывает в переменную answer.
+            answer = Console.ReadLine()
+            'Когда пользователь вводит «да», программа переходит к Do и снова запускается.
+        Loop While answer = "yes"
+
+    End Sub
+
+    'Семь
+    Private Sub UsingForLoops()
+        'Иногда программу нужно запускать только один раз.
+        'В этой программе мы осуществим обратный отсчет от 10.
+
+        Console.Title = "Использование циклов For | Выучи Х за Y минут"
+        'Объявите переменные и Step (размер шага, то есть скорость уменьшения,
+        'например, -1, -2, -3 и т.д.).
+        For i As Integer = 10 To 0 Step -1
+            Console.WriteLine(i.ToString) 'Показывает значение счетчика.
+        Next i 'Рассчитать новое значение i.
+        Console.WriteLine("Поехали")
+        Console.ReadLine()
+    End Sub
+
+    'Восемь
+    Private Sub ConditionalStatement()
+        Console.Title = "Условные выражения | Выучи Х за Y минут"
+        Dim userName As String
+        Console.WriteLine("Привет, как тебя зовут? ") 'Спросите имя пользователя.
+        userName = Console.ReadLine() 'Записать имя в переменную userName.
+        If userName = "Адам" Then
+            Console.WriteLine("Привет, Адам")
+            Console.WriteLine("Спасибо за создание этого полезного сайта")
+            Console.ReadLine()
+        Else
+            Console.WriteLine("Привет " + userName)
+            Console.WriteLine("Вы заглянули на сайт www.learnxinyminutes.com")
+            Console.ReadLine() 'Программа останавливается и выводит вышеуказанный текст.
+        End If
+    End Sub
+
+    'Девять
+    Private Sub IfElseStatement()
+        Console.Title = "Выражения If/Else | Выучи Х за Y минут"
+        'Иногда важно рассмотреть более двух альтернатив.
+        'Иногда некоторые из них лучше других.
+        'Когда это произойдет, нам потребуется более одного утверждения «if» (если).
+        'Оператор «if» подобен торговому автомату.
+        'В котором пользователь пишет код (A1, A2, A3 и т.д.), чтобы выбрать элементы.
+        'Все варианты могут быть объединены в одном утверждении «if».
+
+        Dim selection As String 'Объявить переменную для выбора
+        Console.WriteLine("Пожалуйста, выберите продукт из нашего прекрасного торгового автомата.")
+        Console.WriteLine("A1. для 7Up")
+        Console.WriteLine("A2. для Fanta")
+        Console.WriteLine("A3. для Dr. Pepper")
+        Console.WriteLine("A4. для Diet Coke")
+
+        selection = Console.ReadLine() 'Сохранить выбор пользователя
+        If selection = "A1" Then
+            Console.WriteLine("7up")
+        ElseIf selection = "A2" Then
+            Console.WriteLine("Fanta")
+        ElseIf selection = "A3" Then
+            Console.WriteLine("Dr. Pepper")
+        ElseIf selection = "A4" Then
+            Console.WriteLine("Diet Coke")
+        Else
+            Console.WriteLine("Извините, у меня нет " + selection)
+        End If
+        Console.ReadLine()
+
+    End Sub
+
+End Module
+
+```
diff --git a/ru-ru/linker-ru.html.markdown b/ru-ru/linker-ru.html.markdown
new file mode 100644
index 00000000..7df29c23
--- /dev/null
+++ b/ru-ru/linker-ru.html.markdown
@@ -0,0 +1,203 @@
+---
+category: tool
+tool: linker
+contributors:
+    - ["Alexander Kovalchuk", "https://github.com/Zamuhrishka"]
+translators:
+    - ["Alexander Kovalchuk", "https://github.com/Zamuhrishka"]
+lang: ru-ru
+---
+
+# Основные понятия и определения
+**Счетчик позиций** - у компоновщика есть специальная переменная 
+"." (точка) всегда содержит текущую позицию вывода.
+
+# Функции
+**ADDR(section)** -  возвращает абсолютный адрес указанной секции. Однако 
+данная секция должна быть определенна до использования функции ADDR.
+
+**ALIGN(exp)** -  возвращает значение счетчика позиций, выравненное на границу 
+следующего за exp выражения.
+
+**SIZEOF(section)** -  возвращает размер секции в байтах.
+
+**FILL(param)** -  определяет образец заполнения для текущей секции. Все 
+остальные неуказанные регионы внутри секции заполняются значением указанными 
+в аргументе функции.
+
+**KEEP(param)** -  используется чтобы помечать param как неустранимый.
+
+**ENTRY(func)** -  определяет функцию, которая будет являться точкой входа 
+в программу.
+
+```bash
+# Определяем точку входа в программу
+ENTRY(Reset_Handler)
+
+# Определяем перемнную которая содержит адрес вершины стека
+_estack = 0x20020000;  
+# Определяем перемнную которая содержит значение размера кучи  
+_Min_Heap_Size = 0x200;
+# Определяем перемнную которая содержит значение размера стека
+_Min_Stack_Size = 0x400; 
+
+# Описание карты памяти доступной для данного процессора
+# MEMORY
+# {
+# ИМЯ_ОБЛАСТИ_ПАМЯТИ	(права доступа)	: ORIGIN = АДРЕС_НАЧАЛА, LENGTH = РАЗМЕР
+# }
+# В нашем примере контроллер содержит три области памяти:
+# RAM - начинается с адреса 0x20000000 и занимает 128 Кбайт;
+# CCMRAM - начинается с адреса 0x10000000и занимает 64 Кбайт;
+# FLASH - начинается с адреса 0x8000000 занимает 1024 Кбайт;
+# Причем RAM память доступка для чтения, записи и исполнения.
+# CCMRAM память доступна только на чтение и запись.
+# FLASH память доступна на чтение и исполнение.
+MEMORY
+{
+	RAM 		(xrw)     : 	ORIGIN = 0x20000000, 	LENGTH = 128K
+	CCMRAM 		(rw)      : 	ORIGIN = 0x10000000, 	LENGTH = 64K
+	FLASH 		(rx)      : 	ORIGIN = 0x8000000, 	LENGTH = 1024K
+}
+
+# Описываем выходные секции
+SECTIONS
+{
+	# Первая секция содержит таблицу векторов прерываний
+  .isr_vector :
+  {
+	# Выравниваем текущую позицию на границу 4-х байт.
+    . = ALIGN(4);
+
+	# Существует опция --gc-sections, которая позволяет собирать мусор из неиспользуемых 
+	# входных разделов. И если есть разделы, которые сборщик муссора не должен трогать, 
+	# то их необходимо указать в качестве аргумента функции KEEP() (аналог ключевого слова 
+	# volatile).
+	# Запись (*(.isr_vector)) означает разделы .isr_vector во всех объектных файлах. Т.к. 
+	# обращение к разделу в общем виде выглядит так: (ИМЯ_ФАЙЛА(ИМЯ_РАЗДЕЛА))	
+    KEEP(*(.isr_vector))    
+
+	# Выравниваем текущую позицию на границу 4-х байт.
+    . = ALIGN(4);
+	
+	# Выражение ">ОБЛАСТЬ_ПАМЯТИ" указывает в какую именно область памяти будет помещенна 
+	# данная секция.	В нашем слущае секция .isr_vector будет размещена во FLASH памяти.
+  } >FLASH
+
+# ИТОГО: Секция .isr_vector, которая содержит таблицу векторов прерываний выравнивается 
+# по границе 4-х байт, помечается как недоступная для сборщика мусора и размещается в начале 
+# FLASH памяти микроконтроллера.
+
+  # Вторая секция содержит код программы.
+  .text :
+  {
+	# Выравниваем текущую позицию на границу 4-х байт.
+    . = ALIGN(4);
+    
+    # Указываем, что в данной секции будут хранится области .text всех
+	# объектных файлов   
+    *(.text)           
+    *(.text*)          
+
+	# Защищаем от сборщика мусора секции .init и .fini
+    KEEP (*(.init))
+    KEEP (*(.fini))
+
+	# Выравниваем текущую позицию на границу 4-х байт.
+    . = ALIGN(4);
+    
+	# Определяется переменная _etext, которая хранит в себе адрес конца секции .text и которая
+	# может быть доступна в исходном тексте программы через объявление 
+	# volaile unsigned int extern _etext;
+    _etext = .;      
+  } >FLASH
+  
+# ИТОГО: Секция .text, которая содержит код программы выравнивается по границе 4-х байт, 
+# включает в себя: все секции с кодом программы во всех объектных файлах и защищенные 
+от сборщика муссора секции .init и .fini во всех объектных файлах, распологается во FLASH 
+памяти микроконтроллера сразу за таблицей векторов. 
+Секции text, .init и .fini. располагаются в памяти в той последовательности в которой они 
+объявлены в скрипте.
+
+  # Третья секция содержит константные данные.
+  .rodata :
+  {
+	# Выравниваем текущую позицию на границу 4-х байт.
+    . = ALIGN(4);
+
+	# Указываем, что в данной секции будут хранится области .rodataвсех
+	# объектных файлов   
+    *(.rodata)         
+    *(.rodata*)  
+    
+	# Выравниваем текущую позицию на границу 4-х байт.      
+    . = ALIGN(4);
+  } >FLASH
+  
+  # Сохраняем в переменной _sidata  абсолютный адрес секции .data
+  _sidata = LOADADDR(.data);
+
+  # Четвертая секция содержит инициализированные переменные.
+  .data : 
+  {
+	# Выравниваем текущую позицию на границу 4-х байт.
+    . = ALIGN(4);
+
+	# Сохраняем в переменной _sdata адрес текущей позиции (начала секции)
+    _sdata = .;     
+  
+	# Указываем, что в данной секции будут хранится области .data всех
+	# объектных файлов     
+    *(.data)           
+    *(.data*)          
+
+	# Выравниваем текущую позицию на границу 4-х байт.
+    . = ALIGN(4);
+    
+    # Сохраняем в переменной _sdata адрес текущей позиции (конец секции)
+    _edata = .;    
+   
+	# Функция AT указывает на то, что данный сектор хранится в одной области памяти 
+	# (в нашем случае FLASH), а исполняться будет из другой обасти памяти (в нашем случае RAM). 
+	# Есть два типа адрессов:
+	# * VMA (Virtual memory address) - это run-time адрес по которому уомпилятор ожидает 
+	#	видеть данные.
+	# * LMA (Load memory address) - это адрес по которому линкер хранит данные.			
+			
+	#Startup должен код скопировать секцию .data из адрессов LMA в адресса VMA.
+	
+  } >RAM AT> FLASH
+
+  # Пятая секция содержит инициализированные нулем переменные.  
+  .bss :
+  {
+	# Сохраняем в переменной _sbss и __bss_start__  адрес текущей позиции (начала секции)
+    _sbss = .;        
+    __bss_start__ = _sbss;
+    
+	# Указываем, что в данной секции будут хранится области .bss всех
+	# объектных файлов 
+    *(.bss)
+    *(.bss*)
+
+	# Выравниваем текущую позицию на границу 4-х байт.
+    . = ALIGN(4);
+    
+    # Сохраняем в переменной _ebss и __bss_end__ адрес текущей позиции (начала секции)
+    _ebss = .;         
+    __bss_end__ = _ebss;
+  } >RAM
+
+  # Шестая секция содержит кучу и стек. Размещается в самом конце RAM.
+  ._user_heap_stack :
+  {
+    . = ALIGN(4);
+    PROVIDE ( end = . );
+    PROVIDE ( _end = . );
+    . = . + _Min_Heap_Size;
+    . = . + _Min_Stack_Size;
+    . = ALIGN(4);
+  } >RAM
+}
+```
+
diff --git a/ru-ru/markdown-ru.html.markdown b/ru-ru/markdown-ru.html.markdown
index ff7a0cc3..579a9a20 100644
--- a/ru-ru/markdown-ru.html.markdown
+++ b/ru-ru/markdown-ru.html.markdown
@@ -36,13 +36,14 @@ lang: ru-ru
 Markdown является надмножеством HTML, поэтому любой HTML-файл является
 корректным документом Markdown.
 
- ```markdown
+ ```md
 <!-- Это позволяет использовать напрямую
 любые элементы HTML-разметки, такие, например, как этот комментарий.
   Встроенные в документ HTML-элементы не затрагиваются парсером Markdown
 и попадают в итоговый HTML без изменений. Однако следует понимать,
 что эта же особенность не позволяет использовать разметку Markdown внутри
 HTML-элементов -->
+```
 
 ## Заголовки 
 
@@ -50,7 +51,7 @@ HTML-элементы от <h1> до <h6> размечаются очень пр
 текст, который должен стать заголовком, предваряется
 соответствующим количеством символов "#":
 
-```markdown
+```md
 # Это заголовок h1
 ## Это заголовок h2
 ### Это заголовок h3
@@ -60,7 +61,7 @@ HTML-элементы от <h1> до <h6> размечаются очень пр
 ```
 Markdown позволяет размечать заголовки <h1> и <h2> ещё одним способом:
 
-```markdown
+```md
 Это заголовок h1
 ================
 
@@ -72,7 +73,7 @@ Markdown позволяет размечать заголовки <h1> и <h2> �
 
 Текст легко сделать полужирным и/или курсивным:
 
-```markdown
+```md
 *Этот текст будет выведен курсивом.*
 _Так же, как этот._
 
@@ -87,7 +88,7 @@ __И этот тоже.__
 В Github Flavored Markdown, стандарте, который используется в Github,
 текст также можно сделать зачёркнутым:
 
-```markdown
+```md
 ~~Зачёркнутый текст.~~
 ```
 
@@ -96,7 +97,7 @@ __И этот тоже.__
 Абзацами являются любые строки, следующие друг за другом.
 Разделяются же абзацы одной или несколькими пустыми строками:
 
-```markdown
+```md
 Это абзац. Я печатаю в абзаце, разве это не прикольно?
 
 А тут уже абзац №2.
@@ -108,7 +109,7 @@ __И этот тоже.__
 
 Для вставки принудительных переносов можно завершить абзац двумя дополнительными пробелами:
 
-```markdown
+```md
 Эта строка завершается двумя пробелами (выделите, чтобы увидеть!).  
 
 Над этой строкой есть <br />!
@@ -116,7 +117,7 @@ __И этот тоже.__
 
 Цитаты размечаются с помощью символа «>»:
 
-```markdown
+```md
 > Это цитата. В цитатах можно
 > принудительно переносить строки, вставляя «>» в начало каждой следующей строки. А можно просто оставлять их достаточно длинными, и такие длинные строки будут перенесены автоматически.
 > Разницы между этими двумя подходами к переносу строк нет, коль скоро
@@ -133,7 +134,7 @@ __И этот тоже.__
 одного из символов «*», «+» или «-»:
 (символ должен быть одним и тем же для всех элементов)
 
-```markdown
+```md
 * Список,
 * Размеченный
 * Звёздочками
@@ -154,7 +155,7 @@ __И этот тоже.__
 В нумерованных списках каждая строка начинается
 с числа и точки вслед за ним:
 
-```markdown
+```md
 1. Первый элемент
 2. Второй элемент
 3. Третий элемент
@@ -164,7 +165,7 @@ __И этот тоже.__
 любое число в начале каждого элемента, и парсер пронумерует элементы сам!
 Правда, злоупотреблять этим не стоит :)
 
-```markdown
+```md
 1. Первый элемент
 1. Второй элемент
 1. Третий элемент
@@ -173,7 +174,7 @@ __И этот тоже.__
 
 Списки могут быть вложенными:
 
-```markdown
+```md
 1. Введение
 2. Начало работы
 3. Примеры использования
@@ -184,7 +185,7 @@ __И этот тоже.__
 
 Можно даже делать списки задач. Блок ниже создаёт HTML-флажки. 
 
-```markdown
+```md
 Для отметки флажка используйте «x»
 - [ ] Первая задача
 - [ ] Вторая задача
@@ -197,7 +198,7 @@ __И этот тоже.__
 Фрагменты исходного кода (обычно отмечаемые тегом `<code>`) выделяются просто:
 каждая строка блока должна иметь отступ в четыре пробела либо в один символ табуляции.
 
-```markdown
+```md
     Это код,
     причём многострочный
 ```
@@ -205,7 +206,7 @@ __И этот тоже.__
 Вы также можете делать дополнительные отступы, добавляя символы табуляции
 или по четыре пробела:
 
-```markdown
+```md
     my_array.each do |item|
         puts item
     end
@@ -215,7 +216,7 @@ __И этот тоже.__
 не выделяя код в блок. Для этого фрагменты кода нужно обрамлять
 символами «`»:
 
-```markdown
+```md
 Ваня даже не знал, что делает функция `go_to()`!
 ```
 
@@ -237,7 +238,7 @@ end
 Разделители (`<hr>`) добавляются вставкой строки из трёх и более
 (одинаковых) символов «*» или «-», с пробелами или без них:
 
-```markdown
+```md
 ***
 ---
 - - -
@@ -251,18 +252,18 @@ end
 текст ссылки, заключив его в квадратные скобки,
 и сразу после — URL-адрес, заключенный в круглые
 
-```markdown
+```md
 [Ссылка!](http://test.com/)
 ```
 Также для ссылки можно указать всплывающую подсказку (`title`), используя
 кавычки внутри круглых скобок:
 
-```markdown
+```md
 [Ссылка!](http://test.com/ "Ссылка на Test.com")
 ```
 Относительные пути тоже возможны:
 
-```markdown
+```md
 [Перейти к музыке](/music/).
 ```
 
@@ -290,7 +291,7 @@ Markdown также позволяет размечать ссылку в вид
 Разметка изображений очень похожа на разметку ссылок.
 Нужно всего лишь добавить перед ссылкой восклицательный знак!
 
-```markdown
+```md
 ![Альтернативный текст для изображения](http://imgur.com/myimage.jpg "Подсказка")
 ```
 Изображения тоже могут быть оформлены, как сноски.
@@ -301,20 +302,20 @@ Markdown также позволяет размечать ссылку в вид
 ## Разное
 ### Автоссылки
 
-```markdown
+```md
 Ссылка вида <http://testwebsite.com/> эквивалентна
 [http://testwebsite.com/](http://testwebsite.com/)
 ```
 
 ### Автоссылки для адресов электронной почты
 
-```markdown
+```md
 <foo@bar.com>
 ```
 
 ### Экранирование символов
 
-```markdown
+```md
 Я хочу напечатать *текст, заключённый в звёздочки*, но я не хочу,
 чтобы он был курсивным. Тогда я делаю так:
 \*Текст, заключённый в звёздочки\*
@@ -324,7 +325,7 @@ Markdown также позволяет размечать ссылку в вид
 В Github Flavored Markdown для представления клавиш на клавиатуре
 вы можете использовать тег `<kbd>`.
 
-```markdown
+```md
 Ваш компьютер завис? Попробуйте нажать
 <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
 ```
@@ -334,7 +335,7 @@ Markdown также позволяет размечать ссылку в вид
 да и синтаксис имеют не слишком удобный.
 Но если очень нужно, размечайте таблицы так:
 
-```markdown
+```md
 | Столбец 1    | Столбец 2    | Столбец 3    |
 | :----------- | :----------: | -----------: |
 | Выравнивание | Выравнивание | Выравнивание |
@@ -342,7 +343,7 @@ Markdown также позволяет размечать ссылку в вид
 ```
 Или более компактно
 
-```markdown
+```md
 Столбец 1|Столбец 2|Столбец 3
 :--|:-:|--:
 Выглядит|это|страшновато...
diff --git a/ru-ru/php-composer-ru.html.markdown b/ru-ru/php-composer-ru.html.markdown
new file mode 100644
index 00000000..4bdf1029
--- /dev/null
+++ b/ru-ru/php-composer-ru.html.markdown
@@ -0,0 +1,197 @@
+---
+category: tool
+tool: composer
+contributors:
+    - ["Brett Taylor", "https://github.com/glutnix"]
+translators:
+    - ["Aleksey Lysenko", "https://github.com/nasgul"]
+filename: LearnComposer-ru.sh
+lang: ru-ru
+---
+
+[Composer](https://getcomposer.org/) — это инструмент управления зависимостями в PHP.
+Он позволяет вам декларировать библиотеки, от которых зависит ваш проект,
+и он будет управлять ими, то есть устанавливать/обновлять их для вас.
+
+# Установка
+
+```sh
+# Устанавливаем composer.phar в текущую папку
+curl -sS https://getcomposer.org/installer | php
+# Если вы используете этот подход, вам нужно будет вызвать Composer следующим образом:
+php composer.phar about
+
+# Устанавливаем бинарный файл в ~/bin/composer
+# Примечание: убедитесь, что ~/bin находится в переменной PATH вашего окружения
+curl -sS https://getcomposer.org/installer | php -- --install-dir=~/bin --filename=composer
+```
+
+Пользователи Windows должны следовать
+[Инструкциям по установке в Windows ](https://getcomposer.org/doc/00-intro.md#installation-windows)
+
+## Подтверждение установки
+
+```sh
+# # Проверить версию и перечислить параметры
+composer
+
+# Получить дополнительную помощь для параметров
+composer help require
+
+# Проверить, способен ли Composer делать то, что ему нужно, и обновлён ли он
+composer diagnose
+composer diag # краткий вариант
+
+# Обновление Composer до последней версии
+composer self-update
+composer self # краткий вариант
+```
+
+# Использование
+
+Composer сохраняет ваши зависимости проекта в `composer.json`.
+Вы можете отредактировать этот файл, но лучше всего позволить Composer управлять им за вас.
+
+```sh
+#  Создать новый проект в текущей папке
+composer init
+# запускается интерактивная анкета с просьбой предоставить подробную информацию о вашем проекте.
+# Вы прекрасно можете оставить ответы пустыми, если не делаете другие проекты 
+# зависимыми от создаваемого проекта.
+
+# Если файл composer.json уже существует, загрузите зависимости
+composer install
+
+# Чтобы загрузить только зависимости для готового продукта, т.е. 
+# исключая зависимости для разработки
+composer install --no-dev
+
+# Добавить зависимость для готового продукта к этому проекту
+composer require guzzlehttp/guzzle
+# выяснит, какая существует последняя версия guzzlehttp / guzzle,
+# загрузит её и добавит новую зависимость в поле require файла composer.json.
+
+composer require guzzlehttp/guzzle:6.0.*
+# Загрузит последнюю версию, соответствующую шаблону (например, 6.0.2),
+# и добавит зависимость к полю require файла composer.json
+
+composer require --dev phpunit/phpunit:~4.5.0
+# Добавит как зависимость для разработки.
+# Будет использовать последнюю версию> = 4.5.0 и <4.6.0
+
+composer require-dev phpunit/phpunit:^4.5.0
+# Добавит как зависимость для разработки.
+# Будет использовать последнюю версию> = 4.5.0 и <5.0
+
+# Для получения дополнительной информации о совместимости версий Composer см.
+# [Документацию Composer по версиям] (https://getcomposer.org/doc/articles/versions.md)
+
+# Чтобы узнать, какие пакеты доступны для установки и в настоящее время установлены
+composer show
+
+# Чтобы узнать, какие пакеты в настоящее время установлены
+composer show --installed
+
+# Чтобы найти пакет со строкой «mailgun» в названии или описании
+composer search mailgun
+```
+
+[Packagist.org](https://packagist.org/) является основным хранилищем для пакетов Composer.
+Существующие сторонние пакеты ищите там.
+
+## composer.json` и `composer.lock`
+
+Файл `composer.json` хранит параметры допустимых версий каждой зависимости
+вашего проекта, а также другую информацию.
+
+
+Файл `composer.lock` хранит точную загруженную версию каждой зависимости.
+Никогда не редактируйте этот файл.
+
+Если вы включите файл `composer.lock` в свой Git-репозиторий,
+каждый разработчик установит версии зависимостей, которые вы используете.
+Даже когда будет выпущена новая версия зависимости, Composer продолжит загрузку версии,
+записанной в lock-файле.
+
+```sh
+# Если вы хотите обновить все зависимости до новейших версий,
+# которые по-прежнему соответствуют вашим предпочтениям для версий
+composer update
+
+# Если вам нужна новая версия определённой зависимости:
+composer update phpunit/phpunit
+
+# Если вы хотите перенести пакет на более новую версию 
+#с изменением предпочитаемой версии,
+# вам может потребоваться сначала удалить старый пакет и его зависимости.
+composer remove --dev phpunit/phpunit
+composer require --dev phpunit/phpunit:^5.0
+```
+
+## Автозагрузчик
+
+Composer создаёт класс автозагрузки, который вы можете вызвать
+из своего приложения. Вы можете создавать экземпляры классов через пространство имён.
+
+```php
+require __DIR__ . '/vendor/autoload.php';
+
+$mailgun = new Mailgun\Mailgun("key");
+```
+
+### PSR-4-совместимый автозагрузчик
+
+
+Вы можете добавить в автозагрузчик свои собственные пространства имён.
+
+Добавьте поле `autoload` в `composer.json`:
+
+```json
+{
+  "autoload": {
+    "psr-4": {"Acme\\": "src/"}
+  }
+}
+```
+Это скажет автозагрузчику искать что-либо в пространстве имён `\Acme` в папке `src`.
+
+Вы также можете использовать
+[PSR-0, карту классов или просто список файлов для включения](https://getcomposer.org/doc/04-schema.md#autoload).
+Также существует поле `autoload-dev` для пространств имён, предназначенных только для разработки.
+
+При добавлении или изменении ключа автозагрузки вам необходимо перестроить автозагрузчик:
+
+```sh
+composer dump-autoload
+composer dump # краткий вариант
+
+# Оптимизирует пакеты PSR0 и PSR4 для загрузки классов с помощью карты классов.
+# Медленно запускается, но улучшает производительность готового продукта.
+composer dump-autoload --optimize --no-dev
+```
+
+# Кэш Composer
+
+```sh
+# Composer хранит загруженные пакеты для использования в будущем. Очистите кэш с помощью:
+composer clear-cache
+```
+
+# Устранение неполадок
+
+```sh
+composer diagnose
+composer self-update
+composer clear-cache
+```
+
+## Темы, которые ещё (пока) не включены в этот учебник
+
+* Создание и распространение ваших собственных пакетов на Packagist.org или в другом репозитории
+* Предварительные и пост-скриптовые перехватчики: запуск задач,
+когда происходят определенные события Composer
+
+### Ссылки
+
+* [Composer - Dependency Manager for PHP](https://getcomposer.org/)
+* [Packagist.org](https://packagist.org/)
diff --git a/ru-ru/python-ru.html.markdown b/ru-ru/python-ru.html.markdown
index 43142eff..6087a686 100644
--- a/ru-ru/python-ru.html.markdown
+++ b/ru-ru/python-ru.html.markdown
@@ -541,7 +541,7 @@ Human.grunt() #=> "*grunt*"
 
 # Вы можете импортировать модули
 import math
-print(math.sqrt(16)) #=> 4
+print(math.sqrt(16)) #=> 4.0
 
 # Вы можете импортировать отдельные функции модуля
 from math import ceil, floor
diff --git a/ru-ru/ruby-ru.html.markdown b/ru-ru/ruby-ru.html.markdown
index e69c6d94..b1fd04e1 100644
--- a/ru-ru/ruby-ru.html.markdown
+++ b/ru-ru/ruby-ru.html.markdown
@@ -231,6 +231,7 @@ new_hash.value?(3) #=> true
 
 # Управление ходом выполнения (Управляющие структуры)
 
+# Условия
 if true
   'Если истина'
 elsif false
@@ -239,6 +240,15 @@ else
   'Во всех других случаях (тоже опционально)'
 end
 
+# Если условие контролирует выполнение не блока кода, а единственного выражения,
+# можно использовать постфиксную запись условного оператора
+warnings = ['Отсутствует отчество', 'Слишком короткий адрес']
+puts("Обратите внимание:\n" + warnings.join("\n"))  if !warnings.empty?
+
+# Иногда условие лучше звучит с `unless`, чем с `if`
+puts("Обратите внимание:\n" + warnings.join("\n"))  unless warnings.empty?
+
+# Циклы
 for counter in 1..5
   puts "итерация #{counter}"
 end
diff --git a/ru-ru/rust-ru.html.markdown b/ru-ru/rust-ru.html.markdown
new file mode 100644
index 00000000..8b2667cf
--- /dev/null
+++ b/ru-ru/rust-ru.html.markdown
@@ -0,0 +1,313 @@
+---
+language: rust
+
+filename: learnrust-ru.rs
+contributors:
+    - ["P1start", "http://p1start.github.io/"]
+translators:
+    - ["Anatolii Kosorukov", "https://github.com/java1cprog"]
+    - ["Vasily Starostin", "https://github.com/Basil22"]
+lang: ru-ru
+
+---
+
+Язык Rust разработан в Mozilla Research. Он сочетает низкоуровневую производительность с удобством языка высокого уровня и одновременно гарантирует безопасность памяти.
+
+Он достигает этих целей без сборщика мусора или сложной среды выполнения, что позволяет использовать библиотеки Rust как прямую замену
+C-библиотек. И наоборот, Rust умеет использовать готовые С-библиотеки как есть, без накладных расходов.
+
+Первый выпуск Rust, 0.1, произошел в январе 2012 года. В течение 3 лет развитие продвигалось настолько быстро, что язык серьезно менялся без сохранения совместимости. Это дало возможность обкатать и отполировать синтаксис и возможности языка.
+
+15 мая 2015 года был выпущен Rust 1.0 с полной гарантией обратной совместимости. Сборка поставляется в трех вариантах: стабильная версия, бета-версия, ночная версия. Все нововведения языка сперва обкатываются на ночной и бета-версиях, и только потом попадают в стабильную. Выход очередной версии происходит раз в 6 недель. В 2018 году вышло второе большое обновление языка, добавившее ему новых возможностей.
+
+Хотя Rust является языком относительно низкого уровня, он имеет все возможности высокоуровневых языков: процедурное, объектное, функциональное, шаблонное и другие виды программирования. На данный момент Rust является одним из самых мощных (а может быть и самым) по возможностям среди статически типизированных языков. Это делает Rust не только быстрым, но и простым и эффективным для разработки сложного кода.
+
+
+```rust
+// Это однострочный комментарий
+// 
+
+/// Так выглядит комментарий для документации
+/// # Examples
+///
+/// ```
+/// let seven  = 7
+/// ```
+
+///////////////
+// 1. Основы //
+///////////////
+
+// Функции
+// `i32` это целочисленный знаковый тип 32-bit
+#[allow(dead_code)]
+fn add2(x: i32, y: i32) -> i32 {
+    // метод возвращает сумму x и y
+    x + y
+}
+
+// Главная функция программы
+#[allow(unused_variables)]
+#[allow(unused_assignments)]
+#[allow(dead_code)]
+fn main() {
+    // Числа //
+
+    // неизменяемая переменная
+    let x: i32 = 1;
+
+    // Суффиксы целое/дробное
+    let y: i32 = 13i32;
+    let f: f64 = 1.3f64;
+
+    // Автоматическое выведение типа данных
+    // В большинстве случаев компилятор Rust может вычислить 
+    // тип переменной, поэтому вам не нужно явно указывать тип.
+
+    let implicit_x = 1;
+    let implicit_f = 1.3;
+
+    // Арифметика
+    let sum = x + y + 13;
+
+    // Изменяемая переменная
+    let mut mutable = 1;
+    mutable = 4;
+    mutable += 2;
+
+    // Строки //
+
+    // Строковые литералы
+    let x: &str = "hello world!";
+
+    // Печать на консоль
+    println!("{} {}", f, x); // 1.3 hello world
+
+    // `String` – изменяемая строка
+    let s: String = "hello world".to_string();
+
+    // Строковый срез - неизменяемое представление части строки
+    // Представляет собой пару из указателя на начало фрагмента и его длины
+
+    let s_slice: &str = &s;
+
+    println!("{} {}", s, s_slice); // hello world hello world
+
+    // Vectors/arrays //
+
+    // фиксированный массив
+    let four_ints: [i32; 4] = [1, 2, 3, 4];
+
+    // динамический массив
+    let mut vector: Vec<i32> = vec![1, 2, 3, 4];
+    vector.push(5);
+
+    // Срез - неизменяемое представление значений вектора
+    let slice: &[i32] = &vector;
+
+    // Используйте шаблон `{:?}`для печати отладочной информации структур с данными
+    println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
+
+    // Кортежи //
+
+    // Кортеж - это фиксированный набор. 
+    // В нём могут находиться значения разных типов данных.
+    let x: (i32, &str, f64) = (1, "hello", 3.4);
+
+    // Инициализация группы переменных `let`
+    let (a, b, c) = x;
+    println!("{} {} {}", a, b, c); // 1 hello 3.4
+
+    // Доступ по индексу
+    println!("{}", x.1); // hello
+
+    //////////////
+    // 2. Типы //
+    //////////////
+
+    // Структура
+    struct Point {
+        x: i32,
+        y: i32,
+    }
+
+    let origin: Point = Point { x: 0, y: 0 };
+
+    // Структуры могут быть с безымянными полями ‘tuple struct’
+    struct Point2(i32, i32);
+
+    let origin2 = Point2(0, 0);
+
+    // Перечисление
+    enum Direction {
+        Left,
+        Right,
+        Up,
+        Down,
+    }
+
+    let up = Direction::Up;
+
+    // Перечисление с полями
+    // В отличие от C и C++ компилятор автоматически следит за тем,
+    // какой именно тип хранится в перечислении.
+    enum OptionalI32 {
+        AnI32(i32),
+        Nothing,
+    }
+
+    let two: OptionalI32 = OptionalI32::AnI32(2);
+    let nothing = OptionalI32::Nothing;
+
+    // Обобщенные типы данных //
+
+    struct Foo<T> { bar: T }
+
+    // Частоиспользуемое перечисление стандартной библиотеки `Option`
+    enum Optional<T> {
+        SomeVal(T),
+        NoVal,
+    }
+
+    // Методы //
+
+    impl<T> Foo<T> {
+        fn get_bar(self) -> T {
+            self.bar
+        }
+    }
+
+    let a_foo = Foo { bar: 1 };
+    println!("{}", a_foo.get_bar()); // 1
+
+    // Типаж
+
+    trait Frobnicate<T> {
+        fn frobnicate(self) -> Option<T>;
+    }
+
+    impl<T> Frobnicate<T> for Foo<T> {
+        fn frobnicate(self) -> Option<T> {
+            Some(self.bar)
+        }
+    }
+
+    let another_foo = Foo { bar: 1 };
+    println!("{:?}", another_foo.frobnicate()); // Some(1)
+
+    /////////////////////////////////
+    // 3. Сопоставление по шаблону //
+    /////////////////////////////////
+
+    let foo = OptionalI32::AnI32(1);
+    match foo {
+        OptionalI32::AnI32(n) => println!("it’s an i32: {}", n),
+        OptionalI32::Nothing  => println!("it’s nothing!"),
+    }
+
+    // Более сложный пример
+    struct FooBar { x: i32, y: OptionalI32 }
+    let bar = FooBar { x: 15, y: OptionalI32::AnI32(32) };
+
+    match bar {
+        FooBar { x: 0, y: OptionalI32::AnI32(0) } =>
+            println!("The numbers are zero!"),
+        FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m =>
+            println!("The numbers are the same"),
+        FooBar { x: n, y: OptionalI32::AnI32(m) } =>
+            println!("Different numbers: {} {}", n, m),
+        FooBar { x: _, y: OptionalI32::Nothing } =>
+            println!("The second number is Nothing!"),
+    }
+
+    //////////////////////////////////////////////
+    // 4. Управление ходом выполнения программы //
+    //////////////////////////////////////////////
+
+    // `for` loops/iteration
+    let array = [1, 2, 3];
+    for i in array.iter() {
+        println!("{}", i);
+    }
+
+    // Диапазоны
+    for i in 0u32..10 {
+        print!("{} ", i);
+    }
+    println!("");
+    // prints `0 1 2 3 4 5 6 7 8 9 `
+
+    // `if`
+    if 1 == 1 {
+        println!("Maths is working!");
+    } else {
+        println!("Oh no...");
+    }
+
+    // `if` as expression
+    let value = if true {
+        "good"
+    } else {
+        "bad"
+    };
+
+    // `while` loop
+    while 1 == 1 {
+        println!("The universe is operating normally.");
+        break;
+    }
+
+    // Infinite loop
+    loop {
+        println!("Hello!");
+        break;
+    }
+
+    //////////////////////////////////
+    // 5. Защита памяти и указатели //
+    //////////////////////////////////
+
+    // Владеющий указатель – такой указатель может быть только один
+    // Это значит, что при вызоде из блока переменная автоматически становится недействительной.
+    let mut mine: Box<i32> = Box::new(3);
+    *mine = 5; // dereference
+    // Здесь, `now_its_mine` получает во владение `mine`. Т.е. `mine` была перемещена.
+    let mut now_its_mine = mine;
+    *now_its_mine += 2;
+
+    println!("{}", now_its_mine); // 7
+    // println!("{}", mine);  
+
+    //  Ссылки - это неизменяемые указатели
+    //  Если ссылка получает значения, то говорят, что она заимствует это значение.
+    //  Такое значение не может быть изменено или перемещено.
+    let mut var = 4;
+    var = 3;
+    let ref_var: &i32 = &var;
+
+    println!("{}", var);
+    println!("{}", *ref_var);
+    // var = 5; // не скомпилируется
+    // *ref_var = 6; // и это
+
+    // Изменяемые ссылки
+    //
+    let mut var2 = 4;
+    let ref_var2: &mut i32 = &mut var2;
+    *ref_var2 += 2;         // '*' используется для изменения значения
+
+    println!("{}", *ref_var2); // 6 , // var2 would not compile.
+    // ref_var2 имеет тип &mut i32, т.е. он содержит ссылку на i32, а не значение.
+    // var2 = 2; // не скомпилируется, т.к. эта переменная уже была заимствована ранее
+} 
+
+```
+
+## Более подробная информация о языке
+
+Уже есть хорошие книги для изучающих Rust. Основным источником остаётся 
+[The Rust Programming Language](http://doc.rust-lang.org/book/index.html) 
+
+Для компиляции программ при изучении языка весьма удобно использовать 
+[Rust playpen](http://play.rust-lang.org). 
+Множество ресурсов на разных языках можно найти в [этом проекте](https://github.com/ctjhoa/rust-learning).
diff --git a/ru-ru/sql-ru.html.markdown b/ru-ru/sql-ru.html.markdown
new file mode 100644
index 00000000..7353a175
--- /dev/null
+++ b/ru-ru/sql-ru.html.markdown
@@ -0,0 +1,120 @@
+---
+language: SQL
+filename: learnsql-ru.sql
+contributors:
+  - ["Bob DuCharme", "http://bobdc.com/"]
+translators:
+  - ["Shaltaev", "https://github.com/shaltaev"]
+  - ["Andre Polykanine", "https://github.com/Menelion"]
+lang: ru-ru
+---
+
+Язык структурированных запросов (SQL) — это стандартный язык ISO для создания
+и работы с базами данных, хранящимися в наборе таблиц. Реализации обычно
+добавляют свои собственные расширения к языку;
+[Сравнение различных реализаций SQL](http://troels.arvin.dk/db/rdbms/) — хороший справочник по различиям в продуктах.
+
+Реализации обычно предоставляют приглашение командной строки, где вы можете
+вводить команды, описанные ниже, в интерактивном режиме, также есть способ
+выполнить серию таких команд, сохранённых в файле скрипта.
+(Результат того, что вы сделали с помощью интерактивного режима, является
+хорошим примером того, что не стандартизировано, — большинство реализаций SQL
+поддерживают ключевые слова QUIT, EXIT или оба).
+
+Некоторые команды ниже предполагают использование
+[демонстрационного образца базы данных сотрудников от MySQL](https://dev.mysql.com/doc/employee/en/), доступного на [Github](https://github.com/datacharmer/test_db).
+Следовательно, для повторения команд в локальном окружении он должен быть загружен.
+Файлы на github — это скрипты с командами, которые схожи с командами ниже,
+которые создают и манипулируют таблицами и данными о сотрудниках вымышленной
+компании. Синтаксис для запуска этих скриптов будет зависеть от используемой
+вами реализации SQL. Обычно используется утилита, запускаемая из командной
+строки в вашей операционной системе.
+
+```sql
+-- Комментарии начинаются с двух дефисов. Завершайте каждую команду
+-- точкой с запятой.
+
+-- SQL не учитывает регистр букв для ключевых слов. Примеры команд здесь
+-- следуют соглашению о написании в верхнем регистре, потому что
+-- это позволяет легче отличить их от имён баз, таблиц и колонок.
+
+-- Создание и удаление базы данных. Имена базы и таблицы чувствительны
+-- к регистру букв.
+CREATE DATABASE someDatabase;
+DROP DATABASE someDatabase;
+
+-- Список доступных баз.
+SHOW DATABASES;
+
+-- Выбор базы для работы.
+USE employees;
+
+-- Выбрать все строки и колонки из таблицы «departments» (отделы) текущей базы.
+-- В интерактивном режиме обыч	но результат будет выведен на экран.
+SELECT * FROM departments;
+
+-- Тот же запрос, что и выше, но выбор только колонок «dept_no» и «dept_name».
+-- Разбиение команд на несколько строк допустимо.
+SELECT dept_no,
+       dept_name FROM departments;
+
+-- В данном случае будут выбраны все колонки, но только первые 5 строк.
+SELECT * FROM departments LIMIT 5;
+
+-- Выбор названий отделов, содержащих подстроку «en».
+SELECT dept_name FROM departments WHERE dept_name LIKE '%en%';
+
+-- Выбор всех колонок, где названия отделов начинаются на «S»,
+-- после которой идёт ровно четыре символа.
+SELECT * FROM departments WHERE dept_name LIKE 'S____';
+
+-- Выбор всех должностей из таблицы «titles», но без повторений.
+SELECT DISTINCT title FROM titles;
+
+-- В дополнение к предыдущему запросу результат будет отсортирован
+-- в алфавитном порядке (с учётом регистра).
+SELECT DISTINCT title FROM titles ORDER BY title;
+
+-- Показать число строк в таблице отделов.
+SELECT COUNT(*) FROM departments;
+
+-- Показать число строк, где название отдела содержит подстроку «en»
+SELECT COUNT(*) FROM departments WHERE dept_name LIKE '%en%';
+
+-- Объединение информации из нескольких таблиц:
+-- В таблице «titles» перечислены должности, кто их занимал по номеру сотрудника,
+-- а также с какой даты по какую. Получим эту информацию, но используем номера
+-- сотрудников как ссылку на таблицу «employees», чтобы получить имя и фамилию
+-- каждого сотрудника. Выводим только 10 строк.
+SELECT employees.first_name, employees.last_name,
+       titles.title, titles.from_date, titles.to_date
+FROM titles INNER JOIN employees ON
+       employees.emp_no = titles.emp_no LIMIT 10;
+
+-- Список всех таблиц во всех базах. Реализации обычно предоставляют
+-- собственные сокращения, чтобы показать все таблицы текущей базы.
+SELECT * FROM INFORMATION_SCHEMA.TABLES
+WHERE TABLE_TYPE='BASE TABLE';
+
+-- Создать таблицу с именем tablename1 и двумя колонками в текущей базе.
+-- Для колонок имеется множество параметров, таких как тип данных.
+CREATE TABLE tablename1 (fname VARCHAR(20), lname VARCHAR(20));
+
+-- Вставляем строку данных в таблицу «tablename1». Предполагаем, что таблица
+-- настроена таким образом, чтобы принимать эти значения.
+INSERT INTO tablename1 VALUES('Richard','Mutt');
+
+-- В таблице «tablename1» изменить значение fname на «John»
+-- для каждой строки, где колонка lname равна «Mutt».
+UPDATE tablename1 SET fname='John' WHERE lname='Mutt';
+
+-- Удалить из таблицы «tablename1» строки,
+-- где значение колонки lname начинается с «M».
+DELETE FROM tablename1 WHERE lname like 'M%';
+
+-- Удалить все строки из таблицы «tablename1». В итоге получим пустую таблицу.
+DELETE FROM tablename1;
+
+-- Удалить таблицу «tablename1» полностью.
+DROP TABLE tablename1;
+```
diff --git a/ru-ru/yaml-ru.html.markdown b/ru-ru/yaml-ru.html.markdown
new file mode 100644
index 00000000..6eb580d9
--- /dev/null
+++ b/ru-ru/yaml-ru.html.markdown
@@ -0,0 +1,189 @@
+---
+language: yaml
+filename: learnyaml-ru.yaml
+contributors:
+- [Adam Brenecki, 'https://github.com/adambrenecki']
+- [Suhas SG, 'https://github.com/jargnar']
+translators:
+- [Sergei Babin, 'https://github.com/serzn1']
+lang: ru-ru
+---
+
+YAML как язык сериализации данных предназначен прежде всего для использования людьми.
+
+Это строгое надмножество JSON с добавлением синтаксически значимых переносов строк и 
+отступов как в Python. Тем не менее, в отличие от Python, YAML запрещает 
+использование табов для отступов.
+
+```yaml
+---  # начало документа
+
+# Комментарий в YAML выглядит как-то так.
+
+######################
+# Скалярные величины #
+######################
+
+# Наш корневой объект (который продолжается для всего документа) будет соответствовать
+# типу map, который в свою очередь соответствует словарю, хешу или объекту в других языках.
+key: value
+another_key: Другое значение ключа.
+a_number_value: 100
+scientific_notation: 1e+12
+# Число 1 будет интерпретировано как число, а не как логический тип. Если необходимо чтобы
+# значение было интерпретировано как логическое, необходимо использовать true
+boolean: true
+null_value: null
+key with spaces: value
+
+# Обратите внимание что строки используются без кавычек, но могут и с кавычками.
+however: 'Строка заключенная в кавычки.'
+'Ключ заключенный в кавычки.': "Полезно если нужно использовать ':' в вашем ключе."
+single quotes: 'Содержит ''одну'' экранированную строку'
+double quotes: "Содержит несколько: \", \0, \t, \u263A, \x0d\x0a == \r\n, экранированных строк."
+
+# Многострочные строковые значения могут быть записаны как 'строковый блок' (используя |),
+# или как 'сложенный блок' (используя '>').
+literal_block: |
+    Значение всего текста в этом блоке будет присвоено ключу 'literal_block',
+    с сохранением переноса строк.
+
+    Объявление продолжается до удаления отступа и выравнивания с ведущим отступом.
+
+        Любые строки с большим отступом сохраняют остатки своего отступа -  
+        эта строка будет содержать дополнительно 4 пробела.
+folded_style: >
+    Весь блок этого тектса будет значением 'folded_style', но в данном случае
+    все символы новой строки будут заменены пробелами.
+
+    Пустые строки будут преобразованы в перенос строки.
+
+        Строки с дополнительными отступами сохраняют их переносы строк -
+        этот текст появится через 2 строки.
+
+##################
+# Типы коллекций #
+##################
+
+# Вложения используют отступы. Отступ в 2 пробела предпочтителен (но не обязателен).
+a_nested_map:
+  key: value
+  another_key: Another Value
+  another_nested_map:
+    hello: hello
+
+# В словарях (maps) используются не только строковые значения ключей.
+0.25: a float key
+
+# Ключи также могут быть сложными, например многострочными.
+# Мы используем ? с последующим пробелом чтобы обозначить начало сложного ключа.
+? |
+  Этот ключ
+  который содержит несколько строк
+: и это его значение
+
+# YAML также разрешает соответствия между последовательностями со сложными ключами
+# Некоторые парсеры могут выдать предупреждения или ошибку
+# Пример
+? - Manchester United
+  - Real Madrid
+: [2001-01-01, 2002-02-02]
+
+# Последовательности (эквивалент списка или массива) выглядят как-то так
+# (обратите внимание что знак '-' считается отступом):
+a_sequence:
+  - Item 1
+  - Item 2
+  - 0.5  # последовательности могут содержать различные типы.
+  - Item 4
+  - key: value
+    another_key: another_value
+  -
+    - Это последовательность
+    - внутри другой последовательности
+  - - - Объявления вложенных последовательностей
+      - могут быть сжаты
+
+# Поскольку YAML это надмножество JSON, вы можете использовать JSON-подобный 
+# синтаксис для словарей и последовательностей:
+json_map: {"key": "value"}
+json_seq: [3, 2, 1, "takeoff"]
+в данном случае кавычки не обязательны: {key: [3, 2, 1, takeoff]}
+
+##########################
+# Дополнительные функции #
+##########################
+
+# В YAML есть удобная система так называемых 'якорей' (anchors), которые позволяют легко
+# дублировать содержимое внутри документа. Оба ключа в примере будут иметь одинаковые значения:
+anchored_content: &anchor_name Эта строка будет являться значением обоих ключей.
+other_anchor: *anchor_name
+
+# Якоря могут использоваться для дублирования/наследования свойств
+base: &base
+  name: Каждый будет иметь одинаковое имя
+
+# Регулярное выражение << называется ключом объединения независимо от типа языка.
+# Он используется чтобы показать что все ключи одного или более словарей должны быть
+# добавлены в текущий словарь.
+
+foo: &foo
+  <<: *base
+  age: 10
+
+bar: &bar
+  <<: *base
+  age: 20
+
+# foo и bar могли бы иметь имена: Каждый из них имеет аналогичное имя
+
+# В YAML есть теги (tags), которые используются для явного объявления типов.
+explicit_string: !!str 0.5
+# В некоторых парсерах реализованы теги для конкретного языка, пример для Python
+# пример сложного числового типа.
+python_complex_number: !!python/complex 1+2j
+
+# Мы можем использовать сложные ключи с включенными в них тегами из определенного языка
+? !!python/tuple [5, 7]
+: Fifty Seven
+# Могло бы быть {(5, 7): 'Fifty Seven'} в Python
+
+#######################
+# Дополнительные типы #
+#######################
+
+# Строки и числа не единственные величины которые может понять YAML.
+# YAML также поддерживает даты и время в формате ISO.
+datetime: 2001-12-15T02:59:43.1Z
+datetime_with_spaces: 2001-12-14 21:59:43.10 -5
+date: 2002-12-14
+
+# Тег !!binary показывает что эта строка является base64-закодированным
+# представлением двоичного объекта.
+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=
+
+# YAML может использовать объекты типа ассоциативных массивов (set), как представлено ниже:
+set:
+  ? item1
+  ? item2
+  ? item3
+or: {item1, item2, item3}
+
+# Сеты (set) являются простыми эквивалентами словарей со значениями 
+# типа null; запись выше эквивалентна следующей:
+set2:
+  item1: null
+  item2: null
+  item3: null
+
+...  # конец документа
+```
+
+### Больше информации
+
++ [YAML оффициальный вебсайт](http://yaml.org/)
++ [YAML онлайн валидатор](http://www.yamllint.com/)
diff --git a/ruby-ecosystem.html.markdown b/ruby-ecosystem.html.markdown
index 50eedcd0..3c80075b 100644
--- a/ruby-ecosystem.html.markdown
+++ b/ruby-ecosystem.html.markdown
@@ -10,6 +10,16 @@ contributors:
 People using Ruby generally have a way to install different Ruby versions,
 manage their packages (or gems), and manage their gem dependencies.
 
+## Ruby Versions
+
+Ruby was created by Yukihiro "Matz" Matsumoto, who remains somewhat of a
+[BDFL](https://en.wikipedia.org/wiki/Benevolent_Dictator_for_Life), although
+that is changing recently. As a result, the reference implementation of Ruby is
+called MRI (Matz' Reference Implementation), and when you hear a Ruby version,
+it is referring to the release version of MRI.
+
+New major versions of Ruby are traditionally released on Christmas Day. The current major version (25 December 2017) is 2.5. The most popular stable versions are 2.4.4 and 2.3.7 (both released 28 March 2018).
+
 ## Ruby Managers
 
 Some platforms have Ruby pre-installed or available as a package. Most rubyists
@@ -29,28 +39,6 @@ The following are the popular Ruby environment managers:
 * [chruby](https://github.com/postmodern/chruby) - Only switches between rubies.
   Similar in spirit to rbenv. Unopinionated about how rubies are installed.
 
-## Ruby Versions
-
-Ruby was created by Yukihiro "Matz" Matsumoto, who remains somewhat of a
-[BDFL](https://en.wikipedia.org/wiki/Benevolent_Dictator_for_Life), although
-that is changing recently. As a result, the reference implementation of Ruby is
-called MRI (Matz' Reference Implementation), and when you hear a Ruby version,
-it is referring to the release version of MRI.
-
-The three major version of Ruby in use are:
-
-* 2.0.0 - Released in February 2013. Most major libraries and frameworks support
-  2.0.0.
-* 1.9.3 - Released in October 2011. This is the version most rubyists use
-  currently. Also [retired](https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/)
-* 1.8.7 - Ruby 1.8.7 has been
-  [retired](http://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/).
-
-The change between 1.8.7 to 1.9.x is a much larger change than 1.9.3 to 2.0.0.
-For instance, the 1.9 series introduced encodings and a bytecode VM.  There
-are projects still on 1.8.7, but they are becoming a small minority, as most of
-the community has moved to at least 1.9.2 or 1.9.3.
-
 ## Ruby Implementations
 
 The Ruby ecosystem enjoys many different implementations of Ruby, each with
diff --git a/ruby.html.markdown b/ruby.html.markdown
index e0a6bb6e..d77672ab 100644
--- a/ruby.html.markdown
+++ b/ruby.html.markdown
@@ -15,32 +15,30 @@ contributors:
   - ["Gabriel Halley", "https://github.com/ghalley"]
   - ["Persa Zula", "http://persazula.com"]
   - ["Jake Faris", "https://github.com/farisj"]
+  - ["Corey Ward", "https://github.com/coreyward"]
+  - ["Jannik Siebert", "https://github.com/janniks"]
+  - ["Keith Miyake", "https://github.com/kaymmm"]
 ---
 
 ```ruby
 # This is a comment
 
-=begin
-This is a multiline comment
-No-one uses them
-You shouldn't either
-=end
+# In Ruby, (almost) everything is an object.
+# This includes numbers...
+3.class #=> Integer
 
-# First and foremost: Everything is an object.
-
-# Numbers are objects
-
-3.class #=> Fixnum
-
-3.to_s #=> "3"
+# ...and strings...
+"Hello".class #=> String
 
+# ...and even methods!
+"Hello".method(:class).class #=> Method
 
 # Some basic arithmetic
 1 + 1 #=> 2
 8 - 1 #=> 7
 10 * 2 #=> 20
 35 / 5 #=> 7
-2**5 #=> 32
+2 ** 5 #=> 32
 5 % 3 #=> 2
 
 # Bitwise operators
@@ -52,6 +50,7 @@ You shouldn't either
 # for calling a method on an object
 1.+(3) #=> 4
 10.* 5 #=> 50
+100.methods.include?(:/) #=> true
 
 # Special values are objects
 nil # equivalent to null in other languages
@@ -70,11 +69,12 @@ false.class #=> FalseClass
 1 != 1 #=> false
 2 != 1 #=> true
 
-# apart from false itself, nil is the only other 'falsey' value
+# Apart from false itself, nil is the only other 'falsey' value
 
-!nil   #=> true
-!false #=> true
-!0     #=> false
+!!nil   #=> false
+!!false #=> false
+!!0     #=> true
+!!""    #=> true
 
 # More comparisons
 1 < 10 #=> true
@@ -82,15 +82,15 @@ false.class #=> FalseClass
 2 <= 2 #=> true
 2 >= 2 #=> true
 
-# Combined comparison operator
-1 <=> 10 #=> -1
-10 <=> 1 #=> 1
-1 <=> 1 #=> 0
+# Combined comparison operator (returns `1` when the first argument is greater, 
+# `-1` when the second argument is greater, and `0` otherwise)
+1 <=> 10 #=> -1 (1 < 10)
+10 <=> 1 #=> 1 (10 > 1)
+1 <=> 1 #=> 0 (1 == 1)
 
 # Logical operators
 true && false #=> false
 true || false #=> true
-!true #=> false
 
 # There are alternate versions of the logical operators with much lower
 # precedence. These are meant to be used as flow-control constructs to chain
@@ -101,61 +101,54 @@ do_something() and do_something_else()
 # `log_error` only called if `do_something` fails.
 do_something() or log_error()
 
-
-# Strings are objects
-
-'I am a string'.class #=> String
-"I am a string too".class #=> String
+# String interpolation
 
 placeholder = 'use string interpolation'
 "I can #{placeholder} when using double quoted strings"
 #=> "I can use string interpolation when using double quoted strings"
 
-# Prefer single quoted strings to double quoted ones where possible
-# Double quoted strings perform additional inner calculations
-
-# Combine strings, but not with numbers
+# You can combine strings using `+`, but not with other types
 'hello ' + 'world'  #=> "hello world"
 'hello ' + 3 #=> TypeError: can't convert Fixnum into String
 'hello ' + 3.to_s #=> "hello 3"
+"hello #{3}" #=> "hello 3"
 
-# Combine strings and operators
+# ...or combine strings and operators
 'hello ' * 3 #=> "hello hello hello "
 
-# Append to string
+# ...or append to string
 'hello' << ' world' #=> "hello world"
 
-# print to the output with a newline at the end
+# You can print to the output with a newline at the end
 puts "I'm printing!"
 #=> I'm printing!
 #=> nil
 
-# print to the output without a newline
+# ...or print to the output without a newline
 print "I'm printing!"
-#=> I'm printing! => nil
+#=> "I'm printing!" => nil
 
 # Variables
 x = 25 #=> 25
 x #=> 25
 
-# Note that assignment returns the value assigned
-# This means you can do multiple assignment:
+# Note that assignment returns the value assigned.
+# This means you can do multiple assignment.
 
 x = y = 10 #=> 10
 x #=> 10
 y #=> 10
 
-# By convention, use snake_case for variable names
+# By convention, use snake_case for variable names.
 snake_case = true
 
 # Use descriptive variable names
 path_to_project_root = '/good/name/'
-path = '/bad/name/'
+m = '/bad/name/'
 
-# Symbols (are objects)
 # Symbols are immutable, reusable constants represented internally by an
 # integer value. They're often used instead of strings to efficiently convey
-# specific, meaningful values
+# specific, meaningful values.
 
 :pending.class #=> Symbol
 
@@ -167,77 +160,85 @@ status == 'pending' #=> false
 
 status == :approved #=> false
 
+# Strings can be converted into symbols and vice versa.
+status.to_s #=> "pending"
+"argon".to_sym #=> :argon
+
 # Arrays
 
-# This is an array
+# This is an array.
 array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
 
-# Arrays can contain different types of items
-
+# Arrays can contain different types of items.
 [1, 'hello', false] #=> [1, "hello", false]
 
-# Arrays can be indexed
-# From the front
+# Arrays can be indexed.
+# From the front...
 array[0] #=> 1
 array.first #=> 1
 array[12] #=> nil
 
-# Like arithmetic, [var] access
-# is just syntactic sugar
-# for calling a method [] on an object
-array.[] 0 #=> 1
-array.[] 12 #=> nil
-
-# From the end
+# ...or from the back...
 array[-1] #=> 5
 array.last #=> 5
 
-# With a start index and length
+# ...or with a start index and length...
 array[2, 3] #=> [3, 4, 5]
 
-# Reverse an Array
-a=[1,2,3]
-a.reverse! #=> [3,2,1]
-
-# Or with a range
+# ...or with a range...
 array[1..3] #=> [2, 3, 4]
 
-# Add to an array like this
+# You can reverse an Array.
+# Return a new array with reversed values
+[1,2,3].reverse #=> [3,2,1]
+# Reverse an array in place to update variable with reversed values
+a = [1,2,3]
+a.reverse! #=> a==[3,2,1] because of the bang ('!') call to reverse
+
+# Like arithmetic, [var] access is just syntactic sugar
+# for calling a method '[]' on an object.
+array.[] 0 #=> 1
+array.[] 12 #=> nil
+
+# You can add to an array...
 array << 6 #=> [1, 2, 3, 4, 5, 6]
 # Or like this
 array.push(6) #=> [1, 2, 3, 4, 5, 6]
 
-# Check if an item exists in an array
+# ...and check if an item exists in an array
 array.include?(1) #=> true
 
 # Hashes are Ruby's primary dictionary with key/value pairs.
-# Hashes are denoted with curly braces:
+# Hashes are denoted with curly braces.
 hash = { 'color' => 'green', 'number' => 5 }
 
 hash.keys #=> ['color', 'number']
 
-# Hashes can be quickly looked up by key:
-hash['color'] #=> 'green'
+# Hashes can be quickly looked up by key.
+hash['color'] #=> "green"
 hash['number'] #=> 5
 
-# Asking a hash for a key that doesn't exist returns nil:
+# Asking a hash for a key that doesn't exist returns nil.
 hash['nothing here'] #=> nil
 
-# Since Ruby 1.9, there's a special syntax when using symbols as keys:
+# When using symbols for keys in a hash, you can use an alternate syntax.
 
-new_hash = { defcon: 3, action: true }
+hash = { :defcon => 3, :action => true }
+hash.keys #=> [:defcon, :action]
 
-new_hash.keys #=> [:defcon, :action]
+hash = { defcon: 3, action: true }
+hash.keys #=> [:defcon, :action]
 
 # Check existence of keys and values in hash
-new_hash.key?(:defcon) #=> true
-new_hash.value?(3) #=> true
+hash.key?(:defcon) #=> true
+hash.value?(3) #=> true
 
-# Tip: Both Arrays and Hashes are Enumerable
-# They share a lot of useful methods such as each, map, count, and more
+# Tip: Both Arrays and Hashes are Enumerable!
+# They share a lot of useful methods such as each, map, count, and more.
 
 # Control structures
 
+# Conditionals
 if true
   'if statement'
 elsif false
@@ -246,35 +247,34 @@ else
   'else, also optional'
 end
 
+# If a condition controls invokation of a single statement rather than a block of code
+# you can use postfix-if notation
+warnings = ['Patronimic is missing', 'Address too short']
+puts("Some warnings occurred:\n" + warnings.join("\n"))  if !warnings.empty?
+
+# Rephrase condition if `unless` sounds better than `if`
+puts("Some warnings occurred:\n" + warnings.join("\n"))  unless warnings.empty?
+
+# Loops
+# In Ruby, traditional `for` loops aren't very common. Instead, these 
+# basic loops are implemented using enumerable, which hinges on `each`.
+(1..5).each do |counter|
+  puts "iteration #{counter}"
+end
+
+# Which is roughly equivalent to the following, which is unusual to see in Ruby.
 for counter in 1..5
   puts "iteration #{counter}"
 end
-#=> iteration 1
-#=> iteration 2
-#=> iteration 3
-#=> iteration 4
-#=> iteration 5
 
-# HOWEVER, No-one uses for loops.
-# Instead you should use the "each" method and pass it a block.
-# A block is a bunch of code that you can pass to a method like "each".
-# It is analogous to lambdas, anonymous functions or closures in other
-# programming languages.
+# The `do |variable| ... end` construct above is called a 'block'. Blocks are similar
+# to lambdas, anonymous functions or closures in other programming languages. They can
+# be passed around as objects, called, or attached as methods.
 #
-# The "each" method of a range runs the block once for each element of the range.
+# The 'each' method of a range runs the block once for each element of the range.
 # The block is passed a counter as a parameter.
-# Calling the "each" method with a block looks like this:
 
-(1..5).each do |counter|
-  puts "iteration #{counter}"
-end
-#=> iteration 1
-#=> iteration 2
-#=> iteration 3
-#=> iteration 4
-#=> iteration 5
-
-# You can also surround blocks in curly brackets:
+# You can also surround blocks in curly brackets.
 (1..5).each { |counter| puts "iteration #{counter}" }
 
 # The contents of data structures can also be iterated using each.
@@ -285,8 +285,8 @@ hash.each do |key, value|
   puts "#{key} is #{value}"
 end
 
-# If you still need an index you can use "each_with_index" and define an index
-# variable
+# If you still need an index you can use 'each_with_index' and define an index
+# variable.
 array.each_with_index do |element, index|
   puts "#{element} is number #{index} in the array"
 end
@@ -302,9 +302,9 @@ end
 #=> iteration 4
 #=> iteration 5
 
-# There are a bunch of other helpful looping functions in Ruby,
-# for example "map", "reduce", "inject", the list goes on. Map,
-# for instance, takes the array it's looping over, does something
+# There are a bunch of other helpful looping functions in Ruby.
+# For example: 'map', 'reduce', 'inject', the list goes on.
+# Map, for instance, takes the array it's looping over, does something
 # to it as defined in your block, and returns an entirely new array.
 array = [1,2,3,4,5]
 doubled = array.map do |element|
@@ -315,6 +315,7 @@ puts doubled
 puts array
 #=> [1,2,3,4,5]
 
+# Case construct
 grade = 'B'
 
 case grade
@@ -333,7 +334,7 @@ else
 end
 #=> "Better luck next time"
 
-# cases can also use ranges
+# Cases can also use ranges
 grade = 82
 case grade
 when 90..100
@@ -345,9 +346,9 @@ else
 end
 #=> "OK job"
 
-# exception handling:
+# Exception handling
 begin
-  # code here that might raise an exception
+  # Code here that might raise an exception
   raise NoMemoryError, 'You ran out of memory.'
 rescue NoMemoryError => exception_variable
   puts 'NoMemoryError was raised', exception_variable
@@ -365,10 +366,10 @@ def double(x)
   x * 2
 end
 
-# Methods (and all blocks) implicitly return the value of the last statement
+# Methods (and blocks) implicitly return the value of the last statement.
 double(2) #=> 4
 
-# Parentheses are optional where the result is unambiguous
+# Parentheses are optional where the interpretation is unambiguous.
 double 3 #=> 6
 
 double double 3 #=> 12
@@ -377,15 +378,14 @@ def sum(x, y)
   x + y
 end
 
-# Method arguments are separated by a comma
+# Method arguments are separated by a comma.
 sum 3, 4 #=> 7
 
 sum sum(3, 4), 5 #=> 12
 
 # yield
-# All methods have an implicit, optional block parameter
-# it can be called with the 'yield' keyword
-
+# All methods have an implicit, optional block parameter.
+# It can be called with the 'yield' keyword.
 def surround
   puts '{'
   yield
@@ -394,46 +394,78 @@ end
 
 surround { puts 'hello world' }
 
-# {
-# hello world
-# }
-
+#=> {
+#=> hello world
+#=> }
 
-# You can pass a block to a method
-# "&" marks a reference to a passed block
+# Blocks can be converted into a 'proc' object, which wraps the block 
+# and allows it to be passed to another method, bound to a different scope,
+# or manipulated otherwise. This is most common in method parameter lists,
+# where you frequently see a trailing '&block' parameter that will accept 
+# the block, if one is given, and convert it to a 'Proc'. The naming here is
+# convention; it would work just as well with '&pineapple'.
 def guests(&block)
-  block.call 'some_argument'
+  block.class #=> Proc
+  block.call(4)
 end
 
-# You can pass a list of arguments, which will be converted into an array
-# That's what splat operator ("*") is for
+# The 'call' method on the Proc is similar to calling 'yield' when a block is 
+# present. The arguments passed to 'call' will be forwarded to the block as arugments.
+
+guests { |n| "You have #{n} guests." }
+# => "You have 4 guests."
+
+# You can pass a list of arguments, which will be converted into an array.
+# That's what splat operator ("*") is for.
 def guests(*array)
   array.each { |guest| puts guest }
 end
 
-# If a method returns an array, you can use destructuring assignment
-def foods
-    ['pancake', 'sandwich', 'quesadilla']
+# Destructuring
+
+# Ruby will automatically destructure arrays on assignment to multiple variables.
+a, b, c = [1, 2, 3]
+a #=> 1
+b #=> 2
+c #=> 3
+
+# In some cases, you will want to use the splat operator: `*` to prompt destructuring
+# of an array into a list.
+ranked_competitors = ["John", "Sally", "Dingus", "Moe", "Marcy"]
+
+def best(first, second, third)
+  puts "Winners are #{first}, #{second}, and #{third}."
+end
+
+best *ranked_competitors.first(3) #=> Winners are John, Sally, and Dingus.
+
+# The splat operator can also be used in parameters.
+def best(first, second, third, *others)
+  puts "Winners are #{first}, #{second}, and #{third}."
+  puts "There were #{others.count} other participants."
 end
-breakfast, lunch, dinner = foods
-breakfast #=> 'pancake'
-dinner #=> 'quesadilla'
 
-# By convention, all methods that return booleans end with a question mark
-5.even? # false
-5.odd? # true
+best *ranked_competitors 
+#=> Winners are John, Sally, and Dingus.
+#=> There were 2 other participants.
 
-# And if a method ends with an exclamation mark, it does something destructive
+# By convention, all methods that return booleans end with a question mark.
+5.even? #=> false
+5.odd? #=> true
+
+# By convention, if a method name ends with an exclamation mark, it does something destructive
 # like mutate the receiver. Many methods have a ! version to make a change, and
-# a non-! version to just return a new changed version
+# a non-! version to just return a new changed version.
 company_name = "Dunder Mifflin"
 company_name.upcase #=> "DUNDER MIFFLIN"
 company_name #=> "Dunder Mifflin"
-company_name.upcase! # we're mutating company_name this time!
+# We're mutating company_name this time.
+company_name.upcase! #=> "DUNDER MIFFLIN"
 company_name #=> "DUNDER MIFFLIN"
 
+# Classes
 
-# Define a class with the class keyword
+# You can define a class with the 'class' keyword.
 class Human
 
   # A class variable. It is shared by all instances of this class.
@@ -441,7 +473,7 @@ class Human
 
   # Basic initializer
   def initialize(name, age = 0)
-    # Assign the argument to the "name" instance variable for the instance
+    # Assign the argument to the 'name' instance variable for the instance.
     @name = name
     # If no age given, we will fall back to the default in the arguments list.
     @age = age
@@ -457,10 +489,10 @@ class Human
     @name
   end
 
-  # The above functionality can be encapsulated using the attr_accessor method as follows
+  # The above functionality can be encapsulated using the attr_accessor method as follows.
   attr_accessor :name
 
-  # Getter/setter methods can also be created individually like this
+  # Getter/setter methods can also be created individually like this.
   attr_reader :name
   attr_writer :name
 
@@ -475,13 +507,11 @@ class Human
   end
 end
 
-
-# Instantiate a class
+# Instantiating of a class
 jim = Human.new('Jim Halpert')
-
 dwight = Human.new('Dwight K. Schrute')
 
-# Let's call a couple of methods
+# You can call the methods of the generated object.
 jim.species #=> "H. sapiens"
 jim.name #=> "Jim Halpert"
 jim.name = "Jim Halpert II" #=> "Jim Halpert II"
@@ -489,30 +519,30 @@ jim.name #=> "Jim Halpert II"
 dwight.species #=> "H. sapiens"
 dwight.name #=> "Dwight K. Schrute"
 
-# Call the class method
+# Calling of a class method
 Human.say('Hi') #=> "Hi"
 
 # Variable's scopes are defined by the way we name them.
-# Variables that start with $ have global scope
+# Variables that start with $ have global scope.
 $var = "I'm a global var"
 defined? $var #=> "global-variable"
 
-# Variables that start with @ have instance scope
+# Variables that start with @ have instance scope.
 @var = "I'm an instance var"
 defined? @var #=> "instance-variable"
 
-# Variables that start with @@ have class scope
+# Variables that start with @@ have class scope.
 @@var = "I'm a class var"
 defined? @@var #=> "class variable"
 
-# Variables that start with a capital letter are constants
+# Variables that start with a capital letter are constants.
 Var = "I'm a constant"
 defined? Var #=> "constant"
 
-# Class is also an object in ruby. So class can have instance variables.
-# Class variable is shared among the class and all of its descendants.
+# Class is also an object in ruby. So a class can have instance variables.
+# A class variable is shared among the class and all of its descendants.
 
-# base class
+# Base class
 class Human
   @@foo = 0
 
@@ -525,18 +555,17 @@ class Human
   end
 end
 
-# derived class
+# Derived class
 class Worker < Human
 end
 
-Human.foo # 0
-Worker.foo # 0
+Human.foo #=> 0
+Worker.foo #=> 0
 
-Human.foo = 2 # 2
-Worker.foo # 2
-
-# Class instance variable is not shared by the class's descendants.
+Human.foo = 2
+Worker.foo #=> 2
 
+# A class instance variable is not shared by the class's descendants.
 class Human
   @bar = 0
 
@@ -552,8 +581,8 @@ end
 class Doctor < Human
 end
 
-Human.bar # 0
-Doctor.bar # nil
+Human.bar #=> 0
+Doctor.bar #=> nil
 
 module ModuleExample
   def foo
@@ -561,9 +590,8 @@ module ModuleExample
   end
 end
 
-# Including modules binds their methods to the class instances
-# Extending modules binds their methods to the class itself
-
+# Including modules binds their methods to the class instances.
+# Extending modules binds their methods to the class itself.
 class Person
   include ModuleExample
 end
@@ -572,13 +600,12 @@ class Book
   extend ModuleExample
 end
 
-Person.foo     # => NoMethodError: undefined method `foo' for Person:Class
-Person.new.foo # => 'foo'
-Book.foo       # => 'foo'
-Book.new.foo   # => NoMethodError: undefined method `foo'
+Person.foo     #=> NoMethodError: undefined method `foo' for Person:Class
+Person.new.foo #=> "foo"
+Book.foo       #=> "foo"
+Book.new.foo   #=> NoMethodError: undefined method `foo'
 
 # Callbacks are executed when including and extending a module
-
 module ConcernExample
   def self.included(base)
     base.extend(ClassMethods)
@@ -602,10 +629,10 @@ class Something
   include ConcernExample
 end
 
-Something.bar     # => 'bar'
-Something.qux     # => NoMethodError: undefined method `qux'
-Something.new.bar # => NoMethodError: undefined method `bar'
-Something.new.qux # => 'qux'
+Something.bar     #=> "bar"
+Something.qux     #=> NoMethodError: undefined method `qux'
+Something.new.bar #=> NoMethodError: undefined method `bar'
+Something.new.qux #=> "qux"
 ```
 
 ## Additional resources
diff --git a/rust.html.markdown b/rust.html.markdown
index 6b75fa87..92794e69 100644
--- a/rust.html.markdown
+++ b/rust.html.markdown
@@ -41,6 +41,7 @@ Rust not only fast, but also easy and efficient to code in.
 // 1. Basics //
 ///////////////
 
+#[allow(dead_code)]
 // Functions
 // `i32` is the type for 32-bit signed integers
 fn add2(x: i32, y: i32) -> i32 {
@@ -48,6 +49,9 @@ fn add2(x: i32, y: i32) -> i32 {
     x + y
 }
 
+#[allow(unused_variables)]
+#[allow(unused_assignments)]
+#[allow(dead_code)]
 // Main function
 fn main() {
     // Numbers //
@@ -88,10 +92,8 @@ fn main() {
     let s: String = "hello world".to_string();
 
     // A string slice – an immutable view into another string
-    // This is basically an immutable pair of pointers to a string – it doesn’t
-    // actually contain the contents of a string, just a pointer to
-    // the begin and a pointer to the end of a string buffer,
-    // statically allocated or contained in another object (in this case, `s`)
+    // The string buffer can be statically allocated like in a string literal
+    // or contained in another object (in this case, `s`)
     let s_slice: &str = &s;
 
     println!("{} {}", s, s_slice); // hello world hello world
@@ -256,11 +258,16 @@ fn main() {
     // `while` loop
     while 1 == 1 {
         println!("The universe is operating normally.");
+        // break statement gets out of the while loop.
+        //  It avoids useless iterations.
+        break
     }
 
     // Infinite loop
     loop {
         println!("Hello!");
+        // break statement gets out of the loop
+        break
     }
 
     /////////////////////////////////
@@ -281,7 +288,7 @@ fn main() {
     // Reference – an immutable pointer that refers to other data
     // When a reference is taken to a value, we say that the value has been ‘borrowed’.
     // While a value is borrowed immutably, it cannot be mutated or moved.
-    // A borrow lasts until the end of the scope it was created in.
+    // A borrow is active until the last use of the borrowing variable.
     let mut var = 4;
     var = 3;
     let ref_var: &i32 = &var;
@@ -290,6 +297,8 @@ fn main() {
     println!("{}", *ref_var);
     // var = 5; // this would not compile because `var` is borrowed
     // *ref_var = 6; // this would not either, because `ref_var` is an immutable reference
+    ref_var; // no-op, but counts as a use and keeps the borrow active
+    var = 2; // ref_var is no longer used after the line above, so the borrow has ended
 
     // Mutable reference
     // While a value is mutably borrowed, it cannot be accessed at all.
@@ -300,6 +309,7 @@ fn main() {
     println!("{}", *ref_var2); // 6 , // var2 would not compile.
     // ref_var2 is of type &mut i32, so stores a reference to an i32, not the value.
     // var2 = 2; // this would not compile because `var2` is borrowed.
+    ref_var2; // no-op, but counts as a use and keeps the borrow active until here
 }
 ```
 
diff --git a/scala.html.markdown b/scala.html.markdown
index 016e2b4f..c7a8842e 100644
--- a/scala.html.markdown
+++ b/scala.html.markdown
@@ -345,7 +345,7 @@ s(0)      // Boolean = false
 s(1)      // Boolean = true
 
 /* Look up the documentation of map here -
- * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map
+ * https://www.scala-lang.org/api/current/scala/collection/immutable/Map.html
  * and make sure you can read it
  */
 
@@ -716,7 +716,7 @@ import scala.collection.immutable.{Map => _, Set => _, _}
 // Java classes can also be imported. Scala syntax can be used
 import java.swing.{JFrame, JWindow}
 
-// Your programs entry point is defined in an scala file using an object, with a
+// Your programs entry point is defined in a scala file using an object, with a
 // single method, main:
 object Application {
   def main(args: Array[String]): Unit = {
diff --git a/sl-si/asciidoc-sl.html.markdown b/sl-si/asciidoc-sl.html.markdown
new file mode 100644
index 00000000..52f30fbd
--- /dev/null
+++ b/sl-si/asciidoc-sl.html.markdown
@@ -0,0 +1,136 @@
+---
+language: asciidoc
+contributors:
+    - ["Ryan Mavilia", "http://unoriginality.rocks/"]
+    - ["Abel Salgado Romero", "https://twitter.com/abelsromero"]
+translators:
+    - ["Filip Štamcar", "https://github.com/filips123"]
+lang: sl-si
+filename: asciidoc-sl.md
+---
+
+AsciiDoc je označevalni jezik, ki je podoben Markdownu in ga je mogoče uporabiti za vse od knjig do spletnih dnevnikov. Jezik, ki ga je leta 2002 ustvaril Stuart Rackham, je preprost, vendar omogoča veliko prilagoditev.
+
+## Glava dokumenta
+
+Glave so neobvezne in ne smejo vsebovati praznih vrstic. Od vsebine jih mora ločiti vsaj ena prazna vrstica.
+
+### Naslov
+
+```
+= Naslov dokumenta
+
+Prvi stavek dokumenta.
+```
+
+### Naslov in avtor
+
+```
+= Naslov dokumenta
+Ime Priimek <ime.priimek@learnxinyminutes.com>
+
+Prvi stavek dokumenta.
+```
+
+### Naslov in več avtorjev
+
+```
+
+= Naslov dokumenta
+Ime Priimek <ime.priimek@learnxinyminutes.com>; Janez Novak <janez.novak@pirate.com>
+
+Prvi stavek dokumenta.
+```
+
+Vrstica za revizijo
+
+```
+= Naslov dokumenta V1
+Janez Novak <janez.novak@pirate.com>
+v1.0, 2016-01-13
+
+Prvi stavek dokumenta.
+```
+
+## Odstavki
+
+```
+Za odstavke ne potrebujete nič posebnega.
+
+Da jih ločite, dodajte prazno črto med odstavki.
+
+Če želite ustvariti prazno vrstico, dodajte +
+in ustvarili boste prelom vrstice!
+```
+
+## Oblikovanje besedila
+
+```
+_podčrtaj za pošvno_
+*zvezdice za krepko*
+*_kombinacije za zabavo_*
+`krativec za monospace`
+`*krepki monospace*`
+```
+
+## Naslovi razdelkov
+
+```
+= Stopnja 0 (samo za naslov dokumenta)
+
+== Stopnja 1 <h2>
+
+=== Stopnja 2 <h3>
+
+==== Stopnja 3 <h4>
+
+===== Stopnja 4 <h5>
+
+```
+
+## Seznami
+
+Če želite ustvariti neoštevilčen seznam, uporabite zvezdice.
+
+```
+* foo
+* bar
+* baz
+```
+
+Če želite ustvaril oštevilčen seznam, uporabite pike.
+
+```
+. predmet 1
+. predmet 2
+. predmet 3
+```
+
+Seznami lahko do petkrat gnezdite tako, da dodate dodatne zvezdice ali pike.
+
+```
+* foo 1
+** foo 2
+*** foo 3
+**** foo 4
+***** foo 5
+
+. foo 1
+.. foo 2
+... foo 3
+.... foo 4
+..... foo 5
+```
+
+## Nadaljnje branje
+
+Obstajata dve orodji za obdelavo AsciiDoc dokumentov:
+
+1. [AsciiDoc](http://asciidoc.org/): izvirna implementacija v Pythonu je na voljo v glavnih distribucijah Linuxa. Stabilen in trenutno v vzdrževalnem načinu.
+2. [Asciidoctor](http://asciidoctor.org/): alternativna Ruby implementacija, uporabno tudi iz Java in JavaScript. Z aktivnim razvojem si prizadeva razširiti sintakso AsciiDoc z novimi funkcijami in izhodnimi formati.
+
+Naslednje povezave so povezane `Asciidoctor` implementacijo:
+
+* [Markdown - AsciiDoc syntax comparison](http://asciidoctor.org/docs/user-manual/#comparison-by-example): primerjava skupnih elementov Markdowna in AsciiDoca.
+* [Getting started](http://asciidoctor.org/docs/#get-started-with-asciidoctor): namestitev in navodila, ki omogočajo enostavne dokumente.
+* [Asciidoctor User Manual](http://asciidoctor.org/docs/user-manual/): popolni priročnik z enim dokumentom s sklicevanjem na sintakso, primeri in oridji za upodabljanje.
diff --git a/smalltalk.html.markdown b/smalltalk.html.markdown
index a253df55..ae7ecb0e 100644
--- a/smalltalk.html.markdown
+++ b/smalltalk.html.markdown
@@ -1,230 +1,277 @@
 ---
-language: smalltalk
+language: Smalltalk
 filename: smalltalk.st
 contributors:
-    - ["Jigyasa Grover", "https://github.com/jig08"]
+    - ["Jigyasa Grover", "https://github.com/jigyasa-grover"]
+    - ["tim Rowledge", "tim@rowledge.org"]
 ---
 
-- Smalltalk is an object-oriented, dynamically typed, reflective programming language.
+- Smalltalk is a fully object-oriented, dynamically typed, reflective programming language with no 'non-object' types.
 - Smalltalk was created as the language to underpin the "new world" of computing exemplified by "human–computer symbiosis."
 - It was designed and created in part for educational use, more so for constructionist learning, at the Learning Research Group (LRG) of Xerox PARC by Alan Kay, Dan Ingalls, Adele Goldberg, Ted Kaehler, Scott Wallace, and others during the 1970s.
 
-Feedback highly appreciated! Reach me at [@jigyasa_grover](https://twitter.com/jigyasa_grover) or send me an e-mail at `grover.jigyasa1@gmail.com`.
+`Feedback highly appreciated! Reach me at [@jigyasa_grover](https://twitter.com/jigyasa_grover) or send me an e-mail at grover.jigyasa1@gmail.com.`
 
+## The Basics
 
-##Allowable characters:
+### Everything is an object
+Yes, everything. Integers are instances of one of the numeric classes. Classes are instances of the class Metaclass and are just as manipulable as any other object. All classes are part of a single class tree; no disjoint class trees. Stack frames are objects and can be manipulated, which is how the debugger works. There are no pointers into memory locations that you can dereference and mess with.
+
+### Functions are not called; messages are sent to objects
+- Work is done by sending messages to objects, which decide how to respond to that message and run a method as a result, which eventually returns some object to the original message sending code.
+- The system knows the class of the object receiving a message and looks up the message in that class's list of methods. If it is not found, the lookup continues in the super class until either it is found or the root of the classes is reached and there is still no relevant method. 
+- If a suitable method is found the code is run, and the same process keeps on going with all the methods sent by that method and so on forever.
+- If no suitable method is found an exception is raised, which typically results in a user interface notifier to tell the user that the message was not understood. It is entirely possible to catch the exception and do something to fix the problem, which might range from 'ignore it' to 'load some new packages for this class and try again'.
+- A method (more strictly an instance of the class CompiledMethod) is a chunk of Smalltalk code that has been compiled into bytecodes. Executing methods start at the beginning and return to the sender when a return is encountered (we use ^ to signify 'return the follwing object') or the end of the code is reached, in which case the current object running the code is returned.
+
+### Simple syntax
+Smalltalk has a simple syntax with very few rules. 
+The most basic operation is to send a message to an object
+`anObject aMessage`
+
+There are three sorts of messages
+- unary - a single string that may be several words conjoined in what we call camelcase form, with no arguments. For example 'size', 'reverseBytes', 'convertToLargerFormatPixels'
+- binary - a small set of symbols of the sort often used for arithmetic operations in most languages, requiring a single argument. For example '+', '//', '@'. We do not use traditional arithmetic precedence, something to keep an eye on.
+- keyword - the general form where multiple arguments can be passed. As with the unary form we use camelcase to join words together but arguments are inserted in the midst of the message with colons used to separate them lexically. For example 'setTemperature:', 'at:put:', 'drawFrom:to:lineWidth:fillColor:'
+
+#### An example
+`result := myObject doSomethingWith: thatObject`
+We are sending the message 'doSomethingWith:' to myObject. This happens to be a message that has a single argument but that's not important yet.
+'myObject' is a 'MyExampleClass' instance so the system looks at the list of messages understood by MyExampleClass
+- beClever
+- doWierdThing:
+- doSomethingWith
+
+In searching we see what initially looks like a match - but no, it lacks the final colon. So we find the super class of MyExampleClass - BigExampleClass. Which has a list of known messages of its own
+- beClever
+- doSomethingWith:
+- buildCastleInAir
+- annoyUserByDoing:
+
+We find a proper exact match and start to execute the code
+```
+doSomethingWith: argumentObject
+"A comment about what this code is meant to do and any known limitations, problems, where it might be further documented etc"
+self size > 4 ifTrue: [^argumentObject sizeRelatingTo: self].
+```   
+
+Everything here except the `^` involves sending more messages. Event the `ifTrue:` that you might think is a language control structure is just Smalltalk code.
+
+We start by sending `size` to `self`. `self` is the object currently running the code - so in this case it is the myObject we started with. `size` is a very common message that we might anticipate tells us something about how big an object is; you could look it up with the Smalltalk tools very simply. The result we get is then sent the message `>` with the plain old integer 4 (which is an object too; no strange primitive types to pollute the system here) and nobody should be surprised the `>` is a comparison that answers true or false. That boolean (which is actually a Boolean object in Smalltalk) is sent the message `ifTrue:` with the block of code between the `[]` as its argument; obvioulsy a true boolean might be expected to run that block of code and a false to ignore it. 
+
+If the block is run then we do some more message sending to the argument object and noting the `^` we return the answer back to our starting point and it gets assigned to `result`. If the block is ignored we seem to run out of code and so `self` is returned and assigned to `result`.
+
+## Smalltalk quick reference cheat-sheet
+Taken from [Smalltalk Cheatsheet](http://www.angelfire.com/tx4/cus/notes/smalltalk.html)
+
+#### Allowable characters:
 - a-z
 - A-Z
 - 0-9
 - .+/\*~<>@%|&?
 - blank, tab, cr, ff, lf
 
-##Variables:
-- variables must be declared before use
-- shared vars must begin with uppercase
-- local vars must begin with lowercase
-- reserved names: `nil`, `true`, `false`, `self`, `super`, and `Smalltalk`
+#### Variables:
+- variable names must be declared before use but are untyped
+- shared vars (globals, class vars) conventionally begin with uppercase (except the reserved names shown below)
+- local vars (instance vars, temporaries, method & block arguments) conventionally begin with lowercase
+- reserved names: `nil`, `true`, `false`, `self`, `super`, and `thisContext`
 
-##Variable scope:
-- Global: defined in Dictionary Smalltalk and accessible by all objects in system                                 - Special: (reserved) `Smalltalk`, `super`, `self`, `true`, `false`, & `nil`
+#### Variable scope:
+- Global: defined in a Dictionary named 'Smalltalk' and accessible by all objects in system
+- Special: (reserved) `Smalltalk`, `super`, `self`, `true`, `false`, & `nil`
 - Method Temporary: local to a method
 - Block Temporary: local to a block
-- Pool: variables in a Dictionary object
-- Method Parameters: automatic local vars created as a result of message call with params
-- Block Parameters: automatic local vars created as a result of value: message call
-- Class: shared with all instances of one class & its subclasses
-- Class Instance: unique to each instance of a class
-- Instance Variables: unique to each instance
+- Pool: variables in a Dictionary object, possibly shared with classes not directly related by inheritance
+- Method Parameters: automatic method temp vars that name the incoming parameters. Cannot be assigned to 
+- Block Parameters: automatic block temp vars that name the incoming parameters. Cannot be assigned to
+- Class: shared with all instances of a class & its subclasses
+- Class Instance: unique to each instance of a class. Too commonly confused with class variables
+- Instance Variables: unique to each instance of a class
 
-`"Comments are enclosed in quotes"`
+`"Comments are enclosed in quotes and may be arbitrary length"`
 
-`"Period (.) is the statement separator"`
+`"Period (.) is the statement separator. Not required on last line of a method"`
 
-## Transcript:
-```
-Transcript clear.                                           "clear to transcript window"
-Transcript show: 'Hello World'.                             "output string in transcript window"
-Transcript nextPutAll: 'Hello World'.                       "output string in transcript window"
-Transcript nextPut: $A.                                     "output character in transcript window"
-Transcript space.                                           "output space character in transcript window"
-Transcript tab.                                             "output tab character in transcript window"
-Transcript cr.                                              "carriage return / linefeed"
-'Hello' printOn: Transcript.                                "append print string into the window"
-'Hello' storeOn: Transcript.                                "append store string into the window"
-Transcript endEntry.                                        "flush the output buffer"
+#### Transcript:
+```
+Transcript clear.                        "clear to transcript window"
+Transcript show: 'Hello World'.          "output string in transcript window"
+Transcript nextPutAll: 'Hello World'.    "output string in transcript window"
+Transcript nextPut: $A.                  "output character in transcript window"
+Transcript space.                        "output space character in transcript window"
+Transcript tab.                          "output tab character in transcript window"
+Transcript cr.                           "carriage return / linefeed"
+'Hello' printOn: Transcript.             "append print string into the window"
+'Hello' storeOn: Transcript.             "append store string into the window"
+Transcript endEntry.                     "flush the output buffer"
 ```
 
-##Assignment:
+#### Assignment:
 ```
 | x y |
-x _ 4.                                                      "assignment (Squeak) <-"
-x := 5.                                                     "assignment"
-x := y := z := 6.                                           "compound assignment"
+x _ 4.                            "assignment (Squeak) <-"
+x := 5.                           "assignment"
+x := y := z := 6.                 "compound assignment"
 x := (y := 6) + 1.
-x := Object new.                                            "bind to allocated instance of a class"
-x := 123 class.                                             "discover the object class"
-x := Integer superclass.                                    "discover the superclass of a class"
-x := Object allInstances.                                   "get an array of all instances of a class"
-x := Integer allSuperclasses.                               "get all superclasses of a class"
-x := 1.2 hash.                                              "hash value for object"
-y := x copy.                                                "copy object"
-y := x shallowCopy.                                         "copy object (not overridden)"
-y := x deepCopy.                                            "copy object and instance vars"
-y := x veryDeepCopy.                                        "complete tree copy using a dictionary"
+x := Object new.                  "bind to allocated instance of a class"
+x := 123 class.                   "discover the object class"
+x := Integer superclass.          "discover the superclass of a class"
+x := Object allInstances.         "get an array of all instances of a class"
+x := Integer allSuperclasses.     "get all superclasses of a class"
+x := 1.2 hash.                    "hash value for object"
+y := x copy.                      "copy object"
+y := x shallowCopy.               "copy object (not overridden)"
+y := x deepCopy.                  "copy object and instance vars"
+y := x veryDeepCopy.              "complete tree copy using a dictionary"
 ```
 
-##Constants:
+#### Constants:
 ```
 | b |
-b := true.                                                  "true constant"
-b := false.                                                 "false constant"
-x := nil.                                                   "nil object constant"
-x := 1.                                                     "integer constants"
-x := 3.14.                                                  "float constants"
-x := 2e-2.                                                  "fractional constants"
-x := 16r0F.                                                 "hex constant".
-x := -1.                                                    "negative constants"
-x := 'Hello'.                                               "string constant"
-x := 'I''m here'.                                           "single quote escape"
-x := $A.                                                    "character constant"
-x := $ .                                                    "character constant (space)"
-x := #aSymbol.                                              "symbol constants"
-x := #(3 2 1).                                              "array constants"
-x := #('abc' 2 $a).                                         "mixing of types allowed"
-
-```
-
-## Booleans:
+b := true.                "true constant"
+b := false.               "false constant"
+x := nil.                 "nil object constant"
+x := 1.                   "integer constants"
+x := 3.14.                "float constants"
+x := 2e-2.                "fractional constants"
+x := 16r0F.               "hex constant".
+x := -1.                  "negative constants"
+x := 'Hello'.             "string constant"
+x := 'I''m here'.         "single quote escape"
+x := $A.                  "character constant"
+x := $ .                  "character constant (space)"
+x := #aSymbol.            "symbol constants"
+x := #(3 2 1).            "array constants"
+x := #('abc' 2 $a).       "mixing of types allowed"
+```
+
+#### Booleans:
 ```
 | b x y |
 x := 1. y := 2.
-b := (x = y).                                               "equals"
-b := (x ~= y).                                              "not equals"
-b := (x == y).                                              "identical"
-b := (x ~~ y).                                              "not identical"
-b := (x > y).                                               "greater than"
-b := (x < y).                                               "less than"
-b := (x >= y).                                              "greater than or equal"
-b := (x <= y).                                              "less than or equal"
-b := b not.                                                 "boolean not"
-b := (x < 5) & (y > 1).                                     "boolean and"
-b := (x < 5) | (y > 1).                                     "boolean or"
-b := (x < 5) and: [y > 1].                                  "boolean and (short-circuit)"
-b := (x < 5) or: [y > 1].                                   "boolean or (short-circuit)"
-b := (x < 5) eqv: (y > 1).                                  "test if both true or both false"
-b := (x < 5) xor: (y > 1).                                  "test if one true and other false"
-b := 5 between: 3 and: 12.                                  "between (inclusive)"
-b := 123 isKindOf: Number.                                  "test if object is class or subclass of"
-b := 123 isMemberOf: SmallInteger.                          "test if object is type of class"
-b := 123 respondsTo: sqrt.                                  "test if object responds to message"
-b := x isNil.                                               "test if object is nil"
-b := x isZero.                                              "test if number is zero"
-b := x positive.                                            "test if number is positive"
-b := x strictlyPositive.                                    "test if number is greater than zero"
-b := x negative.                                            "test if number is negative"
-b := x even.                                                "test if number is even"
-b := x odd.                                                 "test if number is odd"
-b := x isLiteral.                                           "test if literal constant"
-b := x isInteger.                                           "test if object is integer"
-b := x isFloat.                                             "test if object is float"
-b := x isNumber.                                            "test if object is number"
-b := $A isUppercase.                                        "test if upper case character"
-b := $A isLowercase.                                        "test if lower case character"
-
-```
-
-## Arithmetic expressions:
+b := (x = y).                         "equals"
+b := (x ~= y).                         "not equals"
+b := (x == y).                         "identical"
+b := (x ~~ y).                         "not identical"
+b := (x > y).                          "greater than"
+b := (x < y).                          "less than"
+b := (x >= y).                         "greater than or equal"
+b := (x <= y).                         "less than or equal"
+b := b not.                            "boolean not"
+b := (x < 5) & (y > 1).                "boolean and"
+b := (x < 5) | (y > 1).                "boolean or"
+b := (x < 5) and: [y > 1].             "boolean and (short-circuit)"
+b := (x < 5) or: [y > 1].              "boolean or (short-circuit)"
+b := (x < 5) eqv: (y > 1).             "test if both true or both false"
+b := (x < 5) xor: (y > 1).             "test if one true and other false"
+b := 5 between: 3 and: 12.             "between (inclusive)"
+b := 123 isKindOf: Number.             "test if object is class or subclass of"
+b := 123 isMemberOf: SmallInteger.     "test if object is type of class"
+b := 123 respondsTo: sqrt.             "test if object responds to message"
+b := x isNil.                          "test if object is nil"
+b := x isZero.                         "test if number is zero"
+b := x positive.                       "test if number is positive"
+b := x strictlyPositive.               "test if number is greater than zero"
+b := x negative.                       "test if number is negative"
+b := x even.                           "test if number is even"
+b := x odd.                            "test if number is odd"
+b := x isLiteral.                      "test if literal constant"
+b := x isInteger.                      "test if object is integer"
+b := x isFloat.                        "test if object is float"
+b := x isNumber.                       "test if object is number"
+b := $A isUppercase.                   "test if upper case character"
+b := $A isLowercase.                   "test if lower case character"
+```
+
+#### Arithmetic expressions:
 ```
 | x |
-x := 6 + 3.                                                 "addition"
-x := 6 - 3.                                                 "subtraction"
-x := 6 * 3.                                                 "multiplication"
-x := 1 + 2 * 3.                                             "evaluation always left to right (1 + 2) * 3"
-x := 5 / 3.                                                 "division with fractional result"
-x := 5.0 / 3.0.                                             "division with float result"
-x := 5.0 // 3.0.                                            "integer divide"
-x := 5.0 \\ 3.0.                                            "integer remainder"
-x := -5.                                                    "unary minus"
-x := 5 sign.                                                "numeric sign (1, -1 or 0)"
-x := 5 negated.                                             "negate receiver"
-x := 1.2 integerPart.                                       "integer part of number (1.0)"
-x := 1.2 fractionPart.                                      "fractional part of number (0.2)"
-x := 5 reciprocal.                                          "reciprocal function"
-x := 6 * 3.1.                                               "auto convert to float"
-x := 5 squared.                                             "square function"
-x := 25 sqrt.                                               "square root"
-x := 5 raisedTo: 2.                                         "power function"
-x := 5 raisedToInteger: 2.                                  "power function with integer"
-x := 5 exp.                                                 "exponential"
-x := -5 abs.                                                "absolute value"
-x := 3.99 rounded.                                          "round"
-x := 3.99 truncated.                                        "truncate"
-x := 3.99 roundTo: 1.                                       "round to specified decimal places"
-x := 3.99 truncateTo: 1.                                    "truncate to specified decimal places"
-x := 3.99 floor.                                            "truncate"
-x := 3.99 ceiling.                                          "round up"
-x := 5 factorial.                                           "factorial"
-x := -5 quo: 3.                                             "integer divide rounded toward zero"
-x := -5 rem: 3.                                             "integer remainder rounded toward zero"
-x := 28 gcd: 12.                                            "greatest common denominator"
-x := 28 lcm: 12.                                            "least common multiple"
-x := 100 ln.                                                "natural logarithm"
-x := 100 log.                                               "base 10 logarithm"
-x := 100 log: 10.                                           "logarithm with specified base"
-x := 100 floorLog: 10.                                      "floor of the log"
-x := 180 degreesToRadians.                                  "convert degrees to radians"
-x := 3.14 radiansToDegrees.                                 "convert radians to degrees"
-x := 0.7 sin.                                               "sine"
-x := 0.7 cos.                                               "cosine"
-x := 0.7 tan.                                               "tangent"
-x := 0.7 arcSin.                                            "arcsine"
-x := 0.7 arcCos.                                            "arccosine"
-x := 0.7 arcTan.                                            "arctangent"
-x := 10 max: 20.                                            "get maximum of two numbers"
-x := 10 min: 20.                                            "get minimum of two numbers"
-x := Float pi.                                              "pi"
-x := Float e.                                               "exp constant"
-x := Float infinity.                                        "infinity"
-x := Float nan.                                             "not-a-number"
-x := Random new next; yourself. x next.                     "random number stream (0.0 to 1.0)"
-x := 100 atRandom.                                          "quick random number"
-
-```
-
-##Bitwise Manipulation:
+x := 6 + 3.                             "addition"
+x := 6 - 3.                             "subtraction"
+x := 6 * 3.                             "multiplication"
+x := 1 + 2 * 3.                         "evaluation always left to right (1 + 2) * 3"
+x := 5 / 3.                             "division with fractional result"
+x := 5.0 / 3.0.                         "division with float result"
+x := 5.0 // 3.0.                        "integer divide"
+x := 5.0 \\ 3.0.                        "integer remainder"
+x := -5.                                "unary minus"
+x := 5 sign.                            "numeric sign (1, -1 or 0)"
+x := 5 negated.                         "negate receiver"
+x := 1.2 integerPart.                   "integer part of number (1.0)"
+x := 1.2 fractionPart.                  "fractional part of number (0.2)"
+x := 5 reciprocal.                      "reciprocal function"
+x := 6 * 3.1.                           "auto convert to float"
+x := 5 squared.                         "square function"
+x := 25 sqrt.                           "square root"
+x := 5 raisedTo: 2.                     "power function"
+x := 5 raisedToInteger: 2.              "power function with integer"
+x := 5 exp.                             "exponential"
+x := -5 abs.                            "absolute value"
+x := 3.99 rounded.                      "round"
+x := 3.99 truncated.                    "truncate"
+x := 3.99 roundTo: 1.                   "round to specified decimal places"
+x := 3.99 truncateTo: 1.                "truncate to specified decimal places"
+x := 3.99 floor.                        "truncate"
+x := 3.99 ceiling.                      "round up"
+x := 5 factorial.                       "factorial"
+x := -5 quo: 3.                         "integer divide rounded toward zero"
+x := -5 rem: 3.                         "integer remainder rounded toward zero"
+x := 28 gcd: 12.                        "greatest common denominator"
+x := 28 lcm: 12.                        "least common multiple"
+x := 100 ln.                            "natural logarithm"
+x := 100 log.                           "base 10 logarithm"
+x := 100 log: 10.                       "floor of the log"
+x := 180 degreesToRadians.              "convert degrees to radians"
+x := 3.14 radiansToDegrees.             "convert radians to degrees"
+x := 0.7 sin.                           "sine"
+x := 0.7 cos.                           "cosine"
+x := 0.7 tan.                           "tangent"
+x := 0.7 arcSin.                        "arcsine"
+x := 0.7 arcCos.                        "arccosine"
+x := 0.7 arcTan.                        "arctangent"
+x := 10 max: 20.                        "get maximum of two numbers"
+x := 10 min: 20.                        "get minimum of two numbers"
+x := Float pi.                          "pi"
+x := Float e.                           "exp constant"
+x := Float infinity.                    "infinity"
+x := Float nan.                         "not-a-number"
+x := Random new next; yourself. x next. "random number stream (0.0 to 1.0)"
+x := 100 atRandom.                      "quick random number"
 ```
-| b x |
-x := 16rFF bitAnd: 16r0F.                                   "and bits"
-x := 16rF0 bitOr: 16r0F.                                    "or bits"
-x := 16rFF bitXor: 16r0F.                                   "xor bits"
-x := 16rFF bitInvert.                                       "invert bits"
-x := 16r0F bitShift: 4.                                     "left shift"
-x := 16rF0 bitShift: -4.                                    "right shift"
-"x := 16r80 bitAt: 7."                                      "bit at position (0|1) [!Squeak]"
-x := 16r80 highbit.                                         "position of highest bit set"
-b := 16rFF allMask: 16r0F.                                  "test if all bits set in mask set in receiver"
-b := 16rFF anyMask: 16r0F.                                  "test if any bits set in mask set in receiver"
-b := 16rFF noMask: 16r0F.                                   "test if all bits set in mask clear in receiver"
 
+#### Bitwise Manipulation:
+```
+| b x |
+x := 16rFF bitAnd: 16r0F.           "and bits"
+x := 16rF0 bitOr: 16r0F.            "or bits"
+x := 16rFF bitXor: 16r0F.           "xor bits"
+x := 16rFF bitInvert.               "invert bits"
+x := 16r0F bitShift: 4.             "left shift"
+x := 16rF0 bitShift: -4.            "right shift"
+"x := 16r80 bitAt: 7."              "bit at position (0|1) [!Squeak]"
+x := 16r80 highbit.                 "position of highest bit set"
+b := 16rFF allMask: 16r0F.          "test if all bits set in mask set in receiver"
+b := 16rFF anyMask: 16r0F.          "test if any bits set in mask set in receiver"
+b := 16rFF noMask: 16r0F.           "test if all bits set in mask clear in receiver"
 ```
 
-## Conversion:
+#### Conversion:
 ```
 | x |
-x := 3.99 asInteger.                                        "convert number to integer (truncates in Squeak)"
-x := 3.99 asFraction.                                       "convert number to fraction"
-x := 3 asFloat.                                             "convert number to float"
-x := 65 asCharacter.                                        "convert integer to character"
-x := $A asciiValue.                                         "convert character to integer"
-x := 3.99 printString.                                      "convert object to string via printOn:"
-x := 3.99 storeString.                                      "convert object to string via storeOn:"
-x := 15 radix: 16.                                          "convert to string in given base"
+x := 3.99 asInteger.               "convert number to integer (truncates in Squeak)"
+x := 3.99 asFraction.              "convert number to fraction"
+x := 3 asFloat.                    "convert number to float"
+x := 65 asCharacter.               "convert integer to character"
+x := $A asciiValue.                "convert character to integer"
+x := 3.99 printString.             "convert object to string via printOn:"
+x := 3.99 storeString.             "convert object to string via storeOn:"
+x := 15 radix: 16.                 "convert to string in given base"
 x := 15 printStringBase: 16.
 x := 15 storeStringBase: 16.
-
 ```
 
-## Blocks:
+#### Blocks:
 - blocks are objects and may be assigned to a variable
 - value is last expression evaluated unless explicit return
 - blocks may be nested
@@ -239,13 +286,15 @@ x := 15 storeStringBase: 16.
 x := [ y := 1. z := 2. ]. x value.                          "simple block usage"
 x := [ :argOne :argTwo |   argOne, ' and ' , argTwo.].      "set up block with argument passing"
 Transcript show: (x value: 'First' value: 'Second'); cr.    "use block with argument passing"
+
 "x := [ | z | z := 1.]. *** localvars not available in squeak blocks"
 ```
 
-## Method calls:
+#### Method calls:
 - unary methods are messages with no arguments
 - binary methods
-- keyword methods are messages with selectors including colons standard categories/protocols:                     - initialize-release    (methods called for new instance)
+- keyword methods are messages with selectors including colons standard categories/protocols:
+- initialize-release    (methods called for new instance)
 - accessing             (get/set methods)
 - testing               (boolean tests - is)
 - comparing             (boolean tests with parameter
@@ -254,29 +303,34 @@ Transcript show: (x value: 'First' value: 'Second'); cr.    "use block with argu
 - updating              (receive notification of changes)
 - private               (methods private to class)
 - instance-creation     (class methods for creating instance)
+
 ```
 | x |
-x := 2 sqrt.                                                "unary message"
-x := 2 raisedTo: 10.                                        "keyword message"
-x := 194 * 9.                                               "binary message"
-Transcript show: (194 * 9) printString; cr.                 "combination (chaining)"
-x := 2 perform: #sqrt.                                      "indirect method invocation"
-Transcript                                                  "Cascading - send multiple messages to receiver"
+x := 2 sqrt.                                  "unary message"
+x := 2 raisedTo: 10.                          "keyword message"
+x := 194 * 9.                                 "binary message"
+Transcript show: (194 * 9) printString; cr.   "combination (chaining)"
+x := 2 perform: #sqrt.                        "indirect method invocation"
+Transcript                                    "Cascading - send multiple messages to receiver"
    show: 'hello ';
    show: 'world';
    cr.
-x := 3 + 2; * 100.                                          "result=300. Sends message to same receiver (3)"
+x := 3 + 2; * 100.                            "result=300. Sends message to same receiver (3)"
 ```
 
-##Conditional Statements:
+#### Conditional Statements:
 ```
 | x |
-x > 10 ifTrue: [Transcript show: 'ifTrue'; cr].             "if then"
-x > 10 ifFalse: [Transcript show: 'ifFalse'; cr].           "if else"
-x > 10                                                      "if then else"
+x > 10 ifTrue: [Transcript show: 'ifTrue'; cr].     "if then"
+x > 10 ifFalse: [Transcript show: 'ifFalse'; cr].   "if else"
+
+"if then else"
+x > 10                                                      
    ifTrue: [Transcript show: 'ifTrue'; cr]
    ifFalse: [Transcript show: 'ifFalse'; cr].
-x > 10                                                      "if else then"
+
+"if else then"
+x > 10                                                      
    ifFalse: [Transcript show: 'ifFalse'; cr]
    ifTrue: [Transcript show: 'ifTrue'; cr].
 Transcript
@@ -285,7 +339,9 @@ Transcript
          ifTrue: ['ifTrue']
          ifFalse: ['ifFalse']);
    cr.
-Transcript                                                  "nested if then else"
+
+"nested if then else"
+Transcript                                                  
    show:
       (x > 10
          ifTrue: [x > 5
@@ -293,318 +349,336 @@ Transcript                                                  "nested if then else
             ifFalse: ['B']]
          ifFalse: ['C']);
    cr.
-switch := Dictionary new.                                   "switch functionality"
+
+"switch functionality"
+switch := Dictionary new.     
 switch at: $A put: [Transcript show: 'Case A'; cr].
 switch at: $B put: [Transcript show: 'Case B'; cr].
 switch at: $C put: [Transcript show: 'Case C'; cr].
 result := (switch at: $B) value.
 ```
 
-## Iteration statements:
+#### Iteration statements:
 ```
 | x y |
 x := 4. y := 1.
-[x > 0] whileTrue: [x := x - 1. y := y * 2].                "while true loop"
-[x >= 4] whileFalse: [x := x + 1. y := y * 2].              "while false loop"
-x timesRepeat: [y := y * 2].                                "times repeat loop (i := 1 to x)"
-1 to: x do: [:a | y := y * 2].                              "for loop"
-1 to: x by: 2 do: [:a | y := y / 2].                        "for loop with specified increment"
-#(5 4 3) do: [:a | x := x + a].                             "iterate over array elements"
+[x > 0] whileTrue: [x := x - 1. y := y * 2].     "while true loop"
+[x >= 4] whileFalse: [x := x + 1. y := y * 2].   "while false loop"
+x timesRepeat: [y := y * 2].                     "times repeat loop (i := 1 to x)"
+1 to: x do: [:a | y := y * 2].                   "for loop"
+1 to: x by: 2 do: [:a | y := y / 2].             "for loop with specified increment"
+#(5 4 3) do: [:a | x := x + a].                  "iterate over array elements"
 ```
 
-## Character:
+#### Character:
 ```
 | x y |
-x := $A.                                                    "character assignment"
-y := x isLowercase.                                         "test if lower case"
-y := x isUppercase.                                         "test if upper case"
-y := x isLetter.                                            "test if letter"
-y := x isDigit.                                             "test if digit"
-y := x isAlphaNumeric.                                      "test if alphanumeric"
-y := x isSeparator.                                         "test if separator char"
-y := x isVowel.                                             "test if vowel"
-y := x digitValue.                                          "convert to numeric digit value"
-y := x asLowercase.                                         "convert to lower case"
-y := x asUppercase.                                         "convert to upper case"
-y := x asciiValue.                                          "convert to numeric ascii value"
-y := x asString.                                            "convert to string"
-b := $A <= $B.                                              "comparison"
+x := $A.                         "character assignment"
+y := x isLowercase.              "test if lower case"
+y := x isUppercase.              "test if upper case"
+y := x isLetter.                 "test if letter"
+y := x isDigit.                  "test if digit"
+y := x isAlphaNumeric.           "test if alphanumeric"
+y := x isSeparator.              "test if separator char"
+y := x isVowel.                  "test if vowel"
+y := x digitValue.               "convert to numeric digit value"
+y := x asLowercase.              "convert to lower case"
+y := x asUppercase.              "convert to upper case"
+y := x asciiValue.               "convert to numeric ascii value"
+y := x asString.                 "convert to string"
+b := $A <= $B.                   "comparison"
 y := $A max: $B.
-
 ```
 
-## Symbol:
+#### Symbol:
 ```
 | b x y |
-x := #Hello.                                                "symbol assignment"
-y := 'String', 'Concatenation'.                             "symbol concatenation (result is string)"
-b := x isEmpty.                                             "test if symbol is empty"
-y := x size.                                                "string size"
-y := x at: 2.                                               "char at location"
-y := x copyFrom: 2 to: 4.                                   "substring"
-y := x indexOf: $e ifAbsent: [0].                           "first position of character within string"
-x do: [:a | Transcript show: a printString; cr].            "iterate over the string"
-b := x conform: [:a | (a >= $a) & (a <= $z)].               "test if all elements meet condition"
-y := x select: [:a | a > $a].                               "return all elements that meet condition"
-y := x asString.                                            "convert symbol to string"
-y := x asText.                                              "convert symbol to text"
-y := x asArray.                                             "convert symbol to array"
-y := x asOrderedCollection.                                 "convert symbol to ordered collection"
-y := x asSortedCollection.                                  "convert symbol to sorted collection"
-y := x asBag.                                               "convert symbol to bag collection"
-y := x asSet.                                               "convert symbol to set collection"
-```
-
-## String:
+x := #Hello.                                      "symbol assignment"
+y := 'String', 'Concatenation'.                   "symbol concatenation (result is string)"
+b := x isEmpty.                                   "test if symbol is empty"
+y := x size.                                      "string size"
+y := x at: 2.                                     "char at location"
+y := x copyFrom: 2 to: 4.                         "substring"
+y := x indexOf: $e ifAbsent: [0].                 "first position of character within string"
+x do: [:a | Transcript show: a printString; cr].  "iterate over the string"
+b := x conform: [:a | (a >= $a) & (a <= $z)].     "test if all elements meet condition"
+y := x select: [:a | a > $a].                     "return all elements that meet condition"
+y := x asString.                                  "convert symbol to string"
+y := x asText.                                    "convert symbol to text"
+y := x asArray.                                   "convert symbol to array"
+y := x asOrderedCollection.                       "convert symbol to ordered collection"
+y := x asSortedCollection.                        "convert symbol to sorted collection"
+y := x asBag.                                     "convert symbol to bag collection"
+y := x asSet.                                     "convert symbol to set collection"
+```
+
+#### String:
 ```
 | b x y |
-x := 'This is a string'.                                    "string assignment"
-x := 'String', 'Concatenation'.                             "string concatenation"
-b := x isEmpty.                                             "test if string is empty"
-y := x size.                                                "string size"
-y := x at: 2.                                               "char at location"
-y := x copyFrom: 2 to: 4.                                   "substring"
-y := x indexOf: $a ifAbsent: [0].                           "first position of character within string"
-x := String new: 4.                                         "allocate string object"
-x                                                           "set string elements"
+x := 'This is a string'.                           "string assignment"
+x := 'String', 'Concatenation'.                    "string concatenation"
+b := x isEmpty.                                    "test if string is empty"
+y := x size.                                       "string size"
+y := x at: 2.                                      "char at location"
+y := x copyFrom: 2 to: 4.                          "substring"
+y := x indexOf: $a ifAbsent: [0].                  "first position of character within string"
+x := String new: 4.                                "allocate string object"
+x                                                  "set string elements"
    at: 1 put: $a;
    at: 2 put: $b;
    at: 3 put: $c;
    at: 4 put: $e.
-x := String with: $a with: $b with: $c with: $d.            "set up to 4 elements at a time"
-x do: [:a | Transcript show: a printString; cr].            "iterate over the string"
-b := x conform: [:a | (a >= $a) & (a <= $z)].               "test if all elements meet condition"
-y := x select: [:a | a > $a].                               "return all elements that meet condition"
-y := x asSymbol.                                            "convert string to symbol"
-y := x asArray.                                             "convert string to array"
-x := 'ABCD' asByteArray.                                    "convert string to byte array"
-y := x asOrderedCollection.                                 "convert string to ordered collection"
-y := x asSortedCollection.                                  "convert string to sorted collection"
-y := x asBag.                                               "convert string to bag collection"
-y := x asSet.                                               "convert string to set collection"
-y := x shuffled.                                            "randomly shuffle string"
-```
-
-## Array:         Fixed length collection
+x := String with: $a with: $b with: $c with: $d.  "set up to 4 elements at a time"
+x do: [:a | Transcript show: a printString; cr].  "iterate over the string"
+b := x conform: [:a | (a >= $a) & (a <= $z)].     "test if all elements meet condition"
+y := x select: [:a | a > $a].                     "return all elements that meet condition"
+y := x asSymbol.                                  "convert string to symbol"
+y := x asArray.                                   "convert string to array"
+x := 'ABCD' asByteArray.                          "convert string to byte array"
+y := x asOrderedCollection.                       "convert string to ordered collection"
+y := x asSortedCollection.                        "convert string to sorted collection"
+y := x asBag.                                     "convert string to bag collection"
+y := x asSet.                                     "convert string to set collection"
+y := x shuffled.                                  "randomly shuffle string"
+```
+
+#### Array:
+Fixed length collection
 - ByteArray:     Array limited to byte elements (0-255)
 - WordArray:     Array limited to word elements (0-2^32)
 
 ```
 | b x y sum max |
-x := #(4 3 2 1).                                            "constant array"
-x := Array with: 5 with: 4 with: 3 with: 2.                 "create array with up to 4 elements"
-x := Array new: 4.                                          "allocate an array with specified size"
-x                                                           "set array elements"
+x := #(4 3 2 1).                                 "constant array"
+x := Array with: 5 with: 4 with: 3 with: 2.      "create array with up to 4 elements"
+x := Array new: 4.                               "allocate an array with specified size"
+x                                                "set array elements"
    at: 1 put: 5;
    at: 2 put: 4;
    at: 3 put: 3;
    at: 4 put: 2.
-b := x isEmpty.                                             "test if array is empty"
-y := x size.                                                "array size"
-y := x at: 4.                                               "get array element at index"
-b := x includes: 3.                                         "test if element is in array"
-y := x copyFrom: 2 to: 4.                                   "subarray"
-y := x indexOf: 3 ifAbsent: [0].                            "first position of element within array"
-y := x occurrencesOf: 3.                                    "number of times object in collection"
-x do: [:a | Transcript show: a printString; cr].            "iterate over the array"
-b := x conform: [:a | (a >= 1) & (a <= 4)].                 "test if all elements meet condition"
-y := x select: [:a | a > 2].                                "return collection of elements that pass test"
-y := x reject: [:a | a < 2].                                "return collection of elements that fail test"
-y := x collect: [:a | a + a].                               "transform each element for new collection"
-y := x detect: [:a | a > 3] ifNone: [].                     "find position of first element that passes test"
-sum := 0. x do: [:a | sum := sum + a]. sum.                 "sum array elements"
-sum := 0. 1 to: (x size) do: [:a | sum := sum + (x at: a)]. "sum array elements"
-sum := x inject: 0 into: [:a :c | a + c].                   "sum array elements"
-max := x inject: 0 into: [:a :c | (a > c)                   "find max element in array"
+b := x isEmpty.                                  "test if array is empty"
+y := x size.                                     "array size"
+y := x at: 4.                                    "get array element at index"
+b := x includes: 3.                              "test if element is in array"
+y := x copyFrom: 2 to: 4.                        "subarray"
+y := x indexOf: 3 ifAbsent: [0].                 "first position of element within array"
+y := x occurrencesOf: 3.                         "number of times object in collection"
+x do: [:a | Transcript show: a printString; cr]. "iterate over the array"
+b := x conform: [:a | (a >= 1) & (a <= 4)].      "test if all elements meet condition"
+y := x select: [:a | a > 2].                     "return collection of elements that pass test"
+y := x reject: [:a | a < 2].                     "return collection of elements that fail test"
+y := x collect: [:a | a + a].                    "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: [].          "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum.      "sum array elements"
+sum := 0. 1 to: (x size) 
+            do: [:a | sum := sum + (x at: a)].   "sum array elements"
+sum := x inject: 0 into: [:a :c | a + c].        "sum array elements"
+max := x inject: 0 into: [:a :c | (a > c)        "find max element in array"
    ifTrue: [a]
    ifFalse: [c]].
-y := x shuffled.                                            "randomly shuffle collection"
-y := x asArray.                                             "convert to array"
-"y := x asByteArray."                                       "note: this instruction not available on Squeak"
-y := x asWordArray.                                         "convert to word array"
-y := x asOrderedCollection.                                 "convert to ordered collection"
-y := x asSortedCollection.                                  "convert to sorted collection"
-y := x asBag.                                               "convert to bag collection"
-y := x asSet.                                               "convert to set collection"
+y := x shuffled.                                 "randomly shuffle collection"
+y := x asArray.                                  "convert to array"
+"y := x asByteArray."                            "note: this instruction not available on Squeak"
+y := x asWordArray.                              "convert to word array"
+y := x asOrderedCollection.                      "convert to ordered collection"
+y := x asSortedCollection.                       "convert to sorted collection"
+y := x asBag.                                    "convert to bag collection"
+y := x asSet.                                    "convert to set collection"
 ```
 
-##OrderedCollection: acts like an expandable array
+#### OrderedCollection:
+acts like an expandable array
+
 ```
 | b x y sum max |
-x := OrderedCollection with: 4 with: 3 with: 2 with: 1.     "create collection with up to 4 elements"
-x := OrderedCollection new.                                 "allocate collection"
-x add: 3; add: 2; add: 1; add: 4; yourself.                 "add element to collection"
-y := x addFirst: 5.                                         "add element at beginning of collection"
-y := x removeFirst.                                         "remove first element in collection"
-y := x addLast: 6.                                          "add element at end of collection"
-y := x removeLast.                                          "remove last element in collection"
-y := x addAll: #(7 8 9).                                    "add multiple elements to collection"
-y := x removeAll: #(7 8 9).                                 "remove multiple elements from collection"
-x at: 2 put: 3.                                             "set element at index"
-y := x remove: 5 ifAbsent: [].                              "remove element from collection"
-b := x isEmpty.                                             "test if empty"
-y := x size.                                                "number of elements"
-y := x at: 2.                                               "retrieve element at index"
-y := x first.                                               "retrieve first element in collection"
-y := x last.                                                "retrieve last element in collection"
-b := x includes: 5.                                         "test if element is in collection"
-y := x copyFrom: 2 to: 3.                                   "subcollection"
-y := x indexOf: 3 ifAbsent: [0].                            "first position of element within collection"
-y := x occurrencesOf: 3.                                    "number of times object in collection"
-x do: [:a | Transcript show: a printString; cr].            "iterate over the collection"
-b := x conform: [:a | (a >= 1) & (a <= 4)].                 "test if all elements meet condition"
-y := x select: [:a | a > 2].                                "return collection of elements that pass test"
-y := x reject: [:a | a < 2].                                "return collection of elements that fail test"
-y := x collect: [:a | a + a].                               "transform each element for new collection"
-y := x detect: [:a | a > 3] ifNone: [].                     "find position of first element that passes test"
-sum := 0. x do: [:a | sum := sum + a]. sum.                 "sum elements"
-sum := 0. 1 to: (x size) do: [:a | sum := sum + (x at: a)]. "sum elements"
-sum := x inject: 0 into: [:a :c | a + c].                   "sum elements"
-max := x inject: 0 into: [:a :c | (a > c)                   "find max element in collection"
+x := OrderedCollection 
+     with: 4 with: 3 with: 2 with: 1.            "create collection with up to 4 elements"
+x := OrderedCollection new.                      "allocate collection"
+x add: 3; add: 2; add: 1; add: 4; yourself.      "add element to collection"
+y := x addFirst: 5.                              "add element at beginning of collection"
+y := x removeFirst.                              "remove first element in collection"
+y := x addLast: 6.                               "add element at end of collection"
+y := x removeLast.                               "remove last element in collection"
+y := x addAll: #(7 8 9).                         "add multiple elements to collection"
+y := x removeAll: #(7 8 9).                      "remove multiple elements from collection"
+x at: 2 put: 3.                                  "set element at index"
+y := x remove: 5 ifAbsent: [].                   "remove element from collection"
+b := x isEmpty.                                  "test if empty"
+y := x size.                                     "number of elements"
+y := x at: 2.                                    "retrieve element at index"
+y := x first.                                    "retrieve first element in collection"
+y := x last.                                     "retrieve last element in collection"
+b := x includes: 5.                              "test if element is in collection"
+y := x copyFrom: 2 to: 3.                        "subcollection"
+y := x indexOf: 3 ifAbsent: [0].                 "first position of element within collection"
+y := x occurrencesOf: 3.                         "number of times object in collection"
+x do: [:a | Transcript show: a printString; cr]. "iterate over the collection"
+b := x conform: [:a | (a >= 1) & (a <= 4)].      "test if all elements meet condition"
+y := x select: [:a | a > 2].                     "return collection of elements that pass test"
+y := x reject: [:a | a < 2].                     "return collection of elements that fail test"
+y := x collect: [:a | a + a].                    "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: [].          "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum.      "sum elements"
+sum := 0. 1 to: (x size) 
+            do: [:a | sum := sum + (x at: a)].   "sum elements"
+sum := x inject: 0 into: [:a :c | a + c].        "sum elements"
+max := x inject: 0 into: [:a :c | (a > c)        "find max element in collection"
    ifTrue: [a]
    ifFalse: [c]].
-y := x shuffled.                                            "randomly shuffle collection"
-y := x asArray.                                             "convert to array"
-y := x asOrderedCollection.                                 "convert to ordered collection"
-y := x asSortedCollection.                                  "convert to sorted collection"
-y := x asBag.                                               "convert to bag collection"
-y := x asSet.                                               "convert to set collection"
+y := x shuffled.                                 "randomly shuffle collection"
+y := x asArray.                                  "convert to array"
+y := x asOrderedCollection.                      "convert to ordered collection"
+y := x asSortedCollection.                       "convert to sorted collection"
+y := x asBag.                                    "convert to bag collection"
+y := x asSet.                                    "convert to set collection"
 ```
 
-## SortedCollection:    like OrderedCollection except order of elements determined by sorting criteria
+#### SortedCollection:
+like OrderedCollection except order of elements determined by sorting criteria
+
 ```
 | b x y sum max |
-x := SortedCollection with: 4 with: 3 with: 2 with: 1.      "create collection with up to 4 elements"
-x := SortedCollection new.                                  "allocate collection"
-x := SortedCollection sortBlock: [:a :c | a > c].           "set sort criteria"
-x add: 3; add: 2; add: 1; add: 4; yourself.                 "add element to collection"
-y := x addFirst: 5.                                         "add element at beginning of collection"
-y := x removeFirst.                                         "remove first element in collection"
-y := x addLast: 6.                                          "add element at end of collection"
-y := x removeLast.                                          "remove last element in collection"
-y := x addAll: #(7 8 9).                                    "add multiple elements to collection"
-y := x removeAll: #(7 8 9).                                 "remove multiple elements from collection"
-y := x remove: 5 ifAbsent: [].                              "remove element from collection"
-b := x isEmpty.                                             "test if empty"
-y := x size.                                                "number of elements"
-y := x at: 2.                                               "retrieve element at index"
-y := x first.                                               "retrieve first element in collection"
-y := x last.                                                "retrieve last element in collection"
-b := x includes: 4.                                         "test if element is in collection"
-y := x copyFrom: 2 to: 3.                                   "subcollection"
-y := x indexOf: 3 ifAbsent: [0].                            "first position of element within collection"
-y := x occurrencesOf: 3.                                    "number of times object in collection"
-x do: [:a | Transcript show: a printString; cr].            "iterate over the collection"
-b := x conform: [:a | (a >= 1) & (a <= 4)].                 "test if all elements meet condition"
-y := x select: [:a | a > 2].                                "return collection of elements that pass test"
-y := x reject: [:a | a < 2].                                "return collection of elements that fail test"
-y := x collect: [:a | a + a].                               "transform each element for new collection"
-y := x detect: [:a | a > 3] ifNone: [].                     "find position of first element that passes test"
-sum := 0. x do: [:a | sum := sum + a]. sum.                 "sum elements"
-sum := 0. 1 to: (x size) do: [:a | sum := sum + (x at: a)]. "sum elements"
-sum := x inject: 0 into: [:a :c | a + c].                   "sum elements"
-max := x inject: 0 into: [:a :c | (a > c)                   "find max element in collection"
+x := SortedCollection 
+     with: 4 with: 3 with: 2 with: 1.              "create collection with up to 4 elements"
+x := SortedCollection new.                         "allocate collection"
+x := SortedCollection sortBlock: [:a :c | a > c].  "set sort criteria"
+x add: 3; add: 2; add: 1; add: 4; yourself.        "add element to collection"
+y := x addFirst: 5.                                "add element at beginning of collection"
+y := x removeFirst.                                "remove first element in collection"
+y := x addLast: 6.                                 "add element at end of collection"
+y := x removeLast.                                 "remove last element in collection"
+y := x addAll: #(7 8 9).                           "add multiple elements to collection"
+y := x removeAll: #(7 8 9).                        "remove multiple elements from collection"
+y := x remove: 5 ifAbsent: [].                     "remove element from collection"
+b := x isEmpty.                                    "test if empty"
+y := x size.                                       "number of elements"
+y := x at: 2.                                      "retrieve element at index"
+y := x first.                                      "retrieve first element in collection"
+y := x last.                                       "retrieve last element in collection"
+b := x includes: 4.                                "test if element is in collection"
+y := x copyFrom: 2 to: 3.                          "subcollection"
+y := x indexOf: 3 ifAbsent: [0].                   "first position of element within collection"
+y := x occurrencesOf: 3.                           "number of times object in collection"
+x do: [:a | Transcript show: a printString; cr].   "iterate over the collection"
+b := x conform: [:a | (a >= 1) & (a <= 4)].        "test if all elements meet condition"
+y := x select: [:a | a > 2].                       "return collection of elements that pass test"
+y := x reject: [:a | a < 2].                       "return collection of elements that fail test"
+y := x collect: [:a | a + a].                      "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: [].            "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum.        "sum elements"
+sum := 0. 1 to: (x size) 
+            do: [:a | sum := sum + (x at: a)].     "sum elements"
+sum := x inject: 0 into: [:a :c | a + c].          "sum elements"
+max := x inject: 0 into: [:a :c | (a > c)          "find max element in collection"
    ifTrue: [a]
    ifFalse: [c]].
-y := x asArray.                                             "convert to array"
-y := x asOrderedCollection.                                 "convert to ordered collection"
-y := x asSortedCollection.                                  "convert to sorted collection"
-y := x asBag.                                               "convert to bag collection"
-y := x asSet.                                               "convert to set collection"
+y := x asArray.                                     "convert to array"
+y := x asOrderedCollection.                         "convert to ordered collection"
+y := x asSortedCollection.                          "convert to sorted collection"
+y := x asBag.                                       "convert to bag collection"
+y := x asSet.                                       "convert to set collection"
 ```
 
-## Bag:        like OrderedCollection except elements are in no particular order
+#### Bag:
+like OrderedCollection except elements are in no particular order
+
 ```
 | b x y sum max |
-x := Bag with: 4 with: 3 with: 2 with: 1.                   "create collection with up to 4 elements"
-x := Bag new.                                               "allocate collection"
-x add: 4; add: 3; add: 1; add: 2; yourself.                 "add element to collection"
-x add: 3 withOccurrences: 2.                                "add multiple copies to collection"
-y := x addAll: #(7 8 9).                                    "add multiple elements to collection"
-y := x removeAll: #(7 8 9).                                 "remove multiple elements from collection"
-y := x remove: 4 ifAbsent: [].                              "remove element from collection"
-b := x isEmpty.                                             "test if empty"
-y := x size.                                                "number of elements"
-b := x includes: 3.                                         "test if element is in collection"
-y := x occurrencesOf: 3.                                    "number of times object in collection"
-x do: [:a | Transcript show: a printString; cr].            "iterate over the collection"
-b := x conform: [:a | (a >= 1) & (a <= 4)].                 "test if all elements meet condition"
-y := x select: [:a | a > 2].                                "return collection of elements that pass test"
-y := x reject: [:a | a < 2].                                "return collection of elements that fail test"
-y := x collect: [:a | a + a].                               "transform each element for new collection"
-y := x detect: [:a | a > 3] ifNone: [].                     "find position of first element that passes test"
-sum := 0. x do: [:a | sum := sum + a]. sum.                 "sum elements"
-sum := x inject: 0 into: [:a :c | a + c].                   "sum elements"
-max := x inject: 0 into: [:a :c | (a > c)                   "find max element in collection"
+x := Bag with: 4 with: 3 with: 2 with: 1.        "create collection with up to 4 elements"
+x := Bag new.                                    "allocate collection"
+x add: 4; add: 3; add: 1; add: 2; yourself.      "add element to collection"
+x add: 3 withOccurrences: 2.                     "add multiple copies to collection"
+y := x addAll: #(7 8 9).                         "add multiple elements to collection"
+y := x removeAll: #(7 8 9).                      "remove multiple elements from collection"
+y := x remove: 4 ifAbsent: [].                   "remove element from collection"
+b := x isEmpty.                                  "test if empty"
+y := x size.                                     "number of elements"
+b := x includes: 3.                              "test if element is in collection"
+y := x occurrencesOf: 3.                         "number of times object in collection"
+x do: [:a | Transcript show: a printString; cr]. "iterate over the collection"
+b := x conform: [:a | (a >= 1) & (a <= 4)].      "test if all elements meet condition"
+y := x select: [:a | a > 2].                     "return collection of elements that pass test"
+y := x reject: [:a | a < 2].                     "return collection of elements that fail test"
+y := x collect: [:a | a + a].                    "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: [].          "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum.      "sum elements"
+sum := x inject: 0 into: [:a :c | a + c].        "sum elements"
+max := x inject: 0 into: [:a :c | (a > c)        "find max element in collection"
    ifTrue: [a]
    ifFalse: [c]].
-y := x asOrderedCollection.                                 "convert to ordered collection"
-y := x asSortedCollection.                                  "convert to sorted collection"
-y := x asBag.                                               "convert to bag collection"
-y := x asSet.                                               "convert to set collection"
+y := x asOrderedCollection.                       "convert to ordered collection"
+y := x asSortedCollection.                        "convert to sorted collection"
+y := x asBag.                                     "convert to bag collection"
+y := x asSet.                                     "convert to set collection"
 ```
 
-## Set:           like Bag except duplicates not allowed
-## IdentitySet:   uses identity test (== rather than =)
+#### Set:
+like Bag except duplicates not allowed
+
+#### IdentitySet:
+uses identity test (== rather than =)
+
 ```
 | b x y sum max |
-x := Set with: 4 with: 3 with: 2 with: 1.                   "create collection with up to 4 elements"
-x := Set new.                                               "allocate collection"
-x add: 4; add: 3; add: 1; add: 2; yourself.                 "add element to collection"
-y := x addAll: #(7 8 9).                                    "add multiple elements to collection"
-y := x removeAll: #(7 8 9).                                 "remove multiple elements from collection"
-y := x remove: 4 ifAbsent: [].                              "remove element from collection"
-b := x isEmpty.                                             "test if empty"
-y := x size.                                                "number of elements"
-x includes: 4.                                              "test if element is in collection"
-x do: [:a | Transcript show: a printString; cr].            "iterate over the collection"
-b := x conform: [:a | (a >= 1) & (a <= 4)].                 "test if all elements meet condition"
-y := x select: [:a | a > 2].                                "return collection of elements that pass test"
-y := x reject: [:a | a < 2].                                "return collection of elements that fail test"
-y := x collect: [:a | a + a].                               "transform each element for new collection"
-y := x detect: [:a | a > 3] ifNone: [].                     "find position of first element that passes test"
-sum := 0. x do: [:a | sum := sum + a]. sum.                 "sum elements"
-sum := x inject: 0 into: [:a :c | a + c].                   "sum elements"
-max := x inject: 0 into: [:a :c | (a > c)                   "find max element in collection"
+x := Set with: 4 with: 3 with: 2 with: 1.        "create collection with up to 4 elements"
+x := Set new.                                    "allocate collection"
+x add: 4; add: 3; add: 1; add: 2; yourself.      "add element to collection"
+y := x addAll: #(7 8 9).                         "add multiple elements to collection"
+y := x removeAll: #(7 8 9).                      "remove multiple elements from collection"
+y := x remove: 4 ifAbsent: [].                   "remove element from collection"
+b := x isEmpty.                                  "test if empty"
+y := x size.                                     "number of elements"
+x includes: 4.                                   "test if element is in collection"
+x do: [:a | Transcript show: a printString; cr]. "iterate over the collection"
+b := x conform: [:a | (a >= 1) & (a <= 4)].      "test if all elements meet condition"
+y := x select: [:a | a > 2].                     "return collection of elements that pass test"
+y := x reject: [:a | a < 2].                     "return collection of elements that fail test"
+y := x collect: [:a | a + a].                    "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: [].          "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum.      "sum elements"
+sum := x inject: 0 into: [:a :c | a + c].        "sum elements"
+max := x inject: 0 into: [:a :c | (a > c)        "find max element in collection"
    ifTrue: [a]
    ifFalse: [c]].
-y := x asArray.                                             "convert to array"
-y := x asOrderedCollection.                                 "convert to ordered collection"
-y := x asSortedCollection.                                  "convert to sorted collection"
-y := x asBag.                                               "convert to bag collection"
-y := x asSet.                                               "convert to set collection"
+y := x asArray.                                  "convert to array"
+y := x asOrderedCollection.                      "convert to ordered collection"
+y := x asSortedCollection.                       "convert to sorted collection"
+y := x asBag.                                    "convert to bag collection"
+y := x asSet.                                    "convert to set collection"
 ```
 
-## Interval:
+#### Interval:
 ```
 | b x y sum max |
-x := Interval from: 5 to: 10.                               "create interval object"
+x := Interval from: 5 to: 10.                     "create interval object"
 x := 5 to: 10.
-x := Interval from: 5 to: 10 by: 2.                         "create interval object with specified increment"
+x := Interval from: 5 to: 10 by: 2.               "create interval object with specified increment"
 x := 5 to: 10 by: 2.
-b := x isEmpty.                                             "test if empty"
-y := x size.                                                "number of elements"
-x includes: 9.                                              "test if element is in collection"
-x do: [:k | Transcript show: k printString; cr].            "iterate over interval"
-b := x conform: [:a | (a >= 1) & (a <= 4)].                 "test if all elements meet condition"
-y := x select: [:a | a > 7].                                "return collection of elements that pass test"
-y := x reject: [:a | a < 2].                                "return collection of elements that fail test"
-y := x collect: [:a | a + a].                               "transform each element for new collection"
-y := x detect: [:a | a > 3] ifNone: [].                     "find position of first element that passes test"
-sum := 0. x do: [:a | sum := sum + a]. sum.                 "sum elements"
-sum := 0. 1 to: (x size) do: [:a | sum := sum + (x at: a)]. "sum elements"
-sum := x inject: 0 into: [:a :c | a + c].                   "sum elements"
-max := x inject: 0 into: [:a :c | (a > c)                   "find max element in collection"
+b := x isEmpty.                                   "test if empty"
+y := x size.                                      "number of elements"
+x includes: 9.                                    "test if element is in collection"
+x do: [:k | Transcript show: k printString; cr].  "iterate over interval"
+b := x conform: [:a | (a >= 1) & (a <= 4)].       "test if all elements meet condition"
+y := x select: [:a | a > 7].                      "return collection of elements that pass test"
+y := x reject: [:a | a < 2].                      "return collection of elements that fail test"
+y := x collect: [:a | a + a].                     "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: [].           "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum.       "sum elements"
+sum := 0. 1 to: (x size) 
+            do: [:a | sum := sum + (x at: a)].    "sum elements"
+sum := x inject: 0 into: [:a :c | a + c].         "sum elements"
+max := x inject: 0 into: [:a :c | (a > c)         "find max element in collection"
    ifTrue: [a]
    ifFalse: [c]].
-y := x asArray.                                             "convert to array"
-y := x asOrderedCollection.                                 "convert to ordered collection"
-y := x asSortedCollection.                                  "convert to sorted collection"
-y := x asBag.                                               "convert to bag collection"
-y := x asSet.                                               "convert to set collection"
+y := x asArray.                                   "convert to array"
+y := x asOrderedCollection.                       "convert to ordered collection"
+y := x asSortedCollection.                        "convert to sorted collection"
+y := x asBag.                                     "convert to bag collection"
+y := x asSet.                                     "convert to set collection"
 ```
 
-##Associations:
+#### Associations:
 ```
 | x y |
 x := #myVar->'hello'.
@@ -612,78 +686,82 @@ y := x key.
 y := x value.
 ```
 
-## Dictionary:
-## IdentityDictionary:   uses identity test (== rather than =)
+#### Dictionary:
+#### IdentityDictionary:
+uses identity test (== rather than =)
+
 ```
 | b x y |
-x := Dictionary new.                                        "allocate collection"
-x add: #a->4; add: #b->3; add: #c->1; add: #d->2; yourself. "add element to collection"
-x at: #e put: 3.                                            "set element at index"
-b := x isEmpty.                                             "test if empty"
-y := x size.                                                "number of elements"
-y := x at: #a ifAbsent: [].                                 "retrieve element at index"
-y := x keyAtValue: 3 ifAbsent: [].                          "retrieve key for given value with error block"
-y := x removeKey: #e ifAbsent: [].                          "remove element from collection"
-b := x includes: 3.                                         "test if element is in values collection"
-b := x includesKey: #a.                                     "test if element is in keys collection"
-y := x occurrencesOf: 3.                                    "number of times object in collection"
-y := x keys.                                                "set of keys"
-y := x values.                                              "bag of values"
+x := Dictionary new.                   "allocate collection"
+x add: #a->4; 
+  add: #b->3; 
+  add: #c->1; 
+  add: #d->2; yourself.                "add element to collection"
+x at: #e put: 3.                       "set element at index"
+b := x isEmpty.                        "test if empty"
+y := x size.                           "number of elements"
+y := x at: #a ifAbsent: [].            "retrieve element at index"
+y := x keyAtValue: 3 ifAbsent: [].     "retrieve key for given value with error block"
+y := x removeKey: #e ifAbsent: [].     "remove element from collection"
+b := x includes: 3.                    "test if element is in values collection"
+b := x includesKey: #a.                "test if element is in keys collection"
+y := x occurrencesOf: 3.               "number of times object in collection"
+y := x keys.                           "set of keys"
+y := x values.                         "bag of values"
 x do: [:a | Transcript show: a printString; cr].            "iterate over the values collection"
 x keysDo: [:a | Transcript show: a printString; cr].        "iterate over the keys collection"
 x associationsDo: [:a | Transcript show: a printString; cr]."iterate over the associations"
 x keysAndValuesDo: [:aKey :aValue | Transcript              "iterate over keys and values"
    show: aKey printString; space;
    show: aValue printString; cr].
-b := x conform: [:a | (a >= 1) & (a <= 4)].                 "test if all elements meet condition"
-y := x select: [:a | a > 2].                                "return collection of elements that pass test"
-y := x reject: [:a | a < 2].                                "return collection of elements that fail test"
-y := x collect: [:a | a + a].                               "transform each element for new collection"
-y := x detect: [:a | a > 3] ifNone: [].                     "find position of first element that passes test"
-sum := 0. x do: [:a | sum := sum + a]. sum.                 "sum elements"
-sum := x inject: 0 into: [:a :c | a + c].                   "sum elements"
-max := x inject: 0 into: [:a :c | (a > c)                   "find max element in collection"
+b := x conform: [:a | (a >= 1) & (a <= 4)].      "test if all elements meet condition"
+y := x select: [:a | a > 2].                     "return collection of elements that pass test"
+y := x reject: [:a | a < 2].                     "return collection of elements that fail test"
+y := x collect: [:a | a + a].                    "transform each element for new collection"
+y := x detect: [:a | a > 3] ifNone: [].          "find position of first element that passes test"
+sum := 0. x do: [:a | sum := sum + a]. sum.      "sum elements"
+sum := x inject: 0 into: [:a :c | a + c].        "sum elements"
+max := x inject: 0 into: [:a :c | (a > c)        "find max element in collection"
    ifTrue: [a]
    ifFalse: [c]].
-y := x asArray.                                             "convert to array"
-y := x asOrderedCollection.                                 "convert to ordered collection"
-y := x asSortedCollection.                                  "convert to sorted collection"
-y := x asBag.                                               "convert to bag collection"
-y := x asSet.                                               "convert to set collection"
-
-Smalltalk at: #CMRGlobal put: 'CMR entry'.                  "put global in Smalltalk Dictionary"
-x := Smalltalk at: #CMRGlobal.                              "read global from Smalltalk Dictionary"
-Transcript show: (CMRGlobal printString).                   "entries are directly accessible by name"
-Smalltalk keys do: [ :k |                                   "print out all classes"
+y := x asArray.                                   "convert to array"
+y := x asOrderedCollection.                       "convert to ordered collection"
+y := x asSortedCollection.                        "convert to sorted collection"
+y := x asBag.                                     "convert to bag collection"
+y := x asSet.                                     "convert to set collection"
+
+Smalltalk at: #CMRGlobal put: 'CMR entry'.        "put global in Smalltalk Dictionary"
+x := Smalltalk at: #CMRGlobal.                    "read global from Smalltalk Dictionary"
+Transcript show: (CMRGlobal printString).         "entries are directly accessible by name"
+Smalltalk keys do: [ :k |                         "print out all classes"
    ((Smalltalk at: k) isKindOf: Class)
       ifFalse: [Transcript show: k printString; cr]].
-Smalltalk at: #CMRDictionary put: (Dictionary new).         "set up user defined dictionary"
-CMRDictionary at: #MyVar1 put: 'hello1'.                    "put entry in dictionary"
-CMRDictionary add: #MyVar2->'hello2'.                       "add entry to dictionary use key->value combo"
-CMRDictionary size.                                         "dictionary size"
-CMRDictionary keys do: [ :k |                               "print out keys in dictionary"
+Smalltalk at: #CMRDictionary put: (Dictionary new). "set up user defined dictionary"
+CMRDictionary at: #MyVar1 put: 'hello1'.            "put entry in dictionary"
+CMRDictionary add: #MyVar2->'hello2'.               "add entry to dictionary use key->value combo"
+CMRDictionary size.                                 "dictionary size"
+CMRDictionary keys do: [ :k |                       "print out keys in dictionary"
    Transcript show: k printString; cr].
-CMRDictionary values do: [ :k |                             "print out values in dictionary"
+CMRDictionary values do: [ :k |                     "print out values in dictionary"
    Transcript show: k printString; cr].
-CMRDictionary keysAndValuesDo: [:aKey :aValue |             "print out keys and values"
+CMRDictionary keysAndValuesDo: [:aKey :aValue |     "print out keys and values"
    Transcript
       show: aKey printString;
       space;
       show: aValue printString;
       cr].
-CMRDictionary associationsDo: [:aKeyValue |                 "another iterator for printing key values"
+CMRDictionary associationsDo: [:aKeyValue |           "another iterator for printing key values"
    Transcript show: aKeyValue printString; cr].
-Smalltalk removeKey: #CMRGlobal ifAbsent: [].               "remove entry from Smalltalk dictionary"
-Smalltalk removeKey: #CMRDictionary ifAbsent: [].           "remove user dictionary from Smalltalk dictionary"
+Smalltalk removeKey: #CMRGlobal ifAbsent: [].         "remove entry from Smalltalk dictionary"
+Smalltalk removeKey: #CMRDictionary ifAbsent: [].     "remove user dictionary from Smalltalk dictionary"
 ```
 
-## Internal Stream:
+#### Internal Stream:
 ```
 | b x ios |
 ios := ReadStream on: 'Hello read stream'.
 ios := ReadStream on: 'Hello read stream' from: 1 to: 5.
-[(x := ios nextLine) notNil]
-   whileTrue: [Transcript show: x; cr].
+[(x := ios nextLine) notNil] whileTrue: [Transcript show: x; cr].
 ios position: 3.
 ios position.
 x := ios next.
@@ -696,8 +774,7 @@ ios := ReadWriteStream on: 'Hello read stream' from: 1 to: 5.
 ios := ReadWriteStream with: 'Hello read stream'.
 ios := ReadWriteStream with: 'Hello read stream' from: 1 to: 10.
 ios position: 0.
-[(x := ios nextLine) notNil]
-   whileTrue: [Transcript show: x; cr].
+[(x := ios nextLine) notNil] whileTrue: [Transcript show: x; cr].
 ios position: 6.
 ios position.
 ios nextPutAll: 'Chris'.
@@ -707,7 +784,7 @@ x := ios contents.
 b := ios atEnd.
 ```
 
-## FileStream:
+#### FileStream:
 ```
 | b x ios |
 ios := FileStream newFileNamed: 'ios.txt'.
@@ -718,8 +795,7 @@ ios nextPutAll: 'Hello File'; cr.
 ios close.
 
 ios := FileStream oldFileNamed: 'ios.txt'.
-[(x := ios nextLine) notNil]
-   whileTrue: [Transcript show: x; cr].
+[(x := ios nextLine) notNil] whileTrue: [Transcript show: x; cr].
 ios position: 3.
 x := ios position.
 x := ios next.
@@ -728,120 +804,122 @@ b := ios atEnd.
 ios close.
 ```
 
-## Date:
+#### Date:
 ```
 | x y |
-x := Date today.                                            "create date for today"
-x := Date dateAndTimeNow.                                   "create date from current time/date"
-x := Date readFromString: '01/02/1999'.                     "create date from formatted string"
-x := Date newDay: 12 month: #July year: 1999                "create date from parts"
-x := Date fromDays: 36000.                                  "create date from elapsed days since 1/1/1901"
-y := Date dayOfWeek: #Monday.                               "day of week as int (1-7)"
-y := Date indexOfMonth: #January.                           "month of year as int (1-12)"
-y := Date daysInMonth: 2 forYear: 1996.                     "day of month as int (1-31)"
-y := Date daysInYear: 1996.                                 "days in year (365|366)"
-y := Date nameOfDay: 1                                      "weekday name (#Monday,...)"
-y := Date nameOfMonth: 1.                                   "month name (#January,...)"
-y := Date leapYear: 1996.                                   "1 if leap year; 0 if not leap year"
-y := x weekday.                                             "day of week (#Monday,...)"
-y := x previous: #Monday.                                   "date for previous day of week"
-y := x dayOfMonth.                                          "day of month (1-31)"
-y := x day.                                                 "day of year (1-366)"
-y := x firstDayOfMonth.                                     "day of year for first day of month"
-y := x monthName.                                           "month of year (#January,...)"
-y := x monthIndex.                                          "month of year (1-12)"
-y := x daysInMonth.                                         "days in month (1-31)"
-y := x year.                                                "year (19xx)"
-y := x daysInYear.                                          "days in year (365|366)"
-y := x daysLeftInYear.                                      "days left in year (364|365)"
-y := x asSeconds.                                           "seconds elapsed since 1/1/1901"
-y := x addDays: 10.                                         "add days to date object"
-y := x subtractDays: 10.                                    "subtract days to date object"
-y := x subtractDate: (Date today).                          "subtract date (result in days)"
-y := x printFormat: #(2 1 3 $/ 1 1).                        "print formatted date"
-b := (x <= Date today).                                     "comparison"
-```
-
-## Time:
+x := Date today.                                "create date for today"
+x := Date dateAndTimeNow.                       "create date from current time/date"
+x := Date readFromString: '01/02/1999'.         "create date from formatted string"
+x := Date newDay: 12 month: #July year: 1999    "create date from parts"
+x := Date fromDays: 36000.                      "create date from elapsed days since 1/1/1901"
+y := Date dayOfWeek: #Monday.                   "day of week as int (1-7)"
+y := Date indexOfMonth: #January.               "month of year as int (1-12)"
+y := Date daysInMonth: 2 forYear: 1996.         "day of month as int (1-31)"
+y := Date daysInYear: 1996.                     "days in year (365|366)"
+y := Date nameOfDay: 1                          "weekday name (#Monday,...)"
+y := Date nameOfMonth: 1.                       "month name (#January,...)"
+y := Date leapYear: 1996.                       "1 if leap year; 0 if not leap year"
+y := x weekday.                                 "day of week (#Monday,...)"
+y := x previous: #Monday.                       "date for previous day of week"
+y := x dayOfMonth.                              "day of month (1-31)"
+y := x day.                                     "day of year (1-366)"
+y := x firstDayOfMonth.                         "day of year for first day of month"
+y := x monthName.                               "month of year (#January,...)"
+y := x monthIndex.                              "month of year (1-12)"
+y := x daysInMonth.                             "days in month (1-31)"
+y := x year.                                    "year (19xx)"
+y := x daysInYear.                              "days in year (365|366)"
+y := x daysLeftInYear.                          "days left in year (364|365)"
+y := x asSeconds.                               "seconds elapsed since 1/1/1901"
+y := x addDays: 10.                             "add days to date object"
+y := x subtractDays: 10.                        "subtract days to date object"
+y := x subtractDate: (Date today).              "subtract date (result in days)"
+y := x printFormat: #(2 1 3 $/ 1 1).            "print formatted date"
+b := (x <= Date today).                         "comparison"
+```
+
+#### Time:
 ```
 | x y |
-x := Time now.                                              "create time from current time"
-x := Time dateAndTimeNow.                                   "create time from current time/date"
-x := Time readFromString: '3:47:26 pm'.                     "create time from formatted string"
-x := Time fromSeconds: (60 * 60 * 4).                       "create time from elapsed time from midnight"
-y := Time millisecondClockValue.                            "milliseconds since midnight"
-y := Time totalSeconds.                                     "total seconds since 1/1/1901"
-y := x seconds.                                             "seconds past minute (0-59)"
-y := x minutes.                                             "minutes past hour (0-59)"
-y := x hours.                                               "hours past midnight (0-23)"
-y := x addTime: (Time now).                                 "add time to time object"
-y := x subtractTime: (Time now).                            "subtract time to time object"
-y := x asSeconds.                                           "convert time to seconds"
-x := Time millisecondsToRun: [                              "timing facility"
+x := Time now.                                      "create time from current time"
+x := Time dateAndTimeNow.                           "create time from current time/date"
+x := Time readFromString: '3:47:26 pm'.             "create time from formatted string"
+x := Time fromSeconds: (60 * 60 * 4).               "create time from elapsed time from midnight"
+y := Time millisecondClockValue.                    "milliseconds since midnight"
+y := Time totalSeconds.                             "total seconds since 1/1/1901"
+y := x seconds.                                     "seconds past minute (0-59)"
+y := x minutes.                                     "minutes past hour (0-59)"
+y := x hours.                                       "hours past midnight (0-23)"
+y := x addTime: (Time now).                         "add time to time object"
+y := x subtractTime: (Time now).                    "subtract time to time object"
+y := x asSeconds.                                   "convert time to seconds"
+x := Time millisecondsToRun: [                      "timing facility"
    1 to: 1000 do: [:index | y := 3.14 * index]].
-b := (x <= Time now).                                       "comparison"
+b := (x <= Time now).                               "comparison"
 ```
 
-## Point:
+#### Point:
 ```
 | x y |
-x := 200@100.                                               "obtain a new point"
-y := x x.                                                   "x coordinate"
-y := x y.                                                   "y coordinate"
-x := 200@100 negated.                                       "negates x and y"
-x := (-200@-100) abs.                                       "absolute value of x and y"
-x := (200.5@100.5) rounded.                                 "round x and y"
-x := (200.5@100.5) truncated.                               "truncate x and y"
-x := 200@100 + 100.                                         "add scale to both x and y"
-x := 200@100 - 100.                                         "subtract scale from both x and y"
-x := 200@100 * 2.                                           "multiply x and y by scale"
-x := 200@100 / 2.                                           "divide x and y by scale"
-x := 200@100 // 2.                                          "divide x and y by scale"
-x := 200@100 \\ 3.                                          "remainder of x and y by scale"
-x := 200@100 + 50@25.                                       "add points"
-x := 200@100 - 50@25.                                       "subtract points"
-x := 200@100 * 3@4.                                         "multiply points"
-x := 200@100 // 3@4.                                        "divide points"
-x := 200@100 max: 50@200.                                   "max x and y"
-x := 200@100 min: 50@200.                                   "min x and y"
-x := 20@5 dotProduct: 10@2.                                 "sum of product (x1*x2 + y1*y2)"
-```
-
-## Rectangle:
+x := 200@100.                            "obtain a new point"
+y := x x.                                "x coordinate"
+y := x y.                                "y coordinate"
+x := 200@100 negated.                    "negates x and y"
+x := (-200@-100) abs.                    "absolute value of x and y"
+x := (200.5@100.5) rounded.              "round x and y"
+x := (200.5@100.5) truncated.            "truncate x and y"
+x := 200@100 + 100.                      "add scale to both x and y"
+x := 200@100 - 100.                      "subtract scale from both x and y"
+x := 200@100 * 2.                        "multiply x and y by scale"
+x := 200@100 / 2.                        "divide x and y by scale"
+x := 200@100 // 2.                       "divide x and y by scale"
+x := 200@100 \\ 3.                       "remainder of x and y by scale"
+x := 200@100 + 50@25.                    "add points"
+x := 200@100 - 50@25.                    "subtract points"
+x := 200@100 * 3@4.                      "multiply points"
+x := 200@100 // 3@4.                     "divide points"
+x := 200@100 max: 50@200.                "max x and y"
+x := 200@100 min: 50@200.                "min x and y"
+x := 20@5 dotProduct: 10@2.              "sum of product (x1*x2 + y1*y2)"
+```
+
+#### Rectangle:
 ```
 Rectangle fromUser.
 ```
 
-## Pen:
+#### Pen:
 ```
 | myPen |
 Display restoreAfter: [
    Display fillWhite.
 
-myPen := Pen new.                                           "get graphic pen"
+myPen := Pen new.                            "get graphic pen"
 myPen squareNib: 1.
-myPen color: (Color blue).                                  "set pen color"
-myPen home.                                                 "position pen at center of display"
-myPen up.                                                   "makes nib unable to draw"
-myPen down.                                                 "enable the nib to draw"
-myPen north.                                                "points direction towards top"
-myPen turn: -180.                                           "add specified degrees to direction"
-myPen direction.                                            "get current angle of pen"
-myPen go: 50.                                               "move pen specified number of pixels"
-myPen location.                                             "get the pen position"
-myPen goto: 200@200.                                        "move to specified point"
-myPen place: 250@250.                                       "move to specified point without drawing"
-myPen print: 'Hello World' withFont: (TextStyle default fontAt: 1).
-Display extent.                                             "get display width@height"
-Display width.                                              "get display width"
-Display height.                                             "get display height"
+myPen color: (Color blue).                   "set pen color"
+myPen home.                                  "position pen at center of display"
+myPen up.                                    "makes nib unable to draw"
+myPen down.                                  "enable the nib to draw"
+myPen north.                                 "points direction towards top"
+myPen turn: -180.                            "add specified degrees to direction"
+myPen direction.                             "get current angle of pen"
+myPen go: 50.                                "move pen specified number of pixels"
+myPen location.                              "get the pen position"
+myPen goto: 200@200.                         "move to specified point"
+myPen place: 250@250.                        "move to specified point without drawing"
+myPen print: 'Hello World' 
+      withFont: (TextStyle default fontAt: 1).
+Display extent.                              "get display width@height"
+Display width.                               "get display width"
+Display height.                              "get display height"
 
 ].
 ```
 
-## Dynamic Message Calling/Compiling:
+#### Dynamic Message Calling/Compiling:
 ```
 | receiver message result argument keyword1 keyword2 argument1 argument2 |
+
 "unary message"
 receiver := 5.
 message := 'factorial' asSymbol.
@@ -863,11 +941,14 @@ keyword1 := 'between:' asSymbol.
 keyword2 := 'and:' asSymbol.
 argument1 := 10.
 argument2 := 20.
+
 result := receiver
    perform: (keyword1, keyword2) asSymbol
    withArguments: (Array with: argument1 with: argument2).
+   
 result := Compiler evaluate:
    ((receiver storeString), ' ', keyword1, (argument1 storeString) , ' ', keyword2, (argument2 storeString)).
+   
 result := (Message
    new
       setSelector: (keyword1, keyword2) asSymbol
@@ -875,83 +956,89 @@ result := (Message
    sentTo: receiver.
 ```
 
-## Class/Meta-class:
+#### Class/Meta-Class:
 ```
 | b x |
-x := String name.                                           "class name"
-x := String category.                                       "organization category"
-x := String comment.                                        "class comment"
-x := String kindOfSubclass.                                 "subclass type - subclass: variableSubclass, etc"
-x := String definition.                                     "class definition"
-x := String instVarNames.                                   "immediate instance variable names"
-x := String allInstVarNames.                                "accumulated instance variable names"
-x := String classVarNames.                                  "immediate class variable names"
-x := String allClassVarNames.                               "accumulated class variable names"
-x := String sharedPools.                                    "immediate dictionaries used as shared pools"
-x := String allSharedPools.                                 "accumulated dictionaries used as shared pools"
-x := String selectors.                                      "message selectors for class"
-x := String sourceCodeAt: #size.                            "source code for specified method"
-x := String allInstances.                                   "collection of all instances of class"
-x := String superclass.                                     "immediate superclass"
-x := String allSuperclasses.                                "accumulated superclasses"
-x := String withAllSuperclasses.                            "receiver class and accumulated superclasses"
-x := String subclasses.                                     "immediate subclasses"
-x := String allSubclasses.                                  "accumulated subclasses"
-x := String withAllSubclasses.                              "receiver class and accumulated subclasses"
-b := String instSize.                                       "number of named instance variables"
-b := String isFixed.                                        "true if no indexed instance variables"
-b := String isVariable.                                     "true if has indexed instance variables"
-b := String isPointers.                                     "true if index instance vars contain objects"
-b := String isBits.                                         "true if index instance vars contain bytes/words"
-b := String isBytes.                                        "true if index instance vars contain bytes"
-b := String isWords.                                        "true if index instance vars contain words"
-Object withAllSubclasses size.                              "get total number of class entries"
-```
-
-## Debugging:
+x := String name.                     "class name"
+x := String category.                 "organization category"
+x := String comment.                  "class comment"
+x := String kindOfSubclass.           "subclass type - subclass: variableSubclass, etc"
+x := String definition.               "class definition"
+x := String instVarNames.             "immediate instance variable names"
+x := String allInstVarNames.          "accumulated instance variable names"
+x := String classVarNames.            "immediate class variable names"
+x := String allClassVarNames.         "accumulated class variable names"
+x := String sharedPools.              "immediate dictionaries used as shared pools"
+x := String allSharedPools.           "accumulated dictionaries used as shared pools"
+x := String selectors.                "message selectors for class"
+x := String sourceCodeAt: #size.      "source code for specified method"
+x := String allInstances.             "collection of all instances of class"
+x := String superclass.               "immediate superclass"
+x := String allSuperclasses.          "accumulated superclasses"
+x := String withAllSuperclasses.      "receiver class and accumulated superclasses"
+x := String subclasses.               "immediate subclasses"
+x := String allSubclasses.            "accumulated subclasses"
+x := String withAllSubclasses.        "receiver class and accumulated subclasses"
+b := String instSize.                 "number of named instance variables"
+b := String isFixed.                  "true if no indexed instance variables"
+b := String isVariable.               "true if has indexed instance variables"
+b := String isPointers.               "true if index instance vars contain objects"
+b := String isBits.                   "true if index instance vars contain bytes/words"
+b := String isBytes.                  "true if index instance vars contain bytes"
+b := String isWords.                  "true if index instance vars contain words"
+Object withAllSubclasses size.        "get total number of class entries"
+```
+
+#### Debugging:
 ```
 | a b x |
-x yourself.                                                 "returns receiver"
-String browse.                                              "browse specified class"
-x inspect.                                                  "open object inspector window"
+x yourself.                             "returns receiver"
+String browse.                          "browse specified class"
+x inspect.                              "open object inspector window"
 x confirm: 'Is this correct?'.
-x halt.                                                     "breakpoint to open debugger window"
+x halt.                                 "breakpoint to open debugger window"
 x halt: 'Halt message'.
 x notify: 'Notify text'.
-x error: 'Error string'.                                    "open up error window with title"
-x doesNotUnderstand: #cmrMessage.                           "flag message is not handled"
-x shouldNotImplement.                                       "flag message should not be implemented"
-x subclassResponsibility.                                   "flag message as abstract"
-x errorImproperStore.                                       "flag an improper store into indexable object"
-x errorNonIntegerIndex.                                     "flag only integers should be used as index"
-x errorSubscriptBounds.                                     "flag subscript out of bounds"
-x primitiveFailed.                                          "system primitive failed"
-
-a := 'A1'. b := 'B2'. a become: b.                          "switch two objects"
+x error: 'Error string'.                "open up error window with title"
+x doesNotUnderstand: #cmrMessage.       "flag message is not handled"
+x shouldNotImplement.                   "flag message should not be implemented"
+x subclassResponsibility.               "flag message as abstract"
+x errorImproperStore.                   "flag an improper store into indexable object"
+x errorNonIntegerIndex.                 "flag only integers should be used as index"
+x errorSubscriptBounds.                 "flag subscript out of bounds"
+x primitiveFailed.                      "system primitive failed"
+
+a := 'A1'. b := 'B2'. a become: b.      "switch two objects"
 Transcript show: a, b; cr.
 ```
 
-## Misc
+#### Miscellaneous
 ```
 | x |
-"Smalltalk condenseChanges."                                "compress the change file"
-x := FillInTheBlank request: 'Prompt Me'.                   "prompt user for input"
+"Smalltalk condenseChanges."                    "compress the change file"
+x := FillInTheBlank request: 'Prompt Me'.       "prompt user for input"
 Utilities openCommandKeyHelp
 ```
 
-
-
-
 ## Ready For More?
 
-### Free Online
+### Online Smalltalk systems
+Most Smalltalks are either free as in OSS or have a free downloadable version with some payment required for commercial usage.
+* [Squeak](https://www.squeak.org)
+* [Pharo](http://pharo.org)
+* [Smalltalk/X](https://www.exept.de/en/smalltalk-x.html)
+* [Gemstone](http://gemtalksystems.com/)
+* [VA Smalltalk](http://www.instantiations.com/products/vasmalltalk/)
+* [VisualWorks Smalltalk](http://www.cincomsmalltalk.com/)
 
-* [GNU Smalltalk User's Guide](https://www.gnu.org/software/smalltalk/manual/html_node/Tutorial.html)
-* [smalltalk dot org](http://www.smalltalk.org/)
-* [Computer Programming using GNU Smalltalk](http://www.canol.info/books/computer_programming_using_gnu_smalltalk/)
+### Online Smalltalk books and articles
+* [Smalltalk Programming Resources](http://www.whoishostingthis.com/resources/smalltalk/)
 * [Smalltalk Cheatsheet](http://www.angelfire.com/tx4/cus/notes/smalltalk.html)
 * [Smalltalk-72 Manual](http://www.bitsavers.org/pdf/xerox/parc/techReports/Smalltalk-72_Instruction_Manual_Mar76.pdf)
+* [GNU Smalltalk User's Guide](https://www.gnu.org/software/smalltalk/manual/html_node/Tutorial.html)
+
+#### Historical Documentation(s)
 * [BYTE: A Special issue on Smalltalk](https://archive.org/details/byte-magazine-1981-08)
+* [Smalltalk-72 Manual](http://www.bitsavers.org/pdf/xerox/parc/techReports/Smalltalk-72_Instruction_Manual_Mar76.pdf)
 * [Smalltalk, Objects, and Design](https://books.google.co.in/books?id=W8_Une9cbbgC&printsec=frontcover&dq=smalltalk&hl=en&sa=X&ved=0CCIQ6AEwAWoVChMIw63Vo6CpyAIV0HGOCh3S2Alf#v=onepage&q=smalltalk&f=false)
 * [Smalltalk: An Introduction to Application Development Using VisualWorks](https://books.google.co.in/books?id=zalQAAAAMAAJ&q=smalltalk&dq=smalltalk&hl=en&sa=X&ved=0CCgQ6AEwAmoVChMIw63Vo6CpyAIV0HGOCh3S2Alf/)
-* [Smalltalk Programming Resources](http://www.whoishostingthis.com/resources/smalltalk/)
diff --git a/solidity.html.markdown b/solidity.html.markdown
index b657b6a1..cc719ec7 100644
--- a/solidity.html.markdown
+++ b/solidity.html.markdown
@@ -4,6 +4,8 @@ filename: learnSolidity.sol
 contributors:
   - ["Nemil Dalal", "https://www.nemil.com"]
   - ["Joseph Chow", ""]
+  - ["Bhoomtawath Plinsut", "https://github.com/varshard"]
+  - ["Shooter", "https://github.com/liushooter"]
 ---
 
 Solidity lets you program on [Ethereum](https://www.ethereum.org/), a
@@ -109,9 +111,9 @@ contract SimpleBank { // CapWords
 
     /// @notice Get balance
     /// @return The balance of the user
-    // 'constant' prevents function from editing state variables;
+    // 'view' (ex: constant) prevents function from editing state variables;
     // allows function to run locally/off blockchain
-    function balance() constant public returns (uint) {
+    function balance() view public returns (uint) {
         return balances[msg.sender];
     }
 }
@@ -236,7 +238,7 @@ uint x[][5]; // arr with 5 dynamic array elements (opp order of most languages)
 // Dictionaries (any type to any other type)
 mapping (string => uint) public balances;
 balances["charles"] = 1;
-console.log(balances["ada"]); // is 0, all non-set key values return zeroes
+// balances["ada"] result is 0, all non-set key values return zeroes
 // 'public' allows following from another contract
 contractName.balances("charles"); // returns 1
 // 'public' created a getter (but not setter) like the following:
@@ -341,25 +343,26 @@ function increment(uint x, uint y) returns (uint x, uint y) {
 // Call previous functon
 uint (a,b) = increment(1,1);
 
-// 'constant' (alias for 'view')
+// 'view' (alias for 'constant')
 // indicates that function does not/cannot change persistent vars
-// Constant function execute locally, not on blockchain
+// View function execute locally, not on blockchain
+// Noted: constant keyword will soon be deprecated.
 uint y = 1;
 
-function increment(uint x) constant returns (uint x) {
+function increment(uint x) view returns (uint x) {
     x += 1;
     y += 1; // this line would fail
-    // y is a state variable, and can't be changed in a constant function
+    // y is a state variable, and can't be changed in a view function
 }
 
-// 'pure' is more strict than 'constant', and does not
+// 'pure' is more strict than 'view' or 'constant', and does not
 // even allow reading of state vars
 // The exact rules are more complicated, so see more about
-// constant/pure:
+// view/pure:
 // http://solidity.readthedocs.io/en/develop/contracts.html#view-functions
 
 // 'Function Visibility specifiers'
-// These can be placed where 'constant' is, including:
+// These can be placed where 'view' is, including:
 // public - visible externally and internally (default for function)
 // external - only visible externally (including a call made with this.)
 // private - only visible in the current contract
@@ -401,8 +404,12 @@ event LogSent(address indexed from, address indexed to, uint amount); // note ca
 // Call
 LogSent(from, to, amount);
 
-// For an external party (a contract or external entity), to watch using
-// the Web3 Javascript library:
+/**
+
+For an external party (a contract or external entity), to watch using
+the Web3 Javascript library:
+
+// The following is Javascript code, not Solidity code
 Coin.LogSent().watch({}, '', function(error, result) {
     if (!error) {
         console.log("Coin transfer: " + result.args.amount +
@@ -413,6 +420,8 @@ Coin.LogSent().watch({}, '', function(error, result) {
             "Receiver: " + Coin.balances.call(result.args.to));
     }
 }
+**/
+
 // Common paradigm for one contract to depend on another (e.g., a
 // contract that depends on current exchange rate provided by another)
 
@@ -474,7 +483,7 @@ for(uint x = 0; x < refundAddressList.length; x++) {
 
 // A. Calling external contract
 contract InfoFeed {
-    function info() returns (uint ret) { return 42; }
+    function info() payable returns (uint ret)  { return 42; }
 }
 
 contract Consumer {
@@ -829,7 +838,7 @@ someContractAddress.callcode('function_name');
 ## Additional resources
 - [Solidity Docs](https://solidity.readthedocs.org/en/latest/)
 - [Smart Contract Best Practices](https://github.com/ConsenSys/smart-contract-best-practices)
-- [Solidity Style Guide](https://ethereum.github.io/solidity//docs/style-guide/): Ethereum's style guide is heavily derived from Python's [pep8](https://www.python.org/dev/peps/pep-0008/) style guide.
+- [Superblocks Lab - Browser based IDE for Solidity](https://lab.superblocks.com/)
 - [EthFiddle - The JsFiddle for Solidity](https://ethfiddle.com/)
 - [Browser-based Solidity Editor](https://remix.ethereum.org/)
 - [Gitter Solidity Chat room](https://gitter.im/ethereum/solidity)
@@ -850,9 +859,10 @@ someContractAddress.callcode('function_name');
 - [Hacking Distributed Blog](http://hackingdistributed.com/)
 
 ## Style
-- Python's [PEP8](https://www.python.org/dev/peps/pep-0008/) is used as the baseline style guide, including its general philosophy
+- [Solidity Style Guide](http://solidity.readthedocs.io/en/latest/style-guide.html): Ethereum's style guide is heavily derived from Python's [PEP 8](https://www.python.org/dev/peps/pep-0008/) style guide.
 
 ## Editors
+- [Emacs Solidity Mode](https://github.com/ethereum/emacs-solidity)
 - [Vim Solidity](https://github.com/tomlion/vim-solidity)
 - Editor Snippets ([Ultisnips format](https://gist.github.com/nemild/98343ce6b16b747788bc))
 
diff --git a/sql.html.markdown b/sql.html.markdown
new file mode 100644
index 00000000..2bece208
--- /dev/null
+++ b/sql.html.markdown
@@ -0,0 +1,105 @@
+---
+language: SQL
+filename: learnsql.sql
+contributors:
+  - ["Bob DuCharme", "http://bobdc.com/"]
+---
+
+Structured Query Language (SQL) is an ISO standard language for creating and working with databases stored in a set of tables. Implementations usually add their own extensions to the language; [Comparison of different SQL implementations](http://troels.arvin.dk/db/rdbms/) is a good reference on product differences.
+
+Implementations typically provide a command line prompt where you can enter the commands shown here interactively, and they also offer a way to execute a series of these commands stored in a script file.  (Showing that you’re done with the interactive prompt is a good example of something that isn’t standardized--most SQL implementations support the keywords QUIT, EXIT, or both.)
+
+Several of these sample commands assume that the [MySQL employee sample database](https://dev.mysql.com/doc/employee/en/) available on [github](https://github.com/datacharmer/test_db) has already been loaded. The github files are scripts of commands, similar to the relevant commands below, that create and populate tables of data about a fictional company’s employees. The syntax for running these scripts will depend on the SQL implementation you are using. A utility that you run from the operating system prompt is typical. 
+
+
+```sql
+-- Comments start with two hyphens. End each command with a semicolon.
+
+-- SQL is not case-sensitive about keywords. The sample commands here
+-- follow the convention of spelling them in upper-case because it makes 
+-- it easier to distinguish them from database, table, and column names.
+
+-- Create and delete a database. Database and table names are case-sensitive.
+CREATE DATABASE someDatabase;
+DROP DATABASE someDatabase;
+
+-- List available databases.
+SHOW DATABASES;
+
+-- Use a particular existing database. 
+USE employees;
+
+-- Select all rows and columns from the current database's departments table.
+-- Default activity is for the interpreter to scroll the results on your screen. 
+SELECT * FROM departments;
+
+-- Retrieve all rows from the departments table, 
+-- but only the dept_no and dept_name columns. 
+-- Splitting up commands across lines is OK.
+SELECT dept_no,
+       dept_name FROM departments;
+
+-- Retrieve all departments columns, but just 5 rows. 
+SELECT * FROM departments LIMIT 5;
+
+-- Retrieve dept_name column values from the departments
+-- table where the dept_name value has the substring 'en'. 
+SELECT dept_name FROM departments WHERE dept_name LIKE '%en%';
+
+-- Retrieve all columns from the departments table where the dept_name
+-- column starts with an 'S' and has exactly 4 characters after it. 
+SELECT * FROM departments WHERE dept_name LIKE 'S____';
+
+-- Select title values from the titles table but don't show duplicates.
+SELECT DISTINCT title FROM titles;
+
+-- Same as above, but sorted (case-sensitive) by the title values. 
+SELECT DISTINCT title FROM titles ORDER BY title;
+
+-- Show the number of rows in the departments table.
+SELECT COUNT(*) FROM departments;
+
+-- Show the number of rows in the departments table that
+-- have 'en' as a substring of the dept_name value. 
+SELECT COUNT(*) FROM departments WHERE dept_name LIKE '%en%';
+
+-- A JOIN of information from multiple tables: the titles table shows 
+-- who had what job titles, by their employee numbers, from what 
+-- date to what date. Retrieve this information, but instead of the
+-- employee number, use the employee number as a cross-reference to 
+-- the employees table to get each employee's first and last name
+-- instead. (And only get 10 rows.)
+
+SELECT employees.first_name, employees.last_name,
+       titles.title, titles.from_date, titles.to_date
+FROM titles INNER JOIN employees ON
+       employees.emp_no = titles.emp_no LIMIT 10;
+
+-- List all the tables in all the databases. Implementations typically provide
+-- their own shortcut command to do this with the database currently in use.
+SELECT * FROM INFORMATION_SCHEMA.TABLES
+WHERE TABLE_TYPE='BASE TABLE';
+
+-- Create a table called tablename1, with the two columns shown, for
+-- the database currently in use. Lots of other options are available
+-- for how you specify the columns, such as their datatypes.
+CREATE TABLE tablename1 (fname VARCHAR(20), lname VARCHAR(20));
+
+-- Insert a row of data into the table tablename1. This assumes that the 
+-- table has been defined to accept these values as appropriate for it. 
+INSERT INTO tablename1 VALUES('Richard','Mutt');
+
+-- In tablename1, change the fname value to 'John'
+-- for all rows that have an lname value of 'Mutt'. 
+UPDATE tablename1 SET fname='John' WHERE lname='Mutt';
+
+-- Delete rows from the tablename1 table
+-- where the lname value begins with 'M'.
+DELETE FROM tablename1 WHERE lname like 'M%';
+
+-- Delete all rows from the tablename1 table, leaving the empty table.
+DELETE FROM tablename1;
+
+-- Remove the entire tablename1 table. 
+DROP TABLE tablename1;
+```
diff --git a/standard-ml.html.markdown b/standard-ml.html.markdown
index b34f1c08..0ba42f39 100644
--- a/standard-ml.html.markdown
+++ b/standard-ml.html.markdown
@@ -272,6 +272,9 @@ fun evenly_positioned_elems (odd::even::xs) = even::evenly_positioned_elems xs
 datatype temp =
       C of real
     | F of real
+    
+(*  Declaring a new C temp value...
+    val t: temp = C 45.0  *)
 
 fun temp_to_f t =
     case t of
diff --git a/stylus.html.markdown b/stylus.html.markdown
new file mode 100644
index 00000000..1c5ddd32
--- /dev/null
+++ b/stylus.html.markdown
@@ -0,0 +1,228 @@
+---
+language: stylus
+filename: learnStylus.styl
+contributors:
+  - ["Salomão Neto", "https://github.com/salomaosnff"]
+  - ["Isaac Henrique", "https://github.com/Isaachi1"]
+translators:
+  - ["Divay Prakash", "https://github.com/divayprakash"]
+---
+
+Stylus is a dynamic stylesheet preprocessor language that is compiled into CSS. It aims to add functionality to CSS without breaking compatibility across web browsers.
+It does this using variables, nesting, mixins, functions and more.
+
+Stylus syntax is very flexible. You can use standard CSS syntax and leave the semicolon (;), colon (:) and even the ({) and (}) optional, making your code even more readable.
+
+Stylus does not provide new style options, but gives functionality that lets you make your CSS much more dynamic.
+
+```scss
+
+/* Code style
+==============================*/
+
+/* Keys, semicolon, and colon are optional in Stylus. */
+
+body {
+  background: #000;
+}
+
+body {
+  background: #000
+}
+
+body {
+  background #000
+}
+
+body
+  background #000
+
+body
+  background: #000;
+
+body
+  background: #000
+
+// Single-line comments are removed when Stylus is compiled into CSS.
+
+/* Multi-line comments are preserved. */
+
+
+/* Selectors
+==============================*/
+
+/* Selecting elements within another element */
+body {
+  background: #000000;
+  h1 {
+    color: #FF0000;
+  }
+}
+
+/* Or if you prefer... */
+body
+  background #000000
+  h1
+    color #FF0000
+
+
+/* Getting parent element reference
+==============================*/
+a {
+  color: #0088dd;
+  &:hover {
+    color: #DD8800;
+  }
+}
+
+
+/* Variables
+==============================*/
+
+
+/*
+  You can store a CSS value (such as the color) of a variable.
+  Although it is optional, it is recommended to add $ before a variable name
+  so you can distinguish a variable from another CSS value.
+*/
+
+$primary-color = #A3A4FF
+$secondary-color = #51527F
+$body-font = 'Roboto', sans-serif
+
+/* You can use variables throughout your style sheet.
+Now, if you want to change the color, you only have to make the change once. */
+
+body
+	background-color $primary-color
+	color $secondary-color
+	font-family $body-font
+
+/* After compilation: */
+body {
+	background-color: #A3A4FF;
+	color: #51527F;
+	font-family: 'Roboto', sans-serif;
+}
+
+/ *
+This is much easier to maintain than having to change color
+each time it appears throughout your style sheet.
+* /
+
+
+/* Mixins
+==============================*/
+
+/* If you find that you are writing the same code for more than one
+element, you may want to store that code in a mixin.
+
+center()
+  display block
+	margin-left auto
+	margin-right auto
+	left 0
+	right 0
+
+/* Using the mixin */
+body {
+  center()
+  background-color: $primary-color
+}
+
+/* After compilation: */
+div {
+	display: block;
+	margin-left: auto;
+	margin-right: auto;
+	left: 0;
+	right: 0;
+	background-color: #A3A4FF;
+}
+
+/* You can use mixins to create a shorthand property. */
+
+size($width, $height)
+  width $width
+  height $height
+
+.rectangle
+  size(100px, 60px)
+
+.square
+	size(40px, 40px)
+
+/* You can use a mixin as a CSS property. */
+circle($ratio)
+  width $ratio * 2
+  height $ratio * 2
+  border-radius $ratio
+
+.ball
+  circle 25px
+
+
+/* Interpolation
+==============================*/
+
+vendor(prop, args)
+  -webkit-{prop} args
+  -moz-{prop} args
+  {prop} args
+
+border-radius()
+  vendor('border-radius', arguments)
+
+box-shadow()
+  vendor('box-shadow', arguments)
+
+button
+  border-radius 1px 2px / 3px 4px
+
+
+/* Functions
+==============================*/
+
+/* Functions in Stylus allow you to perform a variety of tasks, such as recalling some data. */
+
+body {
+  background darken(#0088DD, 50%) // Dim color #0088DD by 50%
+}
+
+/* Creating your own function */
+add(a, b)
+  a + b
+
+body
+  padding add(10px, 5)
+
+
+/* Conditions
+==============================*/
+compare(a, b)
+  if a > b
+    bigger
+  else if a < b
+    smaller
+  else
+    equal
+
+compare(5, 2)   // => bigger
+compare(1, 5)   // => smaller
+compare(10, 10) // => equal
+
+
+/* Iterations
+==============================*/
+
+/*
+Repeat loop syntax for:
+for <val-name> [, <key-name>] in <expression>
+*/
+
+for $item in (1..2) /* Repeat block 12 times */
+  .col-{$item}
+    width ($item / 12) * 100% /* Calculate row by column number */
+```
+
+Now that you know a little about this powerful CSS preprocessor, you're ready to create more dynamic style sheets. To learn more, visit the official stylus documentation at http://stylus-lang.com.
diff --git a/swift.html.markdown b/swift.html.markdown
index 516debed..1f9fe897 100644
--- a/swift.html.markdown
+++ b/swift.html.markdown
@@ -8,22 +8,26 @@ contributors:
   - ["Clayton Walker", "https://github.com/cwalk"]
   - ["Fernando Valverde", "http://visualcosita.xyz"]
   - ["Alexey Nazaroff", "https://github.com/rogaven"]
+  - ["@Samasaur1", "https://github.com/Samasaur1"]
 filename: learnswift.swift
 ---
 
 Swift is a programming language for iOS and OS X development created by Apple. Designed to coexist with Objective-C and to be more resilient against erroneous code, Swift was introduced in 2014 at Apple's developer conference WWDC. It is built with the LLVM compiler included in Xcode 6+.
 
-The official [Swift Programming Language](https://itunes.apple.com/us/book/swift-programming-language/id881256329) book from Apple is now available via iBooks.
+The official _[Swift Programming Language](https://itunes.apple.com/us/book/swift-programming-language/id881256329)_ book from Apple is now available via iBooks. It goes into much more detail than this guide, and if you have the time and patience to read it, it's recommended. Some of these examples are from that book.
 
-See also Apple's [getting started guide](https://developer.apple.com/library/prerelease/ios/referencelibrary/GettingStarted/DevelopiOSAppsSwift/), which has a complete tutorial on Swift.
+Another great reference is _About Swift_ on Swift's [website](https://docs.swift.org/swift-book/).
 
 ```swift
 // import a module
-import UIKit
+import Foundation
 
-//
-// MARK: Basics
-//
+// Single-line comments are prefixed with //
+// Multi-line comments start with /* and end with */
+/* Nested multiline comments
+ /* ARE */
+ allowed
+ */
 
 // Xcode supports landmarks to annotate your code and lists them in the jump bar
 // MARK: Section mark
@@ -31,220 +35,383 @@ import UIKit
 // TODO: Do something soon
 // FIXME: Fix this code
 
-// In Swift 2, println and print were combined into one print method. Print automatically appends a new line.
-print("Hello, world") // println is now print
-print("Hello, world", terminator: "") // printing without appending a newline
+//MARK: Hello, World
+// From Swift 3 on, to print, just use the `print` method.
+// It automatically appends a new line.
+print("Hello, world")
+
+//
+// MARK: - Variables
+//
+
+
+//Use `let` to declare a constant and `var` to declare a variable.
+let theAnswer = 42
+var theQuestion = "What is the Answer?"
+theQuestion = "How many roads must a man walk down?"
+theQuestion = "What is six by nine?"
+// Atttempting to reassign a constant throws a compile-time error
+//theAnswer = 54
+
+// Both variables and constants can be declared before they are given a value,
+//   but must be given a value before they are used
+let someConstant: Int
+var someVariable: String
+// These lines will throw errors:
+//print(someConstant)
+//print(someVariable)
+someConstant = 0
+someVariable = "0"
+// These lines are now valid:
+print(someConstant)
+print(someVariable)
+
+// As you can see above, variable types are automatically inferred.
+//   To explicitly declare the type, write it after the variable name,
+//   separated by a colon.
+let aString: String = "A string"
+let aDouble: Double = 0
+
+// Values are never implicitly converted to another type.
+// Explicitly make instances of the desired type.
+let stringWithDouble = aString + String(aDouble)
+let intFromDouble = Int(aDouble)
+
+// For strings, use string interpolation
+let descriptionString = "The value of aDouble is \(aDouble)"
+// You can put any expression inside string interpolation.
+let equation = "Six by nine is \(6 * 9), not 42!"
+// To avoid escaping double quotes and backslashes, change the string delimiter
+let explanationString = #"The string I used was "The value of aDouble is \(aDouble)" and the result was \#(descriptionString)"#
+// You can put as many number signs as you want before the opening quote,
+//   just match them at the ending quote. They also change the escape character
+//   to a backslash followed by the same number of number signs.
+
+let multiLineString = """
+    This is a multi-line string.
+    It's called that because it takes up multiple lines (wow!)
+        Any indentation beyond the closing quotation marks is kept, the rest is discarded.
+    You can include " or "" in multi-line strings because the delimiter is three "s.
+    """
+
+// Arrays
+let shoppingList = ["catfish", "water", "tulips",] //commas are allowed after the last element
+let secondElement = shoppingList[1] // Arrays are 0-indexed
+
+// Arrays declared with let are immutable; the following line throws a compile-time error
+//shoppingList[2] = "mango"
+
+// Arrays are structs (more on that later), so this creates a copy instead of referencing the same object
+var mutableShoppingList = shoppingList
+mutableShoppingList[2] = "mango"
+
+// == is equality
+shoppingList == mutableShoppingList // false
+
+// Dictionaries declared with let are also immutable
+var occupations = [
+    "Malcolm": "Captain",
+    "Kaylee": "Mechanic"
+]
+occupations["Jayne"] = "Public Relations"
+// Dictionaries are also structs, so this also creates a copy
+let immutableOccupations = occupations
+
+immutableOccupations == occupations // true
 
-// variables (var) value can change after being set
-// constants (let) value can NOT be changed after being set
+// Arrays and dictionaries both automatically grow as you add elements
+mutableShoppingList.append("blue paint")
+occupations["Tim"] = "CEO"
 
-var myVariable = 42
+// They can both be set to empty
+mutableShoppingList = []
+occupations = [:]
+
+let emptyArray = [String]()
+let emptyArray2 = Array<String>() // same as above
+// [T] is shorthand for Array<T>
+let emptyArray3: [String] = [] // Declaring the type explicitly allows you to set it to an empty array
+let emptyArray4: Array<String> = [] // same as above
+
+// [Key: Value] is shorthand for Dictionary<Key, Value>
+let emptyDictionary = [String: Double]()
+let emptyDictionary2 = Dictionary<String, Double>() // same as above
+var emptyMutableDictionary: [String: Double] = [:]
+var explicitEmptyMutableDictionary: Dictionary<String, Double> = [:] // same as above
+
+// MARK: Other variables
 let øπΩ = "value" // unicode variable names
-let π = 3.1415926
-let convenience = "keyword" // contextual variable name
-let weak = "keyword"; let override = "another keyword" // statements can be separated by a semi-colon
-let `class` = "keyword" // backticks allow keywords to be used as variable names
-let explicitDouble: Double = 70
-let intValue = 0007 // 7
-let largeIntValue = 77_000 // 77000
-let label = "some text " + String(myVariable) // String construction
-let piText = "Pi = \(π), Pi 2 = \(π * 2)" // String interpolation
-
-// Build Specific values
-// uses -D build configuration
-#if false
-    print("Not printed")
-    let buildValue = 3
-#else
-    let buildValue = 7
-#endif
-print("Build value: \(buildValue)") // Build value: 7
+let 🤯 = "wow" // emoji variable names
+
+// Keywords can be used as variable names
+// These are contextual keywords that wouldn't be used now, so are allowed
+let convenience = "keyword"
+let weak = "another keyword"
+let override = "another keyword"
+
+// Using backticks allows keywords to be used as variable names even if they wouldn't be allowed normally
+let `class` = "keyword"
+
+// MARK: - Optionals
 
 /*
-Optionals are a Swift language feature that either contains a value,
-or contains nil (no value) to indicate that a value is missing.
-A question mark (?) after the type marks the value as optional.
+ Optionals are a Swift language feature that either contains a value,
+ or contains nil (no value) to indicate that a value is missing.
+ Nil is roughly equivalent to `null` in other languages.
+ A question mark (?) after the type marks the value as optional of that type.
+
+ If a type is not optional, it is guaranteed to have a value.
 
-Because Swift requires every property to have a value, even nil must be
-explicitly stored as an Optional value.
+ Because Swift requires every property to have a type, even nil must be
+ explicitly stored as an Optional value.
+
+ Optional<T> is an enum, with the cases .none (nil) and .some(T) (the value)
+ */
 
-Optional<T> is an enum.
-*/
 var someOptionalString: String? = "optional" // Can be nil
-// same as above, but ? is a postfix operator (syntax candy)
-var someOptionalString2: Optional<String> = "optional"
+// T? is shorthand for Optional<T> — ? is a postfix operator (syntax candy)
+let someOptionalString2: Optional<String> = nil
+let someOptionalString3 = String?.some("optional") // same as the first one
+let someOptionalString4 = String?.none //nil
+
+/*
+ To access the value of an optional that has a value, use the postfix
+ operator !, which force-unwraps it. Force-unwrapping is like saying, "I
+ know that this optional definitely has a value, please give it to me."
+
+ Trying to use ! to access a non-existent optional value triggers a
+ runtime error. Always make sure that an optional contains a non-nil
+ value before using ! to force-unwrap its value.
+ */
 
 if someOptionalString != nil {
     // I am not nil
     if someOptionalString!.hasPrefix("opt") {
         print("has the prefix")
     }
-
-    let empty = someOptionalString?.isEmpty
 }
-someOptionalString = nil
 
-/*
-Trying to use ! to access a non-existent optional value triggers a runtime
-error. Always make sure that an optional contains a non-nil value before
-using ! to force-unwrap its value.
-*/
-
-// implicitly unwrapped optional
-var unwrappedString: String! = "Value is expected."
-// same as above, but ! is a postfix operator (more syntax candy)
-var unwrappedString2: ImplicitlyUnwrappedOptional<String> = "Value is expected."
-
-// If let structure -
-// If let is a special structure in Swift that allows you to check if an Optional rhs holds a value, and in case it does - unwraps and assigns it to the lhs.
-if let someOptionalStringConstant = someOptionalString {
+// Swift supports "optional chaining," which means that you can call functions
+//   or get properties of optional values and they are optionals of the appropriate type.
+// You can even do this multiple times, hence the name "chaining."
+
+let empty = someOptionalString?.isEmpty // Bool?
+
+// if-let structure -
+// if-let is a special structure in Swift that allows you to check
+//   if an Optional rhs holds a value, and if it does unwrap
+//   and assign it to the lhs.
+if let someNonOptionalStringConstant = someOptionalString {
     // has `Some` value, non-nil
-    if !someOptionalStringConstant.hasPrefix("ok") {
+    // someOptionalStringConstant is of type String, not type String?
+    if !someNonOptionalStringConstant.hasPrefix("ok") {
         // does not have the prefix
     }
 }
 
-// The nil-coalescing operator ?? unwraps an optional if it contains a non-nil value, or returns a default value.
-var someOptionalString: String?
-let someString = someOptionalString ?? "abc"
-print(someString) // abc
+//if-var is allowed too!
+if var someNonOptionalString = someOptionalString {
+    someNonOptionalString = "Non optional AND mutable"
+    print(someNonOptionalString)
+}
 
-// Swift has support for storing a value of any type.
-// For that purposes there is two keywords: `Any` and `AnyObject`
-// `AnyObject` == `id` from Objective-C
-// `Any` – also works with any scalar values (Class, Int, struct, etc.)
-var anyVar: Any = 7
-anyVar = "Changed value to a string, not good practice, but possible."
-let anyObjectVar: AnyObject = Int(1) as NSNumber
+// You can bind multiple optional values in one if-let statement.
+//   If any of the bound values are nil, the if statement does not execute.
+if let first = someOptionalString, let second = someOptionalString2,
+    let third = someOptionalString3, let fourth = someOptionalString4 {
+    print("\(first), \(second), \(third), and \(fourth) are all not nil")
+}
 
-/*
-    Comment here
+//if-let supports "," (comma) clauses, which can be used to
+//   enforce conditions on newly-bound optional values.
+// Both the assignment and the "," clause must pass.
+let someNumber: Int? = 7
+if let num = someNumber, num > 3 {
+    print("num is not nil and is greater than 3")
+}
 
-    /*
-        Nested comments are also supported
-    */
-*/
+// Implicitly unwrapped optional — An optional value that doesn't need to be unwrapped
+let unwrappedString: String! = "Value is expected."
 
-//
-// MARK: Collections
-//
+// Here's the difference:
+let forcedString = someOptionalString! // requires an exclamation mark
+let implicitString = unwrappedString // doesn't require an exclamation mark
 
 /*
-Array and Dictionary types are structs. So `let` and `var` also indicate
-that they are mutable (var) or immutable (let) when declaring these types.
-*/
-
-// Array
-var shoppingList = ["catfish", "water", "lemons"]
-shoppingList[1] = "bottle of water"
-let emptyArray = [String]() // let == immutable
-let emptyArray2 = Array<String>() // same as above
-var emptyMutableArray = [String]() // var == mutable
-var explicitEmptyMutableStringArray: [String] = [] // same as above
-
+ You can think of an implicitly unwrapped optional as giving permission
+ for the optional to be unwrapped automatically whenever it's used.
+ Rather than placing an exclamation mark after the optional's name each time you use it,
+ you place an exclamation mark after the optional's type when you declare it.
+ */
 
-// Dictionary
-var occupations = [
-    "Malcolm": "Captain",
-    "kaylee": "Mechanic"
-]
-occupations["Jayne"] = "Public Relations"
-let emptyDictionary = [String: Float]() // let == immutable
-let emptyDictionary2 = Dictionary<String, Float>() // same as above
-var emptyMutableDictionary = [String: Float]() // var == mutable
-var explicitEmptyMutableDictionary: [String: Float] = [:] // same as above
+// Otherwise, you can treat an implicitly unwrapped optional the same way the you treat a normal optional
+//   (i.e., if-let, != nil, etc.)
 
+// Pre-Swift 5, T! was shorthand for ImplicitlyUnwrappedOptional<T>
+// Swift 5 and later, using ImplicitlyUnwrappedOptional throws a compile-time error.
+//var unwrappedString2: ImplicitlyUnwrappedOptional<String> = "Value is expected." //error
 
-//
-// MARK: Control Flow
-//
+// The nil-coalescing operator ?? unwraps an optional if it contains a non-nil value, or returns a default value.
+someOptionalString = nil
+let someString = someOptionalString ?? "abc"
+print(someString) // abc
+// a ?? b is shorthand for a != nil ? a! : b
 
-// Condition statements support "," (comma) clauses, which can be used
-// to help provide conditions on optional values.
-// Both the assignment and the "," clause must pass.
-let someNumber = Optional<Int>(7)
-if let num = someNumber, num > 3 {
-    print("num is greater than 3")
-}
+// MARK: - Control Flow
 
-// for loop (array)
-let myArray = [1, 1, 2, 3, 5]
-for value in myArray {
-    if value == 1 {
-        print("One!")
-    } else {
-        print("Not one!")
-    }
-}
+let condition = true
+if condition { print("condition is true") } // can't omit the braces
 
-// for loop (dictionary)
-var dict = ["one": 1, "two": 2]
-for (key, value) in dict {
-    print("\(key): \(value)")
+if theAnswer > 50 {
+    print("theAnswer > 50")
+} else if condition {
+    print("condition is true")
+} else {
+    print("Neither are true")
 }
 
-// for loop (range)
-for i in -1...shoppingList.count {
-    print(i)
-}
-shoppingList[1...2] = ["steak", "peacons"]
-// use ..< to exclude the last number
-
-// while loop
-var i = 1
-while i < 1000 {
-    i *= 2
-}
-
-// repeat-while loop
-repeat {
-    print("hello")
-} while 1 == 2
+// The condition in an `if` statement must be a `Bool`, so the following code is an error, not an implicit comparison to zero
+//if 5 {
+//    print("5 is not zero")
+//}
 
 // Switch
+// Must be exhaustive
+// Does not implicitly fall through, use the fallthrough keyword
 // Very powerful, think `if` statements with syntax candy
 // They support String, object instances, and primitives (Int, Double, etc)
 let vegetable = "red pepper"
+let vegetableComment: String
 switch vegetable {
 case "celery":
-    let vegetableComment = "Add some raisins and make ants on a log."
-case "cucumber", "watercress":
-    let vegetableComment = "That would make a good tea sandwich."
+    vegetableComment = "Add some raisins and make ants on a log."
+case "cucumber", "watercress": // match multiple values
+    vegetableComment = "That would make a good tea sandwich."
 case let localScopeValue where localScopeValue.hasSuffix("pepper"):
-    let vegetableComment = "Is it a spicy \(localScopeValue)?"
+    vegetableComment = "Is it a spicy \(localScopeValue)?"
 default: // required (in order to cover all possible input)
-    let vegetableComment = "Everything tastes good in soup."
+    vegetableComment = "Everything tastes good in soup."
+}
+print(vegetableComment)
+
+// You use the `for-in` loop to iterate over a sequence, such as an array, dictionary, range, etc.
+for element in shoppingList {
+    print(element) // shoppingList is of type `[String]`, so element is of type `String`
+}
+//Iterating through a dictionary does not guarantee any specific order
+for (person, job) in immutableOccupations {
+    print("\(person)'s job is \(job)")
+}
+for i in 1...5 {
+    print(i, terminator: " ") // Prints "1 2 3 4 5"
+}
+for i in 0..<5 {
+    print(i, terminator: " ") // Prints "0 1 2 3 4"
+}
+//for index in range can replace a C-style for loop:
+//    for (int i = 0; i < 10; i++) {
+//        //code
+//    }
+//becomes:
+//    for i in 0..<10 {
+//        //code
+//    }
+//To step by more than one, use the stride(from:to:by:) or stride(from:through:by) functions
+//`for i in stride(from: 0, to: 10, by: 2)` is the same as `for (int i = 0; i < 10; i += 2)`
+//`for i in stride(from: 0, through: 10, by: 2)` is the same as `for (int i = 0; i <= 10; i += 2)
+
+// while loops are just like most languages
+var i = 0
+while i < 5 {
+    i += Bool.random() ? 1 : 0
+    print(i)
 }
 
-//
-// MARK: Functions
-//
+// This is like a do-while loop in other languages — the body of the loop executes a minimum of once
+repeat {
+    i -= 1
+    i += Int.random(in: 0...3)
+} while i < 5
 
-// Functions are a first-class type, meaning they can be nested
-// in functions and can be passed around
+// The continue statement continues executing a loop at the next iteration
+// The break statement ends a swift or loop immediately
 
-// Function with Swift header docs (format as Swift-modified Markdown syntax)
+// MARK: - Functions
 
-/**
-A greet operation
+// Functions are a first-class type, meaning they can be nested in functions and can be passed around.
 
-- A bullet in docs
-- Another bullet in the docs
+// Function with Swift header docs (format as Swift-modified Markdown syntax)
 
-- Parameter name	: A name
-- Parameter day	: A day
-- Returns : A string containing the name and day value.
-*/
+/// A greet operation.
+///
+/// - Parameters:
+///   - name: A name.
+///   - day: A day.
+/// - Returns: A string containing the name and day value.
 func greet(name: String, day: String) -> String {
     return "Hello \(name), today is \(day)."
 }
 greet(name: "Bob", day: "Tuesday")
 
-// similar to above except for the function parameter behaviors
-func greet2(name: String, externalParamName localParamName: String) -> String {
-    return "Hello \(name), the day is \(localParamName)"
+// Ideally, function names and parameter labels combine to make function calls similar to sentences.
+func sayHello(to name: String, onDay day: String) -> String {
+    return "Hello \(name), the day is \(day)"
+}
+sayHello(to: "John", onDay: "Sunday")
+
+//Functions that don't return anything can omit the return arrow; they don't need to say that they return Void (although they can).
+func helloWorld() {
+    print("Hello, World!")
+}
+
+// Argument labels can be blank
+func say(_ message: String) {
+    print(#"I say "\#(message)""#)
+}
+say("Hello")
+
+// Default parameters can be omitted when calling the function.
+func printParameters(requiredParameter r: Int, optionalParameter o: Int = 10) {
+    print("The required parameter was \(r) and the optional parameter was \(o)")
+}
+printParameters(requiredParameter: 3)
+printParameters(requiredParameter: 3, optionalParameter: 6)
+
+// Variadic args — only one set per function.
+func setup(numbers: Int...) {
+    // it's an array
+    let _ = numbers[0]
+    let _ = numbers.count
+}
+
+// pass by ref
+func swapTwoInts(a: inout Int, b: inout Int) {
+    let tempA = a
+    a = b
+    b = tempA
+}
+var someIntA = 7
+var someIntB = 3
+swapTwoInts(a: &someIntA, b: &someIntB) //must be called with an & before the variable name.
+print(someIntB) // 7
+
+type(of: greet) // (String, String) -> String
+type(of: helloWorld) // () -> Void
+
+// Passing and returning functions
+func makeIncrementer() -> ((Int) -> Int) {
+    func addOne(number: Int) -> Int {
+        return 1 + number
+    }
+    return addOne
+}
+var increment = makeIncrementer()
+increment(7)
+
+func performFunction(_ function: (String, String) -> String, on string1: String, and string2: String) {
+    let result = function(string1, string2)
+    print("The result of calling the function on \(string1) and \(string2) was \(result)")
 }
-greet2(name: "John", externalParamName: "Sunday")
 
 // Function that returns multiple items in a tuple
 func getGasPrices() -> (Double, Double, Double) {
@@ -271,46 +438,24 @@ print("Highest gas price: \(pricesTuple2.highestPrice)")
 func testGuard() {
     // guards provide early exits or breaks, placing the error handler code near the conditions.
     // it places variables it declares in the same scope as the guard statement.
+    // They make it easier to avoid the "pyramid of doom"
     guard let aNumber = Optional<Int>(7) else {
-        return
+        return // guard statements MUST exit the scope that they are in.
+        // They generally use `return` or `throw`.
     }
 
     print("number is \(aNumber)")
 }
 testGuard()
 
-// Variadic Args
-func setup(numbers: Int...) {
-    // it's an array
-    let _ = numbers[0]
-    let _ = numbers.count
-}
+// Note that the print function is declared like so:
+//     func print(_ input: Any..., separator: String = " ", terminator: String = "\n")
+// To print without a newline:
+print("No newline", terminator: "")
+print("!")
 
-// Passing and returning functions
-func makeIncrementer() -> ((Int) -> Int) {
-    func addOne(number: Int) -> Int {
-        return 1 + number
-    }
-    return addOne
-}
-var increment = makeIncrementer()
-increment(7)
+// MARK: - Closures
 
-// pass by ref
-func swapTwoInts(a: inout Int, b: inout Int) {
-    let tempA = a
-    a = b
-    b = tempA
-}
-var someIntA = 7
-var someIntB = 3
-swapTwoInts(a: &someIntA, b: &someIntB)
-print(someIntB) // 7
-
-
-//
-// MARK: Closures
-//
 var numbers = [1, 2, 6]
 
 // Functions are special case closures ({})
@@ -336,85 +481,157 @@ numbers = numbers.sorted { $0 > $1 }
 
 print(numbers) // [18, 6, 3]
 
-//
-// MARK: Structures
-//
+// MARK: - Enums
 
-// Structures and classes have very similar capabilities
-struct NamesTable {
-    let names: [String]
+// Enums can optionally be of a specific type or on their own.
+// They can contain methods like classes.
 
-    // Custom subscript
-    subscript(index: Int) -> String {
-        return names[index]
+enum Suit {
+    case spades, hearts, diamonds, clubs
+    var icon: Character {
+        switch self {
+        case .spades:
+            return "♤"
+        case .hearts:
+            return "♡"
+        case .diamonds:
+            return "♢"
+        case .clubs:
+            return "♧"
+        }
     }
 }
 
-// Structures have an auto-generated (implicit) designated initializer
-let namesTable = NamesTable(names: ["Me", "Them"])
-let name = namesTable[1]
-print("Name is \(name)") // Name is Them
-
-//
-// MARK: Error Handling
-//
+// Enum values allow short hand syntax, no need to type the enum type
+// when the variable is explicitly declared
+var suitValue: Suit = .hearts
 
-// The `Error` protocol is used when throwing errors to catch
-enum MyError: Error {
-    case badValue(msg: String)
-    case reallyBadValue(msg: String)
+// Conforming to the CaseIterable protocol automatically synthesizes the allCases property,
+//   which contains all the values. It works on enums without associated values or @available attributes.
+enum Rank: CaseIterable {
+    case ace
+    case two, three, four, five, six, seven, eight, nine, ten
+    case jack, queen, king
+    var icon: String {
+        switch self {
+        case .ace:
+            return "A"
+        case .two:
+            return "2"
+        case .three:
+            return "3"
+        case .four:
+            return "4"
+        case .five:
+            return "5"
+        case .six:
+            return "6"
+        case .seven:
+            return "7"
+        case .eight:
+            return "8"
+        case .nine:
+            return "9"
+        case .ten:
+            return "10"
+        case .jack:
+            return "J"
+        case .queen:
+            return "Q"
+        case .king:
+            return "K"
+        }
+    }
 }
 
-// functions marked with `throws` must be called using `try`
-func fakeFetch(value: Int) throws -> String {
-    guard 7 == value else {
-        throw MyError.reallyBadValue(msg: "Some really bad value")
+for suit in [Suit.clubs, .diamonds, .hearts, .spades] {
+    for rank in Rank.allCases {
+        print("\(rank.icon)\(suit.icon)")
     }
+}
 
-    return "test"
+// String enums can have direct raw value assignments
+// or their raw values will be derived from the Enum field
+enum BookName: String {
+    case john
+    case luke = "Luke"
 }
+print("Name: \(BookName.john.rawValue)")
 
-func testTryStuff() {
-    // assumes there will be no error thrown, otherwise a runtime exception is raised
-    let _ = try! fakeFetch(value: 7)
+// Enum with associated Values
+enum Furniture {
+    // Associate with Int
+    case desk(height: Int)
+    // Associate with String and Int
+    case chair(String, Int)
 
-    // if an error is thrown, then it proceeds, but if the value is nil
-    // it also wraps every return value in an optional, even if its already optional
-    let _ = try? fakeFetch(value: 7)
+    func description() -> String {
+        //either placement of let is acceptable
+        switch self {
+        case .desk(let height):
+            return "Desk with \(height) cm"
+        case let .chair(brand, height):
+            return "Chair of \(brand) with \(height) cm"
+        }
+    }
+}
 
-    do {
-        // normal try operation that provides error handling via `catch` block
-        try fakeFetch(value: 1)
-    } catch MyError.badValue(let msg) {
-        print("Error message: \(msg)")
-    } catch {
-        // must be exhaustive
+var desk: Furniture = .desk(height: 80)
+print(desk.description())     // "Desk with 80 cm"
+var chair = Furniture.chair("Foo", 40)
+print(chair.description())    // "Chair of Foo with 40 cm"
+
+// MARK: - Structures & Classes
+
+/*
+ Structures and classes in Swift have many things in common. Both can:
+ - Define properties to store values
+ - Define methods to provide functionality
+ - Define subscripts to provide access to their values using subscript syntax
+ - Define initializers to set up their initial state
+ - Be extended to expand their functionality beyond a default implementation
+ - Conform to protocols to provide standard functionality of a certain kind
+
+ Classes have additional capabilities that structures don't have:
+ - Inheritance enables one class to inherit the characteristics of another.
+ - Type casting enables you to check and interpret the type of a class instance at runtime.
+ - Deinitializers enable an instance of a class to free up any resources it has assigned.
+ - Reference counting allows more than one reference to a class instance.
+
+ Unless you need to use a class for one of these reasons, use a struct.
+
+ Structures are value types, while classes are reference types.
+ */
+
+// MARK: Structures
+
+struct NamesTable {
+    let names: [String]
+
+    // Custom subscript
+    subscript(index: Int) -> String {
+        return names[index]
     }
 }
-testTryStuff()
 
-//
-// MARK: Classes
-//
+// Structures have an auto-generated (implicit) designated "memberwise" initializer
+let namesTable = NamesTable(names: ["Me", "Them"])
+let name = namesTable[1]
+print("Name is \(name)") // Name is Them
 
-// Classes, structures and its members have three levels of access control
-// They are: internal (default), public, private
+// MARK: Classes
 
-public class Shape {
-    public func getArea() -> Int {
+class Shape {
+    func getArea() -> Int {
         return 0
     }
 }
 
-// All methods and properties of a class are public.
-// If you just need to store data in a
-// structured object, you should use a `struct`
-
-internal class Rect: Shape {
+class Rect: Shape {
     var sideLength: Int = 1
 
     // Custom getter and setter property
-    private var perimeter: Int {
+    var perimeter: Int {
         get {
             return 4 * sideLength
         }
@@ -509,104 +726,143 @@ if let circle = myEmptyCircle {
     print("circle is not nil")
 }
 
+// MARK: - Protocols
 
-//
-// MARK: Enums
-//
+// protocols are also known as interfaces in some other languages
 
-// Enums can optionally be of a specific type or on their own.
-// They can contain methods like classes.
+// `protocol`s can require that conforming types have specific
+// instance properties, instance methods, type methods,
+// operators, and subscripts.
 
-enum Suit {
-    case spades, hearts, diamonds, clubs
-    func getIcon() -> String {
-        switch self {
-        case .spades: return "♤"
-        case .hearts: return "♡"
-        case .diamonds: return "♢"
-        case .clubs: return "♧"
-        }
-    }
+protocol ShapeGenerator {
+    var enabled: Bool { get set }
+    func buildShape() -> Shape
 }
 
-// Enum values allow short hand syntax, no need to type the enum type
-// when the variable is explicitly declared
-var suitValue: Suit = .hearts
+// MARK: - Other
 
-// String enums can have direct raw value assignments
-// or their raw values will be derived from the Enum field
-enum BookName: String {
-    case john
-    case luke = "Luke"
-}
-print("Name: \(BookName.john.rawValue)")
+// MARK: Typealiases
 
-// Enum with associated Values
-enum Furniture {
-    // Associate with Int
-    case desk(height: Int)
-    // Associate with String and Int
-    case chair(String, Int)
+// Typealiases allow one type (or composition of types) to be referred to by another name
+typealias Integer = Int
+let myInteger: Integer = 0
 
-    func description() -> String {
-        switch self {
-        case .desk(let height):
-            return "Desk with \(height) cm"
-        case .chair(let brand, let height):
-            return "Chair of \(brand) with \(height) cm"
-        }
-    }
-}
+// MARK: = Operator
 
-var desk: Furniture = .desk(height: 80)
-print(desk.description())     // "Desk with 80 cm"
-var chair = Furniture.chair("Foo", 40)
-print(chair.description())    // "Chair of Foo with 40 cm"
+// Assignment does not return a value. This means it can't be used in conditional statements,
+//   and the following statement is also illegal
+//    let multipleAssignment = theQuestion = "No questions asked"
+//But you can do this:
+let multipleAssignment = "No questions asked", secondConstant = "No answers given"
 
+// MARK: Ranges
 
-//
-// MARK: Protocols
-//
+// The ..< and ... operators create ranges.
 
-// `protocol`s can require that conforming types have specific
-// instance properties, instance methods, type methods,
-// operators, and subscripts.
+// ... is inclusive on both ends (a "closed range") — mathematically, [0, 10]
+let _0to10 = 0...10
+// ..< is inclusive on the left, exclusive on the right (a "range") — mathematically, [0, 10)
+let singleDigitNumbers = 0..<10
+// You can omit one end (a "PartialRangeFrom") — mathematically, [0, ∞)
+let toInfinityAndBeyond = 0...
+// Or the other end (a "PartialRangeTo") — mathematically, (-∞, 0)
+let negativeInfinityToZero = ..<0
+// (a "PartialRangeThrough") — mathematically, (-∞, 0]
+let negativeInfinityThroughZero = ...0
 
-protocol ShapeGenerator {
-    var enabled: Bool { get set }
-    func buildShape() -> Shape
+// MARK: Wildcard operator
+
+// In Swift, _ (underscore) is the wildcard operator, which allows values to be ignored
+
+// It allows functions to be declared without argument labels:
+func function(_ labelLessParameter: Int, label labeledParameter: Int, labelAndParameterName: Int) {
+    print(labelLessParameter, labeledParameter, labelAndParameterName)
 }
+function(0, label: 0, labelAndParameterName: 0)
 
-// Protocols declared with @objc allow optional functions,
-// which allow you to check for conformance. These functions must be
-// marked with @objc also.
-@objc protocol TransformShape {
-    @objc optional func reshape()
-    @objc optional func canReshape() -> Bool
+// You can ignore the return values of functions
+func printAndReturn(_ str: String) -> String {
+    print(str)
+    return str
 }
+let _ = printAndReturn("Some String")
 
-class MyShape: Rect {
-    var delegate: TransformShape?
+// You can ignore part of a tuple and keep part of it
+func returnsTuple() -> (Int, Int) {
+    return (1, 2)
+}
+let (_, two) = returnsTuple()
 
-    func grow() {
-        sideLength += 2
+// You can ignore closure parameters
+let closure: (Int, Int) -> String = { someInt, _ in
+    return "\(someInt)"
+}
+closure(1, 2) // returns 1
 
-        // Place a question mark after an optional property, method, or
-        // subscript to gracefully ignore a nil value and return nil
-        // instead of throwing a runtime error ("optional chaining").
-        if let reshape = self.delegate?.canReshape?(), reshape {
-            // test for delegate then for method
-            self.delegate?.reshape?()
-        }
-    }
+// You can ignore the value in a for loop
+for _ in 0..<10 {
+    // Code to execute 10 times
 }
 
+// MARK: Access Control
 
-//
-// MARK: Other
-//
+/*
+ Swift has five levels of access control:
+ - Open: Accessible *and subclassible* in any module that imports it.
+ - Public: Accessible in any module that imports it, subclassible in the module it is declared in.
+ - Internal: Accessible and subclassible in the module it is declared in.
+ - Fileprivate: Accessible and subclassible in the file it is declared in.
+ - Private: Accessible and subclassible in the enclosing declaration (think inner classes/structs/enums)
+
+ See more here: https://docs.swift.org/swift-book/LanguageGuide/AccessControl.html
+ */
+
+// MARK: Conditional Compilation, Compile-Time Diagnostics, & Availability Conditions
+
+// Conditional Compilation
+#if false
+print("This code will not be compiled")
+#else
+print("This code will be compiled")
+#endif
+/*
+ Options are:
+ os()                   macOS, iOS, watchOS, tvOS, Linux
+ arch()                 i386, x86_64, arm, arm64
+ swift()                >= or < followed by a version number
+ compiler()             >= or < followed by a version number
+ canImport()            A module name
+ targetEnvironment()    simulator
+ */
+#if swift(<3)
+println()
+#endif
+
+// Compile-Time Diagnostics
+// You can use #warning(message) and #error(message) to have the compiler emit warnings and/or errors
+#warning("This will be a compile-time warning")
+//  #error("This would be a compile-time error")
+
+//Availability Conditions
+if #available(iOSMac 10.15, *) {
+    // macOS 10.15 is available, you can use it here
+} else {
+    // macOS 10.15 is not available, use alternate APIs
+}
+
+// MARK: Any and AnyObject
+
+// Swift has support for storing a value of any type.
+// For that purpose there are two keywords: `Any` and `AnyObject`
+// `AnyObject` == `id` from Objective-C
+// `Any` works with any values (class, Int, struct, etc.)
+var anyVar: Any = 7
+anyVar = "Changed value to a string, not good practice, but possible."
+let anyObjectVar: AnyObject = Int(1) as NSNumber
 
-// `extension`s: Add extra functionality to an already existing type
+// MARK: Extensions
+
+// Extensions allow you to add extra functionality to an already-declared type, even one that you don't have the source code for.
 
 // Square now "conforms" to the `CustomStringConvertible` protocol
 extension Square: CustomStringConvertible {
@@ -619,17 +875,23 @@ print("Square: \(mySquare)")
 
 // You can also extend built-in types
 extension Int {
-    var customProperty: String {
-        return "This is \(self)"
+    var doubled: Int {
+        return self * 2
     }
 
-    func multiplyBy(num: Int) -> Int {
+    func multipliedBy(num: Int) -> Int {
         return num * self
     }
+
+    mutating func multiplyBy(num: Int) {
+        self *= num
+    }
 }
 
-print(7.customProperty) // "This is 7"
-print(14.multiplyBy(num: 3)) // 42
+print(7.doubled) // 14
+print(7.doubled.multipliedBy(num: 3)) // 42
+
+// MARK: Generics
 
 // Generics: Similar to Java and C#. Use the `where` keyword to specify the
 //   requirements of the generics.
@@ -642,10 +904,21 @@ func findIndex<T: Equatable>(array: [T], valueToFind: T) -> Int? {
     }
     return nil
 }
-let foundAtIndex = findIndex(array: [1, 2, 3, 4], valueToFind: 3)
-print(foundAtIndex == 2) // true
+findIndex(array: [1, 2, 3, 4], valueToFind: 3) // 2
+
+// You can extend types with generics as well
+extension Array where Array.Element == Int {
+    var sum: Int {
+        var total = 0
+        for el in self {
+            total += el
+        }
+        return total
+    }
+}
+
+// MARK: Operators
 
-// Operators:
 // Custom operators can start with the characters:
 //      / = - + * % < > ! & | ^ . ~
 // or
@@ -678,4 +951,40 @@ var bar: Float = 20
 
 foo <-> bar
 print("foo is \(foo), bar is \(bar)") // "foo is 20.0, bar is 10.0"
+
+// MARK: - Error Handling
+
+// The `Error` protocol is used when throwing errors to catch
+enum MyError: Error {
+    case badValue(msg: String)
+    case reallyBadValue(msg: String)
+}
+
+// functions marked with `throws` must be called using `try`
+func fakeFetch(value: Int) throws -> String {
+    guard 7 == value else {
+        throw MyError.reallyBadValue(msg: "Some really bad value")
+    }
+
+    return "test"
+}
+
+func testTryStuff() {
+    // assumes there will be no error thrown, otherwise a runtime exception is raised
+    let _ = try! fakeFetch(value: 7)
+
+    // if an error is thrown, then it proceeds, but if the value is nil
+    // it also wraps every return value in an optional, even if its already optional
+    let _ = try? fakeFetch(value: 7)
+
+    do {
+        // normal try operation that provides error handling via `catch` block
+        try fakeFetch(value: 1)
+    } catch MyError.badValue(let msg) {
+        print("Error message: \(msg)")
+    } catch {
+        // must be exhaustive
+    }
+}
+testTryStuff()
 ```
diff --git a/tcl.html.markdown b/tcl.html.markdown
index 40d9111a..3d23870b 100644
--- a/tcl.html.markdown
+++ b/tcl.html.markdown
@@ -5,7 +5,7 @@ contributors:
 filename: learntcl.tcl
 ---
 
-Tcl was created by [John Ousterhout](https://wiki.tcl.tk/John%20Ousterout) as a
+Tcl was created by [John Ousterhout](https://wiki.tcl-lang.org/page/John+Ousterhout) as a
 reusable scripting language for circuit design tools that he authored.  In 1997 he
 was awarded the [ACM Software System
 Award](https://en.wikipedia.org/wiki/ACM_Software_System_Award) for Tcl.   Tcl
@@ -283,7 +283,7 @@ set c [expr {$a + $b}]
 
 # Since "expr" performs variable substitution on its own, brace the expression
 # to prevent Tcl from performing variable substitution first.  See
-# "http://wiki.tcl.tk/Brace%20your%20#%20expr-essions" for details.
+# "https://wiki.tcl-lang.org/page/Brace+your+expr-essions" for details.
 
 
 # "expr" understands variable and script substitution:
@@ -328,6 +328,7 @@ proc greet {greeting name} {
 # the third argument to "proc", is a string.  The previous command
 # can be rewritten using no braces:
 proc greet greeting\ name return\ \"\$greeting,\ \$name!\"
+# "
 
 
 
@@ -580,8 +581,8 @@ a
 
 ## Reference
 
-[Official Tcl Documentation](http://www.tcl.tk/man/tcl/)
+[Official Tcl Documentation](https://www.tcl-lang.org)
 
-[Tcl Wiki](http://wiki.tcl.tk)
+[Tcl Wiki](https://wiki.tcl-lang.org)
 
 [Tcl Subreddit](http://www.reddit.com/r/Tcl)
diff --git a/tcsh.html.markdown b/tcsh.html.markdown
index 80411ea6..e38b7a27 100644
--- a/tcsh.html.markdown
+++ b/tcsh.html.markdown
@@ -1,5 +1,6 @@
 ---
-language: tcsh
+category: tool
+tool: tcsh
 filename: LearnTCSH.csh
 contributors:
        - ["Nicholas Christopoulos", "https://github.com/nereusx"]
diff --git a/textile.html.markdown b/textile.html.markdown
new file mode 100644
index 00000000..2b81674a
--- /dev/null
+++ b/textile.html.markdown
@@ -0,0 +1,505 @@
+---
+language: textile
+contributors:
+    - ["Keith Miyake", "https://github.com/kaymmm"]
+filename: learn-textile.textile
+---
+
+
+Textile is a lightweight markup language that uses a text formatting syntax to
+convert plain text into structured HTML markup. The syntax is a shorthand
+version of HTML that is designed to be easy to read and write. Textile is used
+for writing articles, forum posts, readme documentation, and any other type of
+written content published online.
+
+- [Comments](#comments)
+- [Paragraphs](#paragraphs)
+- [Headings](#headings)
+- [Simple Text Styles](#simple-text-styles)
+- [Lists](#lists)
+- [Code blocks](#code-blocks)
+- [Horizontal rule](#horizontal-rule)
+- [Links](#links)
+- [Images](#images)
+- [Footnotes and Endnotes](#footnotes-and-endnotes)
+- [Tables](#tables)
+- [Character Conversions](#character-conversions)
+- [CSS](#css)
+- [Spans and Divs](#spans-and-divs)
+- [Additional Info](#additional-info)
+
+## Comments
+
+```
+###. Comments begin with three (3) '#' signs followed by a full-stop period '.'.
+Comments can span multiple lines until a blank line is reached.
+
+###..
+Multi-line comments (including blank lines) are indicated by three (3) '#'
+signs followed by two (2) full-stop periods '..'.
+
+This line is also part of the above comment.
+
+The comment continues until the next block element is reached
+
+p. This line is not commented
+
+<!-- HTML comments are also…
+
+respected -->
+
+```
+
+## Paragraphs
+
+```
+###. Paragraphs are a one or multiple adjacent lines of text separated by one or
+multiple blank lines. They can also be indicated explicitly with a 'p. '
+
+This is a paragraph. I'm typing in a paragraph isn't this fun?
+
+Now I'm in paragraph 2.
+I'm still in paragraph 2 too!
+Line breaks without blank spaces are equivalent to a <br /> in XHTML.
+
+p. I'm an explicitly defined paragraph
+
+ Lines starting with a blank space are not wrapped in <p>..</p> tags.
+
+###. Paragraphs (and all block elements) can be aligned using shorthand:
+
+p<. Left aligned paragraph (default).
+
+p>. Right aligned paragraph.
+
+p=. Centered paragraph.
+
+p<>. Justified paragraph.
+
+h3>. Right aligned <h3>
+
+
+###. Paragraphs can be indented using a parentheses for each em
+Indentation utilizes padding-[left/right] css styles.
+
+p(. Left indent 1em.
+
+p((. Left indent 2em.
+
+p))). Right indent 3em.
+
+h2). This is equivalent to <h2 style="padding-right: 1em;">..</h2>
+
+
+###. Block quotes use the tag 'bq.'
+
+bq. This is a block quote.
+
+bq.:http://someurl.com You can include a citation URL immediately after the '.'
+
+bq.. Multi-line blockquotes containing
+
+blank lines are indicated using two periods
+
+p. Multi-line blockquotes continue until a new block element is reached.
+
+bq. You can add a footer to a blockquote using html:
+<footer>citation text</footer>
+
+
+###. Preformatted text blocks:
+
+pre. This text is preformatted.  <= those two spaces will carry through.
+
+pre.. This is a multi-line preformatted…
+
+…text block that includes blank lines
+
+p. End a multi-line preformatted text block with a new block element.
+
+```
+
+## Headings
+
+You can create HTML elements `<h1>` through `<h6>` easily by prepending the
+text you want to be in that element by 'h#.' where # is the level 1-6.
+A blank line is required after headings.
+
+
+```
+h1. This is an <h1>
+
+h2. This is an <h2>
+
+h3. This is an <h3>
+
+h4. This is an <h4>
+
+h5. This is an <h5>
+
+h6. This is an <h6>
+
+```
+
+
+## Simple text styles
+
+```
+###. Bold and strong text are indicated using asterisks:
+
+*This is strong text*
+**This is bold text**
+This is [*B*]old text within a word.
+
+*Strong* and **Bold** usually display the same in browsers
+but they use different HTML markup, thus the distinction.
+
+###. Italics and emphasized text are indicated using underscores.
+
+_This is Emphasized text_
+__This is Italics text__
+This is It[_al_]ics within a word.
+
+_Emphasized_ and __Italics__ text typically display the same in browsers,
+but again, they use different HTML markup and thus the distinction.
+
+###. Superscripts and Subscripts use carats and tildes:
+
+Superscripts are 2 ^nd^ to none, but subscripts are CO ~2~ L too.
+Note the spaces around the superscripts and subscripts.
+
+To avoid the spaces, add square brackets around them:
+2[^nd^] and CO[~2~]L
+
+###. Insertions and deletions are indicated using -/+ symbols:
+This is -deleted- text and this is +inserted+ text.
+
+###. Citations are indicated using double '?':
+
+??This is a cool citation??
+
+```
+
+## Lists
+
+```
+###. Unordered lists can be made using asterisks '*' to indicate levels:
+
+* Item
+** Sub-Item
+* Another item
+** Another sub-item
+** Yet another sub-item
+*** Three levels deep
+
+###. Ordered lists are done with a pound sign '#':
+
+# Item one
+# Item two
+## Item two-a
+## Item two-b
+# Item three
+** Mixed unordered list within ordered list
+
+###. Ordered lists can start above 1 and can continue after another block:
+
+#5 Item 5
+# Item 6
+
+additional paragraph
+
+#_ Item 7 continued from above
+# Item 8
+
+###. Definition lists are indicated with a dash and assignment:
+
+- First item := first item definition
+- Second := second def.
+- Multi-line :=
+Multi-line
+definition =:
+```
+
+## Code blocks
+
+```
+Code blocks use the 'bc.' shorthand:
+
+bc. This is code
+    So is this
+
+This is outside of the code block
+
+bc.. This is a multi-line code block
+
+Blank lines are included in the multi-line code block
+
+p. End a multi-line code block with any block element
+
+p. Indicate @inline code@ using the '@' symbol.
+
+```
+
+## Horizontal rule
+
+Horizontal rules (`<hr/>`) are easily added with two hyphens
+
+```
+--
+```
+
+## Links
+
+```
+###. Link text is in quotes, followed by a colon and the URL:
+
+"Link text":http://linkurl.com/ plain text.
+
+"Titles go in parentheses at the end of the link text"(mytitle):http://url.com
+###. produces <a href... title="mytitle">...</a>
+
+###. Use square brackets when the link text or URL might be ambiguous:
+["Textile on Wikipedia":http://en.wikipedia.org/wiki/Textile_(markup_language)]
+
+###. Named links are useful if the same URL is referenced multiple times.
+Multiple "references":txstyle to the "txstyle":txstyle website.
+
+[txstyle]https://txstyle.org/
+
+```
+
+## Images
+
+```
+###. Images can be included by surrounding its URL with exclamation marks (!)
+Alt text is included in parenthesis after the URL, and they can be linked too:
+
+!http://imageurl.com!
+
+!http://imageurl.com(image alt-text)!
+
+!http://imageurl.com(alt-text)!:http://image-link-url.com
+
+```
+
+## Footnotes and Endnotes
+
+```
+A footnote is indicated with the reference id in square brackets.[1]
+
+fn1. Footnote text with a "link":http://link.com.
+
+A footnote without a link.[2!]
+
+fn2. The corresponding unlinked footnote.
+
+A footnote with a backlink from the footnote back to the text.[3]
+
+fn3^. This footnote links back to the in-text citation.
+
+
+Endnotes are automatically numbered[#first] and are indicated using square[#second]
+brackets and a key value[#first]. They can also be unlinked[#unlinkednote!]
+
+###. Give the endnotes text:
+
+note#first. This is the first endnote text.
+
+note#second. This is the second text.
+
+note#unlinkednote. This one isn't linked from the text.
+
+### Use the notelist block to place the list of notes in the text:
+This list will start with #1. Can also use alpha or Greeks.
+notelist:1. ###. start at 1 (then 2, 3, 4...)
+notelist:c. ###. start at c (then d, e, f...)
+notelist:α. ###. start at α (then β, γ, δ...)
+
+###. The notelist syntax is as follows:
+
+notelist.    Notes with backlinks to every citation made to them.
+notelist+.   Notes with backlinks to every citation made to them,
+               followed by the unreferenced notes.
+notelist^.   Notes with one backlink to the first citation made to each note.
+notelist^+.  Notes with one backlink to the first citation made to each note,
+               followed by unreferenced notes.
+notelist!.   Notes with no backlinks to the citations.
+notelist!+.  Notes with no backlinks to the citations, followed by 
+               unreferenced notes.
+```
+
+## Tables
+
+
+```
+###. Tables are simple to define using the pipe '|' symbol
+
+| A | simple | table | row |
+| And | another | table | row |
+| With an | | empty | cell |
+
+###. Headers are preceded by '|_.'
+|_. First Header |_. Second Header |
+| Content Cell | Content Cell |
+
+###. The <thead> tag is added when |^. above and |-. below the heading are used.
+
+|^.
+|_. First Header |_. Second Header |
+|-.
+| Content Cell | Content Cell |
+| Content Cell | Content Cell |
+
+###. The <tfoot> tag is added when |~. above and |-. below the footer are used.
+
+|~.
+|\2=. A footer, centered & across two columns |
+|-.
+| Content Cell | Content Cell |
+| Content Cell | Content Cell |
+
+###. Attributes are be applied either to individual cells, rows, or to
+the entire table. Cell attributes are placed within each cell:
+
+|a|{color:red}. styled|cell|
+
+###. Row attributes are placed at the beginning of a row,
+followed by a dot and a space:
+
+(rowclass). |a|classy|row|
+
+###. Table attributes are specified by placing the special 'table.' block
+modifier immediately before the table:
+
+table(tableclass).
+|a|classy|table|
+|a|classy|table|
+
+###. Spanning rows and colums:
+A backslash \ is used for a column span:
+
+|\2. spans two cols |
+| col 1 | col 2 |
+
+###. A forward slash / is used for a row span:
+
+|/3. spans 3 rows | row a |
+| row b |
+| row c |
+
+###. Vertical alignments within a table cell:
+
+|^. top alignment|
+|-. middle alignment|
+|~. bottom alignment|
+
+###. Horizontal alignments within a table cell
+
+|:\1. |400|
+|=. center alignment |
+| no alignment |
+|>. right alignment |
+
+```
+or, for the same results
+
+```
+Col 1 | Col2 | Col3
+:-- | :-: | --:
+Ugh this is so ugly | make it | stop
+```
+
+
+## Character Conversions
+
+### Registered, Trademark, Copyright Symbols
+
+```
+RegisteredTrademark(r), Trademark(tm), Copyright (c)
+```
+
+### Acronyms
+
+```
+###. Acronym definitions can be provided in parentheses:
+
+EPA(Environmental Protection Agency) and CDC(Center for Disease Control)
+```
+
+### Angle Brackets and Ampersand
+
+```
+### Angled brackets < and > and ampersands & are automatically escaped:
+< => &lt;
+> => &gt;
+& => &amp;
+```
+
+### Ellipses
+
+```
+p. Three consecutive periods are translated into ellipses...automatically
+```
+
+### Em and En dashes
+
+```
+###. En dashes (short) is a hyphen surrounded by spaces:
+
+This line uses an en dash to separate Oct - Nov 2018.
+
+###. Em dashes (long) are two hyphens with or without spaces:
+
+This is an em dash--used to separate clauses.
+But we can also use it with spaces -- which is a less-used convention.
+That last hyphen between 'less' and 'used' is not converted between words.
+```
+
+## Fractions and other Math Symbols
+
+```
+One quarter: (1/4) => ¼
+One half: (1/2) => ½
+Three quarters: (3/4) => ¾
+Degree: (o) => °
+Plus/minus: (+/-) => ±
+```
+### Multiplication/Dimension
+
+```
+p. Numbers separated by the letter 'x' translate to the multiplication
+or dimension symbol '×':
+3 x 5 => 3 × 5
+```
+
+### Quotes and Apostrophes
+
+```
+###. Straight quotes and apostrophes are automatically converted to
+their curly equivalents:
+
+"these", 'these', and this'n are converted to their HTML entity equivalents.
+Leave them straight using '==' around the text: =="straight quotes"==.
+```
+
+## CSS
+
+```
+p{color:blue}. CSS Styles are enclosed in curly braces '{}'
+p(my-class). Classes are enclosed in parenthesis
+p(#my-id). IDs are enclosed in parentheses and prefaced with a pound '#'.
+```
+
+## Spans and Divs
+
+```
+%spans% are enclosed in percent symbols
+div. Divs are indicated by the 'div.' shorthand
+```
+---
+
+## For More Info
+
+* TxStyle Textile Documentation: [https://txstyle.org/](https://txstyle.org/)
+* promptworks Textile Reference Manual: [https://www.promptworks.com/textile](https://www.promptworks.com/textile)
+* Redmine Textile Formatting: [http://www.redmine.org/projects/redmine/wiki/RedmineTextFormattingTextile](http://www.redmine.org/projects/redmine/wiki/RedmineTextFormattingTextile)
diff --git a/th-th/pascal.th.html.markdown b/th-th/pascal.th.html.markdown
new file mode 100644
index 00000000..bf1da958
--- /dev/null
+++ b/th-th/pascal.th.html.markdown
@@ -0,0 +1,236 @@
+---
+language: Pascal
+filename: learnpascal.pas
+contributors:
+    - ["Ganesha Danu", "http://github.com/blinfoldking"]
+    - ["Keith Miyake", "https://github.com/kaymmm"]
+translators:
+    - ["Worajedt Sitthidumrong", "https://bitbucket.org/wrj"]
+lang: th-th
+---
+
+> Pascal (ปาสกาล) เป็นภาษาโปรแกรมมิ่งทั้งแบบ imperative และ procedural ที่ออกแบบโดย Niklaus Wirth (นิเคล้า เวิร์ท) เมื่อปี 1968-69 และเผยแพร่ตอน 1970 โดยเน้นให้เป็นภาษาที่เล็ก มีประสิทธิภาพ เพื่อเสริมการเขียนโปรแกรมที่มีแนวปฏิบัติที่ดีด้วยการใช้โครงสร้างของตัวภาษา และโครงสร้างข้อมูลมากำกับ ชื่อของภาษานี้ตั้งเป็นเกียรติให้กับนักคณิตศาสตร์ชาวฝรั่งเศส, นักปรัชญา และนักฟิสิกส์ ชื่อ Blaise Pascal (เบลส ปาสกาล) ข้อมูลจาก : [วิกิพีเดีย][1]
+
+การคอมไพล์และรันโค้ดภาษาปาสกาลนี้ สามารถใช้ปาสกาลคอมไพลเลอร์ฟรีชื่อ Free Pascal ได้ โดย [ดาวน์โหลดที่นี่][2]
+
+ด้านล่างจะเป็นโครงสร้างภาษาหลัก ๆ ที่ต้องเข้าใจก่อน ปาสกาลจะเป็นภาษาที่เข้มงวดกับโครงสร้างโค้ดมาก
+
+```pascal
+//โปรแกรมปาสกาล
+//คอมเม้นต์เขียนแบบนี้ ใช้สแลชสองครั้ง
+{
+    แต่ถ้าต้องการคอมเม้นหลาย ๆ บรรทัด
+    ให้ใช้ วงเล็บปีกกา (curly brackets)
+    เนื้อหาอยู่บรรทัดเดียวกันกับปีกกาได้
+}
+
+//อย่างแรก ต้องประกาศ ชื่อโปรแกรม
+program learn_pascal; //<-- ห้ามลืม semicolon
+
+const
+    {
+        ประกาศค่าคงที่ (constant) ในบล็อคนี้
+    }
+type
+    {
+        ประกาศชนิดข้อมูลของเราเองที่นี่ ไม่ว่าจะเป็น ชนิดข้อมูลทั่วไป
+        หรือจะเป็นคลาส 
+    }
+var
+    {
+        ตัวแปร ในภาษาปาสกาล ไม่เหมือนกับภาษาอื่น ๆ 
+        เพราะต้องประกาศในบล็อค var ก่อนใช้งานเสมอ
+    }
+
+//มาถึงส่วนโปรแกรมหลัก หรือ main fucntion นั่นเอง
+begin
+    {
+        โค้ดเราทำงานอะไร อย่างไร ก็เริ่มรันจากตรงนี้
+    }
+end. // จบการทำงานของ _โปรแกรม_ เราจะจบด้วย จุลภาค "."
+```
+
+โค้ดต่อจากนี้ จะเป็นการอธิบายประกาศตัวแปรของปาสกาล
+
+```pascal
+//การประกาศตัวแปร ทำได้แบบนี้
+//var ชื่อตัวแปร : ชนิด ;
+var a:integer;
+var b:integer;
+
+//หรือแบบที่นิยมมากกว่า คือเอามาเก็บในบล็อค var ทั้งหมด
+var 
+    a : integer;
+    b : integer;
+
+//ถ้าจะเอาแบบสั้น ๆ บรรทัดเดียว ก็ทำได้ ทำได้พร้อมกันหลาย ๆ ตัวแปรด้วย
+var a,b : integer;
+```
+
+โค้ดตัวอย่างนี้เป็นโปรแกรม Learn\_More ที่เป็นโครงสร้างโปรแกรมง่าย ๆ ที่จบสมบูรณ์หนึ่งโปรแกรม มีบล็อค program, const, type, main (Begin..End.)
+
+```pascal
+program Learn_More;
+// มาต่อเรื่อง ชนิดของข้อมูล (data types) และ ตัวดำเนินการ (operators)
+
+const
+    PI = 3.141592654;
+    GNU = 'GNU''s Not Unix';
+        // ค่าคงที่ ให้ตั้งชื่อเป็น ตัวพิมพ์ใหญ่ ทั้งหมด ใช้กับชนิดข้อมูลใดๆ ก็ได้
+        // ค่าคงที่ ก็ตามชื่อเลย กำหนดค่าแล้ว ไม่สามารถเปลี่ยนแปลงได้ขณะรัน
+
+// การประกาศชนิดข้อมูลของเราเอง
+// "ชนิด" ของตัวแปรสองแบบนี้ จะนำไปใช้ด้านล่าง
+type
+    ch_array : array [0..255] of char;
+        // อะเรย์ เป็นชนิดข้อมูลที่มี ความยาว/ช่องเก็บข้อมูล และ ชนิดข้อมูล
+        // โค้ดด้านบน เป็นการประกาศอะเรย์ของตัวอักษา 255 ตัวอักษา
+        // ซึ่งได้ ความยาว/ช่องเก็บข้อมูลในตัวแปรตัวนี้ 256 ช่องที่เป็นข้อความ 
+    md_array : array of array of integer;
+        // ด้านบนนี้ เป็นตัวอย่าง อะเรย์สองมิติของเลขจำนวนเต็ม
+        // อะเรย์ ยังซ้อนกับอะเรย์ได้อีกด้วย ทำให้สร้าง อะเรย์หลายมิติได้
+        // เรายังสามารถสร้าง อะเรย์ที่มีความยาวช่องเท่ากับศูนย์ (0) ได้อีกด้วย
+        // ซึ่งทำให้เกิด อะเรย์ที่จำนวนช่องยืดหยุ่นได้ (dymaically sized array)
+
+// การประกาศตัวแปร : ชื่อตัวแปรเหล่านี้จะนำไปใช้ด้านล่างต่อไป
+var
+    int, c, d  : integer;
+           // ประกาศในบล็อค var มีตัวแปรสามตัวเป็นอินทีเจอร์ 
+           // ชนิดจำนวนเต็ม แบบ 16 bit มีช่วงข้อมูล [-32,768.. 32,767]
+           // »int« ในที่นี้เป็น "ชื่อตัวแปร" ที่ต้นฉบับตั้งให้สอดคล้องกับชนิดข้อมูล
+           // อย่าสับสนกับบางภาษาที่มีชนิด int ประกาศหน้าชื่อตัวแปร
+    r    : real;
+           // ตัวแปร r เป็นชนิดเรียล (real) หรือเลขทศนิยม 
+           // real มีช่วงข้อมูล [3.4E-38..3.4E38]
+    bool : boolean;
+           // ข้อมูลชนิดบูเลียน (boolean) มีค่าได้สองแบบ คือ True/False
+    ch   : char;
+           // ตัวแปร ch เป็นชนิดตัวอักษร (ชาร์? คาร์?) หรือคาแรกเตอร์
+           // ตัวอักษรเป็นแบบ ASCII 8 bit ดังนั้นจะไม่ใช่ UTF, Unicode 
+    str  : string;
+           // ตัวแปรสตริงจะเก็บข้อความ หรือ char หลาย ๆ ตัว
+           // ชนิดข้อมูลนี้ไม่เป็นมาตรฐานภาษาแต่คอมไพเลอร์ปาสกาลก็มักจะมีให้
+           // ทั่ว ๆ ไปแล้ว จะเป็นอะเรย์ของ char ความยาวตั้งต้น 255 
+    s    : string[50];
+           // แบบนี้คือ กำหนดความยาว string เอง ให้เก็บ char 50 ตัว
+           // แบบนี้ก็ทำให้ประหยัดหน่วยความจำมากขึ้นนั่นเอง
+    my_str: ch_array;
+           // ชนิดตัวแปร ใช้เป็นชนิดที่เรากำหนดเองก็ได้ อย่างตอนนี้
+           // ch_array เป็น "ชนิดข้อมูล" ที่เราสร้างขึ้นมาในบล็อค type
+    my_2d : md_array;
+           // ตัวแปรแบบอะเรย์ที่ไม่ประกาศขนาด (dynamically sized array)
+           // ก่อนเอาไปใช้จริงต้องระบุขนาดก่อนใช้เสมอ
+
+    // ชนิดข้อมูลแบบ integer เพิ่มเติม
+    b    : byte;     // มีช่วงข้อมูล [0..255]
+    shi  : shortint; // มีช่วงข้อมูล [-128..127]
+    smi  : smallint; // มีช่วงข้อมูล [-32,768..32,767] (standard Integer)
+    w    : word;     // มีช่วงข้อมูล [0..65,535]
+    li   : longint;  // มีช่วงข้อมูล [-2,147,483,648..2,147,483,647]
+    lw   : longword; // มีช่วงข้อมูล [0..4,294,967,295]
+    c    : cardinal; // ก็คือ longword
+    i64  : int64;    // มีช่วงข้อมูล 
+                     // [-9223372036854775808..9223372036854775807]
+    qw   : qword;    // มีช่วงข้อมูล [0..18,446,744,073,709,551,615]
+
+    // ชนิดข้อมูลแบบ real เพิ่มเติม
+    rr   : real;     // มีช่วงข้อมูลที่ขึ้นกับระบบปฏิบัติการ 
+                     // (เช่นเป็นแบบ 8-bit, 16-bit, ฯลฯ)
+    rs   : single;   // มีช่วงข้อมูล [1.5E-45..3.4E38]
+    rd   : double;   // มีช่วงข้อมูล [5.0E-324 .. 1.7E308]
+    re   : extended; // มีช่วงข้อมูล [1.9E-4932..1.1E4932]
+    rc   : comp;     // มีช่วงข้อมูล [-2E64+1 .. 2E63-1]
+
+Begin
+    // การกำหนดค่าตัวแปรให้ขณะประกาศ
+    int  := 1;
+    r    := 3.14;
+    ch   := 'a';  // ใช้ single quote เหมือนกันทั้ง char และ string
+    str  := 'apple';  
+    bool := true;
+    // ภาษาปาสกาล มอง "ชื่อเฉพาะ" แบบไม่สนพิมพ์ใหญ่พิมพ์เล็ก
+    // (case-insensitive language)
+    // ตัวดำเนินการแบบคณิตศาสตร์ (arithmethic operation)
+    int := 1 + 1;   // int = 2 ซึ่งจะกำหนดทับค่าเดิมด้านบนที่เคยประกาศ
+    int := int + 1; // int = 2 + 1 = 3 นำค่าตอนนี้ (2) มา +1 ได้ 3
+    int := 4 div 2; // int = 2 หารด้วย div จะได้ผลเป็น integer เสมอ
+    int := 3 div 2; // int = 1
+    int := 1 div 2; // int = 0
+
+    bool := true or false;  // bool = true
+    bool := false and true; // bool = false
+    bool := true xor true;  // bool = false
+
+    r := 3 / 2;  // หารด้วย / จะได้ผลเป็น real เสมอ
+    r := int;    // เรากำหนดค่า integer ให้ตัวแปร real ได้
+                 // แต่ทำกลับกัน โดยกำหนด real ให้ integer ไม่ได้
+
+    c := str[1]; // กำหนดค่าแรกใน array str ให้ตัวแปร c ที่เป็น char
+    str := 'hello' + 'world'; // เรารวม string เข้าด้วยกันด้วย + 
+
+    my_str[0] := 'a'; // กำหนดค่าให้ string เฉพาะตำแหน่งแบบอะเรย์ทั่วไป
+
+    setlength(my_2d,10,10); // ปรับขนาดอะเรย์ 2 มิติให้เป็นขนาด 10x10
+                            // โดยตัวแปร my_2d นี้สร้างแล้วด้านบน
+    for c := 0 to 9 do      // อะเรย์เริ่มจาก 0 และจบที่ ความยาว-1
+        for d := 0 to 9 do  // ตัวนับ (counter) จำเป็นต้องประกาศก่อนใช้
+        my_2d[c,d] := c * d;
+          // กำหนดอะเรย์หลายมิติ ด้วยการใช้วงเล็บก้ามปู (square brackets)
+
+End.
+// จบโปรแกรมบริบูรณ์ ด้วย "."
+```
+
+ด้านล่าง เป็นตัวอย่างการเขียนโปรแกรมปาสกาลชื่อ Functional\_Programming
+
+```pascal
+program Functional_Programming;
+
+Var
+    i, dummy : integer;
+
+function factorial_recursion(const a: integer) : integer;
+{  ทำการคำนวณแฟคทอเรียลซ้ำ ๆ ของเลขจำนวนเต็ม โดยผ่านพารามิเตอร์ a
+   ถ้าจะประกาศตัวแปรโลคอลในฟังก์ชั่น ก็ทำได้ โดยการใช้บล็อค var ภายในฟังก์ชั่น
+   เช่น :
+   var
+      local_a : integer;
+}
+Begin
+    If a >= 1 Then
+    { ฟังก์ชั่นนี้คืนค่ากลับ โดยการกำหนดค่าที่ผ่านทางพารามิเตอร์ a
+     นำมาคูณกับฟังก์ชั่นที่ผ่าน a-1 สุดท้ายก็กำหนดค่าลงไปให้กับฟังก์ชั่นตรงๆ }
+        factorial_recursion := a * factorial_recursion(a-1)
+    Else
+        factorial_recursion := 1;
+End; // จบ ฟังก์ชั่น ด้วย ";" หลัง End ไม่เหมือนกับจบ โปรแกรม ที่จะใช้ "."
+
+procedure get_integer(var i : integer; dummy : integer);
+{ เรารับ input จากผู้ใช้มาเก็บใน parameter i ที่เป็น integer ที่ตั้งขึ้นใน
+  พารามิเตอร์ โดยใช้ var ประกาศ ทำให้ค่าที่รับเข้ามาจะเปลี่ยนปรับได้จาก
+  ภายนอกการประกาศพารามิเตอร์นี้ ส่วน dummy เป็นตัวแปรที่ปรับเปลี่ยนได้
+  "เฉพาะจากภายในฟังก์ชั่น,โพรซีเยอร์นั้น ๆ }
+Begin
+    write('Enter an integer: ');
+    readln(i);
+    dummy := 4; // dummy จะไม่ทำให้ค่าที่ได้รับมาครั้งแรกใน main block เปลี่ยน
+End;
+
+//--------------------//
+// main program block
+//--------------------//
+Begin 
+    dummy := 3;
+    get_integer(i, dummy);
+    writeln(i, '! = ', factorial_recursion(i));
+    // พิมพ์ค่า i!
+    writeln('dummy = ', dummy); // จะให้ค่าเป็น '3' เสมอ 
+                                // เพราะจะไม่เปลี่ยนเนื่องด้วย
+                                // การประกาศพารามิเตอร์ใน
+                                // โพรซีเยอร์ get_integer ด้านบน
+End.
+
+```
+
+[1]:	https://en.wikipedia.org/wiki/Pascal_(programming_language)
+[2]:	https://www.freepascal.org/
diff --git a/th-th/typescript.th.html.markdown b/th-th/typescript.th.html.markdown
new file mode 100644
index 00000000..5395c2a7
--- /dev/null
+++ b/th-th/typescript.th.html.markdown
@@ -0,0 +1,259 @@
+---
+language: TypeScript
+contributors:
+    - ["Philippe Vlérick", "https://github.com/pvlerick"]
+    - ["Worajedt Sitthidumrong", "https://bitbucket.org/wrj"]
+filename: learntypescript-th.ts
+lang: th-th
+---
+
+TypeScript เป็นภาษาที่มีเป้าหมายเพื่อทำให้การพัฒนาซอฟต์แวร์ขนาดใหญ่ด้วย JavaScript ทำได้ง่ายขึ้น โดยที่ TypeScript ได้เพิ่มแนวคิดที่พบทั่วไป อาทิ classes, modules, interfaces, generics และ static typing (ไม่บังคับ) เข้าไปในภาษา JavaScript ดังนั้น TypeScript ก็เลยเป็น Super Set ของ JavaScript อีกที โค้ด JavaScript ทุกส่วน ก็คือโค้ดที่ทำงานได้ถูกต้องใน TypeScript ทำให้เราเพิ่ม TypeScript เข้าไปใช้ในโปรเจคการพัฒนาของเราได้ไม่ยากเลย เพราะ TypeScript คอมไพล์ผลลัพธ์ออกมาเป็น JavaScript ในท้ายสุดอยู่ดี
+
+บทความนี้จะเน้นเฉพาะ syntax ส่วนขยายของ TypeScript ซึ่งจะไม่รวมกับที่มีใน  [JavaScript](/docs/javascript)
+
+การทดสอบเขียน TypeScript เริ่มได้ง่าย ๆ โดยเข้าไปที่
+[Playground](http://www.typescriptlang.org/Playground) ซึ่งคุณจะเขียนโค้ดพร้อม autocomplete และเห็นเลยว่ามันจะแปลงมาเป็นผลลัพธ์แบบ JavaScript อย่างไร
+
+```ts
+// TypeScript มี data type พื้นฐาน 3 แบบ
+let isDone: boolean = false;
+let lines: number = 42;
+let name: string = "Anders";
+
+// แต่เราก็สามารถละการบอกชนิดได้ โดยชนิดตัวแปรก็จะปรับชนิดของเขาจากข้อมูลที่กำหนดให้โดยตรง
+let isDone = false;
+let lines = 42;
+let name = "Anders";
+
+// ถ้าไม่รู้ ก็กำหนดเป็นชนิด "Any" ได้
+let notSure: any = 4;
+notSure = "maybe a string instead";
+notSure = false; // โอเค ตอนนี้เป็น Boolean แน่ ๆ
+
+// ใช้ const สำหรับสร้าง ค่าคงที่
+const numLivesForCat = 9;
+numLivesForCat = 1; // Error
+
+// สำหรับ collections มี typed arrays และ generic arrays
+// ก็คือ อะเรย์บอกชนิด และ อะเรย์เจเนอริก ตามลำดับ
+let list: number[] = [1, 2, 3];
+// ในอีกทางหนึ่ง สร้างเป็นอะเรย์ชนิด generic array
+let list: Array<number> = [1, 2, 3];
+
+// และสำหรับ enumerations:
+enum Color { Red, Green, Blue };
+let c: Color = Color.Green;
+
+// สุดท้าย, "void" ใช้เมื่อเป็นกรณีพิเศษที่ฟังก์ชันไม่ส่งค่ากลับ
+function bigHorribleAlert(): void {
+  alert("I'm a little annoying box!");
+}
+
+// ฟังก์ชั่น (Functions) เป็นสิ่งที่มีความสำคัญมาเป็นอันดับหนึ่ง รองรับการใช้ "fat arrow" ในการสร้าง lambda function และ type inference
+
+// สไตล์ต่อไปนี้มีค่าเท่ากันกับบรรทัดที่ยกตัวอย่างด้านล่าง เพราะคอมไพเลอร์จะมองเหมือนกัน และได้ JavaScript แบบเดียวกัน
+let f1 = function (i: number): number { return i * i; }
+// อนุมานชนิดที่ส่งกลับ หรือ type inferred
+let f2 = function (i: number) { return i * i; }
+// เขียนแบบ "Fat arrow" แต่บอกชนิดส่งกลับ
+let f3 = (i: number): number => { return i * i; }
+// เขียนแบบ "Fat arrow" แต่อนุมานชนิดส่งกลับ
+let f4 = (i: number) => { return i * i; }
+// เขียนแบบ "Fat arrow" อนุมานชนิดส่งกลับ พร้อมกับไม่มีวงเล็บ แปลว่าไม่ต้องมี return keyword ด้วย
+let f5 = (i: number) => i * i;
+
+// Interfaces นั้นเป็นเหมือนเราออกแบบโครงสร้าง คุณสมบัติต่าง ๆ ตอนเอาไปใช้ จะต้องเป็นไปตาม interface นั้น ๆ เหมือนกับเป็นการกำหนดสเป็คของ "ชนิดข้อมูล"
+interface Person {
+  name: string;
+  // Optional properties กำหนดด้วย "?"
+  age?: number;
+  // และมี function พร้อมชนิดได้ใน interface
+  move(): void;
+}
+
+// Object นี้ implements "Person" interface ทำให้มันเป็นชนิด Person และมันก็มี property name และ function move() 
+let p: Person = { name: "Bobby", move: () => { } };
+// Objects นี้เป็นชนิด Person ด้วย และมี optional property หรือ age?: นั่นเอง
+let validPerson: Person = { name: "Bobby", age: 42, move: () => { } };
+// ไม่ใช่ Person เพราะ age: ต้องเป็น number เท่านั้น ตามข้อกำหนดใน interface Person
+let invalidPerson: Person = { name: "Bobby", age: true };
+
+// Interfaces ยังนำมาใช้ในลักษณะของ function ได้อีกด้วย
+interface SearchFunc {
+  (source: string, subString: string): boolean;
+}
+// เฉพาะชนิด parameters เท่านั้นที่สำคัญ ชื่อของมันไม่จำเป็นต้องเหมือน
+let mySearch: SearchFunc;
+mySearch = function (src: string, sub: string) {
+  return src.search(sub) != -1;
+}
+
+// สมาชิกใน class จะเข้าถึงได้แบบ public เป็นค่าปริยาย
+class Point {
+  // Properties
+  // ตั้งค่า Properties ของ class นี้
+  x: number;
+
+  // Constructor
+  // เราใส่ public/private keywords ตรงนี้ได้ มีผลเหมือนกันกับกำหนด x ด้านบน
+  // ในตัวอย่าง y มีการกำหนดเช่นเดียวกับ x แต่พิมพ์สั้นกว่า
+  // สังเกตว่า มีการกำหนดค่าปริยายให้ parameters ได้ด้วย
+
+  constructor(x: number, public y: number = 0) {
+    this.x = x;
+  }
+
+  // Functions
+  dist() { return Math.sqrt(this.x*this.x + this.y*this.y); }
+
+  // Static members
+  static origin = new Point(0, 0);
+}
+
+// Classes สามารถระบุชนิด interface ที่ต้องการได้ตรง ๆ ด้วยเช่นโค้ดด้านล่าง
+// แต่อะไรที่จะ implement มานั้น ถ้าไม่ได้กำหนดไว้ใน constructor ก็จะเกิดข้อผิดพลาดตอนคอมไพล์
+class PointPerson implements Person {
+    name: string  // ตรงนี้จะผิด แก้ไขโดยการไปสร้างตัวรับค่าเข้ามาผ่านทาง constructor
+    move() {}
+}
+
+let p1 = new Point(10, 20);
+let p2 = new Point(25); //y เป็น 0 เพราะกำหนดค่าปริยายไว้ให้แล้ว
+
+// Inheritance การสืบทอดคุณสมบัติ
+class Point3D extends Point {
+  constructor(x: number, y: number, public z: number = 0) {
+    super(x, y); // เราจะต้องเรียกใช้ super class constructor โดยตรง
+  }
+
+  // Overwrite ฟังก์ชั่นที่มีอยู่เดิมใน Point
+  dist() {
+    let d = super.dist();
+    return Math.sqrt(d * d + this.z * this.z);
+  }
+}
+
+// Modules ใช้เป็นกลุ่มของ class เราใช้ "." เป็นตัวแบ่ง sub modules
+// อย่างกรณีนี้จะเป็น Module.Class เช่น Geometry.Square
+module Geometry {
+  export class Square {
+    constructor(public sideLength: number = 0) {
+    }
+    area() {
+      return Math.pow(this.sideLength, 2);
+    }
+  }
+}
+
+let s1 = new Geometry.Square(5);
+
+// เราทำให้เรียกใช้ง่ายขึ้นโดยการใช้ alias มาอ้างชื่อ module แบบเดียวกับบางภาษา เช่น Python
+import G = Geometry;
+
+let s2 = new G.Square(10);
+
+// Generics
+// Classes
+class Tuple<T1, T2> {
+  constructor(public item1: T1, public item2: T2) {
+  }
+}
+
+// Interfaces
+interface Pair<T> {
+  item1: T;
+  item2: T;
+}
+
+// และ functions
+let pairToTuple = function <T>(p: Pair<T>) {
+  return new Tuple(p.item1, p.item2);
+};
+
+let tuple = pairToTuple({ item1: "hello", item2: "world" });
+
+// เราเรียกใช้ไฟล์ definition แบบนี้:
+/// <reference path="jquery.d.ts" />
+
+// Template Strings ( คือ strings ที่ใช้ backticks ครอบ — "`" ปุ่มบนซ้ายคีย์บอร์ด )
+// แทรกข้อความใน String ด้วย Template Strings
+let name = 'Tyrone';
+let greeting = `Hi ${name}, how are you?`
+// Strings หลายบรรทัดก็ทำได้ใน Template Strings
+let multiline = `This is an example
+of a multiline string`;
+
+// READONLY: ความสามารถใหม่ใน TypeScript 3.1
+interface Person {
+  readonly name: string;
+  readonly age: number;
+}
+
+var p1: Person = { name: "Tyrone", age: 42 };
+p1.age = 25; // Error แน่นอน เพราะ p1.age ถูกกำหนดเป็น read-only
+
+var p2 = { name: "John", age: 60 }; // สังเกตว่า p2 ไม่ได้กำหนดเป็น Person
+var p3: Person = p2; // ทำได้ เป็น read-only alias ของ p2 และกำหนดเป็น Person
+p3.x = 35; // Error p3.x ก็เป็น read-only
+p2.x = 45; // Ok ทำได้แต่ก็จะเปลี่ยนค่า p3.x ด้วย เพราะ p3 เป็น alias ของ p2
+
+class Car {
+  readonly make: string;
+  readonly model: string;
+  readonly year = 2018;
+
+  constructor() {
+    this.make  = "Unknown Make";   // อนุญาตให้กำหนดค่าได้ใน constructor แม้ว่าจะ read-only
+    this.model = "Unknown Model"; // อนุญาตให้กำหนดค่าได้ใน constructor แม้ว่าจะ read-only
+  }
+}
+
+let numbers: Array<number> = [0, 1, 2, 3, 4];
+let moreNumbers: ReadonlyArray<number> = numbers;
+moreNumbers[5] = 5;     // Error, สมาชิกอะเรย์เป็น read-only แปลว่า ห้ามแก้ไข
+moreNumbers.push(5);    // Error, push method ใช้ไม่ได้ เพราะมันจะไปแก้ไข read-only array
+moreNumbers.length = 3; // Error, เพราะ length ก็ต้อง read-only
+numbers = moreNumbers;  // Error, method ที่ทำให้อะเรย์เปลี่ยนได้จะไม่อนุญาต
+
+// Tagged Union Types สำหรับโมเดลสเตท ที่อาจจะมีได้หลายๆ สเตท
+type State = 
+  | { type: "loading" }
+  | { type: "success", value: number }
+  | { type: "error", message: string };
+
+ประกาศ const state: State;
+if (state.type === "success") {
+  console.log(state.value);
+} else if (state.type === "error") {
+  console.error(state.message);
+}
+
+// Iterators และ Generators
+
+// ประโยคแบบ for..of
+// การทำซ้ำกับ ลิสต์ของค่าในออปเจ็คต์
+let arrayOfAnyType = [1, "string", false];
+for (const val of arrayOfAnyType) {
+    console.log(val); // 1, "string", false
+}
+
+let list = [4, 5, 6];
+for (const i of list) {
+   console.log(i); // 4, 5, 6
+}
+
+// ประโยคแบบ for..in
+// การทำซ้ำกับ ลิสต์ของคีย์ในออปเจ็คต์
+for (const i in list) {
+   console.log(i); // 0, 1, 2
+}
+
+
+```
+
+## อ่านเพิ่มเติมที่
+ * [TypeScript Official website] (http://www.typescriptlang.org/)
+ * [TypeScript language specifications] (https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md)
+ * [Anders Hejlsberg - Introducing TypeScript on Channel 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [Source Code on GitHub] (https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed - repository for type definitions] (http://definitelytyped.org/)
diff --git a/tmux.html.markdown b/tmux.html.markdown
index 1214a5ba..1c2c2da3 100644
--- a/tmux.html.markdown
+++ b/tmux.html.markdown
@@ -78,6 +78,7 @@ combinations called 'Prefix' keys.
   p                  # Change to the previous window
   {                  # Swap the current pane with the previous pane
   }                  # Swap the current pane with the next pane
+  [                  # Enter Copy Mode to copy text or view history.
 
   s                  # Select a new session for the attached client
                      interactively
diff --git a/toml.html.markdown b/toml.html.markdown
index 980563f9..385a2437 100755
--- a/toml.html.markdown
+++ b/toml.html.markdown
@@ -12,7 +12,7 @@ It is an alternative to YAML and JSON. It aims to be more human friendly than JS
 Be warned, TOML's spec is still changing a lot. Until it's marked as 1.0, you
 should assume that it is unstable and act accordingly. This document follows TOML v0.4.0. 
 
-```toml
+```
 # Comments in TOML look like this.
 
 ################
@@ -32,7 +32,7 @@ boolean = true
 dateTime = 1979-05-27T07:32:00-08:00
 scientificNotation = 1e+12
 "key can be quoted" = true # Both " and ' are fine
-"key may contains" = "letters, numbers, underscores, and dashes"
+"key may contain" = "letters, numbers, underscores, and dashes"
 
 # A bare key must be non-empty, but an empty quoted key is allowed
 "" = "blank"     # VALID but discouraged
@@ -102,9 +102,10 @@ boolMustBeLowercase = true
 # Datetime #
 ############
 
-date1 = 1979-05-27T07:32:00Z # follows the RFC 3339 spec
-date2 = 1979-05-27T07:32:00 # without offset
-date3 = 1979-05-27 # without offset nor time
+date1 = 1979-05-27T07:32:00Z # UTC time, following RFC 3339/ISO 8601 spec
+date2 = 1979-05-26T15:32:00+08:00 # with RFC 3339/ISO 8601 offset
+date3 = 1979-05-27T07:32:00 # without offset
+date4 = 1979-05-27 # without offset or time
 
 ####################
 # COLLECTION TYPES #
@@ -224,26 +225,26 @@ color = "gray"
 # sub-table will belong to the nearest table element above it.
 
 [[fruit]]
-  name = "apple"
+  name = "apple" # I am a property in fruit table/map
 
-  [fruit.Geometry]
+  [fruit.geometry]
     shape = "round"
-    note = "I am an fruit's property"
+    note = "I am a property in geometry table/map"
 
   [[fruit.color]]
     name = "red"
-    note = "I am an array's item in apple"
+    note = "I am an array item in apple fruit's table/map"
 
   [[fruit.color]]
     name = "green"
-    note = "I am in the same array than red"
+    note = "I am in the same array as red"
 
 [[fruit]]
   name = "banana"
 
   [[fruit.color]]
     name = "yellow"
-    note = "I am an array's item too but banana's one"
+    note = "I am an array item in banana fruit's table/map"
 ```
 
 In JSON land, this code will be:
diff --git a/tr-tr/c++-tr.html.markdown b/tr-tr/c++-tr.html.markdown
new file mode 100644
index 00000000..9d65cf9c
--- /dev/null
+++ b/tr-tr/c++-tr.html.markdown
@@ -0,0 +1,1076 @@
+---
+language: c++
+lang: tr-tr
+filename: learncpp-tr.cpp
+contributors:
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Matt Kline", "https://github.com/mrkline"]
+    - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Connor Waters", "http://github.com/connorwaters"]
+    - ["Ankush Goyal", "http://github.com/ankushg07"]
+    - ["Jatin Dhankhar", "https://github.com/jatindhankhar"]
+    - ["Adem Budak", "https://github.com/p1v0t"]
+---
+
+C++ 
+[yaratıcısı Bjarne Stroustrup'a göre](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote),
+
+- "daha iyi bir C" yapmak
+- veri soyutlamayı desteklemek 
+- nesneye yönelik programlamayı deskteklemek
+- tipten bağımsız programlamayı desteklemek 
+
+için tasarlanmış bir sistem programlama dilir.
+
+Sözdizimi daha yeni dillerden daha zor veya karmaşık olsa da işlemcinin doğrudan çalıştırabileceği
+native komutlara derlenerek, donanım üzerinde (C gibi) sıkı bir kontrol sağlar, bunu yaparken
+tipten bağımsızlık, exception'lar ve sınıflar gibi yüksek-seviyeli özellikleri destekler.
+Bu hız ve kullanışlılık C++'ı en çok kullanılan dillerden biri yapar.
+
+```c++
+//////////////////////
+// C ile karşılaştırma
+//////////////////////
+
+// C++ _neredeyse_ C'nin bir üstkümesidir, değişken tanımı, basit tipleri
+// ve fonksiyonları için temelde aynı sözdizimini paylaşır.
+
+// Aynı C gibi, programın başlangıç noktası bir integer döndüren 
+// main fonksiyonudur.
+// Bu değer programın bitiş statüsünü belli eder.
+// Daha fazla bilgi için bknz http://en.wikipedia.org/wiki/Exit_status .
+
+int main(int argc, char** argv)
+{
+    // Komut satırı argümanları C'de olduğu gibi argv ve argc ile geçilir
+    // argc, argüman sayısını belli eder,
+    // argv, argümanları belli eden, C-stili string'lerin (char*) dizisidir.
+    // İlk argüman çağrılan programın adıdır.
+    // Eğer argümanları umursamıyorsan, argv ve argc kullanılmayabilir 
+    // int main() gibi
+
+    // 0 çıkış durumu başarıyı belirtir.
+    return 0;
+}
+
+// Bunlara rağmen C++ aşağıdaki noktalarda farklılaşır:
+
+// C++'ta, karakterler char türündendir
+sizeof('c') == sizeof(char) == 1
+
+// C'de, karakterler int türündendir
+sizeof('c') == sizeof(int)
+
+
+// C++ katı bir prototip kuralına sahiptir
+void func(); // fonksiyon argüman kabul etmez
+
+// C'de
+void func(); // fonksiyon herhangi bir sayıda argüman kabul edebilir
+
+// C++'da NULL yerine nullptr kullanılır
+int* ip = nullptr;
+
+// C standard başlıkları başına "c" eklenip, sondaki .h
+// kullanılmadan C++'ta kullanılabilir
+#include <cstdio>
+
+int main()
+{
+    printf("Hello, world!\n");
+    return 0;
+}
+
+//////////////////////////////////
+// Fonksiyonun fazladan yüklenmesi
+//////////////////////////////////
+
+// C++ herbir fonksiyonun farklı parametereler
+// aldığı fonksiyon fazladan yüklenmesini desktekler 
+
+void print(char const* myString)
+{
+    printf("String %s\n", myString);
+}
+
+void print(int myInt)
+{
+    printf("My int is %d", myInt);
+}
+
+int main()
+{
+    print("Hello"); // void print(const char*) fonksiyonunu çağırır.
+    print(15); // void print(int) fonksiyonunu çağırır.
+}
+
+////////////////////////////////
+// Default fonksiyon argümanları
+////////////////////////////////
+
+// Eğer çağırıcı tarafından fonksiyona argüman sağlanmamışsa,
+// fonksiyona default argüman verebilirsin
+
+void doSomethingWithInts(int a = 1, int b = 4)
+{
+    // Burada int'lerle birşeyler yap
+}
+
+int main()
+{
+    doSomethingWithInts();      // a = 1,  b = 4
+    doSomethingWithInts(20);    // a = 20, b = 4
+    doSomethingWithInts(20, 5); // a = 20, b = 5
+}
+
+// Default argümanlar, argüman listesinin sonunda yer almalı.
+
+void invalidDeclaration(int a = 1, int b) // Hata!
+{
+}
+
+
+/////////////////////////
+// Namespace(İsim uzayı)
+/////////////////////////
+
+// Namespace'ler değişken, fonksiyon ve diğer bildirimlerin 
+// kapsama alanını ayırır. 
+// Namespace'ler içiçe geçebilir.
+
+namespace First {
+    namespace Nested {
+        void foo()
+        {
+            printf("This is First::Nested::foo\n");
+        }
+    } // Nested namespace'inin sonu
+} // First namespace'inin sonu
+
+namespace Second {
+    void foo()
+    {
+        printf("This is Second::foo\n");
+    }
+}
+
+void foo()
+{
+    printf("This is global foo\n");
+}
+
+int main()
+{
+    // Second namespace'i içinideki tüm sembolleri mevcut kapsama alanına dahil eder.
+    // Dikkat edersen artık yalnızca foo() çağrısı çalışmayacaktır çünkü hangi
+    // namespace'ten çağrıldığı açık değildir.
+    using namespace Second;
+
+    Second::foo(); // "This is Second::foo" yazdırıır
+    First::Nested::foo(); // "This is First::Nested::foo" yazdırır
+    ::foo(); // "This is global foo" yazdırır.
+}
+
+///////////////
+// Input/Output
+///////////////
+
+// C++'ta input ve output stream'leri kullanır.
+// cin, cout ve cerr,sırasıyla, stdin, stdout, ve stderr'i temsil eder.
+// << araya ekleme ve >> aradan çıkarma operatörüdür.
+
+#include <iostream> // I/O stream'lerini dahil etmek için
+
+using namespace std; // Streamler std namespace'i içindedir(standard kütüphane)
+
+int main()
+{
+   int myInt;
+
+   // stdout (veya terminal/screen)'ta çıktı verir
+   cout << "Enter your favorite number:\n";
+   // Girdiyi alır 
+   cin >> myInt;
+
+   // cout ayrıca formatlanabilir
+   cout << "Your favorite number is " << myInt << "\n";
+   // prints "Your favorite number is <myInt>"
+
+    cerr << "Used for error messages";
+}
+
+//////////////
+// String'ler
+/////////////
+
+// String'ler C++'ta nesnedir ve pek çok üye fonksiyonu vardır
+#include <string>
+
+using namespace std; // String'ler de std namespace'i içindedir. (standard kütüphane)
+
+string myString = "Hello";
+string myOtherString = " World";
+
+// + eklemek için kullanıldır 
+cout << myString + myOtherString; // "Hello World"
+
+cout << myString + " You"; // "Hello You"
+
+// C++'ta  stringler are mutable'dır (değişebilir).
+myString.append(" Dog");
+cout << myString; // "Hello Dog"
+
+
+///////////////////////
+// Reference (Referans)
+///////////////////////
+
+// C'deki pointer'lara ek olarak 
+// C++ _reference_'lara sahiptir.
+// Bunlar bir kere atandınğında tekrardan atanamayan pointer'dır
+// ve null olamaz.
+// Değişkenin kendisiyle aynı sözdizimine sahiptir:
+// Değerine ulaşmak için * ihtiyaç yoktur ve
+// atama için & (address of) kullanılmaz.
+
+using namespace std;
+
+string foo = "I am foo";
+string bar = "I am bar";
+
+
+string& fooRef = foo; // Bu foo'nun reference'ını oluşturur.
+fooRef += ". Hi!"; // foo'yu reference'ı üzerinden değiştirir.
+cout << fooRef; // "I am foo. Hi!" yazdırır.
+
+// "fooRef"e yeniden atama yapmaz. Bu "foo = bar" denktir ve bu satırdan sonra
+//  foo == "I am bar" olur
+cout << &fooRef << endl; // foo'un adresini yazdırır
+fooRef = bar;
+cout << &fooRef << endl; //Hala foo'nun adresini yazdırır
+cout << fooRef;  //"I am bar" yazdırır
+
+// fooRef'in adresi aynı kalır yani hala foo'nun adresidir.
+
+const string& barRef = bar; // bar'a const reference oluşturur
+// C'de olduğu gibi, const değerler (pointer'lar ve reference'ler) değiştirilemez.
+barRef += ". Hi!"; // Hata, const reference'ler değiştirilemez.
+
+// Kısa bir ekleme: reference'lere devam etmeden önce, geçici nesne konseptinden
+// bahsetmeliyiz. Mesela aşadaki gibi bir kod var:
+string tempObjectFun() { ... }
+string retVal = tempObjectFun();
+
+// Bu iki satırda aslında ne oluyor:
+//   - tempObjectFun fonksiyonundan bir string nesnesi dönüyor
+//   - dönmüş olan nesneyle yeni bir string oluşturuyor
+//   - dönmüş olan nesne yok ediliyor
+// İşte bu dönen nesneye geçici nesne denir. Geçici nesneler fonksiyon nesne
+// döndürdüğünde oluşturulur ve ifade işini bitirdiğinde yok edilir (Aslında,
+// standard'ın söylediği şey bu ama derleyiciler bu davranışı değiştirmemize 
+// izin veriyor. Daha fazla detay için "return value optimization" diye
+// aratabilirsin. Sonuç olarak aşağıdaki kodda:
+foo(bar(tempObjectFun()))
+
+// foo ve bar'ın varolduğunu kabul ediyoruz, tempObjectFun'dan dönen nesne
+// bar'a geçti ve foo çağrılmadan önce yokedildir.
+
+// Şimdi reference'lara dönelim. "ifadenin sonunda" kuralının bir istisnası
+// eğer geçici nesne const reference'a geçildiyse oratya çıkar, bu durumda
+// nesnenin ömrü mevcut kapsama alanına kadar uzar:
+
+void constReferenceTempObjectFun() {
+  // constRef geçici nesneyi alır ve bu durum fonksiyonun sonuna kadar geçerlidir.
+  const string& constRef = tempObjectFun();
+  ...
+}
+
+// C++11 ile gelen diğer bir reference geçici nesnelere özeldir. Bu türden birden 
+// bir tip tanımlayamazsın ama aşırı yüklenme sırasında bu tipler öncelik alır:
+void someFun(string& s) { ... }  // Regular reference
+void someFun(string&& s) { ... }  // Geçici nesneye reference 
+
+string foo;
+someFun(foo);  // regular reference'ı çağırır
+someFun(tempObjectFun());  // geçici reference'ı çağırır
+
+/////////////////////
+// Enum
+/////////////////////
+
+// Enum'lar sabit değerler yapmak için kullanılır ve çoğunlukla kodun daha okunaklı
+// olması için kullanılır
+
+enum ECarTypes
+{
+  Sedan,
+  Hatchback,
+  SUV,
+  Wagon
+};
+
+ECarTypes GetPreferredCarType()
+{
+	return ECarTypes::Hatchback;
+}
+
+// C++11 ile beraber bir tipi enum'a atamanın kolay bir yolu var, bu enum'un istenen
+// tipe dönüştürmek için kullanışlı bir yöntem
+enum ECarTypes : uint8_t
+{
+  Sedan, // 0
+  Hatchback, // 1
+  SUV = 254, // 254
+  Hybrid // 255
+};
+
+void WriteByteToFile(uint8_t InputValue)
+{
+	// Serialize the InputValue to a file
+}
+
+void WritePreferredCarTypeToFile(ECarTypes InputCarType)
+{
+	// enum uint8_t tipine dönüştürüldü
+	WriteByteToFile(InputCarType);
+}
+
+// Diğer yandan enum'ların yanlışlıkla integer tipini veya diğer enumlara dönüşmesini
+// istemiyorsan enum class olarak tanımlayabilirsin
+enum class ECarTypes : uint8_t
+{
+  Sedan, // 0
+  Hatchback, // 1
+  SUV = 254, // 254
+  Hybrid // 255
+};
+
+void WriteByteToFile(uint8_t InputValue)
+{
+	// Serialize the InputValue to a file
+}
+
+void WritePreferredCarTypeToFile(ECarTypes InputCarType)
+{
+	// ECarTypes, uint8_t tipinde olmasına rağmen, "enum class" olarak 
+	// tanımlandığından derlenmeyecektir!
+	WriteByteToFile(InputCarType);
+}
+
+///////////////////////////////////////////
+// Sınıflar ve nesneye yönelik proglamalama
+///////////////////////////////////////////
+
+// Sınıflara(class) ilk örnek
+#include <iostream>
+
+// Sınıfı tanımla.
+// Sınıflar genelde header (.h veya .hpp) dosyalarında tanımlanır.
+class Dog {
+    // Üye değişkenler ve fonksiyonlar default olarak private'dir.
+    std::string name;
+    int weight;
+
+// Aşağıda, "private:" veya "protected:" bulunana kadar
+// bütün üyeler public'tir.
+public:
+
+    // Default constructor
+    Dog();
+
+    // Üye fonksiyon bildirimi (gerçeklenimi aşağıda)
+    // Dikkat ederseniz using namespace std; yerine
+    // std::string kullandık.
+    // Hiçbir zaman header dosyasında "using namespace std;" kullanma.
+    void setName(const std::string& dogsName);
+
+    void setWeight(int dogsWeight);
+
+    // Nesnenin durumunu değiştirmeyen fonksiyonlar const ile işaretlenmelidir
+
+    // Türetilen sınıflarda fonksiyonu override edebilmek için başına 
+    // _virtual_ eklenmelidir.
+    // Fonksiyonlar, performanslar ilgili nedenlerden ötürü default olarak virtual değildir
+    virtual void print() const;
+
+    // Fonksiyonlar class içinde de tanımlanabilir.
+    // Bu şekille tanımlanan fonksiyonlar otomatik olarak inline olur.
+    void bark() const { std::cout << name << " barks!\n"; }
+
+    // C++ constructor'ların yanında destructor'da sağlar.
+    // Bunlar nesne silindiğinde veya scope'un dışına çıktığında çağrılır.
+    // Bu RAII gibi güçlü paradigmaları etkin kılar.
+    // (aşağıda açıklandı)
+    // Eğer sınıf kendisinden türetiliyorsa, destructor virtual olmalıdır,
+    // eğer virtual değilse, türetilmiş sınıfın destructor'ı nesne, ana sınıf
+    // referans'ı veya pointer'ı üzerinden yok edildiğinde, çağrılmayacaktır.
+    virtual ~Dog();
+
+}; // class tanımının sonuda noktalı virgül(;) olmalıdır.
+
+// Sınıfın üye fonksiyonları genelde .cpp dosyaları içinde gerçeklenir.
+Dog::Dog()
+{
+    std::cout << "A dog has been constructed\n";
+}
+
+// Objects (such as strings) should be passed by reference
+// Nesneler (string gibi) reference ile fonksiyonlara geçilmelidir
+// Eğer nesneleri değiştirilecekse reference ile fonksiyonlara geçilmelidir,
+// değiştirilmeyecekse const reference ile geçilmelidir.
+void Dog::setName(const std::string& dogsName)
+{
+    name = dogsName;
+}
+
+void Dog::setWeight(int dogsWeight)
+{
+    weight = dogsWeight;
+}
+
+// Dikkat edersen "virtual" yalnızca bildirimde gerekli, tanımlamada değil.
+void Dog::print() const
+{
+    std::cout << "Dog is " << name << " and weighs " << weight << "kg\n";
+}
+
+Dog::~Dog()
+{
+    std::cout << "Goodbye " << name << "\n";
+}
+
+int main() {
+    Dog myDog; // "A dog has been constructed" yazdırır
+    myDog.setName("Barkley");
+    myDog.setWeight(10);
+    myDog.print(); // "Dog is Barkley and weighs 10 kg" yazdırır.
+    return 0;
+} // "Goodbye Barkley" yazdırır.
+
+// Inheritance(Miras)
+
+// Bu sınıf, Dog sınıfında public ve protected olan herşeyi miras alır, 
+// private olanları da miras alır ama, public ve protected sınıflar aracılıyla
+// yapılmıyorsa, doğrudan erişemez.
+class OwnedDog : public Dog {
+
+public:
+    void setOwner(const std::string& dogsOwner);
+
+    // print fonksiyonunun davranışını bütün OwnedDogs sınıfı için override eder
+    // (üstünden geçer, kendine uyarlar).
+    // bknz http://en.wikipedia.org/wiki/Polymorphism_(computer_science)
+    // override anahtar sözcüpü kullanılma da olur ama kullanılması aslında bir temel
+    // temel sınıf fonksiyonunun üzerinden geçtiğimizi gösterir.
+    void print() const override;
+
+private:
+    std::string owner;
+};
+
+// Bu arada takip eden .cpp dosyasında:
+
+void OwnedDog::setOwner(const std::string& dogsOwner)
+{
+    owner = dogsOwner;
+}
+
+void OwnedDog::print() const
+{
+    Dog::print(); // Ana dog sınıfındaki print fonksiyonunu çağırır 
+    std::cout << "Dog is owned by " << owner << "\n";
+    // 	      "Dog is <name> and weights <weight>"
+    //        "Dog is owned by <owner>"
+    // 	       yazdırır
+}
+
+/////////////////////////////////////////////////////
+// ilk değer atama ve Operatörün fazladan yüklenmesi
+/////////////////////////////////////////////////////
+
+// C++ dilinde +, -, *, /, gibi operatörlerin davranışını fazladan yükleyebilirsiniz.
+// Bu, operator her kullandınıldığında çağrılan bir fonksiyon tanımlamasıyla yapılır.
+
+#include <iostream>
+using namespace std;
+
+class Point {
+public:
+    // Üye değişkenkenlere default değer atanabilir.
+    double x = 0;
+    double y = 0;
+    
+    // Default constructor
+    Point() { };
+
+    Point (double a, double b) :
+        x(a),
+        y(b)
+    { /* İlk değer atama dışında birşey yapma */ }
+
+    // + operatorünün fazladan yükle.
+    Point operator+(const Point& rhs) const;
+
+    // += operatorünü fazladan yükle
+    Point& operator+=(const Point& rhs);
+
+    // - ve -= operatorleri fazladan yüklemek de mantıklı olurdu
+    // ama kısa tutmak için burda değinmedik.
+};
+
+Point Point::operator+(const Point& rhs) const
+{
+    // yeni bir nokta oluştur ve bunu rhs ile topla
+    return Point(x + rhs.x, y + rhs.y);
+}
+
+Point& Point::operator+=(const Point& rhs)
+{
+    x += rhs.x;
+    y += rhs.y;
+    return *this;
+}
+
+int main () {
+    Point up (0,1);
+    Point right (1,0);
+    // Bu Point + operatorünü çağırır
+    Point result = up + right;
+    // "Result is upright (1,1)" yazdırır.
+    cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
+    return 0;
+}
+
+////////////////////////
+// Şablonlar (Templates)
+////////////////////////
+
+// Şablonlar C++ dilinde tipten bağımsız programlama için kullanılır.
+
+// Zaten aşina olduğun tipten bağımsız programlamayla başladık. Bir tip parametresi
+// alan fonksiyon veya sınıf tanımlamaık için:
+template<class T>
+class Box {
+public:
+    // Bu sınıfta T, herhangi bir tip için kullanılabilir.
+    void insert(const T&) { ... }
+};
+
+// Derleme esnasında derleyici aslında, parametreleri yerine konmuş şekilde herbir şablonu üretir,
+// bu yüzden sınıfın tam tanımı her çağrılma sırasında var olmak zorundadır. Bu nedenle şablon sınıflarını
+// tamamen header dosyalarında görürsün.
+
+// Stack'ta şablon sınıfın bir örneğini oluşturmak için:
+Box<int> intBox;
+
+// ve, anladığın gibi, kullanabilirsin:
+intBox.insert(123);
+
+// Tabi, şablonları içiçe geçirebilirsin:
+Box<Box<int> > boxOfBox;
+boxOfBox.insert(intBox);
+
+// C++11'den önce iki '>' arasına boşluk koymak zorundaydık yoksa sağa kaydırma 
+// operatörü olarak algılanabilirdi.
+
+// Bazen şunu da görebilirsin
+//   template<typename T>
+// 'class' ve 'typename' anahtar sözcükleri çoğunlukla 
+// birbirlerinin yerine kullanılabilir. Tam açıklama için, bknz.
+//   http://en.wikipedia.org/wiki/Typename
+// (evet, bu anahtar sözcüğün kendi Wikipedia sayfası var).
+
+// Benzer şekilde, bir şablon fonksiyon:
+template<class T>
+void barkThreeTimes(const T& input)
+{
+    input.bark();
+    input.bark();
+    input.bark();
+}
+
+// Dikkat edersen tip parametresi hakkında birşey belirtilmedi. Derleyici bunları üretecek
+// ve her parametre geçişinde tip-kontrolü yapacaktır, bu nedenle de fonksiyon herhangi bir T
+// tipi için çalışacaktır!
+
+Dog fluffy;
+fluffy.setName("Fluffy")
+barkThreeTimes(fluffy); // Üç kere "Fluffy barks" yazdırır.
+
+// Şablonun parametresi sınıf olmak zorunda değildir:
+template<int Y>
+void printMessage() {
+  cout << "Learn C++ in " << Y << " minutes!" << endl;
+}
+
+// Ve template'i daha etkili kod için dışarıdan özelleştirebilirsin. 
+// Tabiki gerçek-dünya kullanımlarında özelleştirme bunun kadar kolay değildir.
+// Dikkat edersen, bütün parametreleri dıştan özelleştirmiş olsak bile
+// hala fonksiyonu (veya sınıfı( template olarak tanımlamamız gerekli.
+template<>
+void printMessage<10>() {
+  cout << "Learn C++ faster in only 10 minutes!" << endl;
+}
+
+printMessage<20>();  // "Learn C++ in 20 minutes!" yazdırır
+printMessage<10>();  // "Learn C++ faster in only 10 minutes!" yazdırır
+
+
+///////////////////////////////////////////////
+// İstisnai Durum Yönetimi (Exception Handling)
+///////////////////////////////////////////////
+
+// Standard kütüphane bazı istisnai tipler sağlar
+// (bknz http://en.cppreference.com/w/cpp/error/exception)
+// ama herhangi bir tip de istisnai durum fırlatabilir 
+
+#include <exception>
+#include <stdexcept>
+
+// _try_ bloğu içinde fırlatılan bütün istisnai durumlar, takip eden, _catch_ ile 
+// yakalanabilir.
+try {
+    // _new_ kullanarak heap'ten istisnai durumlar için yer ayırma
+    throw std::runtime_error("A problem occurred");
+}
+
+// istisnai durumlar nesne ise  const reference ile yakala
+catch (const std::exception& ex)
+{
+    std::cout << ex.what();
+}
+
+// Bir önceki _catch_ bloğundan kaçan istisnai durum burda yakala
+catch (...)
+{
+    std::cout << "Unknown exception caught";
+    throw; // Tekrardan istisnai durum fırlatır
+}
+
+///////
+// RAII
+///////
+
+// RAII, "Resource Acquisition Is Initialization" kelimelerinin kısaltmasıdır.
+// Bu Türkçe, "Kaynak alımı aynı zamanda ilk değer atamasıdır." olarak çevrilebilir.
+// Bunu basitçe constructor ile ayrılan hafızanın destructor ile iade edilmesi olarak 
+// düşünebiliriz.
+
+// Bunun ne şekilde kullanışlı olduğunu görmek için
+// bir C dosyasının, dosya işleme biçimine bakabiliriz:
+void doSomethingWithAFile(const char* filename)
+{
+    // Başlangıçta herşeyin yolunda gittiğini düşünelim
+
+    FILE* fh = fopen(filename, "r"); // Dosyayı okuma modunda aç
+
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+    fclose(fh); // Dosyayı kapat
+}
+
+// Malesef hatalarla başa çıkmaya çalışırken işler hızlıca karmaşıklaşır.
+// Mesela fopen'ın başarısız olduğunu varsayalım, ve doSoomethingWithTheFile ve 
+// doSomethingWithIt hata kodları gönderdi.
+//  (İstisnai durumlar yonetimi, hata koduna tercih ediler bir yöntemdir, ama bazı
+//   programcılar, özellikle C arkaplanı olanlar, aynı fikirde değildir.
+// Bu durumda her bir fonksiyon çağrısını kontrol etmeli ve bir problem oluştuysa
+// dosyayı kapatmalıyız.
+
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r");  // Dosyayı okuma modunda aç
+    if (fh == nullptr) // Başarısız olma durumunda dönen değer null olur
+        return false; // Başarısız olma durumunu çağırıcıya bildir
+
+    // Başarısız olma durumunda her iki fonksiyonun da false döndürdüğünü kabul edelim
+    if (!doSomethingWithTheFile(fh)) {
+        fclose(fh); // Dosyayı kapatalım, akıntı olmasın.
+        return false; // Hatayı bildir
+    }
+    if (!doSomethingElseWithIt(fh)) {
+        fclose(fh); // Dosyayı kapatalım, akıntı olmasın.
+        return false; // Hatayı bildir
+    }
+
+    fclose(fh); // Dosyayı kapat
+    return true; // Başarı durumunu ifade eder
+}
+
+// C programcıları biraz goto kullanarak bu durumu temizler
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r");
+    if (fh == nullptr)
+        return false;
+
+    if (!doSomethingWithTheFile(fh))
+        goto failure;
+
+    if (!doSomethingElseWithIt(fh))
+        goto failure;
+
+    fclose(fh); // Dosyayı kapat 
+    return true; // Başarı durumunu ifade eder
+
+failure:
+    fclose(fh);
+    return false; // Hatayı bildir
+}
+
+// Eğer fonksiyon istisnai durum yönetimi araçlarını kullanırsa
+// işler daha temiz olur ama hala en iyi durumun altında kalır.
+void doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r"); 
+    if (fh == nullptr)
+        throw std::runtime_error("Could not open the file.");
+
+    try {
+        doSomethingWithTheFile(fh);
+        doSomethingElseWithIt(fh);
+    }
+    catch (...) {
+        fclose(fh); // Hata durumunda dosyayı kapattığından emin ol
+        throw; // Sonra, tekrardan istisnai durum fırlat
+    }
+
+    fclose(fh); // Dosyayı kapat
+    // Herşey başarılı
+}
+
+// Şimdi aynı şeyi C++'ın dosya stream sınıfıyla (fstream) karşılaştıralım
+// fstream, dosyayı kapatmak için kendi destructor'ını kullanır.
+// Destructor'ın, nesne scope dışına çıktığında otomatik olarak çağrıldığını 
+// hatırlayın.
+void doSomethingWithAFile(const std::string& filename)
+{
+    std::ifstream fh(filename); // Dosyayı aç
+
+    // Dosyayla birşeyler yap
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+} // Dosya, destructor tarafından otomatik olarak kapatıldı
+
+// Bunun _çok büyük_ avantajları var:
+// 1. Ne olursa olursun,
+//    kaynak (bu örnekte dosya tutucusu) temizlenecektir.
+//    Destructor doğru yazıldığında,
+//    Tutucuyu kapatmayı unutma ve kaynak akıntısı _imkansız_dır.
+// 2. Kodun çok daha temiz olduğuna dikkat edin.
+//    Destructor, dosyayı kapatma işini, endilenmemize gerek kalmadan
+//    arka planda halleder.
+// 3. Kod, istisnai durumlara karşı korunaklıdır.
+//    İstisnai durum fonksiyonun herhangi bir yerinde fırlatılabilir ve
+//    temizleme işi gene de yapılır.
+
+// Bütün C++ kodu deyimleri RAII prensibini tüm kaynakları için kullanır.
+// Ek örnekler şunlardır:
+// - unique_ptr ve shared_ptr ile hafıza kullanımı
+// - Tutucular - standard kütüphane linked list,
+//   vector (yani kendiliğinden boyu ayarlanan dizi), hash map vs.
+//   scope'un dışına çıktığında içerini otomatik olarak yok eden tüm yapılar.
+// - lock_guard ve unique_lock kullanan mutex'ler
+
+///////////////////////////////////////
+// Lambda İfadeleri (C++11 ve yukarısı)
+///////////////////////////////////////
+
+// lambda'lar, tam olarak çağrıldığı yerde bir anonim fonksiyon tanımlamak
+// veya fonksiyona argüman geçmek için uygun bir yoldur.
+
+// Mesela, pair'lardan oluşan bir vector'u, pair'ın ikinci değerine 
+// göre sıralamak isteyelim
+
+vector<pair<int, int> > tester;
+tester.push_back(make_pair(3, 6));
+tester.push_back(make_pair(1, 9));
+tester.push_back(make_pair(5, 0));
+
+// sort fonksiyonuna üçüncü argüman olarak lambda ifadesini geç
+// sort, <algorithm> başlığında tanımlı
+
+sort(tester.begin(), tester.end(), [](const pair<int, int>& lhs, const pair<int, int>& rhs) {
+        return lhs.second < rhs.second;
+    });
+
+// Lambda ifadesinin söz dizimine dikkat edin, 
+// lambda'daki [], değişkenleri "tutmak" için kullanılır
+// "Tutma listesi", fonksiyon gövdesinde nelerin, ne şekilde erişilebilir olduğunu tanımlar
+// Şunlardan biri olabilir:
+// 	1. bir değer : [x]
+//	2. bir referans : [&x]
+//	3. mevcut scope içindeki herhangi bir değişkene referans ile [&]
+//	4. 3 ile aynı, ama değer ile [=]
+// Mesela:
+vector<int> dog_ids;
+// number_of_dogs = 3;
+for(int i = 0; i < 3; i++) {
+	dog_ids.push_back(i);
+}
+
+int weight[3] = {30, 50, 10};
+
+// Mesela dog_ids vector'unu dog'ların ağırlıklarına göre sıralamak isteyelim
+// Yani en sonunda şöyle olmalı: [2, 0, 1]
+
+// Burada lambda ifadesi oldukça kullanışlıdır
+
+sort(dog_ids.begin(), dog_ids.end(), [&weight](const int &lhs, const int &rhs) {
+        return weight[lhs] < weight[rhs];
+    });
+// Dikkat edersen "weight" dizisini referans ile aldık.
+// C++'da lambdalar hakkında daha fazla bilgi için : http://stackoverflow.com/questions/7627098/what-is-a-lambda-expression-in-c11
+
+//////////////////////////////////
+// Akıllı For (C++11 ve yukarısı)
+//////////////////////////////////
+
+// Akıllı for döngüsünü bir tutucuyu dolaşmak için kullanabilirsin
+int arr[] = {1, 10, 3};
+
+for(int elem: arr){
+	cout << elem << endl;
+}
+
+// Tutucunun elemanlarının tipi için endişe etmeden "auto" kullanabilirsin
+// Mesela:
+
+for(auto elem: arr) {
+	// arr dizisinin elemanlarıyla ilgili bir şeyler yap
+}
+
+////////////////
+// Güzel Şeyler
+////////////////
+
+// C++ dilinin bakış açısı yeni başlayanlar için (hatta dili iyi bilenler için bile)
+// şaşırtıcı olabilir. 
+// Bu bölüm, ne yazık ki, büyük ölçüde tam değil; C++ kendi ayağına ateş edilebilecek kolay
+// dillerden biridir.
+
+// private metodları override edebilirsin!
+class Foo {
+  virtual void bar();
+};
+class FooSub : public Foo {
+  virtual void bar();  // Foo::bar fonksiyonu override edilir!
+};
+
+
+// 0 == false == NULL (çoğu zaman)!
+bool* pt = new bool;
+*pt = 0; // 'pt'nin gösterdiği değere false atar.
+pt = 0;  // 'pt'ye null pointer atar. Her iki satır uyarısız derlenir.
+
+// nullptr'ın bu meselenin bazılarını çözmesi beklenmiştir:
+int* pt2 = new int;
+*pt2 = nullptr; // Derlenmez.
+pt2 = nullptr;  // pt2'ye null atar.
+
+// bool tipleri için bir istisna vardır.
+// Bu null pointer'ları if(!ptr) ile test etmek içindir.
+// ama sonuç olarak bir bool değerine nullptr atayabilirsin!
+*pt = nullptr;  // '*pt' değeri bir boll olmasına rağmen, hala derlenir!
+
+
+// '=' != '=' != '='!
+// Calls Foo::Foo(const Foo&) or some variant (see move semantics) copy
+// Foo::Foo(const Foo&) çağrısını veya kopyalama constructor'ının bir çeşidinin çağrısınıyapar(taşıma semantiklerine bknz.)
+Foo f2;
+Foo f1 = f2;
+
+// Foo::operator=(Foo&) çağrısını yapar.
+Foo f1;
+f1 = f2;
+
+
+///////////////////////////////////////
+// Tuple (C++11 ve yukarısı)
+///////////////////////////////////////
+
+#include<tuple>
+
+// Ana fikir olarak, Tuple, eski veri yapılarına (C'deki struct'lar) benzer ama isimli veri üyeleri yerine 
+// elemanlarına tuple içindeki sırasına göre erişilir.
+
+// Tuple'ı inşa ederek başlayalım
+// değişkenleri tuple içinde paketliyoruz
+auto first = make_tuple(10, 'A');
+const int maxN = 1e9;
+const int maxL = 15;
+auto second = make_tuple(maxN, maxL);
+
+// 'first' tuple'ının değerlerini yazdırma
+cout << get<0>(first) << " " << get<1>(first) << "\n"; // 10 A yazdırır
+
+// 'second' tuple'ının değerlerini yazdırma
+cout << get<0>(second) << " " << get<1>(second) << "\n"; // 1000000000 15 yazdırır
+
+// Değişkenleri tuple'dan çıkarma
+
+int first_int;
+char first_char;
+tie(first_int, first_char) = first;
+cout << first_int << " " << first_char << "\n";  // 10 A yazdırır
+
+// Ayrıca şu şekide de tuple oluşturabiliriz.
+
+tuple<int, char, double> third(11, 'A', 3.14141);
+// tuple_size, tuple'daki eleman sayısını (constexpr olarak) döndürür
+
+cout << tuple_size<decltype(third)>::value << "\n"; // 3 yazdırır
+
+// tuple_cat, tuple'daki tüm elemanları aynı sırada birleştirir.
+
+auto concatenated_tuple = tuple_cat(first, second, third);
+// concatenated_tuple = (10, 'A', 1e9, 15, 11, 'A', 3.14141) olur
+
+cout << get<0>(concatenated_tuple) << "\n"; // 10 yazdırır
+cout << get<3>(concatenated_tuple) << "\n"; // 15 yazdırır
+cout << get<5>(concatenated_tuple) << "\n"; // 'A' yazdırır
+
+
+/////////////////////
+// Tutucular
+/////////////////////
+
+// Tutucular veya Standard Şablon Kütüphanesi(STL) önceden tanımlanmış şablonlar sunar.
+// Bunlar elemanları için ayrılan hafıza alanını yönetir
+// ve onlara erişim ve değiştirmek için üye fonksiyonlar sağlar
+
+// Bazı tutucular şunlardır:
+
+// Vector (Dinamik Dizi)
+// koşma anında nesne dizisi veya list oluşturmamızı sağlar
+#include <vector>
+string val;
+vector<string> my_vector; // vector'ü tanımla
+cin >> val;
+my_vector.push_back(val); // val değerini my_vector vectörüne push edecektir
+my_vector.push_back(val); // val değerini yeniden push edecektir (şu an iki elemanı var)
+
+// vector içinde dolaşmak için iki seçenek var:
+// ya klasik döngüyle (0. index'ten son index'e kadar iterasyon yaparak)
+for (int i = 0; i < my_vector.size(); i++) {
+	cout << my_vector[i] << endl; // vector'ün elemanlarına uşamak için [] operatörünü kullanabiliriz
+}
+
+// ya da iteratör kulllanarak:
+vector<string>::iterator it; // vector için iterator tanımla
+for (it = my_vector.begin(); it != my_vector.end(); ++it) {
+	cout << *it  << endl;
+}
+
+// Set(Küme)
+// Set'ler benzersiz(unique) elemanları belirli bir sırada saklayan tutuculardır.
+// Set, benzersiz değerleri, herhangi bir fonksiyon veya kod gerektirmeksizin, sıralı olarak
+
+#include<set>
+set<int> ST;    // int tipi için set tanımlar
+ST.insert(30);  // ST kümesini 30 değerini dahil eder
+ST.insert(10);  // ST kümesini 10 değerini dahil eder
+ST.insert(20);  // ST kümesini 20 değerini dahil eder
+ST.insert(30);  // ST kümesini 30 değerini dahil eder
+// Şimdi kümedeki elemanlar aşağıdaki gibidir
+//  10 20 30
+
+// Bir eleman silmek için:
+ST.erase(20);  // 20 değerine sahip elemanı siler
+// Set ST: 10 30
+// Iterator kullanarak Set içinde iterasyon yapmak için:
+set<int>::iterator it;
+for(it=ST.begin();it<ST.end();it++) {
+	cout << *it << endl;
+}
+// Output:
+// 10
+// 30
+
+// Tutucuyu tamamen silmek için Tutucu_Adi.clear() kullanırız
+ST.clear();
+cout << ST.size();  // ST kümesinin eleman sayısı(size)nı yazdırır.
+// Output: 0
+
+// NOTE: Aynı elemanlari içerebilen kümle için multiset kullanırız
+
+// Map(Harita)
+// Map, elemanları anahtar değer, haritalanmış değer şeklinde özel bir sırada saklar.
+// anahtar_değer -> haritalanmış_değer
+
+#include<map>
+map<char, int> mymap;  // Anahtar char ve değer int olacak şekilde map tanımlar
+
+mymap.insert(pair<char,int>('A',1));
+// 1 değeri için A anahtar değerini ekler
+mymap.insert(pair<char,int>('Z',26));
+// 26 değeri için Z anahtar değerini ekler
+
+// Map'te dolaşma
+map<char,int>::iterator it;
+for (it=mymap.begin(); it!=mymap.end(); ++it)
+    std::cout << it->first << "->" << it->second << '\n';
+// Output:
+// A->1
+// Z->26
+
+// Anahtar'a atanmış değeri bulmak için
+it = mymap.find('Z');
+cout << it->second;
+
+// Output: 26
+
+
+/////////////////////////////////////////////
+// Mantıksal ve Bit seviyesindeki operatörler
+/////////////////////////////////////////////
+
+// Pek çok C++ operatörleri diğer dillerdekiyle aynıdır
+
+// Mantıksal operatörler
+
+// C++, bool ifadelerinde Kısa-devre değerlendirmesini kullanır yani ikinci argüman yalnızca ilk argüman
+// ifadenin değerine karar vermek için yeterli değilse çalıştırılır
+
+true && false // **mantıksal ve** işlemi yapılır ve yanlış sonucu üretilir
+true || false // **mantıksal veya** işlemi yapılır ve true  sonucu üretilir 
+! true        // **mantıksal değil** işlemi yapılır ve yalnış sonucu üretilir
+
+// Sembolleri kullanmak yerine onlara karşılık gelen anahtar kelimeler kullanılabilir
+true and false // **mantıksal ve** işlemi yapılır ve yanlış sonucu üretilir
+true or false  // **mantıksal veya** işlemi yapılır ve true  sonucu üretilir 
+not true       // **mantıksal değil** işlemi yapılır ve yalnış sonucu üretilir
+
+// Bit seviyesindeki operatörler
+
+// **<<** Sola kaydırma operatörü
+// << bitleri sola kaydırır
+4 << 1 // 4'ün bitlerini 1 sola kaydırır ve 8 sonucunu verir
+// x << n, x * 2^n olarak düşünülebilir
+
+
+// **>>** Sağa kaydırma operatörü
+// >> bitleri sağa kaydırır
+4 >> 1 // 4'ün bitlerini 1 sağa kaydırır ve 2 sonucunu verir
+// x >> n, x / 2^n olarak düşünülebilir
+
+~4    // Bit seviyesinde değil işlemini gerçekleştirir
+4 | 3 // Bit seviyesinde veya işlemini gerçekleştirir
+4 & 3 // Bit seviyesinde ve işlemini gerçekleştirir
+4 ^ 3 // Bit seviyesinde xor işlemini gerçekleştirir
+
+// Eşdeğer anahtar kelimeler
+compl 4    // Bit seviyesinde değil işlemini gerçekleştirir
+4 bitor 3  // Bit seviyesinde veya işlemini gerçekleştiri
+4 bitand 3 // Bit seviyesinde ve işlemini gerçekleştirir
+4 xor 3    // Bit seviyesinde xor işlemini gerçekleştirir
+
+
+```
+İleri okuma:
+
+* Güncel bir referans [CPP Reference](http://cppreference.com/w/cpp) adresinde bulunabilir.
+* Ek kaynaklar [CPlusPlus](http://cplusplus.com) adresinde bulunabilir.
+* Dilin temellerini ve kodlama ortamını belirleyen bir öğretici [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb) adresinde bulunabilir.
diff --git a/tr-tr/clojure-tr.html.markdown b/tr-tr/clojure-tr.html.markdown
new file mode 100644
index 00000000..5ebe5ce6
--- /dev/null
+++ b/tr-tr/clojure-tr.html.markdown
@@ -0,0 +1,491 @@
+---
+language: clojure
+lang: tr-tr
+filename: learnclojure-tr.clj
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+    - ["Seçkin KÜKRER", "https://leavenha.github.io"]
+translators:
+    - ["Seçkin KÜKRER", "https://leavenha.github.io"]
+---
+
+[JVM]: https://tr.wikipedia.org/wiki/Java_sanal_makinesi
+[STM]: https://en.wikipedia.org/wiki/Software_transactional_memory
+
+Clojure, Lisp dialekti, barınan bir dildir. [JVM][JVM] üzerinde barınıyor. Clojure, Lisp'in tüm gücü ve kendi mantalitesi ile mükemmel bir genel-amaçlı programlama dilidir. Clojure, Eş-zamanlı programlama, Makrolar, Fonksiyonel Programlama, Tembel yapılar ve daha fazlasını vaadediyor.
+
+(Bu örnekleri çalıştırmak için Clojure 1.2 versionu veya daha yenisine sahip olmalısınız.)
+
+
+```clojure
+; Noktalı Virgül, satırı yorumlamak için kullanılır.
+
+; Clojure programları formlardan meydana gelir,
+; Parantezlerle çevirili değerler, boşluk ile ayrılır. --Virgül ile değil--
+;
+; Clojure okuyucusu*, listedeki ilk elemanı çağırılacak bir fonksiyon
+; Veya makro, geri kalan ifadeleri o çağırıma argüman olarak kabul eder.
+;
+
+; Bir dosyadaki ilk çağırım isim-uzayı tanımlamak için `ns` olmalı.
+(ns clojure-öğren)
+
+;
+; Bir diğer yorumlama seçeneği de, ifade-içi. Bu diyez (`#`), ve alt çizgi
+; İle başlar ve herhangi bir s-ifade'ye uygulanabilir.
+;
+#_(bu çağırım değerlendirilmeyecektir)
+
+; Öncelikle fonksiyon çağırımları ve temel işlemler:
+
+; Örnek bir fonksiyon çağırımı:
+; (örnek-bir-fonksiyon ilk-argüman ikinci-argüman)
+
+; `str` aldığı argümanları bir karakter katarı olarak geri verir.
+(str "Merhaba" " " "dünya!") ; => "Merhaba dünya!"
+
+; Matematik, oldukça sezgisel ve basit
+(+ 1 1) ; => 2
+(- 2 1) ; => 1
+(* 1 2) ; => 2
+(/ 2 1) ; => 2
+
+; Eşitlik için `=`
+(= 1 1) ; => true
+(= 2 1) ; => false
+
+; `not` beklediğiniz gibi, mantıksal ifadeleri tersine çevirir.
+(not true) ; => false
+
+; Clojure formları, iç-içe çağırılabilir
+; Değerlendirilen çağırımlar bir üst form'a argüman
+; Olarak verilir.
+(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2
+
+; Tipler
+;;;;;;;;;;;;;
+
+; Clojure, Java'nın temel tipleri olan mantıksal (boolean),
+; Tam sayılar (int) ve karakter katarlarını (string) kullanır.
+; Değerleri denetlemek için `class` fonksiyonunu kullanın.
+(class 1) ; Tam sayı sabitleri ön-tanımlı olarak `java.lang.Long` ile tanımlanır.
+(class 1.); Kayan noktalı sayı sabitleri
+; Ön-tanımlı olarak `java.lang.Double` ile tanımlanır.
+(class ""); Karakter katarı sabitleri her zaman, --sadece-- çift tırnak
+; ile tanımlanır ve ön-tanımlı olarak `java.lang.String` tipindedir.
+(class false) ; Mantıksal değer sabitleri, `java.lang.Boolean`.
+(class nil); "Null", (tanımsız) değerler `nil` ile tanımlanır.
+
+; Clojure okuyucusu her paranter ifadesini bir çağırım olarak
+; değerlendirdiğinden bir liste tanımlamak için çağırımı durdurmalıyız.
+'(+ 1 2) ; => (+ 1 2)
+; ((quote (+ 1 2)) için bir kısa yoldur)
+
+; Alıntılanmış listeleri çağırabilirsiniz.
+(eval '(+ 1 2)) ; => 3
+
+; Koleksiyonlar ve Ardışıklar
+;;;;;;;;;;;;;;;;;;;
+
+; Listeler bağlı-liste veri yapısı,
+; Vektörler dizi altyapısı kullanır. 
+(class '(1 2 3)); => clojure.lang.PersistentList
+(class [1 2 3]); => clojure.lang.PersistentVector
+
+; Bir liste `(1 2 3)` şeklinde gösterilebilir, yazılabilir.
+; Fakat bu listeyi, Alıntılamalıyız --Quote--.
+; Bu, onu bir fonksiyon çağırımı olarak değil,
+; bir liste olarak değerlendirilmesini sağlayacaktır.
+; Ayrıca, `(list 1 2 3)` tamamen `'(1 2 3)` ifadesi ile
+; eşdeğerdir.
+
+; 'Koleksiyonlar' sadece bir veri grubudur.
+; Vektörler ve Listeler, koleksiyondur:
+(coll? '(1 2 3)) ; => true
+(coll? [1 2 3]) ; => true
+
+; 'Ardışıklar' (seqs), bir veri listesinin soyut tanımlamasıdır.
+; Sadece listeler ardışıktır.
+(seq? '(1 2 3)) ; => true
+(seq? [1 2 3]) ; => false
+
+; Bir ardışık, ulaşıldığında sadece giriş verisi vermelidir.
+; Yani, ardışıklar tembel olabilir. | Sonsuz ardışıklar tanımlanabilir.
+(range 4) ; => (0 1 2 3)
+(range) ; => (0 1 2 3 4 ...) (sonsuz bir ardışık)
+(take 4 (range)) ;  (0 1 2 3)
+
+; Bu yapılarda ekleme işlemi için `cons` kullanılır.
+(cons 4 [1 2 3]) ; => (4 1 2 3)
+(cons 4 '(1 2 3)) ; => (4 1 2 3)
+
+; `conj` bir koleksiyona en verimli şekilde veri ekler.
+; Bu, listeler için liste başına, vektörler için ise vektör sonuna demektir.
+(conj [1 2 3] 4) ; => [1 2 3 4]
+(conj '(1 2 3) 4) ; => (4 1 2 3)
+
+; `concat` koleksiyonları birleştirmek için kullanılır.
+(concat [1 2] '(3 4)) ; => (1 2 3 4)
+
+; `filter` ve `map` koleksiyonlarla işlem yapmak için
+; ön-tanımlı yüksek-seviyeli fonksiyonlardır.
+;
+; ps: `inc` argümanını bir arttıran bir fonksiyon.
+(map inc [1 2 3]) ; => (2 3 4)
+(filter even? [1 2 3]) ; => (2)
+
+; Koleksiyonları indirgemek için `reduce` kullanılır.
+(reduce + [1 2 3 4])
+; = (+ (+ (+ 1 2) 3) 4)
+; => 10
+
+; Reduce, bir ilk-tanım değeri alabilir.
+(reduce conj [] '(3 2 1))
+; = (conj (conj (conj [] 3) 2) 1)
+; => [3 2 1]
+
+; Fonksiyonlar
+;;;;;;;;;;;;;;;;;;;;;
+
+; Yeni bir fonksiyon oluşturmak için `fn` kullanın.
+; Bir fonksiyon her zaman son ifadesini döndürür.
+(fn [] "Merhaba Dünya!") ; => fn
+
+; Fonksiyonu çağırmak için bir çift paranteze daha ihtiyaç var.
+((fn [] "Merhaba Dünya!")) ; => "Merhaba Dünya!"
+
+; İsim uzayında bir değişken tanımlamak için `def`
+; kullanılır.
+(def x 1)
+x ; => 1
+
+; Bir değişkene fonksiyon değeri atamak için,
+(def merhaba-dünya (fn [] "Merhaba Dünya!"))
+(merhaba-dünya) ; => "Merhaba Dünya!"
+
+; Bu süreci, `defn` ile kısaltabiliriz.
+(defn hello-world [] "Merhaba Dünya!")
+
+; `defn` fonksiyon çağırımındaki üçüncü eleman
+; --vektör-- bir argüman listesidir. Fonksiyonun alacağı
+; argümanları tanımlar.
+(defn merhaba [isim]
+  (str "Merhaba " isim))
+(merhaba "Dünya!") ; => "Merhaba Dünya!"
+
+; Ayrıca, `#()` kısa yolunu, fonksiyon deklare etmek için
+; kullanabiliriz.
+(def merhaba2 #(str "Merhaba " %1))
+(merhaba2 "Dünya!") ; => "Merhaba Dünya!"
+
+; Çok düzeyli fonksiyonlar da tanımlanabilir,
+(defn merhaba3
+  ([] "Merhaba Dünya!")
+  ([isim] (str "Merhaba " isim)))
+(merhaba3) ; => "Merhaba Dünya!"
+(merhaba3 "A. NESİN!") ; => "Hello A. NESİN!"
+
+; Fonksiyonlar, belirsiz-sayıda argüman alabilir,
+; ve bunları sizin için bir ardışıkta depolayabilir.
+(defn argüman-sayısı [& argümanlarım]
+  (str "Verilen argüman sayısı:" (count argümanlarım) ", argümanlar: " argümanlarım))
+(argüman-sayısı "Öğün" "Çalış" "Güven")
+; => "Verilen argüman sayısı:3, argümanlar: ("Öğün" "Çalış" "Güven")"
+
+; Elbette, sıradan ve belirsiz-sayılı fonksiyon argümanlarını
+; harmanlayabilirsiniz.
+(defn merhabalar [ev-sahibi & misafirler]
+  (str "Merhabalar, " misafirler ". Benim adım " ev-sahibi "."))
+(merhabalar "İklim" "Ayşe" "Fatma" "Nurdan")
+; => "Merhabalar, (\"Ayşe\" \"Fatma\" \"Nurdan\"). Benim adım İklim."
+
+
+; Eşlemeler
+;;;;;;;;;;
+
+; Hash-Maps, Array-Maps
+; Hash-Eşlemeleri ve Dizi-Eşlemeleri bir arayüzü paylaşırlar.
+; Hash-Eşlemeleri daha hızlıdır, fakat anahtar sıralaması tutmazlar.
+(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap
+(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap
+
+; Dizi-Eşlemeleri bir çok işlem sırasında otomatik olarak Hash-Eşlemelerine
+; dönüşürler. Eğer yeterince büyürlerse, endişelenmenize gerek yoktur.
+
+; Eşlemeler anahtar değeri olarak herhangi hash-ifadesi (hashable)
+; alabilirler. Ama çoğunlukla, bu iş için anahtar-kelimeler `keyword`
+; kullanılır.
+; Anahtar-kelimeler, karakter katarları gibidirler, fakat
+; bir kaç artıları vardır.
+(class :a) ; => clojure.lang.Keyword
+
+(def karakterkatarı-eşlemesi {"a" 1, "b" 2, "c" 3})
+karakterkatarı-eşlemesi  ; => {"a" 1, "b" 2, "c" 3}
+
+(def anahtar-eşlemesi {:a 1, :b 2, :c 3})
+anahtar-eşlemesi ; => {:a 1, :c 3, :b 2}
+
+; Bu arada, virgüller her zaman boşluk olarak değerlendirilir
+; ve etkisizdirler.
+
+; Bir eşlemeleden fonksiyon notasyonu ile değer çağırmak,
+(karakterkatarı-eşlemesi "a") ; => 1
+(anahtar-eşlemesi :a) ; => 1
+
+; Keyword tipleri kendi değerlerini argüman olarak aldıkları bir
+; eşlemeden değer notasyonu ile çağırabilirler.
+(:b anahtar-eşlemesi) ; => 2
+
+; Bu notasyonu, bir karakter katarı ile denemeyiniz.
+;("a" karakterkatarı-eşlemesi)
+; => Exception: java.lang.String cannot be cast to clojure.lang.IFn
+
+; Verilmemiş bir değeri çağırmak, `nil` döndürecektir.
+(karakterkatarı-eşlemesi "d") ; => nil
+
+; Eşlemelere yeni değerler eklemek için `assoc` kullanırız.
+(def yeni-anahtar-eşlemesi (assoc anahtar-eşlemesi :d 4))
+yeni-anahtar-eşlemesi ; => {:a 1, :b 2, :c 3, :d 4}
+
+; Ama unutmayın, Clojure veri yapıları değişmezdir!
+anahtar-eşlemesi ; => {:a 1, :b 2, :c 3}
+
+; Değer silmek için ise `dissoc` kullanılır.
+(dissoc anahtar-eşlemesi :a :b) ; => {:c 3}
+
+; Kümeler
+;;;;;;
+
+(class #{1 2 3}) ; => clojure.lang.PersistentHashSet
+(set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3}
+
+; `conj` ile bir değer eklenir.
+(conj #{1 2 3} 4) ; => #{1 2 3 4}
+
+; `disj` ile değer çıkarılır.
+(disj #{1 2 3} 1) ; => #{2 3}
+
+; Fonksiyon notasyonu kümelerde de tanımlıdır.
+; Kendi içlerinde değer arayan bir fonksiyon olarak
+; kullanılabilirler.
+(#{1 2 3} 1) ; => 1
+(#{1 2 3} 4) ; => nil
+
+; `clojure.sets` isim-uzayında daha fazla fonksiyon vardır.
+
+; Kullanışlı Formlar
+;;;;;;;;;;;;;;;;;
+
+; Clojure için mantıksal yapılar bir özel-form'dur.
+; Ve diğer fonksiyonlar gibi kullanılabilir.
+; `if` fonksiyonunun ilk argümanı bir test ifadesidir.
+(if true "ya şundadır" "ya bunda") ; => "ya şundadır"
+; İkinci ifade doğru, üçüncü ifade ise yanlışsa ifadeleridir.
+; Eğer test terimi doğru olarak değerlendirilirse,
+; doğru ifadesi, yanlışsa yanlış ifadesi değerlendirilir ve döndürülür.
+;
+; Bir yanlışsa ifadesi yoksa `nil` döndürülür.
+(if false "a") ; => nil
+
+; Yerel geçici-değişken tanımlamak için `let` kullanılır.
+; İfadelerin varlığı `let` çağırımı ile sınırlıdır.
+(let [a 1 b 2]
+  (> a b)) ; => false
+
+; İfade ve çağırımları `do` ile gruplayabilirsiniz.
+; Çağırımların sonuncusu `do` ifadesinin değeri olarak 
+; döndürülecektir.
+(do
+  (print "Selamlar!")
+  "Dünya!") ; => "Dünya!" (prints "Selamlar!")
+
+; Fonksiyonlar kapalı bir `do` ifadesi ile çevrelenmiştir.
+(defn yazdır-ve-selamla! [isim]
+  (println "Merhaba, " isim "!")
+  (str "Merhaba, " isim "!"))
+(yazdır-ve-selamla! "Zübeyde") ;=> "Merhaba, Zübeyde!" ("Merhaba, Zübeyde!" yazdırır.)
+
+; `let` ifadesi de kapalı bir `do` ile gelmektedir.
+(let [isim "Ayten"]
+  (print "Merhabalar, " isim)
+  (str "Merhabalar, " isim)) ; => "Merhabalar, " ("Merhabalar, Ayten" yazdırır)
+
+; Sıralama-makroları (-> ve ->>) ile veri dönüşümünü daha temiz ifade
+; edebilirsiniz.
+; Bu makrolar ilk argümanı sonraki her çağırımın içine yerleştirir.
+;
+; `->` makrosu, ifadeyi çağırımların ilk argümanı olacak şekilde yerleştirir.
+(->
+   {:a 1 :b 2} 
+   (assoc :c 3) ;=> (assoc {:a 1 :b 2} :c 3)
+   (dissoc :b))
+   
+; Bu ifade aşağıdaki şekilde yazılabilir:
+; (dissoc (assoc {:a 1 :b 2} :c 3) :b)
+; ve `{:a 1 :c 3}` olarak değer bulur.
+
+; Sondan-Sıralama-Makrosu (->>) ise aynı şeyi yapar,
+; tek fark ise, ifadeyi, çağırımların son argümanı olarak yerleştirir.
+;
+(->>
+   (range 10)    ;=> '(0 1 2 3 4 5 6 7 8 9)
+   (map inc)     ;=> (map inc (range 10))
+   (filter odd?) ;=> (filter odd? (map inc (range 10)))
+   (into []))    ;=> (into [] (filter odd? (map inc (range 10))))
+                 ; Sonuç: [1 3 5 7 9]
+
+; Bir ifadedeki önceki veri dönüşümlerinin sonucunu nereye
+; koyacağınız konusunda daha fazla özgürlük istediğiniz bir durumda,
+; Sıralama-Makrolarından daha özgür bi' şey kullanmak istersiniz;
+; `as->` makrosu ile dönüşümlerin çıktısına bir isim atayabilir
+; ve ardışık çağırımlarda yer tutucu olarak kullanabilirsiniz.
+
+(as-> [1 2 3] girdi
+  (map inc girdi);=> ifadeyi isterseniz çağırımın son argümanı olarak,
+  (nth girdi 2) ;=>  veya çağırımın ilk argümanı olarak, 
+  (conj [4 5 6] girdi [8 9 10])) ;=> ya da istediğiniz sırada kullanabilirsiniz.
+;=> [4 5 6 4 [8 9 10]]
+
+
+
+; Modüller
+;;;;;;;;;;;;;;;
+
+; `use` çağırdığınız modüldeki tüm tanımlara erişmenize olanak verir.
+(use 'clojure.set)
+
+; Şu anda, küme fonksiyonlarını kullanabiliriz.
+(intersection #{1 2 3} #{2 3 4}) ; => #{2 3}
+(difference #{1 2 3} #{2 3 4}) ; => #{1}
+
+; Ayrıca eklenecek fonksiyonları seçebilirsiniz de:
+(use '[clojure.set :only [intersection]])
+
+; Bir modülü eklemek için `require` kullanılır. 
+(require 'clojure.string)
+
+; İsim-uzayı kapsamlı çağırımlar aşağıdaki şekildedir:
+; isim-uzayı/fonksiyon-ismi --isim uzayı ismi ve fonksiyon ismi
+; arasına eğik çizgi koymanız yeterli.
+; Burada, modül `clojure.string` ve fonksiyon ismi `blank?`
+(clojure.string/blank? "") ; => true
+
+; Ekleme sırasında, bir modüle takma-ad verilebilir.
+(require '[clojure.string :as str])
+(str/replace "Bu bir özet metindir, test için kullanılabilir!"
+  #"[aeıioöuü]" str/upper-case)
+; => "BU bIr ÖzEt mEtIndIr, tEst IçIn kUllAnIlAbIlIr!"
+; (#"", burada düzenli ifadeler için bir sözdizimsel-şekerlemeyi ifade eder)
+
+; Bir isim-uzayı tanımlamasında `require` kullanılabilir.
+; `ns` bir makrodur ve `require` (ve `use`, ama lütfen kullanmayın)
+; dahil olmak üzere bir çok çağırım için işlevsellik sağlamaktadır.
+; Bu notasyonu kullanırsanız, modüllerinizi alıntılamak zorunda kalmazsınız.
+(ns test
+  (:require
+    [clojure.string :as str]
+    [clojure.set :as set]))
+
+
+; Java
+;;;;;;;;;;;;;;;;;
+
+; Java, kocaman ve kullanışlı bir standart kütüphaneye sahip,
+; Clojure, Java etkileşimi ile, bundan yararlanabilirsiniz.
+
+; `import` diğer modüller gibi, bir java modülü de ele alabilir.
+; Date, bir Java modülü.
+(import java.util.Date)
+
+; `ns` çağırımında da kullanabilirsiniz.
+(ns test
+  (:import java.util.Date
+           java.util.Calendar))
+           
+; Bir Java nesnesinden oluşturmak için `new` çağırımını kullanabilirsiniz.
+(new Date)
+
+; Ayrıca Clojure Okuyucusu, size bunun daha farklı bir yolunu sunar:
+; Sınıf isminin sonuna koyulacak bir nokta `.` ile
+; bu yapılabilir.
+(Date.) ; <bir tarih nesnesi>
+
+; `.` --nokta-- çağırımı, size nesnelerdeki metotlara erişme imkanı verir.
+(. (new Date) getTime) ; <bir zaman-damgası>
+(.getTime (Date.)) ; Üstteki ifade ile tamamen aynı sonucu verir.
+
+; Sınıf içindeki statik metotlara erişmek için `/` ayracını
+; sınıf ile metot ismi birleştirmek için kullanabilirsiniz.
+; (örnekSınıf/statikMetot)
+(System/currentTimeMillis) ; <bir zaman-damgası> (`system` her zaman sunulur)
+
+; Sınıflarla işlem yaparken, `doto` bu süreci kolaylaştırabilir.
+; İlk argüman sınıf nesnesi, sonraki her çağırım, nesne üzerinde yapılır.
+(import java.util.Calendar)
+(doto (Calendar/getInstance)
+  (.set 2000 1 1 0 0 0) ; => `set` metodu, `doto` ifadesine verilen
+                        ; sınıf nesnesi üzerinde çağırılır.
+  .getTime) ; => Bir tarih nesnesi. set to 2000-01-01 00:00:00
+
+
+; STM
+;;;;;;;;;;;;;;;;;
+
+; 'Software Transactional Memory' Clojure'un değişmez veri yapılarını
+; ele alırken kullandığı bir mekanizmadır. Clojure içinde bunu kullanan
+; birkaç yapı vardır.
+
+; Bir `atom` en basitidir. Bir ilkleme-değeri verin.
+(def benim-atomum (atom {}))
+
+; Bir atomu güncellemek için `swap!` kullanılır.
+; `swap!` fonksiyonu, ilk argüman olarak aldığı atomu, ikinci argüman
+; olarak aldığı fonksiyona uygular. Bu fonksiyona ek argümanlar ise
+; fonksiyondan sonra gelirler.
+(swap! benim-atomum assoc :a 1)
+; benim-atomum'un değerini (assoc {} :a 1) ifadesinin sonucu ile değiştirir.
+(swap! benim-atomum assoc :b 2)
+; benim-atomum'un değerini (assoc {:a 1} :b 2) ifadesinin sonucu ile değiştirir.
+
+; `deref` ile, atomun değerini çözümleyebilirsiniz. 
+benim-atomum  ;=> Atom<#...> (Atom ifadesi döndürür)
+@benim-atomum ; => {:a 1 :b 2}
+
+; İşte, `atom` kullanan basit bir sayaç.
+(def sayaç (atom 0)) ;=> Şu anki isim uzayına, `sayaç` ile, 0 başlangıç
+; değeri ile bir atom tanımladık.
+(defn sayaç-arttır [benim-atomum]
+  (swap! sayaç inc)) ;=> Atom'un değerini bir arttır.
+
+(sayaç-arttır sayaç)
+(sayaç-arttır sayaç)
+(sayaç-arttır sayaç)
+(sayaç-arttır sayaç)
+(sayaç-arttır sayaç)
+(sayaç-arttır sayaç)
+
+@sayaç ; => 6
+
+; Diğer STM yapıları `ref`'ler ve `agent`'lar.
+; Ref'ler: http://clojure.org/refs
+; Agent'lar: http://clojure.org/agents
+```
+
+### Çevirim-içi içerikler
+
+Bu içerik, Rich Hickey'nin derin yazılım geliştirme anlayışına ve John McCarthy'nin vizyonu olan Lisp'in, Clojure'a miras verdiklerini anlamak için elbette yeterli değildir. Fakat fonksiyonel paradigma ve bu paradigmanın modern bir Lisp lehçesinde kullanımına göz kırpmış oldunuz.
+
+Clojure.org, bir çok içerik ve makale var. (İngilizce içerik):
+[http://clojure.org/](http://clojure.org/)
+
+Clojuredocs.org, örneklerle bezenmiş Clojure dökümantasyonu:
+[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
+
+4Clojure, interaktif bir şekilde FP ve Clojure yeteneklerinizi geliştirmenize olanak veriyor:
+[http://www.4clojure.com/](http://www.4clojure.com/)
+
+Clojure-doc.org, Başlangıç için bir içeriklere sahip:
+[http://clojure-doc.org/](http://clojure-doc.org/)
+
+BraveClojure, bir başka clojure öğreten web sitesi:
+[https://www.braveclojure.com/](https://www.braveclojure.com/)
diff --git a/tr-tr/dynamic-programming-tr.html.markdown b/tr-tr/dynamic-programming-tr.html.markdown
index 606ecf04..e6a734a7 100644
--- a/tr-tr/dynamic-programming-tr.html.markdown
+++ b/tr-tr/dynamic-programming-tr.html.markdown
@@ -8,24 +8,28 @@ translators:
 lang: tr-tr
 ---
 
-Dinamik Programlama
-Giriş
+# Dinamik Programlama
+
+## Giriş
+
 Dinamik Programlama, göreceğimiz gibi belirli bir problem sınıfını çözmek için kullanılan güçlü bir tekniktir. Fikir çok basittir, verilen girdiyle ilgili bir sorunu çözdüyseniz, aynı sorunun tekrar çözülmesini önlemek için sonucunu gelecekte referans olarak kaydedilmesine dayanır.
 
 Her zaman hatırla! "Geçmiş hatırlayamayanlar, aynı şeyleri tekrar yaşamaya mahkumlardır!"
 
-Bu tür sorunların çözüm yolları
+## Bu tür sorunların çözüm yolları
 
-1-Yukarıdan aşağıya:
+1. Yukarıdan aşağıya:
 Verilen problemi çözerek çözmeye başlayın. Sorunun zaten çözüldüğünü görürseniz, kaydedilen cevabı döndürmeniz yeterlidir. Çözülmemişse, çözünüz ve cevabı saklayınız. Bu genellikle düşünmek kolaydır ve çok sezgiseldir. Buna Ezberleştirme denir.
 
-2-Aşağıdan yukarıya:
+2. Aşağıdan yukarıya:
 Sorunu analiz edin ve alt problemlerin çözülme sırasını görün ve önemsiz alt sorundan verilen soruna doğru başlayın. Bu süreçte, problemi çözmeden önce alt problemlerin çözülmesi gerekmektedir. Buna Dinamik Programlama denir.
 
-Örnek
-En Uzun Artan Subsequence problemi belirli bir dizinin en uzun artan alt dizini bulmaktır. S = {a1, a2, a3, a4, ............., an-1} dizisi göz önüne alındığında, en uzun bir alt kümeyi bulmak zorundayız, böylece tüm j ve i, j için <I, aj <ai alt kümesinde. Her şeyden önce, en son alt dizgenin (LSi) değerini dizinin son elemanı olan ai'nin her indeksinde bulmalıyız. Daha sonra en büyük LSi, verilen dizideki en uzun alt dizin olacaktır. Başlamak için, ai, dizinin elemanı olduğundan (Son öğe) LSi atanır. Sonra tüm j için j <i ve aj <ai gibi, En Büyük LSj'yi buluruz ve LSi'ye ekleriz. Sonra algoritma O (n2) zaman alır.
+## Örnek
+
+En Uzun Artan Subsequence problemi belirli bir dizinin en uzun artan alt dizini bulmaktır. `S = {a1, a2, a3, a4, ............., an-1}` dizisi göz önüne alındığında, en uzun bir alt kümeyi bulmak zorundayız, böylece tüm j ve i, `j<I` için , `aj<ai` alt kümesinde. Her şeyden önce, en son alt dizgenin (LSi) değerini dizinin son elemanı olan ai'nin her indeksinde bulmalıyız. Daha sonra en büyük LSi, verilen dizideki en uzun alt dizin olacaktır. Başlamak için, ai, dizinin elemanı olduğundan (Son öğe) LSi atanır. Sonra tüm j için `j<i` ve `aj<ai` gibi, En Büyük LSj'yi buluruz ve LSi'ye ekleriz. Sonra algoritma `O(n2)` zaman alır.
 
-En uzun artan alt dizinin uzunluğunu bulmak için sözde kod: Bu algoritmaların karmaşıklığı dizi yerine daha iyi veri yapısı kullanılarak azaltılabilir. Büyük dizin ve dizin gibi selefi dizi ve değişkeni saklama çok zaman kazandıracaktır.
+En uzun artan alt dizinin uzunluğunu bulmak için sözde kod:
+Bu algoritmaların karmaşıklığı dizi yerine daha iyi veri yapısı kullanılarak azaltılabilir. Büyük dizin ve dizin gibi selefi dizi ve değişkeni saklama çok zaman kazandıracaktır.
 
 Yönlendirilmiş asiklik grafiğinde en uzun yolu bulmak için benzer bir kavram uygulanabilir.
 
@@ -40,10 +44,12 @@ for i=0 to n-1
     
 ```  
 
-Bazı Ünlü Dinamik Programlama Problemleri
--Floyd Warshall Algorithm - Tutorial and C Program source code:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs—floyd-warshall-algorithm-with-c-program-source-code
--Integer Knapsack Problem - Tutorial and C Program source code: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming—the-integer-knapsack-problem
--Longest Common Subsequence - Tutorial and C Program source code : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming—longest-common-subsequence
+### Bazı Ünlü Dinamik Programlama Problemleri
+
+- Floyd Warshall Algorithm - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code]()
+- Integer Knapsack Problem - Tutorial and C Program source code: [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem]()
+- Longest Common Subsequence - Tutorial and C Program source code : [http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence]()
+
+## Online Kaynaklar
 
-Online Kaynaklar
-https://www.codechef.com/wiki/tutorial-dynamic-programming
+- [codechef](https://www.codechef.com/wiki/tutorial-dynamic-programming)
diff --git a/tr-tr/edn-tr.html.markdown b/tr-tr/edn-tr.html.markdown
new file mode 100644
index 00000000..9a2ac1ff
--- /dev/null
+++ b/tr-tr/edn-tr.html.markdown
@@ -0,0 +1,157 @@
+---
+language: edn
+filename: learnedn-tr.edn
+lang: tr-tr
+contributors:
+  - ["Seçkin KÜKRER", "https://github.com/LeaveNhA"]
+---
+
+# Y = 20 Dakika.
+
+### Genişletilebilir Veri Notasyonu (EDN, Extensible Data Notation).
+
+### Okunuşu: (Türkçe: ey-di-en), (English: eed-n)
+
+### Kodlama Türü: UTF-8
+
+EDN Clojure sözdiziminin bir alt kümesidir. Bu alt küme, amacı gereği kod barındırmaz. Ve kendisi bir tip sistemi değildir. Bir şeması da yoktur. En basit tabirle; Genişletilebilir Veri Notasyonu kabul edilebilir elemanların bir kümesidir.
+
+EDN elementleri, akışları ve dosyaları UTF-8 kullanılarak kodlanmalıdır. Üstelik, dökümanı çevreleyen işaretçiler de olmadığı için akış, dağıtık programlama mesaj arayüzü ve diğer dinamik sistemler için idealdir.
+
+
+```clojure
+; Yorumlar, yorumlarımız, noktalı virgül ile başlıyor.
+;; Genellikle ikili olarak kullanılıyorlar.
+
+;; |--------------------------------|
+;  |--------- Genel Yapısı ---------|
+;; |--------------------------------|
+
+;; Boşluklar --whitespaces--, elementler için en yaygın ayıraçtır.
+"Mustafa" "Kemal" "ATATÜRK"
+;; Fakat okunuşu arttırdığı gerekçesiyle "," (virgüller --commas--) EDN yorumlayıcısı tarafından görmezden gelinir ve boşluk olarak nitelendirilir.
+"Mustafa","Kemal","PAŞA"
+;; Üstelik bu yenilikçi sözdizimsel kurala rağmen, {}, [] () gibi koleksiyon karakterlerini ayırmak için boşluğa ya da boşluğa çözümlenen virgüle ihtiyacınız yoktur.
+[["MUSTAFA"] ["KEMAL"] [[{"ATA" "ATATÜRK"}]]]
+;; Üst düzey vektör elemanlarını birbirinden ayıran boşlukları da kaldırabilirsiniz.
+;; Fakat bu size, okunması zor bir vektör dışında hiç bir şey vermeyecektir.
+
+;; |--------------------------------|
+;  |-------- Atomik Yapılar --------|
+;; |--------------------------------|
+
+; Mantıksal Değerler
+;; Mantıksal Doğru, çoğu teknolojide aynı gösterimi var.
+true
+;; Mantıksal Yanlış.
+false
+
+; Karakter Katarları
+;; Karakter katarları, --SADECE-- çift tırnak ile belirtilebilir.
+"İzmirin dağlarında çiçekler açar!"
+;; C, C++, Java v.b. gibi dillerin desteklediği kaçış sekanslarını da destekler.
+"Altın güneş orda sırmalar saçar.\nBozulmuş düşmanlar yel gibi kaçar."
+;; Kaçış sekansları için bknz: $!$
+
+; Karakter Sabitleri
+;; Karakter sabitleri önlerinde bir ters eğik çizgi ile temsil edilirler.
+\T \Ü \R \K
+;; Üstelik, belirli kaçıl sekanslarının da karşılığı Karakter Sabiti olarak var.
+\newline \return
+
+; Anahtar Kelimeler
+;; Anahtar Kelimeler, önlerinde bir ":" iki nokta --colon--
+:yımırta
+:kaşar
+:bıngıl
+
+; Semboller
+;; Semboller tanımlayıcıları temsil etmek için kullanılır.
+;; "/" karakteri, Sembol Sabitlerinde isim-uzayı ayıracı olarak kullanılıyor.
+izmir/kızları
+;; "mutfak" isim uzayındaki "ekmek-bıçağı" isimli sembole çözümlenir.
+
+banyo/fayans
+parke
+laminat
+
+; Sayısal Değerler
+;; Tam Sayı sabiti.
+1991
+;; Kayan Noktalı Sabiti.
+19.67
+
+; Listeler
+;; Listeler, yukarıdaki temel tiplerin ardışıklanmasıdır.
+(bomba :bomba nokta \c \o \m)
+
+; Vektörler
+;; Vektörler bir bakıma Listelere benzeseler de, bir çok açıdan farklıdırlar.
+;; Mesela Listenin aksine Vektörler, Rastgele Erişime imkan verir.
+[[] "şimdi" "asker"]
+
+; Eşlemeler
+;; Sıfır veya daha fazla Anahtar-Değer çifti kabul eder.
+;; Not: Clojure Veri Yapıları Soyutlaması ile Eşlemeler de, teknik olarak ardışık olarak işlenebilir.
+{:canı :neler-ister?
+ :uykuda "mevlam"}
+;; Bu ve diğer tüm Veri Yapıları Homojendir, birbirilerini barındırabilir, kapsayabilir, içerebilirler.
+;; Ayrıca okunurluk gibi farklı sebeplerle virgül kullanımında özgürsünüz.
+{{:id_ "129u391824981237981237" :kim "BEN"}, göster!}
+
+; Kümeler
+;; Kümeler eşsiz eleman barındıran bir yapıdır.
+;; Matematikteki karşılığını veriyor dersek yanlış olmaz.
+#{:sen 3 milyar 750 milyon}
+
+;; |--------------------------------|
+;  |------ Etiketli Elemanlar ------|
+;; |--------------------------------|
+
+;; EDN (Genişletilebilir Veri Notasyonu), # sembolü ile genişletilebilir.
+
+#benimuygulamam/bağlantı {:içerik "Y dakikada EDN Öğren" :url "https://learnxinyminutes.com/docs/tr-tr/edn-tr" :tıhlama-aksiyonu yırrttılll!}
+
+;; Ve bu yapıyı yorumlayacak bir de yapı gerekiyor.
+(defn ->bağlantı [props]
+  (str "<a href='" (:url props) "'" ">"
+        (:içerik props)
+        "</a>"))
+
+;; Bu örnekte yorumlayıcıya, basit bir fonksiyon veriyoruz.
+;; `clojure.edn/read-string` aslında bir ayarlar Eşlemesi kabul ediyor.
+;; (Bu tür fonksiyon genişlemeleri, Clojure ekosisteminde yaygındır.)
+
+(clojure.edn/read-string
+  {:readers {'benimuygulamam/bağlantı ->bağlantı}}
+  "#benimuygulamam/bağlantı {:içerik \"Y dakikada EDN Öğren\" :url \"https://learnxinyminutes.com/docs/tr-tr/edn-tr\" :tıhlama-aksiyonu yırrttılll!}")
+;=> "<a href='https://learnxinyminutes.com/docs/tr-tr/edn-tr'>Y dakikada EDN Öğren</a>"
+
+;; |--------------------------------|
+;  |--- Ön Tanımlı Genişletmeler ---|
+;; |--------------------------------|
+
+; Tarih Etiketi
+;; Bu etiket `inst` ön-ekinden sonra bir RFC-3339 formatında bir karakter katarı beklemektedir.
+#inst "2013-10-21T14:50:00+00:00" ; => Formatlanmış bir şekilde: 21/10/2013 14:50:00
+
+; UUID Etiketi
+;; Bu etiket `uuid` ön-ekinden sonra bir UUID karşılığını karakter katarı olarak kabul eder.
+#uuid "11k12fae-7d3c-11k0-a765-0010ckke6hgk"
+
+```
+
+# Son Ek
+Bu içerik, EDN'i tanıtmakta kısıtlı bir açıyla, özet bilgiler sunmaktadır.
+Fakat, Clojure ve diğer Veri Odaklı dillerde, Verinin yolculuğunu anlamak için önemli bir rol oynamaktadır.
+EDN'in var olan probleme çözümü ve artı/eksilerinin doğru şekilde kavranması mühimdir.
+Ben bu dökümanı hazırlarken, EDN ve gerçek dünya kullanımını anlatan yoktu. Fakat ümidim, Clojure ve diğer teknolojiler üzerinde kullanımının artmasından sonra birinin bu ihtiyacı giderecek özgün kaynak çıkarmasıdır.
+
+Başarılar!
+
+# Referanslar
+
+- [EDN Formatı Standardı](https://github.com/edn-format/edn)
+- [Gerçeklemeler](https://github.com/edn-format/edn/wiki/Implementations)
+- [Etiketlenmiş Elementler](http://www.compoundtheory.com/clojure-edn-walkthrough/)
+- [Clojure.Docs EDN İçeriği](https://clojuredocs.org/clojure.edn)
diff --git a/tr-tr/git-tr.html.markdown b/tr-tr/git-tr.html.markdown
new file mode 100644
index 00000000..87c1820c
--- /dev/null
+++ b/tr-tr/git-tr.html.markdown
@@ -0,0 +1,596 @@
+---
+category: tool
+lang: tr-tr
+tool: git
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Leo Rudberg" , "http://github.com/LOZORD"]
+    - ["Betsy Lorton" , "http://github.com/schbetsy"]
+    - ["Bruno Volcov", "http://github.com/volcov"]
+    - ["Andrew Taylor", "http://github.com/andrewjt71"]
+    - ["Jason Stathopulos", "http://github.com/SpiritBreaker226"]
+    - ["Milo Gilad", "http://github.com/Myl0g"]
+    - ["Adem Budak", "https://github.com/p1v0t"]
+    
+filename: LearnGit-tr.txt
+---
+
+Git dağınık versiyon kontrol ve kaynak kod yönetim sistemidir.
+
+Bunu projenin bir seri anlık durumunu kaydederek yapar ve bu anlık durumları 
+kullanarak versiyon ve kaynak kodu yönetmeni sağlar.
+
+## Versiyonlama Konseptleri
+
+### Versiyon kontrol nedir?
+
+Versiyon kontrol, zaman içerisinde dosya(lar)daki değişikliği kaydeden sistemdir.
+
+### Merkezi Versiyonlama vs. Dağınık Versiyonlama
+
+* Merkezi versiyon kontrolü dosyaların eşitlenmesine, takibine ve yedeklenmesine odaklanır. 
+* Dağınık versiyon kontrolü değişimin paylaşılmasına odaklanır. Her değişiminin benzersiz bir adı vardır.
+* Dağınık sistemlerin belirlenmiş bir yapısı yoktur. Git ile kolayca SVN'deki gibi merkezi bir sistem elde edebilirsin. 
+
+[Daha fazla bilgi](http://git-scm.com/book/en/Getting-Started-About-Version-Control)
+
+### Neden Git?
+
+* Çevrimdışı çalışabilir
+* Diğerleriyle beraber çalışmak kolaydır!
+* Dallanma kolaydır!
+* Dallanma hızlıdır!
+* Git hızlıdır
+* Git esnektir
+
+## Git Mimarisi
+
+### Repository
+
+Bir grup dosya, dizin, geriye dönük kayıt, commit, head. Bunları kaynak kodun veri
+yapısı gibi düşünebilirsin, herbir kaynak kod "elemanı" seni kendi revizyon geçmişine 
+eriştirir. 
+
+Bir git repo'su .git dizini ve çalışma ağacından oluşur. 
+
+### .git Dizini (repository bileşeni)
+
+.git dizini bütün konfigrasyon, log, dallanma, HEAD ve daha fazlasını tutar.
+[detaylı liste](http://gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
+
+### Çalışma Ağacı (repository bileşeni)
+
+Temelde repo'daki dizinlerin ve dosyalarındır. Sıkça çalışma ağacın olarak anılır.
+
+### Index (.git dizininin birleşeni)
+
+Index git'in evreleme alanıdır (staging area). Temelde çalışma ağacını Git repo'sundan 
+ayıran bir katmandır. Bu geliştiricilere neyin Git repo'suna gönderileceği hakkında daha 
+fazla güç verir. 
+
+### Commit
+
+Bir git commit'i Çalışma Ağacındaki bir takım değişiklerdir. Mesela 5 tane dosya
+eklemişsindir ve diğer 2 tanesini silmişindir, bu değişikler commit'te (anlık kayıtta) 
+tutulacaktır. Bu commit daha sonra diğer repo'lara bastırılabilir (pushed) ve bastırılmaz!
+
+### Branch
+
+Bir branch esasen yaptığın son commit'e göstericidir(pointer). Commit'lemeye devam ettiğinde,
+bu gösterici otomatik olarak son commit'e güncellenir.
+
+### Tag
+
+Bir tag, tarihteki belirli bir noktanın işaretidir. İnsanlar bunu genelde 
+sürüm notları için kullanır (v1.0 vs.)
+
+### HEAD ve head (.git dizininin birleşenleri)
+
+HEAD mevcut branch'a bir göstericidir. Bir repository yalnızca 1 *aktif*
+HEAD'e sahiptir.
+head, commit'e bir göstericidir. Bir repository herhangi bir sayıda head'e sahip olabilir.
+
+### Git'in Stage'leri
+* Modified - Dosyada değişikler yapıldı ama henüz Git Veritabanına commit yapılmadı.
+* Staged - Modified edilmiş bir dosyayı, sonraki commit'e gitmek üzere işaretler.
+* Committed - Dosyalar Git Veritabanına commit'lendi.  
+
+### Kavramsal Kaynaklar 
+
+* [Bilgisayar Bilimciler için Git](http://eagain.net/articles/git-for-computer-scientists/)
+* [Tasarımcılar için Git](http://hoth.entp.com/output/git_for_designers.html)
+
+## Komutlar
+
+### init
+
+Boş bir Git repository'si oluştur. Git repository'sinin ayarları, depolanmış
+bilgileri ve daha fazlası ".git" adlı dizinde (bir klasör) tutulur.
+
+```bash
+$ git init
+```
+
+### config
+
+Ayarları yapılandırmak için. Repository, sistemin kendisi veya global yapılandırmalar
+için olarabilir. (global yapılandırma dosyası `~/.gitconfig`).
+
+```bash
+# Print & Set Some Basic Config Variables (Global)
+$ git config --global user.email "MyEmail@Zoho.com"
+$ git config --global user.name "My Name"
+```
+
+[git config hakkında daha fazla bilgi için.](http://git-scm.com/docs/git-config)
+
+### help
+
+Her bir komutun detaylı kılavuzuna hızlı bir erişim için. Ya da sadece bazı şeylerin
+anlamı için hızlı bir hatırlatıcı için.
+
+```bash
+# Quickly check available commands
+$ git help
+
+# Check all available commands
+$ git help -a
+
+# Command specific help - user manual
+# git help <command_here>
+$ git help add
+$ git help commit
+$ git help init
+# or git <command_here> --help
+$ git add --help
+$ git commit --help
+$ git init --help
+```
+
+### dosyaları ignore etme 
+
+git'in bazı dosya(ları) ve klasör(leri) kasıtlı olarak takip etmemesi için. Genel
+olarak,repository'de ne de olsa paylaşılacak, private ve temp dosyaları için.
+
+```bash
+$ echo "temp/" >> .gitignore
+$ echo "private_key" >> .gitignore
+```
+
+### status
+
+index dosyası(temelde çalıştığın repo) ve mevcut HEAD commit arasındaki farkı göstermek için.
+
+```bash
+# Will display the branch, untracked files, changes and other differences
+$ git status
+
+# To learn other "tid bits" about git status
+$ git help status
+```
+
+### add
+
+Dosyaları staging area'ya eklemek için. Eğer yeni dosyaları staging area'ya `git add` 
+yapmazsanız, commit'lere eklenmez!
+
+```bash
+# add a file in your current working directory
+$ git add HelloWorld.java
+
+# add a file in a nested dir
+$ git add /path/to/file/HelloWorld.c
+
+# Regular Expression support!
+$ git add ./*.java
+
+# You can also add everything in your working directory to the staging area.
+$ git add -A
+```
+Bu yalnızca dosyayı staging area'a/index'e ekler, çalışılan dizine/repo'ya commit etmez.
+
+### branch
+
+Branch'ları yönetir. Bu komutu kullanarak, branch'ları görebilir, düzenleyebilir, oluşturabilir, silebilirsin.
+
+```bash
+# list existing branches & remotes
+$ git branch -a
+
+# create a new branch
+$ git branch myNewBranch
+
+# delete a branch
+$ git branch -d myBranch
+
+# rename a branch
+# git branch -m <oldname> <newname>
+$ git branch -m myBranchName myNewBranchName
+
+# edit a branch's description
+$ git branch myBranchName --edit-description
+```
+
+### tag
+
+tag'leri yönetir
+
+```bash
+# List tags
+$ git tag
+
+# Create a annotated tag
+# The -m specifies a tagging message, which is stored with the tag.
+# If you don’t specify a message for an annotated tag,
+# Git launches your editor so you can type it in.
+$ git tag -a v2.0 -m 'my version 2.0'
+
+# Show info about tag
+# That shows the tagger information, the date the commit was tagged,
+# and the annotation message before showing the commit information.
+$ git show v2.0
+
+# Push a single tag to remote
+$ git push origin v2.0
+
+# Push a lot of tags to remote
+$ git push origin --tags
+```
+
+### checkout
+
+index'in versiyonun eşlemek için çalışma ağacındaki,veya belirtilen ağactaki, tüm dosyaları günceller.
+
+```bash
+# Checkout a repo - defaults to master branch
+$ git checkout
+
+# Checkout a specified branch
+$ git checkout branchName
+
+# Create a new branch & switch to it
+# equivalent to "git branch <name>; git checkout <name>"
+
+$ git checkout -b newBranch
+```
+
+### clone
+
+Varolan bir repository'i yeni bir dizine clone'lar veya kopyalar. 
+Ayrıca clone'lanmış repodaki her bir branch için, uzak branch'a bastırmana izin veren,
+uzak takip branch'ları ekler.
+
+```bash
+# Clone learnxinyminutes-docs
+$ git clone https://github.com/adambard/learnxinyminutes-docs.git
+
+# shallow clone - faster cloning that pulls only latest snapshot
+$ git clone --depth 1 https://github.com/adambard/learnxinyminutes-docs.git
+
+# clone only a specific branch
+$ git clone -b master-cn https://github.com/adambard/learnxinyminutes-docs.git --single-branch
+```
+
+### commit
+
+index'in mevcut içeriğini yeni bir "commit"te saklar. Bu commit, kullanıcının oluşturduğu
+bir mesajı ve yapılan değişiklikleri saklar. 
+
+```bash
+# commit with a message
+$ git commit -m "Added multiplyNumbers() function to HelloWorld.c"
+
+# signed commit with a message (user.signingkey must have been set
+# with your GPG key e.g. git config --global user.signingkey 5173AAD5)
+$ git commit -S -m "signed commit message"
+
+# automatically stage modified or deleted files, except new files, and then commit
+$ git commit -a -m "Modified foo.php and removed bar.php"
+
+# change last commit (this deletes previous commit with a fresh commit)
+$ git commit --amend -m "Correct message"
+```
+
+### diff
+
+Shows differences between a file in the working directory, index and commits.
+Bir dosyanın, çalışma ağacı, index ve commit'ler arasındaki farklarını göster.
+
+```bash
+# Show difference between your working dir and the index
+$ git diff
+
+# Show differences between the index and the most recent commit.
+$ git diff --cached
+
+# Show differences between your working dir and the most recent commit
+$ git diff HEAD
+```
+
+### grep
+
+Bir repository'de hızlıca arama yapmana izin verir.
+
+İsteğe Bağlı Yapılandırmalar:
+
+```bash
+# Thanks to Travis Jeffery for these
+# Set line numbers to be shown in grep search results
+$ git config --global grep.lineNumber true
+
+# Make search results more readable, including grouping
+$ git config --global alias.g "grep --break --heading --line-number"
+```
+
+```bash
+# Search for "variableName" in all java files
+$ git grep 'variableName' -- '*.java'
+
+# Search for a line that contains "arrayListName" and, "add" or "remove"
+$ git grep -e 'arrayListName' --and \( -e add -e remove \)
+```
+
+Daha fazla örnek için
+[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
+
+### log
+
+Repository'deki commitleri gösterir.
+
+```bash
+# Show all commits
+$ git log
+
+# Show only commit message & ref
+$ git log --oneline
+
+# Show merge commits only
+$ git log --merges
+
+# Show all commits represented by an ASCII graph
+$ git log --graph
+```
+
+### merge
+
+Dış commit'lerdeki değişiklikleri mevcut branch'a "merge" et (birleştir).
+
+```bash
+# Merge the specified branch into the current.
+$ git merge branchName
+
+# Always generate a merge commit when merging
+$ git merge --no-ff branchName
+```
+
+### mv
+
+Bir dosyayı yeniden taşı veya yeniden adlandır
+
+```bash
+# Renaming a file
+$ git mv HelloWorld.c HelloNewWorld.c
+
+# Moving a file
+$ git mv HelloWorld.c ./new/path/HelloWorld.c
+
+# Force rename or move
+# "existingFile" already exists in the directory, will be overwritten
+$ git mv -f myFile existingFile
+```
+
+### pull
+
+Bir repository'den çeker ve diğer branch'a merge eder.
+
+```bash
+# Update your local repo, by merging in new changes
+# from the remote "origin" and "master" branch.
+# git pull <remote> <branch>
+$ git pull origin master
+
+# By default, git pull will update your current branch
+# by merging in new changes from its remote-tracking branch 
+$ git pull
+
+# Merge in changes from remote branch and rebase
+# branch commits onto your local repo, like: "git fetch <remote> <branch>, git 
+# rebase <remote>/<branch>"
+$ git pull origin master --rebase
+```
+
+### push
+
+Bir branch'taki değişikleri, uzak branch'a bastır ve birleştir.
+
+```bash
+# Push and merge changes from a local repo to a
+# remote named "origin" and "master" branch.
+# git push <remote> <branch>
+$ git push origin master
+
+# By default, git push will push and merge changes from
+# the current branch to its remote-tracking branch 
+$ git push
+
+# To link up current local branch with a remote branch, add -u flag:
+$ git push -u origin master
+# Now, anytime you want to push from that same local branch, use shortcut:
+$ git push
+```
+
+### stash
+
+Stash'leme çalışma dizinindeki kirli durumu alır ve bitmemiş değişiklikler 
+yığınına kaydeder. Bu değişikleri istediğin zaman tekrar uygulayabilirsin.
+
+Mesela git repo'nda bazı işler yaptın ama remote'dan pull yapmak istiyorsun.
+Bazı dosyalarında kirli (commit'lenmemiş) değişiklikler olduğundan `git pull`
+yapamazsın. Onun yerine önce `git stash` ile değişikliklerini yığına kaydet!
+
+(stash, sözlük anlamı: bir şeyi, özel bir yere güvenli biçimde saklamak)
+
+```bash
+$ git stash
+Saved working directory and index state \
+  "WIP on master: 049d078 added the index file"
+  HEAD is now at 049d078 added the index file
+  (To restore them type "git stash apply")
+```
+
+Şimdi pull yapabilirsin!
+
+```bash
+git pull
+```
+`...changes apply...`
+
+Herşeyin tamam olduğunu kontrol et
+
+```bash
+$ git status
+# On branch master
+nothing to commit, working directory clean
+```
+Şu ana kadar neleri stash'lediğini `git stash list` kullanarak görebilirsin.
+Stash'lenen şeyler Son-Giren-İlk-Çıkar şeklinde tutulduğundan en son değişim
+en üste olacaktır.
+
+```bash
+$ git stash list
+stash@{0}: WIP on master: 049d078 added the index file
+stash@{1}: WIP on master: c264051 Revert "added file_size"
+stash@{2}: WIP on master: 21d80a5 added number to log
+```
+Şimdi de kirli değişiklileri yığından çıkarıp uygulayalım.
+
+```bash
+$ git stash pop
+# On branch master
+# Changes not staged for commit:
+#   (use "git add <file>..." to update what will be committed)
+#
+#      modified:   index.html
+#      modified:   lib/simplegit.rb
+#
+```
+
+`git stash apply` da aynı şeyi yapar
+
+Şimdi kendi işine dönmeye hazırsın!
+
+[Ek Okuma.](http://git-scm.com/book/en/v1/Git-Tools-Stashing)
+
+### rebase (dikkat)
+
+Branch'ta commit'lenen tüm değişimleri al ve onları başka bir branch'ta tekrar oynat
+*Public repo'ya push edilmiş commit'leri rebase etme*
+
+```bash
+# Rebase experimentBranch onto master
+# git rebase <basebranch> <topicbranch>
+$ git rebase master experimentBranch
+```
+
+[Ek Okuma.](http://git-scm.com/book/en/Git-Branching-Rebasing)
+
+### reset (dikkat)
+
+Reset the current HEAD to the specified state. This allows you to undo merges,
+pulls, commits, adds, and more. It's a great command but also dangerous if you 
+don't know what you are doing.
+
+HEAD'i belirtilen duruma resetle. Bu merge'leri, pull'ları, commit'leri, add'leri
+ve daha fazlasını geriye almanı sağlar. Muhteşem bir komuttur ama aynı zamanda, ne
+yaptığını bilmiyorsan, tehlikelidir.
+
+```bash
+# Reset the staging area, to match the latest commit (leaves dir unchanged)
+$ git reset
+
+# Reset the staging area, to match the latest commit, and overwrite working dir
+$ git reset --hard
+
+# Moves the current branch tip to the specified commit (leaves dir unchanged)
+# all changes still exist in the directory.
+$ git reset 31f2bb1
+
+# Moves the current branch tip backward to the specified commit
+# and makes the working dir match (deletes uncommitted changes and all commits
+# after the specified commit).
+$ git reset --hard 31f2bb1
+```
+
+### reflog (dikkat)
+
+Reflog, verilen zaman içinde,default olarak 90 gündür, yaptığın git komutlarını listeler.
+
+Bu sana beklemediğin şekilde yanlış giden komutları geriye çevirme şansı verir. 
+(mesela, eğer bir rebase uygulamanı kırdıysa)
+
+Şu şekilde yapıbilirsin:
+
+1. `git reflog` rebase için tüm git komutlarını listele
+
+```
+38b323f HEAD@{0}: rebase -i (finish): returning to refs/heads/feature/add_git_reflog
+38b323f HEAD@{1}: rebase -i (pick): Clarify inc/dec operators
+4fff859 HEAD@{2}: rebase -i (pick): Update java.html.markdown
+34ed963 HEAD@{3}: rebase -i (pick): [yaml/en] Add more resources (#1666)
+ed8ddf2 HEAD@{4}: rebase -i (pick): pythonstatcomp spanish translation (#1748)
+2e6c386 HEAD@{5}: rebase -i (start): checkout 02fb96d
+```
+2. Nereye reset'leyeceğini seç, şu durumda `2e6c386` veya `HEAD@{5}`
+3. 'git reset --hard HEAD@{5}' bu repo'nu seçilen head'e eşitler 
+4. Rebase'e yeniden başlayabilir veya onu yalnız bırakabilirsin.
+
+[Ek Okuma.](https://git-scm.com/docs/git-reflog)
+
+### revert
+
+Revert commit'leri geri almada kullanılır. Projenin durumunu önceki bir noktaya 
+alan reset ile karıştırılmamalıdır. Revert, belirtilen commit'in tersine yeni bir
+commit ekleyecektir.
+
+```bash
+# Revert a specified commit
+$ git revert <commit>
+```
+
+### rm
+
+git add'in tersine, git rm çalışma ağacından dosyaları kaldırır.
+
+```bash
+# remove HelloWorld.c
+$ git rm HelloWorld.c
+
+# Remove a file from a nested dir
+$ git rm /pather/to/the/file/HelloWorld.c
+```
+
+## Daha Fazla Bilgi
+
+* [tryGit - Git'i öğrenmek için eğlenceli interaktif bir yol](http://try.github.io/levels/1/challenges/1)
+
+* [Git Dallanmayı Öğren -  Git'i web üzerinde öğrenmek için en görsel ve interaktif yol](http://learngitbranching.js.org/)
+
+* [Udemy Git Tutorial: Kapsayıcı bir kılavuz](https://blog.udemy.com/git-tutorial-a-comprehensive-guide/)
+
+* [Git Immersion - Git'in temelinden başlayan bir tur](http://gitimmersion.com/)
+
+* [git-scm - Video Tutorial](http://git-scm.com/videos)
+
+* [git-scm - Dökümantasyon](http://git-scm.com/docs)
+
+* [Atlassian Git - Tutorial & Workflow](https://www.atlassian.com/git/)
+
+* [SalesForce Kopya Kağıdı](http://res.cloudinary.com/hy4kyit2a/image/upload/SF_git_cheatsheet.pdf)
+
+* [GitGuys](http://www.gitguys.com/)
+
+* [Git - Basit bir kılavuz](http://rogerdudler.github.io/git-guide/index.html)
+
+* [Pro Git](http://www.git-scm.com/book/en/v2)
+
+* [Yeni başlayanlar için Git ve Github](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners)
diff --git a/tr-tr/html-tr.html.markdown b/tr-tr/html-tr.html.markdown
new file mode 100644
index 00000000..b4afe7df
--- /dev/null
+++ b/tr-tr/html-tr.html.markdown
@@ -0,0 +1,157 @@
+---
+language: html
+filename: learnhtml-tr.txt
+contributors:
+    - ["Christophe THOMAS", "https://github.com/WinChris"]
+translators:
+    - ["Kemal MUTLU", "https://github.com/kemtake"]
+    - ["Nuri Akman", "https://github.com/vedia"]
+lang: tr-tr
+---
+
+HTML, HyperText Markup Language (Hiper Metin İşaretleme Dili) anlamına gelir.
+
+Web sayfaları yazmamızı sağlayan bir dildir. Bu işaretleme dili, metin ve verilerin nasıl gösterilmesi gerektiği kodlanarak web sayfaları yazmamızı sağlar. Aslında, html dosyaları basit metin dosyalarıdır.
+
+Bu işaretleme nedir? Sayfanın verilerini, açılış etiketleri ve kapanış etiketleri ile çevreleyerek düzenleme yöntemidir. Bu işaretleme, içerdiği metne anlam vermeyi sağlar. Diğer bilgisayar dillerinde olduğu gibi, HTML’nin birçok sürümü vardır. Burada HTML5 hakkında konuşacağız. 
+
+**NOT :** Etkilerin nasıl çalıştıklarını anlamak, çıktılarını görebilmek için [codepen](https://codepen.io/) gibi bir siteden de faydalanabilirsiniz. Bu makale temel olarak HTML sözdizimi ve bazı yararlı ipuçlarıyla ilgilidir.
+
+```html
+<!-- Yorumlar bu satır gibi eklenir! -->
+
+<!--
+	Yorumlar
+    birden
+	fazla
+	satıra
+	yayılabilir!
+-->
+
+<!-- #################### Başlık #################### -->
+
+<!-- İşte, analiz edeceğimiz örnek bir HTML dosyası. -->
+
+
+<!doctype html>
+	<html>
+		<head>
+			<title>Benim Sitem</title>
+		</head>
+		<body>
+			<h1>Merhaba dünya!</h1>
+			<a href="http://codepen.io/anon/pen/xwjLbZ">
+				Bunun ne olduğuna bir bak.
+			</a>
+			<p>Bu bir paragraftır.</p>
+			<p>Bu başka bir paragraf.</p>
+			<ul>
+				<li>Bu, numaralandırılmamış bir listede bulunan bir öğe/maddedir (madde imi)</li>
+				<li>Bu başka bir öğe</li>
+				<li>Ve bu listedeki son öğe </li>
+			</ul>
+		</body>
+	</html>
+
+<!--
+Bir HTML dosyası, tarayıcıya her zaman sayfanın HTML olduğunu belirterek başlar.
+-->
+<!doctype html>
+
+<!-- Bundan sonra, bir <html> etiketi açılarak başlar. -->
+<html>
+
+<!-- dosyanın sonu </html> etiketi ile kapatılır.  -->
+</html>
+
+<!-- Sayfada, bu son etiketten sonra hiçbir şey bulunmamalıdır. -->
+
+<!-- Açılış ve kapanış etiketleri arasında (<html> </html>) şunları bulunur: -->
+
+<!-- <head> ile tanımlanan bir sayfa başlığu (bu, </head> ile kapatılmalıdır). -->
+<!-- Baslik, gösterilmeyen bazi aciklamalar ve ek bilgiler icerir; buna üstveri denir. -->
+
+<head>
+	<!-- <title> etiketi, tarayıcıda gösterilecek başlığı gösterir. Pencerenin başlık çubuğu ve sekme adı.-->
+	<title>Benim Sitem</title>
+</head>
+
+<!-- <head> bölümünden sonra, <body> etiketi gelir. -->
+<!-- Bu noktaya kadar, tarif edilen hiçbir şey tarayıcı penceresinde görünmez. -->
+<!-- <body> etiketinden sonra  görüntülenecek içeriğe yer verilir. -->
+
+<body>
+	<!-- h1 etiketi bir başlık oluşturur. -->
+	<h1>Merhaba Dünya!</h1>
+	<!--
+		Ayrıca başlıklar <h1> etiketinden  <h6> etiketine kadar gidebilir.
+		<h1> etiketi en önemli, <h6> etiketi en düşük öncelikli başlığı yazmamızı sağlar.
+	-->
+
+	<!-- href="" özniteliğine verilen URL'ye bir köprü oluşturur.  -->
+	<a href="http://codepen.io/anon/pen/xwjLbZ">
+		Bunun ne olduğuna bir bak.
+	</a>
+
+	<!--  <p> etiketi, html sayfasına metin eklememize izin verir. -->
+	<p>Bu bir paragraftır.</p>
+	<p>Bu başka bir paragraf.</p>
+
+	<!-- <ul> etiketi bir madde imi listesi oluşturur. -->
+	<!--
+          Numaralandırılmış bir listeye sahip olmak için <ol> etiketi de kullanılabilir. Bu durumda 1. madde 2. madde vb. şekilde gider.
+	-->
+	<ul>
+		<li>Bu, numaralandırılmamış bir bir liste kalemidir (madde imi)</li>
+		<li>Bu başka bir öğe</li>
+		<li>Ve bu listedeki son öğe</li>
+	</ul>
+</body>
+
+<!-- İşte bir html dosyası oluşturmak bu kadar basit. -->
+
+<!-- Ancak birçok farklı HTML etiketi türü de eklenebilir. -->
+
+<!-- <img /> etiketi bir resim eklemek için kullanılır. -->
+<!--
+Resmin kaynağı, src = "" özniteliği kullanılarak belirtilir.
+Kaynak, bir URL veya bilgisayarınızdaki bir dosyanın yolu olabilir.
+-->
+<img src="http://i.imgur.com/XWG0O.gif"/>
+
+<!-- HTML'de bir Tablo oluşturmak da mümkündür. -->
+
+<!--  Bir <table> elemanı açarız. -->
+<table>
+
+	<!-- <tr> bir satır oluşturmamızı sağlar. -->
+	<tr>
+		<!-- <th> tablo sütununa bir başlık vermemize izin verir. -->
+		<th>Birinci Başlık</th>
+		<th>İkinci Başlık</th>
+	</tr>
+
+	<tr>
+		<!-- <td> bir tablo hücresi oluşturmamızı sağlar. -->
+		<td>ilk satırın, ilk hücresi (sutunu)</td>
+		<td>ilk satırın, ikinci hücresi (sutunu)</td>
+	</tr>
+
+	<tr>
+		<td>ikinci satırın, ilk hücresi (sutunu) </td>
+		<td>ikinci satırın, ikinci hücresi (sutunu)</td>
+	</tr>
+</table>
+
+```
+
+## Kullanım
+
+HTML içeriği, .html veya .htm ile biten dosyalara yazılır. Mim türü text/html .
+HTML olarak yazılmış dosyalar,  `.html` veya `.htm` dosya uzantısına sahiptirler. mime type'ı ise `text/html` dir.
+
+## Daha fazla bilgi için
+
+* [wikipedia](https://en.wikipedia.org/wiki/HTML)
+* [HTML tutorial](https://developer.mozilla.org/en-US/docs/Web/HTML)
+* [W3School](http://www.w3schools.com/html/html_intro.asp)
diff --git a/tr-tr/markdown-tr.html.markdown b/tr-tr/markdown-tr.html.markdown
index b8f11e39..6caba1da 100644
--- a/tr-tr/markdown-tr.html.markdown
+++ b/tr-tr/markdown-tr.html.markdown
@@ -11,7 +11,7 @@ filename: markdown-tr.md
 Markdown, 2004 yılında John Gruber tarafından oluşturuldu. Asıl amacı kolay okuma ve yazmayı sağlamakla beraber kolayca HTML (artık bir çok diğer formatlara) dönüşüm sağlamaktır.
 
 
-```markdown
+```md
 <!-- Markdown, HTML'i kapsar, yani her HTML dosyası geçerli bir Markdown dosyasıdır, bu demektir
 ki Markdown içerisinde HTML etiketleri kullanabiliriz, örneğin bu yorum elementi, ve
 markdown işleyicisinde etki etmezler. Fakat, markdown dosyası içerisinde HTML elementi oluşturursanız,
diff --git a/tr-tr/python-tr.html.markdown b/tr-tr/python-tr.html.markdown
index 01285080..99a3eb4e 100644
--- a/tr-tr/python-tr.html.markdown
+++ b/tr-tr/python-tr.html.markdown
@@ -458,7 +458,7 @@ Human.grunt() #=> "*grunt*"
 
 # Modülleri sayfaya dahil edebilirsiniz
 import math
-print math.sqrt(16) #=> 4
+print math.sqrt(16) #=> 4.0
 
 # Modül içerisinden spesifik bir fonksiyonu getirebilirsiniz
 from math import ceil, floor
diff --git a/tr-tr/python3-tr.html.markdown b/tr-tr/python3-tr.html.markdown
index e53d5568..b78d517f 100644
--- a/tr-tr/python3-tr.html.markdown
+++ b/tr-tr/python3-tr.html.markdown
@@ -4,7 +4,7 @@ contributors:
     - ["Louie Dinh", "http://pythonpracticeprojects.com"]
     - ["Steven Basart", "http://github.com/xksteven"]
     - ["Andre Polykanine", "https://github.com/Oire"]
-    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["Batuhan Osman T.", "https://github.com/BTaskaya"]
 translators:
     - ["Eray AYDIN", "http://erayaydin.me/"]
 lang: tr-tr
@@ -484,7 +484,7 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
 
 
 # Sınıf oluşturmak için objeden alt sınıf oluşturacağız.
-class Insan(obje):
+class Insan(object):
 
     # Sınıf değeri. Sınıfın tüm nesneleri tarafından kullanılabilir
     tur = "H. sapiens"
@@ -499,7 +499,7 @@ class Insan(obje):
 
     # Bir metot. Bütün metotlar ilk parametre olarak "self "alır.
     def soyle(self, mesaj):
-        return "{isim}: {mesaj}".format(isim=self.name, mesaj=mesaj)
+        return "{isim}: {mesaj}".format(isim=self.isim, mesaj=mesaj)
 
     # Bir sınıf metotu bütün nesnelere paylaştırılır
     # İlk parametre olarak sınıf alırlar
diff --git a/tr-tr/sql-tr.html.markdown b/tr-tr/sql-tr.html.markdown
new file mode 100644
index 00000000..54007d32
--- /dev/null
+++ b/tr-tr/sql-tr.html.markdown
@@ -0,0 +1,125 @@
+---

+language: SQL

+contributors:

+  - ["Metin Yalçınkaya", "https://github.com/mtnylnky"]

+lang: tr-tr

+filename: learnsql-tr.sql

+---

+

+

+```sql

+-- Yorumlar iki tire ile başlar

+

+-- KISITLAR

+Not null -- Bir kolon asla boş olamaz

+default -- Boş olan yerlere varsayılan bir değer atar

+unique -- Bir kolondaki tüm değerlerin farklı olması kısıtlaması

+primary key -- Bir tablodaki her veri için kimlik bilgisi niteliğindedir

+check -- Bir kolondaki değerlerin belli bir kısıtlamayı sağlamasını sağlar

+

+-- Tablo oluşturulur

+CREATE TABLE tablo1 ();

+

+-- Tabloyu içerisinde kolonlar ile oluşturma

+CREATE TABLE tablo1(id INTEGER PRIMARY KEY NOT NULL UNIQUE, ad TEXT, soyad TEXT, yas INTEGER);

+

+-- TABLO varlığını kontrol eder

+.table

+

+-- Veri tabanında olan bütün tabloları görüntüler.

+.schema

+

+-- Satır ekle

+INSERT INTO tablo1 ( ad, soyad) VALUES ("Deger1","Deger2");

+

+-- Veritabanında tablo üzerindeki verileri görüntüle 

+-- Sadece 'ad' gibi sınırlı bir veri için

+SELECT ad FROM tablo1;

+-- Bütün veriler için

+SELECT * FROM tablo1;

+

+-- Veri güncelleme

+UPDATE tablo1 SET ad = "deger1-2"; WHERE name = "Deger1";

+

+-- Satır sil

+DELETE FROM tablo1 WHERE id = 1;

+DELETE FROM tablo1 WHERE ad = "Deger1" OR ad = "Deger2";

+

+-- Tabloya sonradan kolon ekleme

+ALTER TABLE tablo1 ADD COLUMN email TEXT;

+

+-- Tablodaki kolon adı değiştirme

+EXEC sp_rename ' tablo1.[ad]', Ad, 'COLUMN';

+

+-- Tablo adı değiştirme

+ALTER TABLE table1 RENAME TO Table1;

+

+-- Tabloyu silme

+DROP TABLE Table1;

+

+-- BİR TABLOYU BAŞKA TABLO KULLANARAK DOLDURMAK

+INSERT INTO Tablo2 SELECT id,ad, soyad, email from Tablo1;

+

+-- LIKE KOMUTU

+-- Belirli bir kritere göre arama yaparken kullanılır

+-- Adı 'A' ile başlayan veriler

+SELECT * FROM tablo1 WHERE adi LIKE "A%";

+-- İçinde 'A' olan veriler

+SELECT * FROM tablo1 WHERE adi LIKE "%A%";

+

+-- LIMIT KOMUTU

+-- Gösterilen satır sayısını sınırlamak için

+SELECT * FROM Tablo1 LIMIT 6;

+-- Gösterilen satırları belirli bir noktadan başlamak üzere sınırlamak için

+SELECT * FROM Tablo1 LIMIT 6 OFFSET 3;

+

+-- ORDER BY KOMUTU

+-- Herhangi bir kolona göre gösterilen değerleri azalan veya artan şekilde sıralamak için

+SELECT kolon FROM tablo1 WHERE yas ORDER BY column1, column2, .. columnN] [ASC | DESC];

+SELECT * FROM Tablo1 ORDER BY yas ASC

+SELECT * FROM Tablo1 ORDER BY yas DESC

+

+-- DISTINCT ANAHTAR SÖZCÜĞÜ

+-- Bu anahtar sözcükle sadece farklı değerler gösterilir.

+SELECT DISTINCT yas FROM tablo1;

+

+-- JOIN KOMUTU

+-- CROSS JOIN

+-- Cross join bir tablodaki her satırı ikinci tablodaki bir satır ile eşleştirmek için kulanılır.

+-- Eğer birinci tabloda x satır ikinci tabloda y satır varsa sonuçta x*y satır olur.

+SELECT ... FROM table1 CROSS JOIN table2 …

+SELECT ad, yas FROM Tablo1 CROSS JOIN Tablo2;

+

+-- INNER JOIN

+-- Inner join iki tablodaki ortak kolon değerlerini kullanarak bir sonuç üretir.

+SELECT ... FROM table1 [INNER] JOIN table2 ON conditional_expression …

+SELECT ad, yas FROM Tablo1 INNER JOIN Tablo2 ON Tablo1.ad = Tablo2.soyad;

+

+-- OUTER JOIN

+-- Outer join iki tablodaki ortak kolon değerlerinin dışında kalanları kullanarak bir sonuç üretir.

+SELECT isci_num, isim, dept FROM Tablo1 LEFT OUTER JOIN Tablo2 ON Tablo1.id = Tablo2.isci_num;

+

+-- ÇEKİRDEK FONKSİYONLAR

+COUNT -- Sayma

+AVG -- Ortalama

+ABS -- Mutlak değer

+SUM -- Toplam

+RANDOM -- Rastgele

+ROUND -- Yuvarlama

+MAX -- Maksimim

+MIN -- Minimum

+UPPER -- Büyük Harf

+LOWER -- Küçük Harf

+LENGTH -- Uzunluk

+CURRENT_TIMESTAMP -- Zaman

+

+SELECT max(yas) FROM Table1;

+SELECT min(yas) FROM Table1;

+SELECT avg(yas) FROM Table1;

+SELECT * From Table1 WHERE yas ==18;

+SELECT sum(yas) FROM Table1;

+SELECT random() AS Random;

+SELECT upper(ad) FROM Table1;

+SELECT lower(ad) FROM Table1;

+SELECT ad, length(ad) FROM Table1;

+```
\ No newline at end of file
diff --git a/typescript.html.markdown b/typescript.html.markdown
index acc258b4..00f0cbc5 100644
--- a/typescript.html.markdown
+++ b/typescript.html.markdown
@@ -5,13 +5,19 @@ contributors:
 filename: learntypescript.ts
 ---
 
-TypeScript is a language that aims at easing development of large scale applications written in JavaScript.
-TypeScript adds common concepts such as classes, modules, interfaces, generics and (optional) static typing to JavaScript.
-It is a superset of JavaScript: all JavaScript code is valid TypeScript code so it can be added seamlessly to any project. The TypeScript compiler emits JavaScript.
+TypeScript is a language that aims at easing development of large scale
+applications written in JavaScript.  TypeScript adds common concepts such as
+classes, modules, interfaces, generics and (optional) static typing to
+JavaScript.  It is a superset of JavaScript: all JavaScript code is valid
+TypeScript code so it can be added seamlessly to any project. The TypeScript
+compiler emits JavaScript.
 
-This article will focus only on TypeScript extra syntax, as opposed to [JavaScript](/docs/javascript).
+This article will focus only on TypeScript extra syntax, as opposed to
+[JavaScript](/docs/javascript).
 
-To test TypeScript's compiler, head to the [Playground] (http://www.typescriptlang.org/Playground) where you will be able to type code, have auto completion and directly see the emitted JavaScript.
+To test TypeScript's compiler, head to the
+[Playground](https://www.typescriptlang.org/play) where you will be able
+to type code, have auto completion and directly see the emitted JavaScript.
 
 ```ts
 // There are 3 basic types in TypeScript
@@ -19,7 +25,8 @@ let isDone: boolean = false;
 let lines: number = 42;
 let name: string = "Anders";
 
-// But you can omit the type annotation if the variables are derived from explicit literals
+// But you can omit the type annotation if the variables are derived
+// from explicit literals
 let isDone = false;
 let lines = 42;
 let name = "Anders";
@@ -113,6 +120,13 @@ class Point {
   static origin = new Point(0, 0);
 }
 
+// Classes can be explicitly marked as implementing an interface.
+// Any missing properties will then cause an error at compile-time.
+class PointPerson implements Person {
+    name: string
+    move() {}
+}
+
 let p1 = new Point(10, 20);
 let p2 = new Point(25); //y will be 0
 
@@ -178,6 +192,74 @@ let greeting = `Hi ${name}, how are you?`
 let multiline = `This is an example
 of a multiline string`;
 
+// READONLY: New Feature in TypeScript 3.1
+interface Person {
+  readonly name: string;
+  readonly age: number;
+}
+
+var p1: Person = { name: "Tyrone", age: 42 };
+p1.age = 25; // Error, p1.age is read-only
+
+var p2 = { name: "John", age: 60 };
+var p3: Person = p2; // Ok, read-only alias for p2
+p3.age = 35; // Error, p3.age is read-only
+p2.age = 45; // Ok, but also changes p3.age because of aliasing
+
+class Car {
+  readonly make: string;
+  readonly model: string;
+  readonly year = 2018;
+
+  constructor() {
+    this.make = "Unknown Make"; // Assignment permitted in constructor
+    this.model = "Unknown Model"; // Assignment permitted in constructor
+  }
+}
+
+let numbers: Array<number> = [0, 1, 2, 3, 4];
+let moreNumbers: ReadonlyArray<number> = numbers;
+moreNumbers[5] = 5; // Error, elements are read-only
+moreNumbers.push(5); // Error, no push method (because it mutates array)
+moreNumbers.length = 3; // Error, length is read-only
+numbers = moreNumbers; // Error, mutating methods are missing
+
+// Tagged Union Types for modelling state that can be in one of many shapes
+type State = 
+  | { type: "loading" }
+  | { type: "success", value: number }
+  | { type: "error", message: string };
+
+declare const state: State;
+if (state.type === "success") {
+  console.log(state.value);
+} else if (state.type === "error") {
+  console.error(state.message);
+}
+
+// Iterators and Generators
+
+// for..of statement
+// iterate over the list of values on the object being iterated
+let arrayOfAnyType = [1, "string", false];
+for (const val of arrayOfAnyType) {
+    console.log(val); // 1, "string", false
+}
+
+let list = [4, 5, 6];
+for (const i of list) {
+   console.log(i); // 4, 5, 6
+}
+
+// for..in statement
+// iterate over the list of keys on the object being iterated
+for (const i in list) {
+   console.log(i); // 0, 1, 2
+}
+
+
+
+
 ```
 
 ## Further Reading
diff --git a/uk-ua/cypher-ua.html.markdown b/uk-ua/cypher-ua.html.markdown
new file mode 100644
index 00000000..e1eef5a2
--- /dev/null
+++ b/uk-ua/cypher-ua.html.markdown
@@ -0,0 +1,254 @@
+---
+language: cypher
+filename: LearnCypher.cql
+contributors:
+    - ["Théo Gauchoux", "https://github.com/TheoGauchoux"]
+translators:
+    - ["AstiaSun", "https://github.com/AstiaSun"]
+lang: uk-ua
+---
+
+Cypher - це мова запитів Neo4j для спрощення роботи з графами. Вона повторює синтаксис SQL та перемішує його з таким собі ascii стилем для відображення структури графа.
+Цей навчальний матеріал передбачає, що ви вже знайомі із концепцією графів, зобрема що таке вершини та зв'язки між ними.
+
+[Деталі тут](https://neo4j.com/developer/cypher-query-language/)
+
+
+Вершини
+---
+
+**Відображує запис у графі.**
+
+`()`
+Таким чином у запиті позначається пуста *вершина*. Використовується зазвичай для того, щоб позначити, що вона є, проте це не так вже й важливо для запиту.
+
+`(n)`
+Це вершина, яка має назву **n**, до неї можна повторно звертатись у запиті. Звернення до вершини **n** починається з нижнього підкреслення та використовує camelCase (верблюжий регіст).
+
+`(p:Person)`
+Можна також додати *ярлик* до вершини, в данному випадку - **Person**. Це як тип / клас / категорія. Назва *ярлика* починається з великої літери та використовує верблюжу нотацію.
+
+`(p:Person:Manager)`
+Вершина може мати кілька *ярликів*.
+
+`(p:Person {name : 'Théo Gauchoux', age : 22})`
+Вершина також може мати різні *властивості*, в данному випадку - **name** та **age**. Також мають починатися з великої літери та використовувати верблюжу нотацію.
+
+Наступні типи дозволяється використовувати у властивостях:
+
+ - Чиселиний
+ - Булевий
+ - Рядок
+ - Списки попередніх примітивних типів
+
+*Увага! В Cypher не існує типу, що відображає час. Замість нього можна використовувати рядок із визначеним шаблоном або чисельне відображення певної дати.*
+
+`p.name`
+За допомогою крапки можна звернутись до властивості вершини.
+
+
+Зв'язки (або ребра)
+---
+
+**Сполучають дві вершини**
+
+`[:KNOWS]`
+Це *зв'язок* з *ярликом* **KNOWS**. Це такий же самий *ярлик* як і у вершини. Починається з великої літери та використовує ВЕРХНІЙ\_РЕГІСТР\_ІЗ\_ЗМІЇНОЮ\_НОТАЦІЄЮ.
+
+`[k:KNOWS]`
+Це той же самий *зв'язок*, до якого можна звертатись через змінну **k**. Можна подалі використовувати у запиті, хоч це і не обов'язково. 
+
+`[k:KNOWS {since:2017}]`
+Той же *зв'язок*, але вже із *властивостями* (як у *вершини*), в данному випадку властивість - це  **since**.
+
+`[k:KNOWS*..4]`
+Це структурна інформація, яку використовують *шляхи*, які розглянуті нижче. В данному випадку, **\*..4** говорить: "Сумістити шаблон із зв'язком **k**, що повторюватиметься від одного до чотирьох разів."
+
+
+Шляхи
+---
+
+**Спосіб поєднувати вершини та зв'язки.**
+
+`(a:Person)-[:KNOWS]-(b:Person)`
+Шлях описує, що вершини **a** та **b** знають (knows) один одного.
+
+`(a:Person)-[:MANAGES]->(b:Person)`
+Шлях може бути направленим. Цей описує, що **а** є менеджером **b**.
+
+`(a:Person)-[:KNOWS]-(b:Person)-[:KNOWS]-(c:Person)`
+Можна створювати ланцюги зі зв'язків. Цей шлях описує друга друга (**a** знає **b**, який в свою чергу знає **c**).
+
+`(a:Person)-[:MANAGES]->(b:Person)-[:MANAGES]->(c:Person)`
+Ланцюг, аналогічно, також може бути направленим. Шлях описує, що **a** -  бос **b** і супер бос для **c**.
+
+Шаблони, які часто використовуються (з документації Neo4j):
+
+```
+// Друг-мого-друга 
+(user)-[:KNOWS]-(friend)-[:KNOWS]-(foaf)
+
+// Найкоротший шлях
+path = shortestPath( (user)-[:KNOWS*..5]-(other) )
+
+// Спільна фільтрація
+(user)-[:PURCHASED]->(product)<-[:PURCHASED]-()-[:PURCHASED]->(otherProduct)
+
+// Навігація по дереву
+(root)<-[:PARENT*]-(leaf:Category)-[:ITEM]->(data:Product)
+
+```
+
+
+Запити на створення
+---
+
+Створити нову вершину:
+```
+CREATE (a:Person {name:"Théo Gauchoux"})
+RETURN a
+```
+*`RETURN`  дозволяє повернути результат після виконання запиту. Можна повертати кілька значень, наприклад, `RETURN a, b`.*
+
+Створити новий зв'язок (із двома вершинами):
+```
+CREATE (a:Person)-[k:KNOWS]-(b:Person)
+RETURN a,k,b
+```
+
+Запити на знаходження
+---
+
+Знайти всі вершини:
+```
+MATCH (n)
+RETURN n
+```
+
+Знайти вершини за ярликом:
+```
+MATCH (a:Person)
+RETURN a
+```
+
+Знайти вершини за ярликом та властивістю:
+```
+MATCH (a:Person {name:"Théo Gauchoux"})
+RETURN a
+```
+
+Знайти вершини відповідно до зв'язків (ненаправлених):
+```
+MATCH (a)-[:KNOWS]-(b)
+RETURN a,b
+```
+
+Знайти вершини відповідно до зв'язків (направлених):
+```
+MATCH (a)-[:MANAGES]->(b)
+RETURN a,b
+```
+
+Знайти вершини за допомогою `WHERE`:
+```
+MATCH (p:Person {name:"Théo Gauchoux"})-[s:LIVES_IN]->(city:City)
+WHERE s.since = 2015
+RETURN p,state
+```
+
+Можна використовувати вираз `MATCH WHERE` разом із операцією `CREATE`:
+```
+MATCH (a), (b)
+WHERE a.name = "Jacquie" AND b.name = "Michel"
+CREATE (a)-[:KNOWS]-(b)
+```
+
+
+Запити на оновлення
+---
+
+Оновити окрему властивість вершини:
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p.age = 23
+```
+
+Оновити всі властивості вершини:
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p = {name: "Michel", age: 23}
+```
+
+Додати нову властивіcть до вершини:
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p + = {studies: "IT Engineering"}
+```
+
+Повісити ярлик на вершину:
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+SET p:Internship
+```
+
+
+Запити на видалення
+---
+
+Видалити окрему вершину (пов'язані ребра повинні бути видалені перед цим):
+```
+MATCH (p:Person)-[relationship]-()
+WHERE p.name = "Théo Gauchoux"
+DELETE relationship, p
+```
+
+Видалити властивість певної вершини:
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+REMOVE p.age
+```
+
+*Зверніть увагу, що ключове слово `REMOVE` це не те саме, що й  `DELETE`!*
+
+Видалити ярлик певної вершини: 
+```
+MATCH (p:Person)
+WHERE p.name = "Théo Gauchoux"
+DELETE p:Person
+```
+
+Видалити всю базу даних: 
+```
+MATCH (n)
+OPTIONAL MATCH (n)-[r]-()
+DELETE n, r
+```
+
+*Так, це `rm -rf /` на мові Cypher !*
+
+
+Інші корисні запити
+---
+
+`PROFILE`
+Перед виконанням, показати план виконання запитів.
+
+`COUNT(e)`
+Порахувати елементи (вершини та зв'язки), що відповідають **e**.
+
+`LIMIT x`
+Обмежити результат до x перших результатів.
+
+
+Особливі підказки
+---
+
+- У мові Cypher існують лише однорядкові коментарі, що позначаються двійним слешем : // Коментар
+- Можна виконати скрипт Cypher, збережений у файлі **.cql** прямо в Neo4j (прямо як імпорт). Проте, не можна мати мати кілька виразів в цьому файлі (розділених **;**).
+- Використовуйте командний рядок Neo4j для написання запитів Cypher, це легко і швидко.
+- Cypher планує бути стандартною мовою запитів для всіх графових баз даних (більш відома як  **OpenCypher**).
diff --git a/uk-ua/go-ua.html.markdown b/uk-ua/go-ua.html.markdown
new file mode 100644
index 00000000..933b34f9
--- /dev/null
+++ b/uk-ua/go-ua.html.markdown
@@ -0,0 +1,449 @@
+---
+name: Go
+category: language
+language: Go
+filename: learngo.go
+contributors:
+    - ["Sonia Keys", "https://github.com/soniakeys"]
+    - ["Christopher Bess", "https://github.com/cbess"]
+    - ["Jesse Johnson", "https://github.com/holocronweaver"]
+    - ["Quint Guvernator", "https://github.com/qguv"]
+    - ["Jose Donizetti", "https://github.com/josedonizetti"]
+    - ["Alexej Friesen", "https://github.com/heyalexej"]
+    - ["Clayton Walker", "https://github.com/cwalk"]
+    - ["Leonid Shevtsov", "https://github.com/leonid-shevtsov"]
+translators:
+    - ["AstiaSun", "https://github.com/AstiaSun"]
+lang: uk-ua
+---
+
+Go був створений для того, щоб виконати задачу. Це не останній тренд в теорії мов програмування, а спосіб вирішення реальних проблем.
+
+Він увібрав принципи з імперативних мов зі статичною типізацією.
+Go швидко компілюється та виконується, а його багатопоточність легка для
+вивчення, оскільки багатоядерні CPU стали буденністю. Ця мова програмування успішно використовується у кодах великих продуктів (~100 мільйонів в Google, Inc.)
+
+Go має чудову стандартну бібліотеку та чимале ком'юніті.
+
+```go
+// Однорядковий коментар
+/* Багато-
+ рядковий коментар */
+
+// Кожен файл вихідного коду має починатись із ключового слова package.
+// main - це спеціальна назва, що оголошує виконуваний код, а не бібліотеку.
+package main
+
+// import оголошує бібліотеки, що використовуються в даному файлі.
+import (
+	"fmt"       // Пакет стандартної бібліотеки Go.
+	"io/ioutil" // Цей пакет реалізує деякі I/O функції утиліт.
+	m "math"    // Бібліотека математичних операцій з локальним псевдонімом m.
+	"net/http"  // Так, веб сервер!
+	"os"        // Функції операційної системи, такі як робота з файловою системою.
+	"strconv"   // Перетворення текстових змінних.
+)
+
+// Оголошення функції. 
+// Функція main - особлива. Це вхідна точка для виконуваних програм.
+// Ви можете любити це, або ж ненавидіти, але Go використовує фігурні дужки.
+func main() {
+	// Println виводить рядок в stdout.
+	// Ця функція входить у пакет fmt.
+	fmt.Println("Hello world!")
+
+	// Викликати іншу функцію з цього файлу.
+	beyondHello()
+}
+
+// Аргументи функцій описуються у круглих дужках.
+// Навіть якщо ніякі аргументи не передаються, пусті круглі дужки - обов`язкові.
+func beyondHello() {
+	var x int // Оголошення змінної. Перед використанням змінні обов'язково мають бути оголошені.
+	x = 3     // Присвоєння значення.
+	// "Короткі" оголошення використовують := щоб окреслити тип, оголосити та присвоїти значення.
+	y := 4
+	sum, prod := learnMultiple(x, y)        // Функція повертає два значення.
+	fmt.Println("sum:", sum, "prod:", prod) // Просто вивід.
+	learnTypes()                            // < y хвилин, потрібно вивчити більше!
+}
+
+/* <- багаторядковий коментар
+Функції можуть мати параметри та повертати довільну кількість значень.
+В цьому прикладі `x`, `y` - це аргументи, а `sum`, `prod` - це змінні, що повертаються.
+Зверніть увагу, що `x` та `sum` мають тип `int`.
+*/
+func learnMultiple(x, y int) (sum, prod int) {
+	return x + y, x * y // Повернути два значення.
+}
+
+// Кілька вбудованих типів та літералів.
+func learnTypes() {
+	// Короткі оголошення зазвичай виконують все, що необхідно.
+	str := "Вчи Go!" // рядок (string).
+
+	s2 := `"Необроблений" текст
+може містити переноси рядків.` // Також має тип рядок.
+
+	// Не ASCII символи. Go використовує UTF-8.
+	g := 'Σ' // руничний тип, псевдонім для int32, містить позицію юнікод кода.
+
+	f := 3.14195 // float64, IEEE-754 64-бітне число з плаваючою крапкою.
+	c := 3 + 4i  // complex128, комплексні числа, що являють собою два float64.
+
+	// Синтаксис ініціалізації з var.
+	var u uint = 7 // Беззнаковий цілочисельний тип, проте розмір залежить від імплементації, так само як і int.
+	var pi float32 = 22. / 7
+
+	// Синтаксис перетворення типів з коротким оголошенням.
+	n := byte('\n') // Байт - це переіменований uint8.
+
+	// Розмір масива фіксований протягом часу виконання.
+	var a4 [4]int           // Масив з 4 чисел, всі проініціалізовані 0.
+	a5 := [...]int{3, 1, 5, 10, 100} // Масив проініціалізованих чисел з фіксованим розміром у 
+	// п'ять елементів, що мають значення 3, 1, 5, 10, та 100.
+
+	// Зрізи мають динамічний розмір. Переваги є і у масивів, й у зрізів, проте
+	// останні використовуються частіше.
+	s3 := []int{4, 5, 9}    // Порівняйте з a5. Тут немає трьокрапки.
+	s4 := make([]int, 4)    // Виділяє пам'ять для зрізу з 4 чисел, проініціалізованих 0.
+	var d2 [][]float64      // Декларація, нічого не виділяється.
+	bs := []byte("a slice") // Синтаксис переведення у інший тип.
+
+	// Оскільки зрізи динамічні, до них можна додавати елементи за необхідністю.
+	// Для цієї операції використовується вбудована функція append().
+	// Перший аргумент - це зріз, до якого додається елемент. Зазвичай 
+	// змінна масиву оновлюється на місці, як у прикладі нижче.
+	s := []int{1, 2, 3}		// В результаті отримуємо зріз із 3 чисел.
+	s = append(s, 4, 5, 6)	// додаємо 3 елементи. Зріз тепер довжини 6.
+	fmt.Println(s) // Оновлений зріз тепер має значення [1 2 3 4 5 6]
+
+	// Щоб об'єднати два зрізи, замість того, щоб проходитись по всім елементам,
+	// можна передати посилання на зріз із трьокрапкою, як у прикладі нижче. Таким чином,
+	// зріз розпакується і його елементи додадуться до зріза s.
+	s = append(s, []int{7, 8, 9}...)
+	fmt.Println(s)	// Оновлений зріз тепер дорівнює [1 2 3 4 5 6 7 8 9]
+
+	p, q := learnMemory() // Оголошує змінні p, q, що є вказівниками на числа.
+	fmt.Println(*p, *q)   // * іде попереду вказівника. Таким чином, виводяться числа.
+
+	// Асоціативний масив (map) - це динамічно розширюваний тип даних, як хеш
+	// або словник в інших мовах програмування
+	m := map[string]int{"three": 3, "four": 4}
+	m["one"] = 1
+
+	// В Go  змінні, які не використовуються, вважаються помилкою.
+	// Нижнє підкреслення дозволяє "використати" змінну, але проігнорувати значення.
+	_, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a5, s4, bs
+	// Зазвичай це використовується, щоб проігнорувати значення, що повертає функція.
+	// Наприклад, в скрипті нашвидкоруч можна проігнорувати помилку, яку повертає
+	// функція os.Create, вважаючи, що файл буде створений за будь-яких умов.
+	file, _ := os.Create("output.txt")
+	fmt.Fprint(file, "Приклад, як відбувається запис у файл.")
+	file.Close()
+	
+	// Вивід значень змінних.
+	fmt.Println(s, c, a4, s3, d2, m)
+
+	learnFlowControl() // Рухаємось далі.
+}
+
+// Навідміну від більшості інших мов програмування, функції в Go підтримують 
+// іменоване значення, що повертається. 
+// Змінні, значення яких повертається функцією, вказуються із зазначенням типу при
+// оголошенні функції. Таким чином, можна з легкістю повернути їхні значення в різних
+// точках коду, не перелічуючи їх після ключового слова return.
+func learnNamedReturns(x, y int) (z int) {
+	z = x * y
+	return // z не потрібно вказувати, при оголошенні описано змінну для повернення.
+}
+
+// Go використовує сміттєзбірник. В ньому використовуються вказівники, проте немає 
+// операцій з вказівниками. Можлива помилка при використовуванні вказівника nil, але не 
+// при збільшенні значення вказівника (перехід по адресам пам'яті). 
+func learnMemory() (p, q *int) {
+	// Іменовані змінні, що повертаються, p та q, мають тип вказівника на чисельне значення.
+	p = new(int) // Вбудована функція виділяє нову пам'ять.
+	// Виділена адреса пам'яті чисельного типу int ініціалізовується 0, p більше не nil.
+	s := make([]int, 20) // Виділити пам'ять для 20 чисел у вигляді суцільного блоку в пам'яті.
+	s[3] = 7             // Присвоїти значення одному з них.
+	r := -2              // Оголосити нову локальну змінну.
+	return &s[3], &r     // Оператор & повертає адресу в пам'яті об'єкта.
+}
+
+func expensiveComputation() float64 {
+	return m.Exp(10)
+}
+
+func learnFlowControl() {
+	// if твердження вимагає фігурні дужки, але не вимагає округлих.
+	if true {
+		fmt.Println("Кажу ж")
+	}
+	// Форматування стандартизовано командою командного рядка "go fmt". 
+	if false {
+		// Pout.
+	} else {
+		// Gloat.
+	}
+	// Використання перемикача (switch) замість ланцюга if-тверджень.
+	x := 42.0
+	switch x {
+	case 0:
+	case 1:
+	case 42:
+		// Кейси не "провалюються". Натомість, є ключове слово `fallthrough`:
+		// https://github.com/golang/go/wiki/Switch#fall-through (англ)
+	case 43:
+		// Недоступний.
+	default:
+		// Кейс за замовчуванням не обов'язковий.
+	}
+	// Як і if, формат оголошення циклу for не вимагає круглих дужок:
+	// Змінні, оголошені всередині if та for - належать цій області видимості.
+	for x := 0; x < 3; x++ { // ++ - це твердження.
+		fmt.Println("iteration", x)
+	}
+	// Тут x == 42.
+
+	// For - це єдиний цикл в Go, проте він має кілька різних форм.
+	for { // Ініціалізація циклу.
+		break    // Упс, помилково зайшли.
+		continue // Недоступне твердження.
+	}
+
+	// Можна використовувати діапазони, зрізи, рядки, асоціативні масиви, або ж
+	// канал для ітерації в циклі. Діапазон (range) повертає один (канал) або два
+	// значення (масив, зріз, рядок та асоціативний масив).
+	for key, value := range map[string]int{"one": 1, "two": 2, "three": 3} {
+		// для кожної пари в асоціативному масиві, надрукувати ключ та значення
+		fmt.Printf("key=%s, value=%d\n", key, value)
+	}
+	// якщо потрібне тільки значення, можна застосувати нижнє підкреслення як ключ
+	for _, name := range []string{"Bob", "Bill", "Joe"} {
+		fmt.Printf("Hello, %s\n", name)
+	}
+
+	// так само, як і з циклом for, оператор := в розгалуженні означає оголосити 
+	// локальну змінну в області видимості if та присвоїти значення. Далі
+	// значення змінної проходить перевірку y > x.
+	if y := expensiveComputation(); y > x {
+		x = y
+	}
+	// Літерали функцій - це замикання
+	xBig := func() bool {
+		return x > 10000 // Посилання на x, що був оголошений раніше, перед switch.
+	}
+	x = 99999
+	fmt.Println("xBig:", xBig()) // true
+	x = 1.3e3                    // Тобто, тепер x == 1300
+	fmt.Println("xBig:", xBig()) // false тепер.
+
+	// Функція може бути оголошена та викликана в одному рядку, поводячи себе 
+	// як аргумент функції, але за наступних умов:
+	// 1) літерал функції негайно викликається за допомогою ()
+	// 2) тип значення, що повертається, точно відповідає очікуваному типу аргументу
+	fmt.Println("Add + double two numbers: ",
+		func(a, b int) int {
+			return (a + b) * 2
+		}(10, 2)) // Викликаємо з аргументами 10 та 2
+	// => Додати + подвоїти два числа: 24
+
+	// Коли вам це знадобиться, ви полюбите це
+	goto love
+love:
+
+	learnFunctionFactory() // функція, що повертає функцію - це весело(3)(3)
+	learnDefer()      // Швидкий обхід до важливого ключового слова.
+	learnInterfaces() // Тут на вас чекає крута штука!
+}
+
+func learnFunctionFactory() {
+	// Два наступних твердження роблять однакові дії, але другий приклад частіше 
+	// застосовується
+	fmt.Println(sentenceFactory("summer")("A beautiful", "day!"))
+
+	d := sentenceFactory("summer")
+	fmt.Println(d("A beautiful", "day!"))
+	fmt.Println(d("A lazy", "afternoon!"))
+}
+
+// Декоратори звична річ для багатьох мов програмування. В Go їх можна реалізувати
+// за допомогою літералів функцій, що приймають аргументи.
+func sentenceFactory(mystring string) func(before, after string) string {
+	return func(before, after string) string {
+		return fmt.Sprintf("%s %s %s", before, mystring, after) // новий рядок
+	}
+}
+
+func learnDefer() (ok bool) {
+	// твердження defer змушує функцію посилатись на список. Список 
+	// збережених викликів виконується ПІСЛЯ того, як оточуюча функція закінчує
+	// виконання.
+	defer fmt.Println("відкладені твердження виконуються у зворотньому порядку (LIFO).")
+	defer fmt.Println("\nЦей рядок надрукується першим, тому що")
+	// Відкладення зазвичай використовується для того, щоб закрити файл. Таким чином,
+	// функція, що закриває файл, залишається близькою до функції, що відкриває файл.
+	return true
+}
+
+// Оголошує Stringer як тип інтерфейсу з одним методом, String.
+type Stringer interface {
+	String() string
+}
+
+// Оголошує pair як структуру з двома полями, цілими числами x та y.
+type pair struct {
+	x, y int
+}
+
+// Оголошує метод для типу pair. pair тепер реалізує Stringer, оскільки pair оголосив
+// всі методи в цьому інтерфейсі.
+func (p pair) String() string { // p тепер називається "приймачем"
+	// Sprintf - ще одна функція з пакету fmt.
+	// Крапка використовується, щоб звернутись до полів об'єкту p.
+	return fmt.Sprintf("(%d, %d)", p.x, p.y)
+}
+
+func learnInterfaces() {
+	// Синтаксис з використанням фігурних дужок називається "літералом структури".
+	// Він застосовується до ініціалізованої структури. Оператор := оголошує
+	// та ініціалізує p цією структурою.
+	p := pair{3, 4}
+	fmt.Println(p.String()) // Викликає метод String об'єкта p типу pair.
+	var i Stringer          // Оголошує і інтерфейсного типу Stringer.
+	i = p                   // Допустиме, оскільки pair реалізує Stringer
+	// Викликає метод String об'єкта і, що має тип Stringer. Виводить те ж саме, що й 
+	// аналогічний метод вище.
+	fmt.Println(i.String())
+
+	// Функції з бібліотеки fmt викликають метод String, щоб запросити у об'єкта
+	// своє представлення, яке можна надрукувати.
+	fmt.Println(p) // Виводить те ж саме, що й раніше.
+	fmt.Println(i) // Виводить те ж саме, що й раніше.
+
+	learnVariadicParams("great", "learning", "here!")
+}
+
+// Кількість аргументів функції може бути змінною.
+func learnVariadicParams(myStrings ...interface{}) {
+	// Пройтись по значенням всіх аргументів.
+	// _ - це ігнорування порядкового номеру аргумента в масиві.
+	for _, param := range myStrings {
+		fmt.Println("param:", param)
+	}
+
+	// Передати значення аргументів як параметр змінної величини.
+	fmt.Println("params:", fmt.Sprintln(myStrings...))
+
+	learnErrorHandling()
+}
+
+func learnErrorHandling() {
+	// Ідіома ", ok"використовується, щоб перевірити виконання команди без помилок.
+	m := map[int]string{3: "three", 4: "four"}
+	if x, ok := m[1]; !ok { // ok буде мати значення false, тому що 1 не знаходиться 
+							// в асоціативному масиві.
+		fmt.Println("немає таких")
+	} else {
+		fmt.Print(x) // x буде мати значення 1, якщо 1 знаходиться в m.
+	}
+	// Значення помилки повідомляє не тільки, що все добре, але й може розповісти 
+	// більше про проблему.
+	if _, err := strconv.Atoi("non-int"); err != nil { // _ ігнорує значення
+		// виводить помилку 'strconv.ParseInt: parsing "non-int": invalid syntax'
+		fmt.Println(err)
+	}
+	// Ми розглянемо інтерфейси дещо пізніше. А поки, розглянемо багатопоточність.
+	learnConcurrency()
+}
+
+// Канал с - це потокозохищений об'єкт для спілкування між потоками.
+func inc(i int, c chan int) {
+	c <- i + 1 // Оператор <- виконує операцію "надіслати",якщо змінна каналу 
+			   // знаходиться зліва від нього.
+}
+
+// inc виконує збільшення значення на 1. Ми використаємо його, щоб збільшувати
+// числа рівночасно.
+func learnConcurrency() {
+	// вже знайома функція make, яка раніше використовувалась для виділення пам'яті, 
+	// тут використовується для створення каналу. Make виділяє пам'ять та ініціалізує
+	// зрізи, асоційовані масиви та канали. Новостворений канал буде передавати 
+	// цілочисельні значення.
+	c := make(chan int)
+	// Запустити три одночасні ґорутини. Числа будуть збільшуватись рівночасно, імовірно
+	// паралельно якщо пристрій здатний до цього та правильно сконфігурований.
+	// Всі три ґорутини надсилають значення в один канал.
+	go inc(0, c) // Твердження go запускає нову ґорутину.
+	go inc(10, c)
+	go inc(-805, c)
+	// Читаємо три результати з каналу та друкуємо їх.
+	// Порядок результатів - невідомий!
+	fmt.Println(<-c, <-c, <-c) // якщо канал знаходиться справа від оператора <-, 
+								// він виконує функцію "приймача".
+
+	cs := make(chan string)       // Ще один канал, який примає рядки.
+	ccs := make(chan chan string) // Канал каналів рядків.
+	go func() { c <- 84 }()       // Запустимо нову ґорутину, щоб надіслати значення в канал с.
+	go func() { cs <- "wordy" }() // Надсилаємо "wordy" в канал cs.
+	// Ключове слово select має синтаксис, подібний до switch, проте кожен кейс
+	// включає в себе операцію з каналом. Він обирає довільний кейс з наявних, які готові
+	// комунікувати (передавати дані).
+	select {
+	case i := <-c: // Отримане значення може бути присвоєно змінній,
+		fmt.Printf("it's a %T", i)
+	case <-cs: // або значення може бути проігнороване.
+		fmt.Println("it's a string")
+	case <-ccs: // Пустий канал, не готовий комунікувати.
+		fmt.Println("Не відбудеться.")
+	}
+	// На цьому етапі, значення було прочитане або з с або з cs. Одна з двох
+	// ґорутин завершилась, але інша все ще заблокована.
+
+	learnWebProgramming() // Go вміє й у веб. Так, ти хочеш зробити це.
+}
+
+// Лиш одна функція з пакету http запускає веб сервер.
+func learnWebProgramming() {
+	
+	// перший аргумент ListenAndServe - це TCP адреса, який сервер буде слухати.
+	// Другий аргумент - це інтерфейс, а точніше http.Handler.
+	go func() {
+		err := http.ListenAndServe(":8080", pair{})
+		fmt.Println(err) // не ігноруйте помилки
+	}()
+
+	requestServer()
+}
+
+// pair матиме тип http.Handler, якщо реалізувати один його метод, ServeHTTP.
+func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Відповідати на запити можна методом, що належить http.ResponseWriter.
+	w.Write([]byte("Ти вивчив Go за Y хвилин!"))
+}
+
+func requestServer() {
+	resp, err := http.Get("http://localhost:8080")
+	fmt.Println(err)
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	fmt.Printf("\nWebserver said: `%s`", string(body))
+}
+```
+
+## Подальше вивчення
+
+Основним джерелом всієї інформації про Go залишається [офіційна веб-сторінка](http://golang.org/). Там можна знайти уроки, інтерактивно пограти та багато про що почитати.
+Окрім туру, у [документації](https://golang.org/doc/) міститься інформація як писати чистий та ефективний код на Go, документація пакетів та окремих команд, а також історія релізів.
+
+Надзвичайно рекомендується ознайомитись із визначенням мови. Вона легко читається та на диво коротка (в порівнянні з іншими сучасними мовами).
+
+Можна погратись з кодом вище на [Go playground](https://play.golang.org/p/tnWMjr16Mm). Спробуй змінити його та запустити із свого браузера. Поміть, що можна використовувати [https://play.golang.org](https://play.golang.org) як [REPL](https://uk.wikipedia.org/wiki/REPL) до тестів та коду в твоєму браузері, без встановлення Go.
+
+В списку для прочитання новачкам в Go - [вихідний код стандартної бібліотеки](http://golang.org/src/pkg/). Код всеосяжно задокоментований, тому є найкращим прикладом з боку зручного для прочитання та швидкості розуміння коду на цій мові програмування. Приведений стиль та ідіоми Go.
+Крім того, можна просто натиснути на назву функції в [документації](http://golang.org/pkg/), щоб перейти до її реалізації.
+
+Іншим прекрасним посиланням для вивчення Go є [Go by example](https://gobyexample.com/).
+
+Go Mobile додає підтримку мобільних платформ (Android та iOS). Можна написати нативний код на Go  для мобільних застосунків або написати бібліотеку, що міститиме прив'язки (bindings) з пакету Go, які можуть бути викликані з Java (Android) та Objective-C (iOS). Деталі можна дізнатись на [веб-сторінці Go Mobile](https://github.com/golang/go/wiki/Mobile).
diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown
index 1d600400..40d56988 100644
--- a/uk-ua/java-ua.html.markdown
+++ b/uk-ua/java-ua.html.markdown
@@ -30,7 +30,7 @@ JavaDoc-коментар виглядає так. Використовуєтьс
 
 // Імпорт класу ArrayList з пакета java.util
 import java.util.ArrayList;
-// Імпорт усіх класів з пакета java.security 
+// Імпорт усіх класів з пакета java.security
 import java.security.*;
 
 // Кожний .java файл містить один зовнішній публічний клас, ім’я якого співпадає
@@ -99,13 +99,13 @@ public class LearnJava {
 
         // Примітка: Java не має беззнакових типів.
 
-        // Float — 32-бітне число з рухомою комою одиничної точності за стандартом IEEE 754 
+        // Float — 32-бітне число з рухомою комою одиничної точності за стандартом IEEE 754
         // 2^-149 <= float <= (2-2^-23) * 2^127
         float fooFloat = 234.5f;
         // f або F використовується для позначення того, що змінна має тип float;
         // інакше трактується як double.
 
-        // Double — 64-бітне число з рухомою комою подвійної точності за стандартом IEEE 754 
+        // Double — 64-бітне число з рухомою комою подвійної точності за стандартом IEEE 754
         // 2^-1074 <= x <= (2-2^-52) * 2^1023
         double fooDouble = 123.4;
 
@@ -130,13 +130,13 @@ public class LearnJava {
         // байтів, операції над ними виконуються функціями, які мають клас BigInteger
         //
         // BigInteger можна ініціалізувати, використовуючи масив байтів чи рядок.
-        
+
         BigInteger fooBigInteger = new BigInteger(fooByteArray);
 
 
         // BigDecimal — Незмінні знакові дробові числа довільної точності
         //
-        // BigDecimal складається з двох частин: цілого числа довільної точності 
+        // BigDecimal складається з двох частин: цілого числа довільної точності
         // з немасштабованим значенням та 32-бітного масштабованого цілого числа
         //
         // BigDecimal дозволяє розробникам контролювати десяткове округлення.
@@ -147,10 +147,10 @@ public class LearnJava {
         // чи немасштабованим значенням (BigInteger) і масштабованим значенням (int).
 
         BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
-        
+
         // Для дотримання заданої точності рекомендується використовувати
-        // конструктор, який приймає String 
-        
+        // конструктор, який приймає String
+
         BigDecimal tenCents = new BigDecimal("0.1");
 
 
@@ -295,7 +295,7 @@ public class LearnJava {
             // Виконається 10 разів, fooFor 0->9
         }
         System.out.println("Значення fooFor: " + fooFor);
-        
+
         // Вихід із вкладеного циклу через мітку
         outer:
         for (int i = 0; i < 10; i++) {
@@ -306,7 +306,7 @@ public class LearnJava {
             }
           }
         }
-        
+
         // Цикл For Each
         // Призначений для перебору масивів та колекцій       
         int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};       
@@ -318,7 +318,7 @@ public class LearnJava {
 
         // Оператор вибору Switch Case
         // Оператор вибору працює з типами даних byte, short, char, int.
-        // Також працює з переліками Enum, 
+        // Також працює з переліками Enum,
         // класом String та класами-обгортками примітивних типів:
         // Character, Byte, Short та Integer.
         int month = 3;
@@ -334,7 +334,7 @@ public class LearnJava {
                      break;
         }
         System.out.println("Результат Switch Case: " + monthString);
-        
+
         // Починаючи з Java 7 і далі, вибір рядкових змінних здійснюється так:
         String myAnswer = "можливо";
         switch(myAnswer) {
@@ -398,7 +398,7 @@ public class LearnJava {
 
         // toString повертає рядкове представлення об’єкту.
         System.out.println("Інформація про об’єкт trek: " + trek.toString());
-        
+
         // У Java немає синтаксису для явного створення статичних колекцій.
         // Це можна зробити так:
 
@@ -554,7 +554,7 @@ public interface Digestible {
 
 // Можна створити клас, що реалізує обидва інтерфейси.
 public class Fruit implements Edible, Digestible {
-  
+
     @Override
     public void eat() {
         // ...
@@ -592,7 +592,7 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
 // Позначення класу як абстрактного означає, що оголошені у ньому методи мають
 // бути реалізовані у дочірніх класах. Подібно до інтерфейсів, не можна створити екземпляри
 // абстракних класів, але їх можна успадковувати. Нащадок зобов’язаний реалізувати всі абстрактні
-// методи. на відміну від інтерфейсів, абстрактні класи можуть мати як визначені,
+// методи. На відміну від інтерфейсів, абстрактні класи можуть мати як визначені,
 // так і абстрактні методи. Методи в інтерфейсах не мають тіла,
 // за винятком статичних методів, а змінні неявно мають модифікатор final, на відміну від
 // абстрактного класу. Абстрактні класи МОЖУТЬ мати метод «main».
@@ -694,41 +694,41 @@ public abstract class Mammal()
 
 public enum Day {
     SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
-    THURSDAY, FRIDAY, SATURDAY 
+    THURSDAY, FRIDAY, SATURDAY
 }
 
 // Перелік Day можна використовувати так:
 
 public class EnumTest {
-    
+
     // Змінна того же типу, що й перелік
     Day day;
-    
+
     public EnumTest(Day day) {
         this.day = day;
     }
-    
+
     public void tellItLikeItIs() {
         switch (day) {
             case MONDAY:
-                System.out.println("Понеділкі важкі.");
+                System.out.println("Понеділки важкі.");
                 break;
-                    
+
             case FRIDAY:
                 System.out.println("П’ятниці краще.");
                 break;
-                         
-            case SATURDAY: 
+
+            case SATURDAY:
             case SUNDAY:
                 System.out.println("Вихідні найліпші.");
                 break;
-                        
+
             default:
                 System.out.println("Середина тижня так собі.");
                 break;
         }
     }
-    
+
     public static void main(String[] args) {
         EnumTest firstDay = new EnumTest(Day.MONDAY);
         firstDay.tellItLikeItIs(); // => Понеділки важкі.
@@ -737,7 +737,7 @@ public class EnumTest {
     }
 }
 
-// Переліки набагато потужніші, ніж тут показано. 
+// Переліки набагато потужніші, ніж тут показано.
 // Тіло переліків може містити методи та інші змінні.
 // Дивіться більше тут: https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
 
diff --git a/uk-ua/javascript-ua.html.markdown b/uk-ua/javascript-ua.html.markdown
index 397b1c5e..6a64a623 100644
--- a/uk-ua/javascript-ua.html.markdown
+++ b/uk-ua/javascript-ua.html.markdown
@@ -45,7 +45,7 @@ doStuff()
 3; // = 3
 1.5; // = 1.5
 
-// Деякі прості арифметичні операції працють так, як ми очікуємо.
+// Деякі прості арифметичні операції працюють так, як ми очікуємо.
 1 + 1; // = 2
 0.1 + 0.2; // = 0.30000000000000004 (а деякі - ні)
 8 - 1; // = 7
@@ -106,7 +106,7 @@ null == undefined; // = true
 
 // ... але приведення не виконується при ===
 "5" === 5; // = false
-null === undefined; // = false 
+null === undefined; // = false
 
 // ... приведення типів може призвести до дивних результатів
 13 + !0; // 14
@@ -171,7 +171,7 @@ myArray[3] = "світ";
 // Об’єкти в JavaScript схожі на словники або асоціативні масиви в інших мовах
 var myObj = {key1: "Hello", key2: "World"};
 
-// Ключі - це рядки, але лапки не обов’язкі, якщо ключ задовольняє
+// Ключі - це рядки, але лапки не обов’язкові, якщо ключ задовольняє
 // правилам формування назв змінних. Значення можуть бути будь-яких типів.
 var myObj = {myKey: "myValue", "my other key": 4};
 
@@ -258,7 +258,7 @@ function myFunction(thing) {
     return thing.toUpperCase();
 }
 myFunction("foo"); // = "FOO"
- 
+
 // Зверніть увагу, що значення яке буде повернено, повинно починатися на тому ж
 // рядку, що і ключове слово return, інакше завжди буде повертатися значення undefined
 // через автоматичну вставку крапки з комою
@@ -332,7 +332,7 @@ var myObj = {
 };
 myObj.myFunc(); // = "Hello, world!"
 
-// Функції, що прикріплені до об’єктів мають доступ до поточного об’єкта за 
+// Функції, що прикріплені до об’єктів мають доступ до поточного об’єкта за
 // допомогою ключового слова this.
 myObj = {
     myString: "Hello, world!",
@@ -348,7 +348,7 @@ myObj.myFunc(); // = "Hello, world!"
 var myFunc = myObj.myFunc;
 myFunc(); // = undefined
 
-// Функція може бути присвоєна іншому об’єкту. Тоді вона матиме доступ до 
+// Функція може бути присвоєна іншому об’єкту. Тоді вона матиме доступ до
 // цього об’єкта через this
 var myOtherFunc = function() {
     return this.myString.toUpperCase();
@@ -371,7 +371,7 @@ Math.min(42, 6, 27); // = 6
 Math.min([42, 6, 27]); // = NaN (Ой-ой!)
 Math.min.apply(Math, [42, 6, 27]); // = 6
 
-// Але call і apply — тимчасові. Коли ми хочемо зв’язати функцію і об’єкт 
+// Але call і apply — тимчасові. Коли ми хочемо зв’язати функцію і об’єкт
 // використовують bind
 var boundFunc = anotherFunc.bind(myObj);
 boundFunc(" Hello!"); // = "Hello world, Hello!"
@@ -475,7 +475,7 @@ if (Object.create === undefined) { // не перезаписуємо метод
         // Створюємо правильний конструктор з правильним прототипом
         var Constructor = function(){};
         Constructor.prototype = proto;
-    
+
         return new Constructor();
     }
 }
diff --git a/uk-ua/kotlin-ua.html.markdown b/uk-ua/kotlin-ua.html.markdown
new file mode 100644
index 00000000..5e79cc48
--- /dev/null
+++ b/uk-ua/kotlin-ua.html.markdown
@@ -0,0 +1,464 @@
+---
+language: kotlin
+filename: LearnKotlin-uk.kt
+lang: uk-ua
+contributors:
+    - ["S Webber", "https://github.com/s-webber"]
+translators:
+    - ["AstiaSun", "https://github.com/AstiaSun"]
+---
+
+Kotlin - це мова програмування зі статичною типізацією для JVM, Android та браузера. 
+Вона має 100% сумісність із Java.
+
+[Детальніше](https://kotlinlang.org/)
+
+```kotlin
+// Однорядкові коментарі починаються з //
+/*
+Такий вигляд мають багаторядкові коментарі
+*/
+
+// Ключове слово package працює так само, як і в Java.
+package com.learnxinyminutes.kotlin
+
+/*
+Точкою входу для програм на Kotlin є функція під назвою main.
+Вона приймає масив із аргументів, що були передані через командний рядок.
+Починаючи з Kotlin 1.3, функція main може бути оголошена без параметрів взагалі.
+*/
+fun main(args: Array<String>) {
+    /*
+    Оголошення змінних відбувається за допомогою ключових слів var або val.
+    Відмінність між ними полягає в тому, що значення змінних, оголошених через 
+    val, не можна змінювати. Водночас, змінній "var" можна переприсвоїти нове 
+    значення в подальшому.
+    */
+    val fooVal = 10 // більше ми не можемо змінити значення fooVal на інше
+    var fooVar = 10
+    fooVar = 20 // fooVar може змінювати значення
+
+    /*
+    В більшості випадків Kotlin може визначати, якого типу змінна, тому не 
+    потрібно щоразу точно вказувати її тип.
+    Тип змінної вказується наступним чином:
+    */
+    val foo: Int = 7
+
+    /*
+    Рядки мають аналогічне з Java представлення. Спеціальні символи 
+    позначаються за допомогою зворотнього слеша.
+    */
+    val fooString = "My String Is Here!"
+    val barString = "Printing on a new line?\nNo Problem!"
+    val bazString = "Do you want to add a tab?\tNo Problem!"
+    println(fooString)
+    println(barString)
+    println(bazString)
+
+    /*
+    Необроблений рядок розмежовується за допомогою потрійних лапок (""").
+    Необроблені рядки можуть містити переніс рядка (не спеціальний символ \n) та 
+    будь-які інші символи.
+    */
+    val fooRawString = """
+fun helloWorld(val name : String) {
+   println("Hello, world!")
+}
+"""
+    println(fooRawString)
+
+    /*
+    Рядки можуть містити шаблонні вирази.
+    Шаблонний вираз починається із символа доллара "$".
+    */
+    val fooTemplateString = "$fooString has ${fooString.length} characters"
+    println(fooTemplateString) // => My String Is Here! has 18 characters
+
+    /*
+    Щоб змінна могла мати значення null, потрібно це додатково вказати. 
+    Для цього після оголошеного типу змінної додається спеціальний символ "?".
+    Отримати значення такої змінної можна використавши оператор "?.".
+    Оператор "?:" застосовується, щоб оголосити альтернативне значення змінної 
+    у випадку, якщо вона буде рівна null.
+    */
+    var fooNullable: String? = "abc"
+    println(fooNullable?.length) // => 3
+    println(fooNullable?.length ?: -1) // => 3
+    fooNullable = null
+    println(fooNullable?.length) // => null
+    println(fooNullable?.length ?: -1) // => -1
+
+    /*
+    Функції оголошуються з використанням ключового слова fun.
+    Аргументи функції перелічуються у круглих дужках після назви функції.
+    Аргументи можуть мати значення за замовчуванням. Тип значення, що повертатиметься
+    функцією, вказується після оголошення аргументів за необхідністю.
+    */
+    fun hello(name: String = "world"): String {
+        return "Hello, $name!"
+    }
+    println(hello("foo")) // => Hello, foo!
+    println(hello(name = "bar")) // => Hello, bar!
+    println(hello()) // => Hello, world!
+
+    /*
+    Аргументи функції можуть бути помічені ключовим словом vararg. Це дозволяє 
+    приймати довільну кількість аргументів функції зазначеного типу.
+    */
+    fun varargExample(vararg names: Int) {
+        println("Argument has ${names.size} elements")
+    }
+    varargExample() // => Argument has 0 elements
+    varargExample(1) // => Argument has 1 elements
+    varargExample(1, 2, 3) // => Argument has 3 elements
+
+    /*
+    Коли функція складається з одного виразу, фігурні дужки не є обов'язковими. 
+    Тіло функції вказується після оператора "=".
+    */
+    fun odd(x: Int): Boolean = x % 2 == 1
+    println(odd(6)) // => false
+    println(odd(7)) // => true
+
+    // Якщо тип значення, що повертається функцією, може бути однозначно визначено, 
+    // його непотрібно вказувати.
+    fun even(x: Int) = x % 2 == 0
+    println(even(6)) // => true
+    println(even(7)) // => false
+
+    // Функції можуть приймати інші функції як аргументи, а також повертати інші функції.
+    fun not(f: (Int) -> Boolean): (Int) -> Boolean {
+        return {n -> !f.invoke(n)}
+    }
+    // Іменовані функції можуть бути вказані як аргументи за допомогою оператора "::".
+    val notOdd = not(::odd)
+    val notEven = not(::even)
+    // Лямбда-вирази також можуть бути аргументами функції.
+    val notZero = not {n -> n == 0}
+    /*
+    Якщо лямбда-вираз приймає лише один параметр, його оголошення може бути пропущене
+    (разом із ->). Всередині виразу до цього параметра можна звернутись через 
+    змінну "it".
+    */
+    val notPositive = not {it > 0}
+    for (i in 0..4) {
+        println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
+    }
+
+    // Ключове слово class використовується для оголошення класів.
+    class ExampleClass(val x: Int) {
+        fun memberFunction(y: Int): Int {
+            return x + y
+        }
+
+        infix fun infixMemberFunction(y: Int): Int {
+            return x * y
+        }
+    }
+    /*
+    Щоб створити новий об'єкт, потрібно викликати конструктор класу.
+    Зазначте, що в Kotlin немає ключового слова new.
+    */
+    val fooExampleClass = ExampleClass(7)
+    // Методи класу викликаються через крапку.
+    println(fooExampleClass.memberFunction(4)) // => 11
+    /*
+    Якщо функція була позначена ключовим словом infix, тоді її можна викликати через 
+    інфіксну нотацію.
+    */
+    println(fooExampleClass infixMemberFunction 4) // => 28
+
+    /*
+    Класи даних - це лаконічний спосіб створювати класи, що містимуть тільки дані.
+    Методи "hashCode"/"equals" та "toString" автоматично генеруються.
+    */
+    data class DataClassExample (val x: Int, val y: Int, val z: Int)
+    val fooData = DataClassExample(1, 2, 4)
+    println(fooData) // => DataClassExample(x=1, y=2, z=4)
+
+    // Класи даних також мають функцію "copy".
+    val fooCopy = fooData.copy(y = 100)
+    println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
+
+    // Об'єкти можуть бути деструктурувані кількома способами. 
+    val (a, b, c) = fooCopy
+    println("$a $b $c") // => 1 100 4
+
+    // деструктурування у циклі for
+    for ((a, b, c) in listOf(fooData)) {
+        println("$a $b $c") // => 1 100 4
+    }
+
+    val mapData = mapOf("a" to 1, "b" to 2)
+    // Map.Entry також деструктурувуються
+    for ((key, value) in mapData) {
+        println("$key -> $value")
+    }
+
+    // Функція із "with" працює майже так само як це ж твердження у JavaScript.
+    data class MutableDataClassExample (var x: Int, var y: Int, var z: Int)
+    val fooMutableData = MutableDataClassExample(7, 4, 9)
+    with (fooMutableData) {
+        x -= 2
+        y += 2
+        z--
+    }
+    println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8)
+
+    /*
+    Список можна створити використовуючи функцію listOf.
+    Список буде незмінним, тобто елементи не можна буде додавати або видаляти.
+    */
+    val fooList = listOf("a", "b", "c")
+    println(fooList.size) // => 3
+    println(fooList.first()) // => a
+    println(fooList.last()) // => c
+    // доступ до елементів здійснюється через їхні порядковий номер.
+    println(fooList[1]) // => b
+
+    // Змінні списки можна створити використовуючи функцію mutableListOf.
+    val fooMutableList = mutableListOf("a", "b", "c")
+    fooMutableList.add("d")
+    println(fooMutableList.last()) // => d
+    println(fooMutableList.size) // => 4
+
+    // Функція setOf  створює об'єкт типу множина.
+    val fooSet = setOf("a", "b", "c")
+    println(fooSet.contains("a")) // => true
+    println(fooSet.contains("z")) // => false
+
+    // mapOf створює асоціативний масив.
+    val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
+    // Доступ до значень в асоціативних масивах здійснюється через їхні ключі.
+    println(fooMap["a"]) // => 8
+
+    /*
+    Послідовності представлені як колекції лінивих обчислень. Функція generateSequence
+    створює послідовність.
+    */
+    val fooSequence = generateSequence(1, { it + 1 })
+    val x = fooSequence.take(10).toList()
+    println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+    // Приклад використання послідовностей, генерація чисел Фібоначчі:
+    fun fibonacciSequence(): Sequence<Long> {
+        var a = 0L
+        var b = 1L
+
+        fun next(): Long {
+            val result = a + b
+            a = b
+            b = result
+            return a
+        }
+
+        return generateSequence(::next)
+    }
+    val y = fibonacciSequence().take(10).toList()
+    println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
+    // Kotlin має функції вищого порядку для роботи з колекціями.
+    val z = (1..9).map {it * 3}
+                  .filter {it < 20}
+                  .groupBy {it % 2 == 0}
+                  .mapKeys {if (it.key) "even" else "odd"}
+    println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}
+
+    // Цикл for може використовуватись з будь-чим, що має ітератор.
+    for (c in "hello") {
+        println(c)
+    }
+
+    // Принцип роботи циклів "while" не відрізняється від інших мов програмування.
+    var ctr = 0
+    while (ctr < 5) {
+        println(ctr)
+        ctr++
+    }
+    do {
+        println(ctr)
+        ctr++
+    } while (ctr < 10)
+
+    /*
+    if може бути використаний як вираз, що повертає значення. Тому тернарний 
+    оператор ?: не потрібний в Kotlin.
+    */
+    val num = 5
+    val message = if (num % 2 == 0) "even" else "odd"
+    println("$num is $message") // => 5 is odd
+
+    // "when" використовується як альтернатива ланцюгам "if-else if".
+    val i = 10
+    when {
+        i < 7 -> println("first block")
+        fooString.startsWith("hello") -> println("second block")
+        else -> println("else block")
+    }
+
+    // "when" може приймати аргумент.
+    when (i) {
+        0, 21 -> println("0 or 21")
+        in 1..20 -> println("in the range 1 to 20")
+        else -> println("none of the above")
+    }
+
+    // "when" також може використовуватись як функція, що повертає значення.
+    var result = when (i) {
+        0, 21 -> "0 or 21"
+        in 1..20 -> "in the range 1 to 20"
+        else -> "none of the above"
+    }
+    println(result)
+
+    /*
+    Тип об'єкта можна перевірити використавши оператор is. Якщо перевірка проходить 
+    успішно, тоді можна використовувати об'єкт як данний тип не приводячи до нього 
+    додатково.
+    */
+    fun smartCastExample(x: Any) : Boolean {
+        if (x is Boolean) {
+            // x тепер має тип Boolean
+            return x
+        } else if (x is Int) {
+            // x тепер має тип Int
+            return x > 0
+        } else if (x is String) {
+            // x тепер має тип String
+            return x.isNotEmpty()
+        } else {
+            return false
+        }
+    }
+    println(smartCastExample("Hello, world!")) // => true
+    println(smartCastExample("")) // => false
+    println(smartCastExample(5)) // => true
+    println(smartCastExample(0)) // => false
+    println(smartCastExample(true)) // => true
+
+    // Smartcast (розумне приведення) також працює з блоком when
+    fun smartCastWhenExample(x: Any) = when (x) {
+        is Boolean -> x
+        is Int -> x > 0
+        is String -> x.isNotEmpty()
+        else -> false
+    }
+
+    /*
+    Розширення - це ще один спосіб розширити функціонал класу.
+    Подібні методи розширення реалізовані у С#.
+    */
+    fun String.remove(c: Char): String {
+        return this.filter {it != c}
+    }
+    println("Hello, world!".remove('l')) // => Heo, word!
+}
+
+// Класи перелічення також подібні до тих типів, що і в Java.
+enum class EnumExample {
+    A, B, C // Константи перелічення розділені комами.
+}
+fun printEnum() = println(EnumExample.A) // => A
+
+// Оскільки кожне перелічення - це об'єкт класу enum, воно може бути 
+// проініціалізоване наступним чином:
+enum class EnumExample(val value: Int) {
+    A(value = 1),
+    B(value = 2),
+    C(value = 3)
+}
+fun printProperty() = println(EnumExample.A.value) // => 1
+
+// Кожне перелічення має властивості, які дозволяють отримати його ім'я 
+// та порядок (позицію) в класі enum:
+fun printName() = println(EnumExample.A.name) // => A
+fun printPosition() = println(EnumExample.A.ordinal) // => 0
+
+/*
+Ключове слово object можна використати для створення об'єкту сінглтону. Об'єкт не 
+можна інстанціювати, проте на його унікальний екземпляр можна посилатись за іменем.
+Подібна можливість є в сінглтон об'єктах у Scala. 
+*/
+object ObjectExample {
+    fun hello(): String {
+        return "hello"
+    }
+
+    override fun toString(): String {
+        return "Hello, it's me, ${ObjectExample::class.simpleName}"
+    }
+}
+
+
+fun useSingletonObject() {
+    println(ObjectExample.hello()) // => hello
+    // В Kotlin, "Any" - це корінь ієрархії класів, так само, як і "Object" у Java.
+    val someRef: Any = ObjectExample
+    println(someRef) // => Hello, it's me, ObjectExample
+}
+
+
+/* 
+Оператор перевірки на те, що об'єкт не рівний null, (!!) перетворює будь-яке значення в ненульовий тип і кидає виняток, якщо значення рівне null.
+*/
+var b: String? = "abc"
+val l = b!!.length
+
+// Далі - приклади перевизначення методів класу Any в класі-насліднику
+data class Counter(var value: Int) {
+    // перевизначити Counter += Int
+    operator fun plusAssign(increment: Int) {
+        this.value += increment
+    }
+
+    // перевизначити Counter++ та ++Counter
+    operator fun inc() = Counter(value + 1)
+
+    // перевизначити Counter + Counter
+    operator fun plus(other: Counter) = Counter(this.value + other.value)
+
+    // перевизначити Counter * Counter
+    operator fun times(other: Counter) = Counter(this.value * other.value)
+
+    // перевизначити Counter * Int
+    operator fun times(value: Int) = Counter(this.value * value)
+
+    // перевизначити Counter in Counter
+    operator fun contains(other: Counter) = other.value == this.value
+
+    // перевизначити Counter[Int] = Int
+    operator fun set(index: Int, value: Int) {
+        this.value = index + value
+    }
+
+    // перевизначити виклик екземпляру Counter
+    operator fun invoke() = println("The value of the counter is $value")
+
+}
+// Можна також перевизначити оператори через методи розширення.
+// перевизначити -Counter
+operator fun Counter.unaryMinus() = Counter(-this.value)
+
+fun operatorOverloadingDemo() {
+    var counter1 = Counter(0)
+    var counter2 = Counter(5)
+    counter1 += 7
+    println(counter1) // => Counter(value=7)
+    println(counter1 + counter2) // => Counter(value=12)
+    println(counter1 * counter2) // => Counter(value=35)
+    println(counter2 * 2) // => Counter(value=10)
+    println(counter1 in Counter(5)) // => false
+    println(counter1 in Counter(7)) // => true
+    counter1[26] = 10
+    println(counter1) // => Counter(value=36)
+    counter1() // => The value of the counter is 36
+    println(-counter2) // => Counter(value=-5)
+}
+```
+
+### Подальше вивчення
+
+* [Уроки Kotlin](https://kotlinlang.org/docs/tutorials/)
+* [Спробувати попрацювати з Kotlin в браузері](https://play.kotlinlang.org/)
+* [Список корисних посилань](http://kotlin.link/)
diff --git a/uk-ua/mips-ua.html.markdown b/uk-ua/mips-ua.html.markdown
new file mode 100644
index 00000000..8d4517fe
--- /dev/null
+++ b/uk-ua/mips-ua.html.markdown
@@ -0,0 +1,366 @@
+---
+language: "MIPS Assembly"
+filename: MIPS.asm
+contributors:
+  - ["Stanley Lim", "https://github.com/Spiderpig86"]
+translators:
+  - ["AstiaSun", "https://github.com/AstiaSun"]
+lang: uk-ua
+---
+
+Мова ассемблера MIPS (англ. Microprocessor without Interlocked Pipeline Stages) була написана для роботи з мікропроцесорами MIPS, парадигма яких була описана в 1981 році [Джоном Геннессі](https://uk.wikipedia.org/wiki/Джон_Лерой_Геннессі). Ці RISC процесори використовуються у таких вбудованих системах, як маршрутизатори та мережеві шлюзи.
+
+[Детальніше](https://en.wikipedia.org/wiki/MIPS_architecture)
+
+```asm
+# Коментарі позначені як'#'
+
+# Всі символи після '#' ігноруються лексичним аналізатором асемблера.
+
+# Зазвичай програми поділяються на .data та .text частини
+
+.data # У цьому розділі дані зберігаються у пам'яті, виділеній в RAM, подібно до змінних
+	   # в мовах програмування вищого рівня
+
+  # Змінна оголошується наступним чином: [назва]: .[тип] [значення] 
+  # Наприклад:
+  hello_world: .asciiz "Hello World\n"      # Оголосити текстову змінну
+  num1: .word 42                            # word - це чисельний тип 32-бітного розряду
+
+  arr1: .word 1, 2, 3, 4, 5                 # Масив чисел
+  arr2: .byte 'a', 'b'                      # Масив буквених символів (розмір кожного - 1 байт)
+  buffer: .space 60                         # Виділити місце в RAM 
+                                            # (не очищується, тобто не заповнюється 0)
+
+  # Розміри типів даних
+  _byte: .byte 'a'                          # 1 байт
+  _halfword: .half 53                       # 2 байти
+  _word: .word 3                            # 4 байти
+  _float: .float 3.14                       # 4 байти
+  _double: .double 7.0                      # 8 байтів
+
+  .align 2                                  # Вирівнювання пам'яті даних, де число
+                                            # показує кількість байтів, вирівнених 
+                                            # у степені 2. (.align 2 означає 
+                                            # чисельне (word) вирівнювання оскільки 
+                                            # 2^2 = 4 байти)
+
+.text                                       # Розділ, що містить інструкції та
+                                            # логіку програми
+
+.globl _main                                # Оголошує назву інструкції як 
+                                            # глобальну, тобто, яка є доступною для
+                                            # всіх інших файлів
+
+  _main:                                    # програми MIPS виконують інструкції
+                                            # послідовно, тобто першочергово код
+                                            # буде виконуватись після цієї позначки
+
+    # Виведемо на екран "hello world"
+    la $a0, hello_world                     # Завантажує адресу тексту у пам'яті
+    li $v0, 4                               # Завантажує значення системної
+                                            # команди (вказуючи тип функціоналу)
+    syscall                                 # Виконує зазначену системну команду
+                                            # з обраним аргументом ($a0)
+
+    # Регістри (використовуються, щоб тримати дані протягом виконання програми)
+    # $t0 - $t9                             # Тимчасові регістри використовуються
+                                            # для проміжних обчислень всередині
+                                            # підпрограм (не зберігаються між 
+                                            # викликами функцій)
+
+    # $s0 - $s7                             # Збережені регістри, у яких значення 
+                                            # зберігаються між викликами підпрограм.
+                                            # Зазвичай зберігаються у стеку.
+
+    # $a0 - $a3                             # Регістри для передачі аргументів для 
+                                            # підпрограм
+    # $v0 - $v1                             # Регістри для значень, що повертаються
+                                            # від викликаної функції
+
+    # Типи інструкції завантаження / збереження
+    la $t0, label                           # Скопіювати адресу в пам'яті, де 
+                                            # зберігається значення змінної label 
+                                            # в регістр $t0
+    lw $t0, label                           # Скопіювати чисельне значення з пам'яті
+    lw $t1, 4($s0)                          # Скопіювати чисельне значення з адреси
+                                            # пам'яті регістра зі зміщенням в 
+                                            # 4 байти (адреса + 4)
+    lb $t2, label                           # Скопіювати буквений символ в частину
+                                            # нижчого порядку регістра $t2
+    lb $t2, 0($s0)                          # Скопіювати буквений символ з адреси
+                                            # в $s0 із зсувом 0
+    # Подібне використання і 'lh' для halfwords
+
+    sw $t0, label                           # Зберегти чисельне значення в адресу в 
+                                            # пам'яті, що відповідає змінній label
+    sw $t0, 8($s0)                          # Зберегти чисельне значення в адресу, 
+                                            # що зазначена у $s0, та зі зсувом у 8 байтів
+    # Така ж ідея використання 'sb' та 'sh' для буквених символів та halfwords. 
+    # 'sa' не існує
+    
+    
+### Математичні операції ###
+  _math:
+    # Пам'ятаємо, що попередньо потрібно завантажити дані в пам'ять
+    lw $t0, num                             # Із розділа з даними
+    li $t0, 5                               # Або безпосередньо з константи
+    li $t1, 6
+    add $t2, $t0, $t1                       # $t2 = $t0 + $t1
+    sub $t2, $t0, $t1                       # $t2 = $t0 - $t1
+    mul $t2, $t0, $t1                       # $t2 = $t0 * $t1
+    div $t2, $t0, $t1                       # $t2 = $t0 / $t1 (Може не підтримуватись
+                                            # деякими версіями MARS)
+    div $t0, $t1                            # Виконує $t0 / $t1. Отримати частку можна
+                                            # за допомогою команди 'mflo', остаток - 'mfhi'
+
+    # Бітовий зсув
+    sll $t0, $t0, 2                         # Побітовий зсув вліво на 2. Біти вищого порядку
+                                            # не зберігаються, нищого - заповнюються 0
+    sllv $t0, $t1, $t2                      # Зсув вліво зі змінною кількістю у
+                                            # регістрі
+    srl $t0, $t0, 5                         # Побітовий зсув вправо на 5 (не зберігає 
+                                            # біти, біти зліва заповнюються 0)
+    srlv $t0, $t1, $t2                      # Зсув вправо зі змінною кількістю у
+                                            # регістрі
+    sra $t0, $t0, 7                         # Побітовий арифметичний зсув вправо 
+                                            # (зберігає біти)
+    srav $t0, $t1, $t2                      # Зсув вправо зі змінною кількістю у 
+                                            # регістрі зі збереження значеннь бітів
+
+    # Побітові операції
+    and $t0, $t1, $t2                       # Побітове І (AND)
+    andi $t0, $t1, 0xFFF                    # Побітове І з безпосереднім значенням
+    or $t0, $t1, $t2                        # Побітове АБО (OR)
+    ori $t0, $t1, 0xFFF                     # Побітове АБО з безпосереднім значенням
+    xor $t0, $t1, $t2                       # Побітова виключна диз'юнкція (XOR)
+    xori $t0, $t1, 0xFFF                    # Побітове XOR з безпосереднім значенням
+    nor $t0, $t1, $t2                       # Побітова стрілка Пірса (NOR)
+
+## Розгалуження ##
+  _branching:
+    # В основному інструкції розгалуження мають наступну форму:
+    # <instr> <reg1> <reg2> <label>
+    # де label - це назва змінної, в яку ми хочемо перейти, якщо зазначене твердження
+    # правдиве
+
+    beq $t0, $t1, reg_eq                    # Перейдемо у розгалуження reg_eq
+                                            # якщо $t0 == $t1, інакше -
+                                            # виконати наступний рядок
+    bne $t0, $t1, reg_neq                   # Розгалужується, якщо $t0 != $t1
+    b branch_target                         # Розгалуження без умови завжди виконується
+    beqz $t0, req_eq_zero                   # Розгалужується, якщо $t0 == 0
+    bnez $t0, req_neq_zero                  # Розгалужується, якщо $t0 != 0
+    bgt $t0, $t1, t0_gt_t1                  # Розгалужується, якщо $t0 > $t1
+    bge $t0, $t1, t0_gte_t1                 # Розгалужується, якщо $t0 >= $t1
+    bgtz $t0, t0_gt0                        # Розгалужується, якщо $t0 > 0
+    blt $t0, $t1, t0_gt_t1                  # Розгалужується, якщо $t0 < $t1
+    ble $t0, $t1, t0_gte_t1                 # Розгалужується, якщо $t0 <= $t1
+    bltz $t0, t0_lt0                        # Розгалужується, якщо $t0 < 0
+    slt $s0, $t0, $t1                       # Інструкція, що посилає сигнал коли
+                                            # $t0 < $t1, результат зберігається в $s0 
+                                            # (1 - правдиве твердження)
+
+    # Просте твердження якщо (if)
+    # if (i == j)
+    #     f = g + h;
+    #  f = f - i;
+
+    # Нехай $s0 = f, $s1 = g, $s2 = h, $s3 = i, $s4 = j
+    bne $s3, $s4, L1 # if (i !=j)
+    add $s0, $s1, $s2 # f = g + h
+
+    L1:
+      sub $s0, $s0, $s3 # f = f - i
+    
+    # Нижче наведений приклад знаходження максимального значення з 3 чисел
+    # Пряма трансляція в Java з логіки MIPS:
+    # if (a > b)
+    #   if (a > c)
+    #     max = a;
+    #   else
+    #     max = c;
+    # else
+    #     max = b;
+    #   else
+    #     max = c;
+
+    # Нехай $s0 = a, $s1 = b, $s2 = c, $v0 = повернути регістр
+    ble $s0, $s1, a_LTE_b                   # якщо (a <= b) розгалуження(a_LTE_b)
+    ble $s0, $s2, max_C                     # якщо (a > b && a <=c) розгалуження(max_C)
+    move $v0, $s1                           # інакше [a > b && a > c] max = a
+    j done                                  # Перейти в кінець програми
+
+    a_LTE_b:                                # Мітка розгалуження, коли a <= b
+      ble $s1, $s2, max_C                   # якщо (a <= b && b <= c) розгалуження(max_C)
+      move $v0, $s1                         # якщо (a <= b && b > c) max = b
+      j done                                # Перейти в кінець програми
+
+    max_C:
+      move $v0, $s2                         # max = c
+
+    done:                                   # Кінець програми
+
+## Цикли ##
+  _loops:
+    # Цикл складається з умови виходу та з інструкції переходу після його завершення
+    li $t0, 0
+    while:
+      bgt $t0, 10, end_while                # Коли $t0 менше 10, продовжувати ітерації
+      addi $t0, $t0, 1                      # Збільшити значення
+      j while                               # Перейти на початок циклу
+    end_while:
+
+    # Транспонування 2D матриці
+    # Припустимо, що $a0 зберігає адресу цілочисельної матриці розмірністю 3 x 3
+    li $t0, 0                               # Лічильник для i
+    li $t1, 0                               # Лічильник для j
+    matrix_row:
+      bgt $t0, 3, matrix_row_end
+
+      matrix_col:
+        bgt $t1, 3, matrix_col_end
+
+        # ...
+
+        addi $t1, $t1, 1                  # Збільшити лічильник стовпця (col)
+      matrix_col_end:
+
+      # ...
+
+      addi $t0, $t0, 1
+    matrix_row_end:
+
+## Функції ##
+  _functions:
+    # Функції - це процедури, що викликаються, приймають аргументи та повертають значення
+
+    main:                                 # Програма починається з головної функції
+      jal return_1                        # jal збереже поточний ПЦ (програмний центр) в $ra,
+                                          # а потім перейде до return_1
+
+      # Як передати аргументи?
+      # По-перше, ми маємо передати значення аргументів у регістри аргументів
+      li $a0, 1
+      li $a1, 2
+      jal sum                             # Тепер ми можемо викликати функцію
+
+      # Як щодо рекурсії?
+      # Тут потрібно дещо більше роботи оскільки ми маємо впевнитись, що ми збережемо
+      # та зчитаємо попередній ПЦ в $ra, оскільки jal автоматично перепише її при виклику
+      li $a0, 3
+      jal fact
+
+      li $v0, 10
+      syscall
+    
+    # Ця функція повертає 1
+    return_1:
+      li $v0, 1                           # Завантажити val в регіст $v0
+      jr $ra                              # Повернутись до попереднього ПЦ і продовжити виконання 
+
+
+    # Функція з двома аргументами
+    sum:
+      add $v0, $a0, $a1
+      jr $ra                              # Повернутись
+
+    # Рекурсивна функція, яка знаходить факторіал
+    fact:
+      addi $sp, $sp, -8                   # Виділити місце в стеку
+      sw $s0, ($sp)                       # Зберегти регістр, що містить поточне число
+      sw $ra, 4($sp)                      # Зберегти попередній ПЦ
+
+      li $v0, 1                           # Проініціалізувати значення, що повертатиметься
+      beq $a0, 0, fact_done               # Закінчити, якщо параметр 0
+
+      # Інакше, продовжити рекурсію
+      move $s0, $a0                       # Скопіювати $a0 в $s0
+      sub $a0, $a0, 1
+      jal fact
+
+      mul $v0, $s0, $v0                   # Множення
+
+      fact_done:
+        lw $s0, ($sp)
+        lw $ra, ($sp)                     # Відновити ПЦ
+        addi $sp, $sp, 8
+
+        jr $ra
+
+## Макроси ##
+  _macros:
+    # Макроси надзвичайно корисні для заміни блоків коду, що повторюються, за допомогою
+    # однієї змінної, для покращення читабельності
+    # Це не заміна функцій.
+    # Вони мають бути оголошені перед використанням
+
+    # Макрос для виведення нових рядків (оскільки операція досить часто виконується)
+    .macro println()
+      la $a0, newline                     # Значення нового рядка зберігатиметься тут
+      li $v0, 4
+      syscall
+    .end_macro
+
+    println()                             # Асемблер скопіює цей блок коду сюди
+                                          # перед тим, як виконувати його
+
+    # Можна передавати параметри у макроси.
+    # Параметри позначаються знаком '%' з довільною назвою
+    .macro print_int(%num)
+      li $v0, 1
+      lw $a0, %num
+      syscall
+    .end_macro
+    
+    li $t0, 1
+    print_int($t0)
+    
+    # Значення також можна передавати безпосередньо в макроси
+    .macro immediates(%a, %b)
+      add $t0, %a, %b
+    .end_macro
+
+    immediates(3, 5)
+
+    # Одночасно із назвами змінних
+    .macro print(%string)
+      la $a0, %string
+      li $v0, 4
+      syscall
+    .end_macro
+
+    print(hello_world)
+
+## Масиви ##
+.data
+  list: .word 3, 0, 1, 2, 6                 # Це масив чисел
+  char_arr: .asciiz "hello"                 # Це текстовий масив
+  buffer: .space 128                        # Виділяє блок пам'яті, що
+                                            # автоматично не очищується
+                                            # Ці блоки пам'яті вирівнені
+                                            # вирівнені поруч один з одним
+
+.text
+  la $s0, list                              # Завантажити адресу списку
+  li $t0, 0                                 # Лічильник
+  li $t1, 5                                 # Довжина списку
+
+  loop:
+    bgt $t0, $t1, end_loop
+
+    lw $a0, ($s0)
+    li $v0, 1
+    syscall                                 # Вивести число
+
+    addi $s0, $s0, 4                        # Розмір числа - 4 байти
+    addi $t0, $t0, 1                        # Збільшити
+    j loop
+  end_loop:
+
+## Включення ##
+# Потрібно для імпорту сторонніх файлів у програму (насправді, код з цього файлу 
+# копіюється та вставляється в місце, де оголошений імпорт)
+.include "somefile.asm"
+
+```
diff --git a/uk-ua/python-ua.html.markdown b/uk-ua/python-ua.html.markdown
new file mode 100644
index 00000000..4091e433
--- /dev/null
+++ b/uk-ua/python-ua.html.markdown
@@ -0,0 +1,818 @@
+---
+language: python
+lang: uk-ua
+contributors:
+    - ["Louie Dinh", "http://ldinh.ca"]
+    - ["Amin Bandali", "https://aminb.org"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+    - ["evuez", "http://github.com/evuez"]
+    - ["asyne", "https://github.com/justblah"]
+    - ["habi", "http://github.com/habi"]
+translators:
+    - ["Oleh Hromiak", "https://github.com/ogroleg"]
+filename: learnpython-ua.py
+---
+
+Мову Python створив Гвідо ван Россум на початку 90-х. Наразі це одна з 
+найбільш популярних мов. Я закохався у Python завдяки простому і зрозумілому
+синтаксису. Це майже як виконуваний псевдокод.
+
+З вдячністю чекаю ваших відгуків: [@louiedinh](http://twitter.com/louiedinh)
+або louiedinh [at] [поштовий сервіс від Google]
+
+Примітка: Ця стаття стосується Python 2.7, проте має працювати і 
+у інших версіях Python 2.x. Python 2.7 підходить до кінця свого терміну, 
+його підтримку припинять у 2020, тож наразі краще починати вивчення Python 
+з версії 3.x.
+Аби вивчити Python 3.x, звертайтесь до статті по Python 3.
+
+```python
+# Однорядкові коментарі починаються з символу решітки.
+
+""" Текст, що займає декілька рядків,
+    може бути записаний з використанням 3 знаків " і 
+    зазвичай використовується у якості
+    вбудованої документації
+"""
+
+####################################################
+## 1. Примітивні типи даних та оператори
+####################################################
+
+# У вас є числа
+3  # => 3
+
+# Математика працює досить передбачувано
+1 + 1  # => 2
+8 - 1  # => 7
+10 * 2  # => 20
+35 / 5  # => 7
+
+# А ось з діленням все трохи складніше. Воно цілочисельне і результат
+# автоматично округлюється у меншу сторону.
+5 / 2  # => 2
+
+# Аби правильно ділити, спершу варто дізнатися про числа
+# з плаваючою комою.
+2.0  # Це число з плаваючою комою
+11.0 / 4.0  # => 2.75 ох... Так набагато краще
+
+# Результат цілочисельного ділення округлюється у меншу сторону
+# як для додатніх, так і для від'ємних чисел.
+5 // 3  # => 1
+5.0 // 3.0  # => 1.0  # Працює і для чисел з плаваючою комою
+-5 // 3  # => -2
+-5.0 // 3.0  # => -2.0
+
+# Зверніть увагу, що ми також можемо імпортувати модуль для ділення, 
+# див. розділ Модулі
+# аби звичне ділення працювало при використанні лише '/'.
+from __future__ import division
+
+11 / 4  # => 2.75  ...звичне ділення
+11 // 4  # => 2 ...цілочисельне ділення
+
+# Залишок від ділення
+7 % 3  # => 1
+
+# Піднесення до степеня
+2 ** 4  # => 16
+
+# Приорітет операцій вказується дужками
+(1 + 3) * 2  # => 8
+
+# Логічні оператори
+# Зверніть увагу: ключові слова «and» і «or» чутливі до регістру букв
+True and False  # => False
+False or True  # => True
+
+# Завважте, що логічні оператори також використовуються і з цілими числами
+0 and 2  # => 0
+-5 or 0  # => -5
+0 == False  # => True
+2 == True  # => False
+1 == True  # => True
+
+# Для заперечення використовується not
+not True  # => False
+not False  # => True
+
+# Рівність — це ==
+1 == 1  # => True
+2 == 1  # => False
+
+# Нерівність — це !=
+1 != 1  # => False
+2 != 1  # => True
+
+# Ще трохи порівнянь
+1 < 10  # => True
+1 > 10  # => False
+2 <= 2  # => True
+2 >= 2  # => True
+
+# Порівняння можуть бути записані ланцюжком!
+1 < 2 < 3  # => True
+2 < 3 < 2  # => False
+
+# Рядки позначаються символом " або '
+"Це рядок."
+'Це теж рядок.'
+
+# І рядки також можна додавати!
+"Привіт " + "світ!" # => "Привіт світ!"
+# Рядки можна додавати і без '+'
+"Привіт " "світ!"  # => "Привіт світ!"
+
+# ... або множити
+"Привіт" * 3  # => "ПривітПривітПривіт"
+
+# З рядком можна працювати як зі списком символів
+"Це рядок"[0]  # => 'Ц'
+
+# Ви можете дізнатися довжину рядка
+len("Це рядок")  # => 8
+
+# Символ % використовується для форматування рядків, наприклад:
+"%s можуть бути %s" % ("рядки", "інтерпольовані")
+
+# Новий спосіб форматування рядків — використання методу format.
+# Це бажаний спосіб.
+"{} є {}".format("Це", "заповнювач")
+"{0} можуть бути {1}".format("рядки", "форматовані")
+# Якщо ви не хочете рахувати, то можете скористатися ключовими словами.
+"{name} хоче з'істи {food}".format(name="Боб", food="лазанью")
+
+# None - це об'єкт
+None  # => None
+
+# Не використовуйте оператор рівності '=='' для порівняння 
+# об'єктів з None. Використовуйте для цього «is»
+"etc" is None  # => False
+None is None  # => True
+
+# Оператор 'is' перевіряє ідентичність об'єктів. Він не 
+# дуже корисний при роботі з примітивними типами, проте 
+# незамінний при роботі з об'єктами.
+
+# None, 0 і порожні рядки/списки рівні False.
+# Всі інші значення рівні True
+bool(0)  # => False
+bool("")  # => False
+
+
+####################################################
+## 2. Змінні та колекції
+####################################################
+
+# В Python є оператор print
+print "Я Python. Приємно познайомитись!"  # => Я Python. Приємно познайомитись!
+
+# Отримати дані з консолі просто
+input_string_var = raw_input(
+    "Введіть щось: ")  # Повертає дані у вигляді рядка
+input_var = input("Введіть щось: ")  # Працює з даними як з кодом на python
+# Застереження: будьте обережні при використанні методу input()
+
+# Оголошувати змінні перед ініціалізацією не потрібно.
+some_var = 5  # За угодою використовується нижній_регістр_з_підкресленнями
+some_var  # => 5
+
+# При спробі доступу до неініціалізованої змінної
+# виникне виняткова ситуація.
+# Див. розділ Потік управління, аби дізнатись про винятки більше.
+some_other_var  # Помилка в імені
+
+# if може використовуватися як вираз
+# Такий запис еквівалентний тернарному оператору '?:' у мові С
+"yahoo!" if 3 > 2 else 2  # => "yahoo!"
+
+# Списки зберігають послідовності
+li = []
+# Можна одразу створити заповнений список
+other_li = [4, 5, 6]
+
+# Об'єкти додаються у кінець списку за допомогою методу append
+li.append(1)  # li тепер дорівнює [1]
+li.append(2)  # li тепер дорівнює [1, 2]
+li.append(4)  # li тепер дорівнює [1, 2, 4]
+li.append(3)  # li тепер дорівнює [1, 2, 4, 3]
+# І видаляються з кінця методом pop
+li.pop()  # => повертає 3 і li стає рівним [1, 2, 4]
+# Повернемо елемент назад
+li.append(3)  # li тепер знову дорівнює [1, 2, 4, 3]
+
+# Поводьтесь зі списком як зі звичайним масивом
+li[0]  # => 1
+# Присвоюйте нові значення вже ініціалізованим індексам за допомогою =
+li[0] = 42
+li[0]  # => 42
+li[0] = 1  # Зверніть увагу: повертаємось до попереднього значення
+# Звертаємось до останнього елементу
+li[-1]  # => 3
+
+# Спроба вийти за границі масиву призводить до помилки в індексі
+li[4]  # помилка в індексі
+
+# Можна звертатися до діапазону, використовуючи так звані зрізи
+# (Для тих, хто любить математику: це називається замкнуто-відкритий інтервал).
+li[1:3]  # => [2, 4]
+# Опускаємо початок
+li[2:]  # => [4, 3]
+# Опускаємо кінець
+li[:3]  # => [1, 2, 4]
+# Вибираємо кожен другий елемент
+li[::2]  # => [1, 4]
+# Перевертаємо список
+li[::-1]  # => [3, 4, 2, 1]
+# Використовуйте суміш вищеназваного для більш складних зрізів
+# li[початок:кінець:крок]
+
+# Видаляємо довільні елементи зі списку оператором del
+del li[2]  # li тепер [1, 2, 3]
+
+# Ви можете додавати списки
+li + other_li  # => [1, 2, 3, 4, 5, 6]
+# Зверніть увагу: значення li та other_li при цьому не змінились.
+
+# Поєднувати списки можна за допомогою методу extend
+li.extend(other_li)  # Тепер li дорівнює [1, 2, 3, 4, 5, 6]
+
+# Видалити перше входження значення
+li.remove(2)  # Тепер li дорівнює [1, 3, 4, 5, 6]
+li.remove(2)  # Помилка значення, оскільки у списку li немає 2
+
+# Вставити елемент за вказаним індексом
+li.insert(1, 2)  # li знову дорівнює [1, 2, 3, 4, 5, 6]
+
+# Отримати індекс першого знайденого елементу
+li.index(2)  # => 1
+li.index(7)  # Помилка значення, оскільки у списку li немає 7
+
+# Перевірити елемент на входження у список можна оператором in
+1 in li  # => True
+
+# Довжина списку обчислюється за допомогою функції len
+len(li)  # => 6
+
+# Кортежі схожі на списки, лише незмінні
+tup = (1, 2, 3)
+tup[0]  # => 1
+tup[0] = 3  # Виникає помилка типу
+
+# Все те ж саме можна робити і з кортежами
+len(tup)  # => 3
+tup + (4, 5, 6)  # => (1, 2, 3, 4, 5, 6)
+tup[:2]  # => (1, 2)
+2 in tup  # => True
+
+# Ви можете розпаковувати кортежі (або списки) у змінні
+a, b, c = (1, 2, 3)  # a == 1, b == 2 и c == 3
+d, e, f = 4, 5, 6  # дужки можна опустити
+# Кортежі створюються за замовчуванням, якщо дужки опущено
+g = 4, 5, 6  # => (4, 5, 6)
+# Дивіться, як легко обміняти значення двох змінних
+e, d = d, e  # тепер d дорівнює 5, а e дорівнює 4
+
+# Словники містять асоціативні масиви
+empty_dict = {}
+# Ось так описується попередньо заповнений словник
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# Значення можна отримати так само, як і зі списку
+filled_dict["one"]  # => 1
+
+# Можна отримати всі ключі у виді списку за допомогою методу  keys
+filled_dict.keys()  # => ["three", "two", "one"]
+# Примітка: збереження порядку ключів у словників не гарантується
+# Ваші результати можуть не співпадати з цими.
+
+# Можна отримати і всі значення у вигляді списку, використовуйте метод values
+filled_dict.values()  # => [3, 2, 1]
+# Те ж зауваження щодо порядку ключів діє і тут
+
+# Отримуйте всі пари ключ-значення у вигляді списку кортежів 
+# за допомогою "items()"
+filled_dict.items()  # => [("one", 1), ("two", 2), ("three", 3)]
+
+# За допомогою оператору in можна перевіряти ключі на входження у словник
+"one" in filled_dict # => True
+1 in filled_dict  # => False
+
+# Спроба отримати значення за неіснуючим ключем викине помилку ключа
+filled_dict["four"]  # помилка ключа
+
+# Аби уникнути цього, використовуйте метод get()
+filled_dict.get("one")  # => 1
+filled_dict.get("four")  # => None
+# Метод get також приймає аргумент за замовчуванням, значення якого буде
+# повернуто при відсутності вказаного ключа
+filled_dict.get("one", 4)  # => 1
+filled_dict.get("four", 4)  # => 4
+# Зверніть увагу, що filled_dict.get("four") все ще => None
+# (get не встановлює значення елементу словника)
+
+# Присвоюйте значення ключам так само, як і в списках
+filled_dict["four"] = 4  # тепер filled_dict["four"] => 4
+
+# Метод setdefault() вставляє пару ключ-значення лише 
+# за відсутності такого ключа
+filled_dict.setdefault("five", 5)  #  filled_dict["five"] повертає 5
+filled_dict.setdefault("five", 6)  #  filled_dict["five"] все ще повертає 5
+
+
+# Множини містять... ну, загалом, множини
+# (які схожі на списки, проте в них не може бути елементів, які повторюються)
+empty_set = set()
+# Ініціалізація множини набором значень
+some_set = set([1,2,2,3,4])  # some_set тепер дорівнює set([1, 2, 3, 4])
+
+# Порядок не гарантовано, хоча інколи множини виглядають відсортованими
+another_set = set([4, 3, 2, 2, 1])  # another_set тепер set([1, 2, 3, 4])
+
+# Починаючи з Python 2.7, ви можете використовувати {}, аби створити множину
+filled_set = {1, 2, 2, 3, 4}  # => {1, 2, 3, 4}
+
+# Додавання нових елементів у множину
+filled_set.add(5)  # filled_set тепер дорівнює {1, 2, 3, 4, 5}
+
+# Перетин множин: &
+other_set = {3, 4, 5, 6}
+filled_set & other_set  # => {3, 4, 5}
+
+# Об'єднання множин: |
+filled_set | other_set  # => {1, 2, 3, 4, 5, 6}
+
+# Різниця множин: -
+{1,2,3,4} - {2,3,5}  # => {1, 4}
+
+# Симетрична різниця множин: ^
+{1, 2, 3, 4} ^ {2, 3, 5}  # => {1, 4, 5}
+
+# Перевіряємо чи множина зліва є надмножиною множини справа
+{1, 2} >= {1, 2, 3}  # => False
+
+# Перевіряємо чи множина зліва є підмножиною множини справа
+{1, 2} <= {1, 2, 3}  # => True
+
+# Перевірка на входження у множину: in
+2 in filled_set  # => True
+10 in filled_set  # => False
+
+
+####################################################
+## 3. Потік управління
+####################################################
+
+# Для початку створимо змінну
+some_var = 5
+
+# Так виглядає вираз if. Відступи у python дуже важливі!
+# результат: «some_var менше, ніж 10»
+if some_var > 10:
+    print("some_var набагато більше, ніж 10.")
+elif some_var < 10:  # Вираз elif є необов'язковим.
+    print("some_var менше, ніж 10.")
+else:  # Це теж необов'язково.
+    print("some_var дорівнює 10.")
+
+
+"""
+Цикли For проходять по спискам
+
+Результат:
+    собака — це ссавець
+    кішка — це ссавець
+    миша — це ссавець
+"""
+for animal in ["собака", "кішка", "миша"]:
+    # Можете використовувати оператор {0} для інтерполяції форматованих рядків
+    print "{0} — це ссавець".format(animal) 
+    
+"""
+"range(число)" повертає список чисел
+від нуля до заданого числа
+Друкує:
+    0
+    1
+    2
+    3
+"""
+for i in range(4):
+    print(i)
+"""
+"range(нижня_границя, верхня_границя)" повертає список чисел
+від нижньої границі до верхньої
+Друкує:
+    4
+    5
+    6
+    7
+"""
+for i in range(4, 8):
+    print i
+
+"""
+Цикли while продовжуються до тих пір, поки вказана умова не стане хибною.
+Друкує:
+    0
+    1
+    2
+    3
+"""
+x = 0
+while x < 4:
+    print(x)
+    x += 1  # Короткий запис для x = x + 1
+
+# Обробляйте винятки блоками try/except
+
+# Працює у Python 2.6 і вище:
+try:
+    # Аби створити виняток, використовується raise
+    raise IndexError("Помилка у індексі!")
+except IndexError as e:
+    pass  # pass — оператор, який нічого не робить. Зазвичай тут відбувається
+    # відновлення після помилки.
+except (TypeError, NameError):
+    pass  # Винятки можна обробляти групами, якщо потрібно.
+else:  # Необов'язковий вираз. Має слідувати за останнім блоком except
+    print("Все добре!")   # Виконається лише якщо не було ніяких винятків
+finally:  # Виконується у будь-якому випадку
+    print "Тут ми можемо звільнити ресурси"
+
+# Замість try/finally для звільнення ресурсів 
+# ви можете використовувати вираз with
+with open("myfile.txt") as f:
+    for line in f:
+        print line
+
+
+####################################################
+## 4. Функції
+####################################################
+
+# Використовуйте def для створення нових функцій
+def add(x, y):
+    print "x дорівнює {0}, а y дорівнює {1}".format(x, y)
+    return x + y  # Повертайте результат за допомогою ключового слова return
+
+
+# Виклик функції з аргументами
+add(5, 6)  # => друкує «x дорівнює 5, а y дорівнює 6» і повертає 11
+
+# Інший спосіб виклику функції — виклик з іменованими аргументами
+add(y=6, x=5)  # Іменовані аргументи можна вказувати у будь-якому порядку
+
+
+# Ви можете визначити функцію, яка приймає змінну кількість аргументів,
+# які будуть інтерпретовані як кортеж, за допомогою *
+def varargs(*args):
+    return args
+
+
+varargs(1, 2, 3)  # => (1,2,3)
+
+
+# А також можете визначити функцію, яка приймає змінне число
+# іменованих аргументів, котрі будуть інтерпретовані як словник, за допомогою **
+def keyword_args(**kwargs):
+    return kwargs
+
+
+# Давайте подивимось що з цього вийде
+keyword_args(big="foot", loch="ness")  # => {"big": "foot", "loch": "ness"}
+
+# Якщо хочете, можете використовувати обидва способи одночасно
+def all_the_args(*args, **kwargs):
+    print(args)
+    print(kwargs)
+
+
+"""
+all_the_args(1, 2, a=3, b=4) друкує:
+    (1, 2)
+    {"a": 3, "b": 4}
+"""
+
+# Коли викликаєте функції, то можете зробити навпаки!
+# Використовуйте символ * аби розпакувати позиційні аргументи і 
+# ** для іменованих аргументів
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args)  # еквівалентно foo(1, 2, 3, 4)
+all_the_args(**kwargs)  # еквівалентно foo(a=3, b=4)
+all_the_args(*args, **kwargs)  # еквівалентно foo(1, 2, 3, 4, a=3, b=4)
+
+# ви можете передавати довільне число позиційних або іменованих аргументів
+# іншим функціям, які їх приймають, розпаковуючи за допомогою
+# * або ** відповідно
+def pass_all_the_args(*args, **kwargs):
+    all_the_args(*args, **kwargs)
+    print varargs(*args)
+    print keyword_args(**kwargs)
+
+
+# Область визначення функцій
+x = 5
+
+
+def set_x(num):
+    # Локальна змінна x - не те ж саме, що глобальна змінна x
+    x = num  # => 43
+    print x  # => 43
+
+
+def set_global_x(num):
+    global x
+    print x  # => 5
+    x = num  # глобальна змінна x тепер дорівнює 6
+    print x  # => 6
+
+
+set_x(43)
+set_global_x(6)
+
+# В Python функції є об'єктами першого класу
+def create_adder(x):
+    def adder(y):
+        return x + y
+
+    return adder
+
+
+add_10 = create_adder(10)
+add_10(3)  # => 13
+
+# Також є і анонімні функції
+(lambda x: x > 2)(3)  # => True
+(lambda x, y: x ** 2 + y ** 2)(2, 1)  # => 5
+
+# Присутні вбудовані функції вищого порядку
+map(add_10, [1, 2, 3])  # => [11, 12, 13]
+map(max, [1, 2, 3], [4, 2, 1])  # => [4, 2, 3]
+
+filter(lambda x: x > 5, [3, 4, 5, 6, 7])  # => [6, 7]
+
+# Для зручного відображення і фільтрації можна використовувати 
+# включення у вигляді списків
+[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]
+
+# Ви також можете скористатися включеннями множин та словників
+{x for x in 'abcddeef' if x in 'abc'}  # => {'a', 'b', 'c'}
+{x: x ** 2 for x in range(5)}  # => {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
+
+
+####################################################
+## 5. Класи
+####################################################
+
+# Аби отримати клас, ми наслідуємо object.
+class Human(object):
+    # Атрибут класу. Він розділяється всіма екземплярами цього класу.
+    species = "H. sapiens"
+
+    # Звичайний конструктор, буде викликаний при ініціалізації екземпляру класу
+    # Зверніть увагу, що подвійне підкреслення на початку та наприкінці імені
+    # використовується для позначення об'єктів та атрибутів,
+    # які використовуються Python, але знаходяться у просторах імен, 
+    # якими керує користувач. Не варто вигадувати для них імена самостійно.
+    def __init__(self, name):
+        # Присвоєння значення аргумента атрибуту класу name
+        self.name = name
+
+        # Ініціалізуємо властивість
+        self.age = 0
+
+    # Метод екземпляру. Всі методи приймають self у якості першого аргументу
+    def say(self, msg):
+       return "%s: %s" % (self.name, msg)
+
+    # Методи класу розділяються між усіма екземплярами
+    # Вони викликаються з вказанням викликаючого класу 
+    # у якості першого аргументу
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # Статичний метод викликається без посилання на клас або екземпляр
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+    # Властивість.
+    # Перетворює метод age() в атрибут тільки для читання
+    # з таким же ім'ям.
+    @property
+    def age(self):
+        return self._age
+
+    # Це дозволяє змінювати значення властивості
+    @age.setter
+    def age(self, age):
+        self._age = age
+
+    # Це дозволяє видаляти властивість
+    @age.deleter
+    def age(self):
+        del self._age
+
+
+# Створюємо екземпляр класу
+i = Human(name="Данило")
+print(i.say("привіт"))  # Друкує: «Данило: привіт»
+
+j = Human("Меланка")
+print(j.say("Привіт"))  # Друкує: «Меланка: привіт»
+
+# Виклик методу класу
+i.get_species()  # => "H. sapiens"
+
+# Зміна розділюваного атрибуту
+Human.species = "H. neanderthalensis"
+i.get_species()  # => "H. neanderthalensis"
+j.get_species()  # => "H. neanderthalensis"
+
+# Виклик статичного методу
+Human.grunt()  # => "*grunt*"
+
+# Оновлюємо властивість
+i.age = 42
+
+# Отримуємо значення
+i.age  # => 42
+
+# Видаляємо властивість
+del i.age
+i.age  # => виникає помилка атрибуту
+
+####################################################
+## 6. Модулі
+####################################################
+
+# Ви можете імпортувати модулі
+import math
+
+print(math.sqrt(16))  # => 4.0
+
+# Ви можете імпортувати окремі функції з модуля
+from math import ceil, floor
+
+print(ceil(3.7))  # => 4.0
+print(floor(3.7))  # => 3.0
+
+# Можете імпортувати всі функції модуля.
+# Попередження: краще так не робіть
+from math import *
+
+# Можете скорочувати імена модулів
+import math as m
+
+math.sqrt(16) == m.sqrt(16)  # => True
+# Ви також можете переконатися, що функції еквівалентні
+from math import sqrt
+
+math.sqrt == m.sqrt == sqrt  # => True
+
+# Модулі в Python — це звичайні Python-файли. Ви
+# можете писати свої модулі та імпортувати їх. Назва
+# модуля співпадає з назвою файлу.
+
+# Ви можете дізнатися, які функції та атрибути визначені
+# в модулі
+import math
+
+dir(math)
+
+
+# Якщо у вас є Python скрипт з назвою math.py у тій же папці, що
+# і ваш поточний скрипт, то файл math.py
+# може бути завантажено замість вбудованого у Python модуля.
+# Так трапляється, оскільки локальна папка має перевагу
+# над вбудованими у Python бібліотеками.
+
+####################################################
+## 7. Додатково
+####################################################
+
+# Генератори
+# Генератор "генерує" значення тоді, коли вони запитуються, замість того, 
+# щоб зберігати все одразу
+
+# Метод нижче (*НЕ* генератор) подвоює всі значення і зберігає їх 
+# в `double_arr`. При великих розмірах може знадобитися багато ресурсів!
+def double_numbers(iterable):
+    double_arr = []
+    for i in iterable:
+        double_arr.append(i + i)
+    return double_arr
+
+
+# Тут ми спочатку подвоюємо всі значення, потім повертаємо їх,
+# аби перевірити умову
+for value in double_numbers(range(1000000)):  # `test_non_generator`
+    print value
+    if value > 5:
+        break
+
+
+# Натомість ми можемо скористатися генератором, аби "згенерувати"
+# подвійне значення, як тільки воно буде запитане
+def double_numbers_generator(iterable):
+    for i in iterable:
+        yield i + i
+
+
+# Той самий код, але вже з генератором, тепер дозволяє нам пройтися по
+# значенням і подвоювати їх одне за одним якраз тоді, коли вони обробляються
+# за нашою логікою, одне за одним. А як тільки ми бачимо, що value > 5, ми
+# виходимо з циклу і більше не подвоюємо більшість значень, 
+# які отримали на вхід (НАБАГАТО ШВИДШЕ!)
+for value in double_numbers_generator(xrange(1000000)):  # `test_generator`
+    print value
+    if value > 5:
+        break
+
+# Між іншим: ви помітили використання `range` у `test_non_generator` і 
+# `xrange` у `test_generator`?
+# Як `double_numbers_generator` є версією-генератором `double_numbers`, так
+# і `xrange` є аналогом `range`, але у вигляді генератора.
+# `range` поверне нам масив з 1000000 значень
+# `xrange`, у свою чергу, згенерує 1000000 значень для нас тоді, 
+# коли ми їх запитуємо / будемо проходитись по ним.
+
+# Аналогічно включенням у вигляді списків, ви можете створювати включення
+# у вигляді генераторів.
+values = (-x for x in [1, 2, 3, 4, 5])
+for x in values:
+    print(x)  # друкує -1 -2 -3 -4 -5
+
+# Включення у вигляді генератора можна явно перетворити у список
+values = (-x for x in [1, 2, 3, 4, 5])
+gen_to_list = list(values)
+print(gen_to_list)  # => [-1, -2, -3, -4, -5]
+
+# Декоратори
+# Декоратор – це функція вищого порядку, яка приймає та повертає функцію.
+# Простий приклад використання – декоратор add_apples додає елемент 'Apple' в
+# список fruits, який повертає цільова функція get_fruits.
+def add_apples(func):
+    def get_fruits():
+        fruits = func()
+        fruits.append('Apple')
+        return fruits
+    return get_fruits
+
+@add_apples
+def get_fruits():
+    return ['Banana', 'Mango', 'Orange']
+
+# Друкуємо список разом з елементом 'Apple', який знаходиться в ньому:
+# Banana, Mango, Orange, Apple
+print ', '.join(get_fruits())
+
+# У цьому прикладі beg обертає say
+# Beg викличе say. Якщо say_please дорівнюватиме True, то повідомлення,
+# що повертається, буде змінено.
+from functools import wraps
+
+
+def beg(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, say_please = target_function(*args, **kwargs)
+        if say_please:
+            return "{} {}".format(msg, "Будь ласка! Я бідний :(")
+        return msg
+
+    return wrapper
+
+
+@beg
+def say(say_please=False):
+    msg = "Ви можете купити мені пива?"
+    return msg, say_please
+
+
+print say()  # Ви можете купити мені пива?
+print say(say_please=True)  # Ви можете купити мені пива? Будь ласка! Я бідний :(
+```
+
+## Готові до більшого?
+
+### Безкоштовні онлайн-матеріали
+
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [Официальная документация](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/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+
+### Платні
+
+* [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)
+
diff --git a/uk-ua/rust-ua.html.markdown b/uk-ua/rust-ua.html.markdown
new file mode 100644
index 00000000..4ec2b7c9
--- /dev/null
+++ b/uk-ua/rust-ua.html.markdown
@@ -0,0 +1,331 @@
+---
+language: rust
+contributors:
+    - ["P1start", "http://p1start.github.io/"]
+translators:
+  - ["Volodymyr Korniichuk", "https://github.com/ezhikus"]
+filename: learnrust-uk.rs
+lang: uk-ua
+---
+
+Rust - це мова програмування, що розрабляється спільнотою Mozilla Research
+Rust поєднує в собі низькорівневий контроль швидкодії з високорівневими 
+інструментами забезпечення гарантій цілісності та безпеки.
+
+Rust досягає своїх цілей без автоматичного збирання сміття і не вимагає 
+наявності певного середовища виконання, що робить можливим пряму заміну 
+бібліотек, написаних на мові С на бібліотеки, написані на Rust.
+
+Перший реліз Rust (версія 0.1) вийшла в січні 2012 року і з тих пір оновлення 
+виходили так часто, що загальною порадою розробникам було не чекати якоїсь 
+стабільної версії, а використовувати нічні збірки компілятора.
+
+15 травня 2015 року вийшла версія Rust 1.0. Для цієї версії була дана гарантія
+зворотної сумісності. Подальші нічні збірки покращили швидкість компіляції та
+деякі інші аспекти. На даний момент оновлення Rust виходять кожні 6 тижнів.
+Бета-версія Rust 1.1 вийшла одночасно з релізом Rust 1.0.
+
+Не зважаючи на те, що Rust є відносно низькорівневою мовою програмування, в
+ній є деякі концепти, притаманні високорівневим мовам. Це робить Rust не лише
+швидким, але й досить зручним та ефективним інструментом розробки.
+
+```rust
+// Це коментар. Він починається в цьому рядку...
+// і продовжується в цьому
+
+/// Цей коментар включає в себе документацію і підтримує markdown.
+/// # Приклади
+///
+/// ```
+/// let five = 5
+/// ```
+
+///////////////
+// 1. Основи //
+///////////////
+
+#[allow(dead_code)]
+// Функції
+// `i32` - це 32-бітний цілочислений знаковий тип даних
+fn add2(x: i32, y: i32) -> i32 {
+    // неявне повернення результату (в кінці рядку немає крапки з комою)
+    x + y
+}
+
+#[allow(unused_variables)]
+#[allow(unused_assignments)]
+#[allow(dead_code)]
+// Головна функція
+fn main() {
+    // Числа //
+
+    // Незмінне число
+    let x: i32 = 1;
+
+    // суфікси для позначення цілого числа та числа з плаваючою змінною
+    let y: i32 = 13i32;
+    let f: f64 = 1.3f64;
+
+    // Вивід типів
+    // Як правило, Rust може самостійно визначити тип змінної, отож
+    // ви можете не прописувати його явно
+    // В даному документі типи явно прописані в багатьох місцях, це зроблено 
+    // виключно в навчальних цілях. В реальному коді вивід типів спрацює 
+    // в більшості випадків
+    let implicit_x = 1;
+    let implicit_f = 1.3;
+
+    // арифметика
+    let sum = x + y + 13;
+
+    // Змінні
+    let mut mutable = 1;
+    mutable = 4;
+    mutable += 2;
+
+    // Строки //
+
+    // Строкові літерали
+    let x: &str = "Привіт, світ!";
+
+    // Друк на екран
+    println!("{} {}", f, x); // 1.3 Привіт, світ!
+
+    // `String` – строка, що розміщується в "купі"
+    let s: String = "hello world".to_string();
+
+    // Строковий зріз - це незмінне відображення якоїсь строки (або її частини)
+    // Зріз можна розглядати як константну пару покажчиків (на початок та кінець
+    // якоїсь строки)
+    let s_slice: &str = &s;
+
+    println!("{} {}", s, s_slice); // Привіт, світ! Привіт, світ!
+
+    // Вектори/масиви //
+
+    // Масив фіксованого розміру
+    let four_ints: [i32; 4] = [1, 2, 3, 4];
+
+    // Масив змінного розміру (вектор)
+    let mut vector: Vec<i32> = vec![1, 2, 3, 4];
+    vector.push(5);
+
+    // Зріз - незмінне відображення масиву
+    // Це схоже на строковий зріз, але в даному випадку мова йде про вектори
+    let slice: &[i32] = &vector;
+
+    // Використовуйте `{:?}` щоб вивести щось в цілях відлагодження
+    println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
+
+    // Кортеж //
+
+    // Кортеж - це набір фіксованого розміру, що включає значення кількох типів
+    let x: (i32, &str, f64) = (1, "привіт", 3.4);
+
+    // розбираємо кортеж "х" на окремі змінні "a", "b" та "с"
+    let (a, b, c) = x;
+    println!("{} {} {}", a, b, c); // 1 привіт 3.4
+
+    // доступ по індексу
+    println!("{}", x.1); // привіт
+
+    //////////////
+    // 2. Типи //
+    //////////////
+
+    // Структура
+    struct Point {
+        x: i32,
+        y: i32,
+    }
+
+    let origin: Point = Point { x: 0, y: 0 };
+
+    // Структура з безіменними полями, "кортежна структура"
+    struct Point2(i32, i32);
+
+    let origin2 = Point2(0, 0);
+
+    // перелічуваний тип даних
+    enum Direction {
+        Left,
+        Right,
+        Up,
+        Down,
+    }
+
+    let up = Direction::Up;
+
+    // перелічуваний тип даних з полями
+    enum OptionalI32 {
+        AnI32(i32),
+        Nothing,
+    }
+
+    let two: OptionalI32 = OptionalI32::AnI32(2);
+    let nothing = OptionalI32::Nothing;
+
+    // Узагальнене програмування //
+
+    struct Foo<T> { bar: T }
+
+    // Ось так стандартна бібліотека Rust оголошує `Option`
+    enum Optional<T> {
+        SomeVal(T),
+        NoVal,
+    }
+
+    // Методи //
+
+    impl<T> Foo<T> {
+        // Методи приймають неявний параметр `self`
+        fn get_bar(self) -> T {
+            self.bar
+        }
+    }
+
+    let a_foo = Foo { bar: 1 };
+    println!("{}", a_foo.get_bar()); // 1
+
+    // Типажі (в інших мовах програмування схожою сутністю є інтерфейси) //
+
+    trait Frobnicate<T> {
+        fn frobnicate(self) -> Option<T>;
+    }
+
+    impl<T> Frobnicate<T> for Foo<T> {
+        fn frobnicate(self) -> Option<T> {
+            Some(self.bar)
+        }
+    }
+
+    let another_foo = Foo { bar: 1 };
+    println!("{:?}", another_foo.frobnicate()); // Some(1)
+
+    /////////////////////////
+    // 3. Відповідність шаблону //
+    /////////////////////////
+
+    let foo = OptionalI32::AnI32(1);
+    match foo {
+        OptionalI32::AnI32(n) => println!("Це тип i32: {}", n),
+        OptionalI32::Nothing  => println!("Це ніщо!"),
+    }
+
+    // Складніший приклад
+    struct FooBar { x: i32, y: OptionalI32 }
+    let bar = FooBar { x: 15, y: OptionalI32::AnI32(32) };
+
+    match bar {
+        FooBar { x: 0, y: OptionalI32::AnI32(0) } =>
+            println!("Числа рівні нулю!"),
+        FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m =>
+            println!("Числа однакові"),
+        FooBar { x: n, y: OptionalI32::AnI32(m) } =>
+            println!("Числа різні: {} {}", n, m),
+        FooBar { x: _, y: OptionalI32::Nothing } =>
+            println!("Друге число - ніщо!"),
+    }
+
+    /////////////////////
+    // 4. Потік керування //
+    /////////////////////
+
+    // Цикл `for` 
+    let array = [1, 2, 3];
+    for i in array.iter() {
+        println!("{}", i);
+    }
+
+    // Діапазони
+    for i in 0u32..10 {
+        print!("{} ", i);
+    }
+    println!("");
+    // друкує `0 1 2 3 4 5 6 7 8 9 `
+
+    // `if`
+    if 1 == 1 {
+        println!("Математика працює!");
+    } else {
+        println!("Ой, лишенько...");
+    }
+
+    // `if` як вираз
+    let value = if true {
+        "добре"
+    } else {
+        "погано"
+    };
+
+    // Цикл `while`
+    while 1 == 1 {
+        println!("Всесвіт функціонує стабільно.");
+        // Вираз break перериває цикл
+        break
+    }
+
+    // Нескінченний цикл
+    loop {
+        println!("Привіт!");
+        // Вираз break перериває цикл
+        break
+    }
+
+    /////////////////////////////////
+    // 5. Вказівники і безпека пам'яті //
+    /////////////////////////////////
+
+    // Володіючий вказівник - тільки хтось один може "володіти" вказівником в 
+    // будь-який момент. Це означає, що коли "Box" вийде за межі області 
+    // видимості - його можна безпечно звільнити
+    let mut mine: Box<i32> = Box::new(3);
+    *mine = 5; // розіменування `mine` з присвоєнням йому нового значення
+    // `now_its_mine` перебирає на себе володіння над `mine`. Іншими словами, 
+    // `mine` переміщується.
+    let mut now_its_mine = mine;
+    *now_its_mine += 2;
+
+    println!("{}", now_its_mine); // 7
+    // println!("{}", mine); // цей код не скомпілюється, оскільки тепер 
+    // покажчиком на дані володіє `now_its_mine`
+
+    // Посилання – незмінний вказівник на дані
+    // При створенні посилання на якесь значення, ми говоримо, що значення 
+    // було "запозичене". Поки значення є запозиченим - воно не може бути 
+    // змінене або переміщене. Запозичення пропадає, як тільки стається вихід з 
+    // області видимості, де було створене посилання
+    let mut var = 4;
+    var = 3;
+    let ref_var: &i32 = &var;
+
+    println!("{}", var); // На відміну від `mine`, `var` можна використати
+    println!("{}", *ref_var);
+    // var = 5; // цей код не скомпілюється, оскільки `var` зараз є запозиченим
+    // *ref_var = 6; // цей код також не зкомпілюється, оскільки `ref_var` 
+    // є незмінним посиланням
+
+    // Змінне посилання
+    // Значення можна запозичити з можливістю зміни. У цьому випадку доступ до 
+    // оригінального значення втрачається.
+    let mut var2 = 4;
+    let ref_var2: &mut i32 = &mut var2;
+    *ref_var2 += 2;    // '*' використовується для доступу до змінного посилання
+
+    println!("{}", *ref_var2); // 6 , // при заміні на var2 код не зкомпілюється
+    // ref_var2 має тип &mut i32, отож зберігає посилання на i32, а не  значення
+    // var2 = 2; // цей рядок не зкомпілюється, оскільки `var2` є запозиченим.
+}
+```
+
+## Матеріали для самовдосконалення
+
+В даному матеріалі ми оглянули лише основи Rust. Більше матеріалу ви можете 
+знайти на сайті 
+[The Rust Programming Language](http://doc.rust-lang.org/book/index.html)
+Також існує Reddit-розділ [/r/rust](http://reddit.com/r/rust). Люди на каналі
+irc.mozilla.org також завжди раді допомогти новачкам.
+
+Ви можете спробувати можливості Rust за допомогою онлайн-компілятора на сторінці
+[Rust playpen](http://play.rust-lang.org) або 
+[Rust website](http://rust-lang.org).
diff --git a/uk-ua/wasm-ua.html.markdown b/uk-ua/wasm-ua.html.markdown
new file mode 100644
index 00000000..34f8cef8
--- /dev/null
+++ b/uk-ua/wasm-ua.html.markdown
@@ -0,0 +1,226 @@
+---
+language: WebAssembly
+lang: uk-ua
+filename: learnwasm-ua.wast
+contributors:
+    - ["Dean Shaff", "http://dean-shaff.github.io"]
+translators:
+    - ["Oleh Hromiak", "https://github.com/ogroleg"]
+---
+
+```
+;; learnwasm-ua.wast
+
+(module
+  ;; У WebAssembly весь код знаходиться в модулях. Будь-яка операція
+  ;; може бути записана за допомогою s-виразу. Також існує синтаксис "стек машини",
+  ;; втім, він не сумісний з проміжним бінарним представленням коду.
+
+  ;; Формат бінарного проміжного представлення майже повністю сумісний 
+  ;; з текстовим форматом WebAssembly.
+  ;; Деякі відмінності:
+  ;; local_set -> local.set
+  ;; local_get -> local.get
+
+  ;; Код розміщується у функціях
+
+  ;; Типи даних
+  (func $data_types
+    ;; WebAssembly має чотири типи даних:
+    ;; i32 - ціле число, 32 біти
+    ;; i64 - ціле число, 64 біти (не підтримується у JavaScript)
+    ;; f32 - число з плаваючою комою, 32 біти
+    ;; f64 - число з плаваючою комою, 64 біти
+
+    ;; Створити локальну змінну можна за допомогою ключового слова "local".
+    ;; Змінні потрібно оголошувати на початку функції.
+
+    (local $int_32 i32)
+    (local $int_64 i64)
+    (local $float_32 f32)
+    (local $float_64 f64)
+
+    ;; Змінні, оголошені вище, ще не ініціалізовані, себто, не мають значення.
+    ;; Давайте присвоїмо їм значення за допомогою <тип даних>.const:
+
+    (local.set $int_32 (i32.const 16))
+    (local.set $int_32 (i64.const 128))
+    (local.set $float_32 (f32.const 3.14))
+    (local.set $float_64 (f64.const 1.28))
+  )
+
+  ;; Базові операції
+  (func $basic_operations
+
+    ;; Нагадаємо, у WebAssembly будь-що є s-виразом, включно
+    ;; з математичними виразами або зчитуванням значень змінних
+
+    (local $add_result i32)
+    (local $mult_result f64)
+
+    (local.set $add_result (i32.add (i32.const 2) (i32.const 4)))
+    ;; тепер add_result дорівнює 6!
+
+    ;; Для кожної операції потрібно використовувати правильний тип:
+    ;; (local.set $mult_result (f32.mul (f32.const 2.0) (f32.const 4.0))) ;; Ніт! mult_result має тип f64!
+    (local.set $mult_result (f64.mul (f64.const 2.0) (f64.const 4.0))) ;; Ніт! mult_result має тип f64!
+
+    ;; У WebAssembly є вбудовані функції накшталт математики та побітових операцій.
+    ;; Варто зазначити, що тут відсутні вбудовані тригонометричні функції.
+    ;; Тож нам потрібно:
+    ;; - написати їх самостійно (не найкраща ідея)
+    ;; - звідкись їх імпортувати (як саме - побачимо згодом)
+  )
+
+  ;; Функції
+  ;; Параметри вказуються ключовим словом `param`, значення, що повертається - `result`
+  ;; Поточне значення стеку і є значенням функції, що повертається
+
+  ;; Ми можемо викликати інші функції за допомогою `call`
+
+  (func $get_16 (result i32)
+    (i32.const 16)
+  )
+
+  (func $add (param $param0 i32) (param $param1 i32) (result i32)
+    (i32.add
+      (local.get $param0)
+      (local.get $param1)
+    )
+  )
+
+  (func $double_16 (result i32)
+    (i32.mul
+      (i32.const 2)
+      (call $get_16))
+  )
+
+  ;; Досі ми не могли що-небудь вивести на консоль і не мали доступу
+  ;; до високорівневої математики (степеневі функції, обрахунок експоненти або тригонометрія).
+  ;; Більше того, ми навіть не могли викликати WASM функції у Javascript!
+  ;; Виклик цих функцій у WebAssembly залежить від того,
+  ;; де ми знаходимось - чи це Node.js, чи середовище браузера.
+
+  ;; Якщо ми у Node.js, то потрібно виконати два кроки. По-перше, ми маємо сконвертувати
+  ;; текстове представлення WASM у справжній код webassembly.
+  ;; Наприклад, ось так (Binaryen):
+
+  ;; wasm-as learn-wasm.wast -o learn-wasm.wasm
+
+  ;; Давай також застосуємо оптимізації:
+
+  ;; wasm-opt learn-wasm.wasm -o learn-wasm.opt.wasm -O3 --rse
+
+  ;; Тепер наш скомпільований WebAssembly можна завантажити у Node.js:
+  ;; const fs = require('fs')
+  ;; const instantiate = async function (inFilePath, _importObject) {
+  ;;  var importObject = {
+  ;;     console: {
+  ;;       log: (x) => console.log(x),
+  ;;     },
+  ;;     math: {
+  ;;       cos: (x) => Math.cos(x),
+  ;;     }
+  ;;   }
+  ;;  importObject = Object.assign(importObject, _importObject)
+  ;;
+  ;;  var buffer = fs.readFileSync(inFilePath)
+  ;;  var module = await WebAssembly.compile(buffer)
+  ;;  var instance = await WebAssembly.instantiate(module, importObject)
+  ;;  return instance.exports
+  ;; }
+  ;;
+  ;; const main = function () {
+  ;;   var wasmExports = await instantiate('learn-wasm.wasm')
+  ;;   wasmExports.print_args(1, 0)
+  ;; }
+
+  ;; Цей код зчитує функції з importObject
+  ;; (вказано у асинхронній JavaScript функції instantiate), а потім експортує функцію
+  ;; "print_args", яку ми викликаємо у Node.js
+
+  (import "console" "log" (func $print_i32 (param i32)))
+  (import "math" "cos" (func $cos (param f64) (result f64)))
+
+  (func $print_args (param $arg0 i32) (param $arg1 i32)
+    (call $print_i32 (local.get $arg0))
+    (call $print_i32 (local.get $arg1))
+  )
+  (export "print_args" (func $print_args))
+
+  ;; Завантаження даних з пам'яті WebAssembly.
+  ;; Наприклад, ми хочемо порахувати cos для елементів Javascript масиву.
+  ;; Нам потрібно отримати доступ до масиву і можливість ітерувати по ньому.
+  ;; У прикладі нижче ми змінимо існуючий масив.
+  ;; f64.load і f64.store приймають адресу числа у пам'яті *у байтах*.
+  ;; Для того, щоб отримати доступ до 3-го елементу масиву, ми маємо передати щось
+  ;; накшталт (i32.mul (i32.const 8) (i32.const 2)) у функцію f64.store.
+
+  ;; У JavaScript ми викличемо `apply_cos64` таким чином
+  ;; (використаємо функцію instantiate з попереднього прикладу):
+  ;;
+  ;; const main = function () {
+  ;;   var wasm = await instantiate('learn-wasm.wasm')
+  ;;   var n = 100
+  ;;   const memory = new Float64Array(wasm.memory.buffer, 0, n)
+  ;;   for (var i=0; i<n; i++) {
+  ;;     memory[i] = i;
+  ;;   }
+  ;;   wasm.apply_cos64(n)
+  ;; }
+  ;;
+  ;; Ця функція не буде працювати, якщо ми виділимо пам'ять для (створимо) Float32Array у JavaScript.
+
+  (memory (export "memory") 100)
+
+  (func $apply_cos64 (param $array_length i32)
+    ;; визначаємо змінну циклу або лічильник
+    (local $idx i32)
+    ;; визначаємо змінну для доступу до пам'яті
+    (local $idx_bytes i32)
+    ;; константа - кількість байтів у числі типу f64.
+    (local $bytes_per_double i32)
+
+    ;; визначаємо змінну, яка зберігатиме значення з пам'яті
+    (local $temp_f64 f64)
+
+    (local.set $idx (i32.const 0))
+    (local.set $idx_bytes (i32.const 0)) ;; не обов'язково
+    (local.set $bytes_per_double (i32.const 8))
+
+    (block
+      (loop
+        ;; записуємо у idx_bytes необхідне зміщення в пам'яті - для поточного числа.
+        (local.set $idx_bytes (i32.mul (local.get $idx) (local.get $bytes_per_double)))
+
+        ;; отримуємо число з пам'яті (за зміщенням):
+        (local.set $temp_f64 (f64.load (local.get $idx_bytes)))
+
+        ;; рахуємо cos:
+        (local.set $temp_64 (call $cos (local.get $temp_64)))
+
+        ;; тепер зберігаємо результат обчислень у пам'ять:
+        (f64.store
+          (local.get $idx_bytes)
+          (local.get $temp_64))
+
+        ;; або робимо все за один крок (альтернативний код)
+        (f64.store
+          (local.get $idx_bytes)
+          (call $cos
+            (f64.load
+              (local.get $idx_bytes))))
+
+        ;; збільшуємо лічильник на одиницю (інкремент)
+        (local.set $idx (i32.add (local.get $idx) (i32.const 1)))
+
+        ;; якщо лічильник дорівнює довжині масиву, то завершуємо цикл
+        (br_if 1 (i32.eq (local.get $idx) (local.get $array_length)))
+        (br 0)
+      )
+    )
+  )
+  (export "apply_cos64" (func $apply_cos64))
+)
+
+```
diff --git a/vi-vn/markdown-vi.html.markdown b/vi-vn/markdown-vi.html.markdown
index 0ba267f9..89b59253 100644
--- a/vi-vn/markdown-vi.html.markdown
+++ b/vi-vn/markdown-vi.html.markdown
@@ -28,7 +28,7 @@ Markdown có sự khác biệt trong cách cài đặt giữa các trình phân
 ## Phần tử HTML
 Markdown là tập cha của HTML, vì vậy bất cứ file HTML nào đều là Markdown đúng.
 
-```markdown
+```md
 <!-- Điều này đồng nghĩa ta có thể sử dụng các phần tử HTML
 trong Markdown, ví dụ như phần tử chú thích/comment.
 Tuy nhiên, nếu sử dụng một phần tử HTML trong file Markdown,
@@ -40,7 +40,7 @@ ta không thể sử dụng cú pháp Markdown cho nội dung bên trong phần
 Ta có thể tạo các phần tử đầu mục HTML từ `<h1>` cho đến `<h6>` dễ dàng
 bằng cách thêm số lượng dấu thăng (#) đằng trước chuỗi cần tạo đầu mục.
 
-```markdown
+```md
 # Đây là đầu mục <h1>
 ## Đây là đầu mục <h2>
 ### Đây là đầu mục <h3>
@@ -50,7 +50,7 @@ bằng cách thêm số lượng dấu thăng (#) đằng trước chuỗi cần
 ```
 Markdown còn cung cấp cách khác để tạo đầu mục hạng nhất h1 và hạng nhì h2.
 
-```markdown
+```md
 Đây là đầu mục h1
 =============
 
@@ -62,7 +62,7 @@ Markdown còn cung cấp cách khác để tạo đầu mục hạng nhất h1 v
 
 Văn bản có thể được định dạng dễ dàng như in nghiêng hay làm đậm sử dụng Markdown.
 
-```markdown
+```md
 *Đoạn văn bản này được in nghiêng.*
 _Và đoạn này cũng như vậy._
 
@@ -76,7 +76,7 @@ __Và đoạn này cũng vậy.__
 
 Trong cài đặt Markdown để hiển thị file của GitHub,ta còn có gạch ngang:
 
-```markdown
+```md
 ~~Đoạn văn bản này được gạch ngang.~~
 ```
 ## Đoạn văn
@@ -84,7 +84,7 @@ Trong cài đặt Markdown để hiển thị file của GitHub,ta còn có gạ
 Đoạn văn bao gồm một hay nhiều dòng văn bản liên tiếp nhau được phân cách
 bởi một hay nhiều dòng trống.
 
-```markdown
+```md
 Đây là đoạn văn thứ nhất.
 
 Đây là đoạn văn thứ hai.
@@ -97,7 +97,7 @@ Dòng này vẫn thuộc đoạn văn thứ hai, do không có cách dòng.
 Nếu cần chèn thêm thẻ ngắt dòng `<br />` của HTML, ta có thể kết thúc đoạn văn bản
 bằng cách thêm vào từ 2 dấu cách (space) trở lên và bắt đầu đoạn văn bản mới.
 
-```markdown
+```md
 Dòng này kết thúc với 2 dấu cách (highlight để nhìn thấy).
 
 Có phần tử <br /> ở bên trên.
@@ -105,7 +105,7 @@ Có phần tử <br /> ở bên trên.
 
 Khối trích dẫn được sử dụng với kí tự >
 
-```markdown
+```md
 > Đây là khối trích dẫn. Ta có thể
 > ngắt dòng thủ công và thêm kí tự `>` trước mỗi dòng hoặc ta có thể để dòng tự ngắt nếu cần thiệt khi quá dài.
 > Không có sự khác biệt nào, chỉ cần nó bắt đầu với kí tự `>`
@@ -120,7 +120,7 @@ Khối trích dẫn được sử dụng với kí tự >
 
 Danh sách không có thứ tự có thể được tạo sử dụng dấu sao, dấu cộng hay dấu trừ đầu dòng.
 
-```markdown
+```md
 * Một mục
 * Một mục
 * Một mục nữa
@@ -140,7 +140,7 @@ hay
 
 Danh sách có thứ tự được tạo bởi một số theo sau bằng một dấu chấm.
 
-```markdown
+```md
 1. Mục thứ nhất
 2. Mục thứ hai
 3. Mục thứ ba
@@ -148,7 +148,7 @@ Danh sách có thứ tự được tạo bởi một số theo sau bằng một
 
 Ta không nhất thiết phải điền số thứ thự cho chỉ mục đúng mà Markdown sẽ tự hiển thị danh sách theo thứ tự đã được sắp xếp, tuy nhiên cách làm này không tốt!
 
-```markdown
+```md
 1. Mục thứ nhất
 1. Mục thứ hai
 1. Mục thứ ba
@@ -157,7 +157,7 @@ Ta không nhất thiết phải điền số thứ thự cho chỉ mục đúng
 
 Ta còn có thể sử dụng danh sách con
 
-```markdown
+```md
 1. Mục thứ nhất
 2. Mục thứ hai
 3. Mục thứ ba
@@ -168,7 +168,7 @@ Ta còn có thể sử dụng danh sách con
 
 Markdown còn cung cấp danh mục (checklist). Nó sẽ hiển thị ra hộp đánh dấu dạng HTML.
 
-```markdown
+```md
 Boxes below without the 'x' are unchecked HTML checkboxes.
 - [ ] First task to complete.
 - [ ] Second task that needs done
@@ -180,14 +180,14 @@ This checkbox below will be a checked HTML checkbox.
 
 Ta có thể đánh dấu một đoạn code (tương tự sử dụng phần tử HTML `<code>`) bằng việc thụt đầu dòng sử dụng bốn dấu cách (space) hoặc một dấu nhảy (tab)
 
-```markdown
+```md
     This is code
     So is this
 ```
 
 Ta còn có thể thêm dấu nhảy (hoặc thêm vào bốn dấu cách nữa) để căn chỉnh phần bên trong đoạn code
 
-```markdown
+```md
     my_array.each do |item|
         puts item
     end
@@ -195,7 +195,7 @@ Ta còn có thể thêm dấu nhảy (hoặc thêm vào bốn dấu cách nữa)
 
 Code hiển thị cùng dòng có thể được đánh dấu sử dụng cặp ``.
 
-```markdown
+```md
 John didn't even know what the `go_to()` function did!
 ```
 
@@ -217,7 +217,7 @@ highlighting of the language you specify after the \`\`\`
 Dòng kẻ ngang (`<hr />`) có thể được thêm vào dễ dàng sử dụng từ 3 kí tự sao (*) hoặc gạch ngang (-), không quan trọng có khoảng cách giữa các kí tự hay không.
 
 
-```markdown
+```md
 ***
 ---
 - - -
@@ -228,17 +228,17 @@ Dòng kẻ ngang (`<hr />`) có thể được thêm vào dễ dàng sử dụng
 
 Một trong những thứ tốt nhất khi làm việc với Markdown là khả năng tạo liên kết hết sức dễ dàng. Đoạn text hiển thị được đóng trong cặp ngoặc vuông [] kèm theo đường dẫn url trong cặp ngoặc tròn ().
 
-```markdown
+```md
 [Click me!](http://test.com/)
 ```
 Ta còn có thể tạo tiêu đề cho liên kết sử dụng cặp ngoặc nháy bên trong cặp ngoặc tròn
 
-```markdown
+```md
 [Click me!](http://test.com/ "Link to Test.com")
 ```
 Đường dẫn tương đối cũng hoạt động.
 
-```markdown
+```md
 [Go to music](/music/).
 ```
 
@@ -264,7 +264,7 @@ Nhưng nó không được sử dụng rộng rãi.
 
 Hiển thị ảnh tương tự như liên kết nhưng có thêm dấu chấm than đằng trước
 
-```markdown
+```md
 ![Thuộc tính alt cho ảnh](http://imgur.com/myimage.jpg "Tiêu đề tùy chọn")
 ```
 
@@ -278,20 +278,20 @@ Và kiểu tham chiếu cũng hoạt động như vậy.
 
 ### Tự động đặt liên kết
 
-```markdown
+```md
 <http://testwebsite.com/> tương đương với
 [http://testwebsite.com/](http://testwebsite.com/)
 ```
 
 ### Tự động đặt liên kết cho email
 
-```markdown
+```md
 <foo@bar.com>
 ```
 
 ### Hiển thị Kí tự đặc biệt
 
-```markdown
+```md
 Khi ta muốn viết *đoạn văn bản này có dấu sao bao quanh* nhưng ta không muốn nó bị in nghiêng, ta có thể sử dụng: \*đoạn văn bản này có dấu sao bao quanh\*.
 ```
 
@@ -299,7 +299,7 @@ Khi ta muốn viết *đoạn văn bản này có dấu sao bao quanh* nhưng ta
 
 Trong Markdown của Github, ta có thể sử dụng thẻ `<kbd>` để thay cho phím trên bàn phím.
 
-```markdown
+```md
 Máy treo? Thử bấm tổ hợp
 <kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
 ```
@@ -307,7 +307,7 @@ Máy treo? Thử bấm tổ hợp
 
 Bảng biểu được hỗ trợ trên Markdown của GitHub, Jira, Trello, v.v và khá khó viết:
 
-```markdown
+```md
 | Cột 1        | Cột2     | Cột 3         |
 | :----------- | :------: | ------------: |
 | Căn trái     | Căn giữa | Căn phải      |
@@ -315,7 +315,7 @@ Bảng biểu được hỗ trợ trên Markdown của GitHub, Jira, Trello, v.v
 ```
 Hoặc có thể sử dụng kết quả dưới đây
 
-```markdown
+```md
 Cột 1 | Cột 2 | Cột 3
 :-- | :-: | --:
 blah | blah | blah
diff --git a/vim.html.markdown b/vim.html.markdown
index d5c4e865..5b84a3ea 100644
--- a/vim.html.markdown
+++ b/vim.html.markdown
@@ -34,6 +34,11 @@ specific points in the file, and for fast editing.
     k                # Move up one line
     l                # Move right one character
 
+    Ctrl+B 	         # Move back one full screen
+    Ctrl+F 	         # Move forward one full screen
+    Ctrl+D 	         # Move forward 1/2 a screen
+    Ctrl+U           # Move back 1/2 a screen
+
     # Moving within the line
 
     0                # Move to beginning of line
@@ -89,10 +94,10 @@ that aims to make getting started with vim more approachable!
 
 Vim is based on the concept on **modes**.
 
-Command Mode - vim starts up in this mode, used to navigate and write commands
-Insert Mode  - used to make changes in your file
-Visual Mode  - used to highlight text and do operations to them
-Ex Mode      - used to drop down to the bottom with the ':' prompt to enter commands
+- Command Mode - vim starts up in this mode, used to navigate and write commands
+- Insert Mode  - used to make changes in your file
+- Visual Mode  - used to highlight text and do operations to them
+- Ex Mode      - used to drop down to the bottom with the ':' prompt to enter commands
 
 ```
     i                # Puts vim into insert mode, before the cursor position
@@ -117,9 +122,9 @@ Ex Mode      - used to drop down to the bottom with the ':' prompt to enter comm
 Vim can be thought of as a set of commands in a
 'Verb-Modifier-Noun' format, where:
 
-Verb     - your action
-Modifier - how you're doing your action
-Noun     - the object on which your action acts on
+- Verb     - your action
+- Modifier - how you're doing your action
+- Noun     - the object on which your action acts on
 
 A few important examples of 'Verbs', 'Modifiers', and 'Nouns':
 
diff --git a/visualbasic.html.markdown b/visualbasic.html.markdown
index 041641d3..221c1eb3 100644
--- a/visualbasic.html.markdown
+++ b/visualbasic.html.markdown
@@ -5,7 +5,7 @@ contributors:
 filename: learnvisualbasic.vb
 ---
 
-```vbnet
+```
 Module Module1
 
     Sub Main()
@@ -139,7 +139,7 @@ Module Module1
 
     'Five
     Private Sub WorkingCalculator()
-        Console.Title = "The Working Calculator| Learn X in Y Minutes"
+        Console.Title = "The Working Calculator | Learn X in Y Minutes"
         'However if you'd like the calculator to subtract, divide, multiple and
         'add up.
         'Copy and paste the above again.
diff --git a/vyper.html.markdown b/vyper.html.markdown
new file mode 100644
index 00000000..fec1a79f
--- /dev/null
+++ b/vyper.html.markdown
@@ -0,0 +1,872 @@
+---
+language: Vyper
+filename: learnVyper.vy
+contributors:
+  - ["Kenny Peluso", "kennyp.herokuapp.com"]
+---
+
+> The content of this document is largely inspired by ["Learn Solidity in Y Minutes"](https:#github.com/adambard/learnxinyminutes-docs/blob/master/solidity.html.markdown)
+
+Vyper lets you program on [Ethereum](https:#www.ethereum.org/), a
+blockchain-based virtual machine that allows the creation and
+execution of smart contracts, without requiring centralized or trusted parties. It was
+designed to improve upon Solidity, another smart contract language for Ethereum, by
+limiting unsafe practices and enhancing readability; Vyper seeks to optimize the
+security and auditability of smart contracts.
+
+Vyper is an experimental, statically typed, contract programming language meant to
+resemble Python. Like objects in OOP, each contract contains state variables, functions,
+and common data types. Contract-specific features include event notifiers for listeners,
+and custom global variables, global constants.
+
+Some Ethereum contract examples include crowdfunding, voting, and blind auctions.
+
+---
+
+## Table of Contents
+
+- Intro
+- Example
+1. Data types and associated methods
+2. Data structures
+3. Simple operators
+4. Global variables of note
+5. Functions and more
+    a. functions
+    b. events
+6. Branching and loops
+7. Objects/contracts
+    a. calling external contracts
+    b. ERC20 built-in
+    c. following an interface
+8. Other keywords
+    a. selfdestruct
+9. Contract design notes
+    a. obfuscation
+    b. storage optimization
+    c. data access in blockchain
+    d. cron job
+    e. observer pattern
+10. Security
+11. Style notes
+12. Natspec comments
+- Other documents
+
+---
+
+## Intro
+
+From [the docs](https://media.readthedocs.org/pdf/vyper/latest/vyper.pdf)
+the foundational tenants of Vyper are:
+
+1. *Security*
+2. *Language and compiler simplicity*
+3. *Auditability*
+
+This allows for the following features:
+
+1. *Bounds and overflow checking*
+   - On the arithmetic and array level
+   - There are no dynamic arrays in Vyper
+2. *Support for signed integers and decimal fixed point numbers*
+3. *Decidability* - You can always compute precise upper bound on gas cost
+4. *Strong typing* - for built-in and custom types
+5. *Small and understandable compiler code*
+6. *Limited support for pure functions*
+    - Anything marked `@constant` is not allowed to change the state
+
+Following the principles and goals, Vyper does not provide the following features:
+
+1. *Modifiers* (defining parts of functions elsewhere)
+2. *Class inheritance*
+3. *Inline assembly*
+4. *Function overloading*
+5. *Operator overloading*
+6. *Recursive calling*
+7. *Infinite-length loops*
+8. *Binary fixed point* (decimal fixed point is used for its exactness)
+
+WITH THE RAPID CHANGES IN ETHEREUM, THIS DOCUMENT IS UNLIKELY TO STAY UP TO
+DATE, SO YOU SHOULD FOLLOW THE LATEST VYPER DOCS AND ETHEREUM BLOG FOR THE LATEST.
+ALL CODE HERE IS PROVIDED AS IS, WITH SUBSTANTIAL RISK OF ERRORS OR DEPRECATED CODE
+PATTERNS.
+
+This document primarily discusses syntax, and so excludes many
+popular design patterns.
+
+As Vyper and Ethereum are under active development, experimental or beta
+features are typically marked, and subject to change. Pull requests welcome.
+
+This document describes Vyper version `0.1.0-beta.8`.
+
+*All of the following code exists for educational purposes only!*
+*None of the following code should be used in production as-is!*
+
+## Example
+
+```python
+# First, a simple todo list contract
+# Implements CRUD operations for tasks
+
+# todo.vy (note .vy extension)
+### **** START EXAMPLE **** ###
+
+# Start with Natspec comment
+# used for documentation
+
+# @title SimpleBank v1
+# @author kennyp
+# @notice This is a simple bank.
+
+# Vyper contracts must obey a particular order:
+#   struct -> interface -> events -> globals and constants -> functions
+# Additionally, like Python, Vyper functions must be defined in the file
+#    before they're called.
+
+# Structs
+
+struct Task:
+    done: bool
+    deleted: bool
+    task: string[100]
+    metadata: bytes32
+
+# Interfaces
+
+contract AnotherContract():
+    def fetch() -> bytes32: constant
+    def inform(_taskId: uint256, _status: uint256) -> bool: modifying
+
+# Events
+
+# Events - publicize actions to external listeners
+# `indexed` means that it's easier to search/filter on this field
+TaskStatus: event({_taskId: indexed(uint256), _status: uint256})
+
+# Global Variables
+
+# State variables are values which are permanently stored in contract storage
+# State vars consist of any value persisting beyond any function's scope
+#   and are permanently stored in contract storage
+
+# You can define your own, custom, unmutable constants
+CREATED: constant(uint256) = 0
+COMPLETED: constant(uint256) = 1
+DELETED: constant(uint256) = 2
+
+# The `public` built-in allows for this address to be read externally
+#   without defining a `get()` constant function
+owner: public(address)
+other: public(address)
+
+# uint256 means "unsigned positive integer between 0 and 2^256 - 1"
+# Overflow protection is built-in to Vyper
+taskCount: uint256
+tasks: map(uint256, Task) # dictionary: key=uint256, value: Task struct
+
+# Private Functions
+
+# Start each function with Pythonic decorators
+# These decorators resemble Natspec but are actually enforced by Vyper's compiler
+# These decorators are:
+# @public XOR @private (either one or the other)
+#   @public (if any contract/user can call it)
+#   @private (if only internal functions can call it)
+# @payable (if the function is payable i.e. accepting ETH)
+# @constant (if the function is not modifying anything on-chain)
+@private
+def _changeTaskStatus( \
+        _sender: address, \
+        _taskId: uint256, \
+        _status: uint256, \
+    ):
+    # backslashes (\) allow for multi-line code
+    # Natspec comments are particularly helpful for documentation and readibility
+    # Natspec can be included using familiar Pythonic docstring syntax
+    """
+    @notice
+    @dev `_sender` MUST be `self.owner`
+    @param _sender Who is triggering this function
+    @param _task The description of the task (only useful when task added)
+    """
+    # NOTE: Private functions do not have access to `msg.sender`
+    # SIDE NOTE: `msg.sender` refers to whoever immediately called the function of
+    #   immediate scope. In other words, if I call a function that calls another
+    #   in-contract, public function, then `msg.sender` turns from my address to
+    #   the address of the current contract.
+    assert _sender == self.owner # failed assertions cause calls/transactions to fail
+    # Note that unlike Solidity, `self.` is required to query the contract's state
+    # Control flow is Pythonic, as is much of Vyper:
+    _task: string[100] # initialized to default value
+    _data: bytes32 = sha3(convert(_sender, bytes32)) # owner is obfuscated (but still visible in logs)
+    if _status == CREATED: # control flow mimics python
+        # How a new struct is instantiated:
+        self.tasks[_taskId] = Task({ \
+            done: False, deleted: False, task: _task, metadata: _data \
+        })
+    elif _status == COMPLETED:
+        # Modifying an existing struct:
+        self.tasks[_taskId].done = True
+    elif _status == DELETED:
+        self.tasks[_taskId].deleted = True
+    AnotherContract(self.other).inform(_taskId, _status) # modifying external call
+    log.TaskStatus(_taskId, _status) # emit an event
+
+# Public Functions
+
+# Pythonic constructor - can receive none or many arguments
+@public
+def __init__(_owner: address, _other_contract: address):
+    """
+    @dev Called once and only upon contract depoyment
+    """
+    self.owner = _owner
+    self.other = _other_contract
+
+# NOTE: Pythonic whitespace rules are mandated in Vyper
+
+@public
+def addTask(_task: string[100]) -> uint256:
+    """
+    @notice Adds a task to contract
+    @param _task Description of task
+    @return Id of newly minted task
+    """
+    # msg.sender gives the address of who/what contract is calling this function
+    self._changeTaskStatus(msg.sender, self.taskCount, CREATED)
+    self.tasks[self.taskCount].task = _task
+    self.taskCount += 1
+    return self.taskCount - 1
+
+@public
+def addSpecialTask(_task: string[100]) -> uint256:
+    """
+    @notice Adds a task with metadata pulled from elsewhere
+    @param _task Description of task
+    @return Id of newly minted task
+    """
+    self._changeTaskStatus(msg.sender, self.taskCount, CREATED)
+    self.tasks[self.taskCount].task = _task
+    self.tasks[self.taskCount].metadata = AnotherContract(self.other).fetch()
+    self.taskCount += 1
+    return self.taskCount - 1
+
+@public
+def completeTask(_taskId: uint256):
+    """
+    @notice Marks a task as "completed"
+    @param _taskId Id of task to complete
+    """
+    self._changeTaskStatus(msg.sender, _taskId, COMPLETED)
+
+@public
+def deleteTask(_taskId: uint256):
+    """
+    @notice Adds a task to contract
+    @param _taskId Id of task to delete
+    """
+    self._changeTaskStatus(msg.sender, _taskId, DELETED)
+
+@public
+@constant # allows function to run locally/off blockchain
+def getTask(_taskId: uint256) -> string[100]:
+    """
+    @notice Getter for a task's description
+    @param _taskId Id of task with desired description
+    @return Description of task
+    """
+    return self.tasks[_taskId].task
+
+### **** END EXAMPLE **** ###
+
+
+# Now, the basics of Vyper
+
+
+# ---
+
+
+# 1. DATA TYPES AND ASSOCIATED METHODS
+# uint256 used for currency amount and for dates (in unix time)
+x: uint256
+
+# int of 128 bits, cannot be changed after contract deployment
+# with 'constant', compiler replaces each occurrence with actual value
+a: constant(int128) = 5
+
+# All state variables (those outside a function)
+#   are by default 'internal' and accessible inside contract
+# Need to explicitly set to 'public' to allow external contracts to access
+#   A getter is automatically created, but NOT a setter
+# Can only be called in the contract's scope (not within functions)
+# Add 'public' field to indicate publicly/externally accessible
+a: public(int128)
+
+# No random functions built in, use other contracts for randomness
+
+# Type casting is limited but exists
+b: int128 = 5
+x: uint256 = convert(b, uint256)
+
+# Types of accounts:
+# Contract Account: f(creator_addr, num_transactions)=address set on contract creation
+# External Account: (person/external entity): f(public_key)=address
+
+# Addresses - An address type can hold an Ethereum address which
+#   equates to 20 bytes or 160 bits. It returns in hexadecimal notation
+#   with a leading 0x. No arithmetic allowed
+owner: public(address)
+
+# Members can be invoked on all addresses:
+owner.balance # returns balance of address as `wei_value`
+owner.codesize # returns code size of address as `int128`
+owner.is_contract # `True` if Contract Account
+
+# All addresses can be sent ether via `send()` built-in
+@public
+@payable
+def sendWei(any_addr: address):
+    send(any_addr, msg.value)
+
+# Bytes available
+a: bytes[2]
+b: bytes[32]
+c: bytes32
+# `b` and `c` are 2 different types
+
+# Bytes are preferable to strings since Vyper currently offers better
+#   support for bytes i.e. more built-ins to deal with `bytes32`, `bytes32`
+#   can be returned from functions and strings[] can't be, UTF8 (string encoding)
+#   uses more storage, etc.
+
+# There are no dynamically sized bytes, similar to how there are no
+#   dynamic arrays
+
+# Fixed-size byte arrays (Strings)
+a: string[100]
+b: string[8]
+c: string[108] = concat(a, b) # check the latest docs for more built-ins
+
+# Time
+t1: timedelta
+t2: timestamp
+# Both types are built-in "custom type" variants of `uint256`
+# `timedelta` values can be added but not `timestamp` values
+
+# Money
+m: wei_value
+# Also has the base type `uint256` like `timestamp` and `timedelta`
+# 1 unit of WEI (a small amount of ETH i.e. ether)
+
+# Custom types
+# specify units used in the contract:
+units: {
+    cm: "centimeter",
+    km: "kilometer"
+}
+# usage:
+a: int128(cm)
+b: uint256(km)
+
+# BY DEFAULT: all values are set to 0 on instantiation
+
+# `clear()` can be called on most types
+#   Does NOT destroy value, but sets value to 0, the initial value
+
+
+# ---
+
+
+# 2. DATA STRUCTURES
+# Arrays
+bytes32[5] nicknames; # static array
+bytes32[] names; # dynamic array
+uint newLength = names.push("John"); # adding returns new length of the array
+# Length
+names.length; # get length
+names.length = 1; # lengths can be set (for dynamic arrays in storage only)
+
+# Multidimensional Arrays
+# At initialization, array dimensions must be hard-coded or constants
+# Initialize a 10-column by 3-row, multidimensional fixed array
+ls: (uint256[10])[3] # parentheses are optional
+@public
+def setToThree():
+    # Multidimensional Array Access and Write
+    # access indices are reversed
+    # set element in row 2 (3rd row) column 5 (6th column) to 3
+    self.ls[2][5] = 3
+
+# Dictionaries (any simple type to any other type including structs)
+theMap: map(uint256, bytes32)
+theMap[5] = sha3("charles")
+# theMap[255] result is 0, all non-set key values return zeroes
+# To make read public, make a getter that accesses the mapping
+@public
+def getMap(_idx: uint256) -> bytes32:
+    """
+    @notice Get the value of `theMap` at `_idx`
+    """
+    return self.theMap[_idx]
+
+self.getMap(5) # returns sha3("charles") in bytes32
+
+# Nested mappings
+aMap: map(address, map(address, uint256))
+# NOTE: Mappings are only allowed as state variables
+# NOTE: Mappings are not iterable; can only be accessed
+
+# To delete (reset the mapping's value to default at a key)
+clear(balances["John"])
+clear(balances); # sets all elements to 0
+
+# Unlike other languages, CANNOT iterate through all elements in
+#   mapping, without knowing source keys - can build data structure
+#   on top to do this
+
+# Structs
+struct Struct:
+    owner: address
+    _balance: uint256 # balance is a reserved keyword, is a member for addresses
+
+exampleStuct: Struct
+
+@public
+def foo() -> uint256:
+    self.exampleStuct = Struct({owner: msg.sender, _balance: 5})
+    self.exampleStuct._balance = 10
+    self.exampleStuct._balance = 5 # set to new value
+    clear(self.exampleStuct._balance)
+    clear(self.exampleStuct)
+    return self.exampleStuct._balance
+
+
+# Data locations: Memory vs. storage vs. calldata - all complex types (arrays,
+# structs) have a data location
+# 'memory' does not persist, 'storage' does
+# Default is 'storage' for local and state variables; 'memory' for func params
+# stack holds small local variables
+
+# for most types, can explicitly set which data location to use
+
+
+# ---
+
+
+# 3. SIMPLE OPERATORS
+# Comparisons, bit operators and arithmetic operators are provided
+# exponentiation: **
+# modulo: %
+# maximum: max(x, y)
+# AND: bitwise_and(x, y)
+# bitwise shift: shift(x, _shift)
+#   where x,y are uint256
+#         _shift is int128
+
+# 4. GLOBAL VARIABLES OF NOTE
+# ** self **
+self # address of contract
+# often used at end of contract life to transfer remaining balance to party:
+self.balance # balance of current contract
+self.someFunction() # calls func externally via call, not via internal jump
+
+# ** msg - Current message received by the contract **
+# Ethereum programmers take NOTE: this `msg` object is smaller than elsewhere
+msg.sender # address of sender
+msg.value # amount of ether provided to this contract in wei, the function should be marked `@payable`
+msg.gas # remaining gas
+
+# ** tx - This transaction **
+# Ethereum programmers take NOTE: this `tx` object is smaller than elsewhere
+tx.origin # address of sender of the transaction
+
+# ** block - Information about current block **
+block.timestamp # time at current block (uses Unix time)
+# Note that `block.timestamp` can be manipulated by miners, so be careful
+block.number # current block number
+block.difficulty # current block difficulty
+
+# ** storage - Persistent storage hash **
+storage['abc'] = 'def'; # maps 256 bit words to 256 bit words
+
+
+# ---
+
+
+# 5. FUNCTIONS AND MORE
+
+# A. FUNCTIONS
+# Simple function
+function increment(uint x) returns (uint) {
+    x += 1;
+    return x;
+}
+
+# Functions can return many arguments
+@public
+@constant
+def increment(x: uint256, y: uint256) -> (uint256, uint256):
+    x += 1
+    y += 1
+    return  (x, y)
+
+# Call previous functon
+@public
+@constant
+def willCall() -> (uint256, uint256):
+    return  self.increment(1,1)
+
+# One should never have to call a function / hold any logic outside
+#   outside the scope of a function in Vyper
+
+# '@constant'
+# indicates that function does not/cannot change persistent vars
+# Constant function execute locally, not on blockchain
+y: uint256
+@public
+@constant
+def increment(x: uint256) -> uint256:
+    x += 1
+    y += 1 # this line would fail
+    # y is a state variable => can't be changed in a constant function
+
+
+# 'Function Decorators'
+# Used like python decorators but are REQUIRED by Vyper
+# @public - visible externally and internally (default for function)
+# @private - only visible in the current contract
+# @constant - doesn't change state
+# @payable - receive ether/ETH
+# @nonrentant(<unique_key>) - Function can only be called once, both externally
+#                             and internally. Used to prevent reentrancy attacks
+
+# Functions hare not hoisted
+# Functions cannot be assigned to a variable
+# Functions cannot be recursive
+
+# All functions that receive ether must be marked 'payable'
+@public
+@payable
+def depositEther():
+    self.balances[msg.sender] += msg.value
+
+
+# B. EVENTS
+# Events are notify external parties; easy to search and
+#   access events from outside blockchain (with lightweight clients)
+#   typically declare after contract parameters
+
+# Declare
+LogSent: event({_from: indexed(address), address: indexed(_to), _amount: uint256})
+# Call
+log.LogSent(from, to, amount)
+
+/**
+For an external party (a contract or external entity), to watch using
+the Web3 Javascript library:
+
+# The following is Javascript code, not Vyper code
+Coin.LogSent().watch({}, '', function(error, result) {
+    if (!error) {
+        console.log("Coin transfer: " + result.args.amount +
+            " coins were sent from " + result.args.from +
+            " to " + result.args.to + ".");
+        console.log("Balances now:\n" +
+            "Sender: " + Coin.balances.call(result.args.from) +
+            "Receiver: " + Coin.balances.call(result.args.to));
+    }
+}
+**/
+
+# Common paradigm for one contract to depend on another (e.g., a
+#   contract that depends on current exchange rate provided by another)
+
+
+# ---
+
+
+# 6. BRANCHING AND LOOPS
+
+# All basic logic blocks from Python work - including if/elif/else, for,
+#   while, break, continue, return - but no switch
+
+# Syntax same as Python, but no type conversion from non-boolean
+# to boolean (comparison operators must be used to get the boolean val)
+
+# REMEMBER: Vyper does not allow resursive calls or infinite loops
+
+
+# ---
+
+
+# 7. OBJECTS/CONTRACTS
+# REMEMBER: Vyper does not allow for inheritance or imports
+
+# A. CALLING EXTERNAL CONTRACTS
+# You must define an interface to an external contract in the current contract
+
+contract InfoFeed():
+    def getInfo() -> uint256: constant
+
+info: uint256
+
+@public
+def __init__(_source: address):
+    self.info = InfoFeed(_source).getInfo()
+
+
+# B. ERC20 BUILT-IN
+# Using the `ERC20` keyword implies that the contract at the address
+#   follows the ERC20 token standard, allowing you to safely call
+#   functions like `transfer()`, etc.
+
+tokenAddress: address(ERC20)
+
+@public
+def transferIt(_to: address, _amt: uint256(wei)):
+    self.tokenAddress.transfer(_to, _amt)
+
+
+# C. FOLLOWING AN INTERFACE
+# Vyper is experimenting with using the following syntax at the top of
+#   a `.vy` file to specify what interfaces are followed by the contract
+# This allows interfaces to be better organized, registered, and recognized
+
+import interfaces.some_interface as SomeInterface
+implements: SomeInterface
+# <rest of contract>
+
+
+# ---
+
+
+# 8. OTHER KEYWORDS
+
+# A. selfdestruct()
+# selfdestruct current contract, sending funds to address (often creator)
+selfdestruct(SOME_ADDRESS);
+
+# removes storage/code from current/future blocks
+# helps thin clients, but previous data persists in blockchain
+
+# Common pattern, lets owner end the contract and receive remaining funds
+@public
+def endItAll() {
+    assert msg.sender == self.creator # Only let the contract creator do this
+    selfdestruct(self.creator) # Makes contract inactive, returns funds
+
+# May want to deactivate contract manually, rather than selfdestruct
+#   (ether sent to selfdestructed contract is lost)
+
+
+# B. sha3()
+# Encrypts strings and other data
+# Very important on the blockchain
+# Takes 1 argument, `concat()` can be called beforehand
+# All strings passed are concatenated before hash action
+sha3(concat("ab", "cd")) # returns bytes32
+
+
+# ---
+
+
+# 9. CONTRACT DESIGN NOTES
+
+# A. Obfuscation
+# All variables are publicly viewable on blockchain, so anything
+#   that is private needs to be obfuscated (e.g., hashed w/secret)
+# Oftentimes, a "commit-reveal" scheme is employed
+
+# Step 1. Commit
+# Place a commitment by sending output of `sha3()`
+sha3("a secret"); # btyes32 commit
+sha3(concat("secret", "other secret", "salt")); # commit multiple things
+# The `sha3()` calculation should occur off-chain, only the bytes32
+#   output should be inputted into some `commit()` function
+commits: map(address, bytes32)
+@public
+def commit(commitment: bytes32):
+    self.commits[msg.sender] = commitment
+
+# Step 2. Reveal
+# Send your previously committed data so the contract can check
+#   if your commitment was honest
+@public
+def reveal(_secret: string[100], _salt: string[100]) -> bool:
+    return sha3(concat(_secret, _salt)) == self.commits[msg.sender]
+
+
+# B. Storage optimization
+# Writing to blockchain can be expensive, as data stored forever; encourages
+#   smart ways to use memory (eventually, compilation will be better, but for now
+#   benefits to planning data structures - and storing min amount in blockchain)
+
+# Cost can often be high for items like multidimensional arrays
+#   (cost is for storing data - not declaring unfilled variables)
+
+
+# C. Data access in blockchain
+# Cannot restrict human or computer from reading contents of
+#   transaction or transaction's state
+
+# While 'private' prevents other *contracts* from reading data
+#   directly - any other party can still read data in blockchain
+
+# All data to start of time is stored in blockchain, so
+#   anyone can observe all previous data and changes
+
+
+# D. Cron Job
+# Contracts must be manually called to handle time-based scheduling;
+#   can create external code to regularly ping or provide incentives
+#   (ether) for others to ping
+
+
+# E. Observer Pattern
+# An Observer Pattern lets you register as a subscriber and
+#   register a function which is called by the oracle (note, the oracle
+#   pays for this action to be run)
+# Some similarities to subscription in Pub/sub
+
+# This is an abstract contract, both client and server classes import,
+#   the client should implement
+
+### **** START EXAMPLE **** ###
+
+contract SomeOracleCallback():
+    def oracleCallback(_value: uint256, _time: timestamp, _info: bytes32): modifying
+
+MAX_SUBS: constant(uint256) = 100
+numSubs: public(uint256) # number of subscribers
+subs: map(uint256, address) # enumerates subscribers
+
+@public
+def addSub(_sub: address) -> uint256:
+    """
+    @notice Add subscriber
+    @param _sub Address to add
+    @return Id of newly added subscriber
+    """
+    self.subs[self.numSubs] = _sub
+    self.numSubs += 1
+    return self.numSubs - 1
+
+@private
+def notify(_value: uint256, _time: timestamp, _info: bytes32) -> bool:
+    """
+    @notice Notify all subscribers
+    @dev Check `numSubs` first; Watch out for gas costs!
+    @param _value whatever
+    @param _time what have you
+    @param _info what else
+    @return True upon successful completion
+    """
+    j: uint256
+    for i in range(MAX_SUBS):
+        j = convert(i, uint256) # `i` is int128 by default
+        if j == self.numSubs:
+            return True
+        SomeOracleCallback(self.subs[j]).oracleCallback(_value, _time, _info)
+
+@public
+def doSomething():
+    """
+    @notice Do something and notify subscribers
+    """
+    # ...something...
+    whatever: uint256 = 6
+    what_have_you: timestamp
+    what_else: bytes32 = sha3("6")
+    self.notify(whatever, what_have_you, what_else)
+
+# Now, your client contract can addSubscriber by importing SomeOracleCallback
+# and registering with Some Oracle
+
+### **** END EXAMPLE **** ###
+
+
+# ---
+
+
+# 10. SECURITY
+# Bugs can be disastrous in Ethereum contracts - and even popular patterns in
+#   Vyper may be found to be antipatterns
+
+# See security links at the end of this doc
+
+
+# ---
+
+
+# 11. STYLE NOTES
+# Based on Python's PEP8 style guide
+# Full Style guide: http:#solidity.readthedocs.io/en/develop/style-guide.html
+
+# Quick summary:
+# 4 spaces for indentation
+# Two lines separate contract declarations (and other top level declarations)
+# Avoid extraneous spaces in parentheses
+# Can omit curly braces for one line statement (if, for, etc)
+# else should be placed on own line
+
+# Specific to Vyper:
+# arguments: snake_case
+# events, interfaces, structs: PascalCase
+# public functions: camelCase
+# private functions: _prefaceWithUnderscore
+
+
+# ---
+
+
+# 12. NATSPEC COMMENTS
+# used for documentation, commenting, and external UIs
+
+# Contract natspec - always above contract definition
+# @title Contract title
+# @author Author name
+
+# Function natspec
+# Should include in docstring of functions in typical Pythonic fashion
+# @notice Information about what function does; shown when function to execute
+# @dev Function documentation for developer
+
+# Function parameter/return value natspec
+# @param someParam Some description of what the param does
+# @return Description of the return value
+
+```
+
+## Additional resources
+- [Installation](https://vyper.readthedocs.io/en/latest/installing-vyper.html)
+- [Vyper Docs](https://media.readthedocs.org/pdf/vyper/latest/vyper.pdf)
+- [Vyper GitHub (under active dev)](https://github.com/ethereum/vyper)
+- [Tools and Resources](https://github.com/ethereum/vyper/wiki/Vyper-tools-and-resources)
+- [Online Compiler](https://vyper.online/)
+
+## Sample contracts
+- [Uniswap](https://github.com/Uniswap/contracts-vyper)
+- [Generalized Governance](https://github.com/kpeluso/gdg)
+- [Dynamic Arrays](https://github.com/kpeluso/vyper-dynamic-array)
+
+## Security
+Vyper is secure by design, but it may be helpful to understand what Vyper is
+protecting you from.
+- [Thinking About Smart Contract Security](https:#blog.ethereum.org/2016/06/19/thinking-smart-contract-security/)
+- [Smart Contract Security](https:#blog.ethereum.org/2016/06/10/smart-contract-security/)
+- [Hacking Distributed Blog](http:#hackingdistributed.com/)
+
+## Style
+- [Vyper Style Guide WIP](https://github.com/ethereum/vyper/issues/905)
+  - Heavily derived from [Solidity's style guide](http:#solidity.readthedocs.io/en/latest/style-guide.html) ...
+  - ... which, in turn, is heavily derived from Python's [PEP 8](https:#www.python.org/dev/peps/pep-0008/) style guide.
+
+## Editors
+- [Vyper for VS Code (alpha)](https://github.com/p-/vscode-vyper)
+
+## Future To Dos
+- Update to current Vyper release
+- List of common design patterns
+
+*Feel free to send a pull request with any edits - or email* `pelusoken -/at-/ gmail`
+
diff --git a/wasm.html.markdown b/wasm.html.markdown
new file mode 100644
index 00000000..98bfc000
--- /dev/null
+++ b/wasm.html.markdown
@@ -0,0 +1,227 @@
+---
+language: WebAssembly
+filename: learn-wasm.wast
+contributors:
+    - ["Dean Shaff", "http://dean-shaff.github.io"]
+---
+
+```
+;; learn-wasm.wast
+
+(module
+  ;; In WebAssembly, everything is included in a module. Moreover, everything
+  ;; can be expressed as an s-expression. Alternatively, there is the
+  ;; "stack machine" syntax, but that is not compatible with Binaryen
+  ;; intermediate representation (IR) syntax.
+
+  ;; The Binaryen IR format is *mostly* compatible with WebAssembly text format.
+  ;; There are some small differences:
+  ;; local_set -> local.set
+  ;; local_get -> local.get
+
+  ;; We have to enclose code in functions
+
+  ;; Data Types
+  (func $data_types
+    ;; WebAssembly has only four types:
+    ;; i32 - 32 bit integer
+    ;; i64 - 64 bit integer (not supported in JavaScript)
+    ;; f32 - 32 bit floating point
+    ;; f64 - 64 bit floating point
+
+    ;; We can declare local variables with the "local" keyword
+    ;; We have to declare all variables before we start doing anything
+    ;; inside the function
+
+    (local $int_32 i32)
+    (local $int_64 i64)
+    (local $float_32 f32)
+    (local $float_64 f64)
+
+    ;; These values remain uninitialized.
+    ;; To set them to a value, we can use <type>.const:
+
+    (local.set $int_32 (i32.const 16))
+    (local.set $int_32 (i64.const 128))
+    (local.set $float_32 (f32.const 3.14))
+    (local.set $float_64 (f64.const 1.28))
+  )
+
+  ;; Basic operations
+  (func $basic_operations
+
+    ;; In WebAssembly, everything is an s-expression, including
+    ;; doing math, or getting the value of some variable
+
+    (local $add_result i32)
+    (local $mult_result f64)
+
+    (local.set $add_result (i32.add (i32.const 2) (i32.const 4)))
+    ;; the value of add_result is now 6!
+
+    ;; We have to use the right data type for each operation:
+    ;; (local.set $mult_result (f32.mul (f32.const 2.0) (f32.const 4.0))) ;; WRONG! mult_result is f64!
+    (local.set $mult_result (f64.mul (f64.const 2.0) (f64.const 4.0))) ;; WRONG! mult_result is f64!
+
+    ;; WebAssembly has some builtin operations, like basic math and bitshifting.
+    ;; Notably, it does not have built in trigonometric functions.
+    ;; In order to get access to these functions, we have to either
+    ;; - implement them ourselves (not recommended)
+    ;; - import them from elsewhere (later on)
+  )
+
+  ;; Functions
+  ;; We specify arguments with the `param` keyword, and specify return values
+  ;; with the `result` keyword
+  ;; The current value on the stack is the return value of a function
+
+  ;; We can call other functions we've defined with the `call` keyword
+
+  (func $get_16 (result i32)
+    (i32.const 16)
+  )
+
+  (func $add (param $param0 i32) (param $param1 i32) (result i32)
+    (i32.add
+      (local.get $param0)
+      (local.get $param1)
+    )
+  )
+
+  (func $double_16 (result i32)
+    (i32.mul
+      (i32.const 2)
+      (call $get_16))
+  )
+
+  ;; Up until now, we haven't be able to print anything out, nor do we have
+  ;; access to higher level math functions (pow, exp, or trig functions).
+  ;; Moreover, we haven't been able to use any of the WASM functions in Javascript!
+  ;; The way we get those functions into WebAssembly
+  ;; looks different whether we're in a Node.js or browser environment.
+
+  ;; If we're in Node.js we have to do two steps. First we have to convert the
+  ;; WASM text representation into actual webassembly. If we're using Binyaren,
+  ;; we can do that with a command like the following:
+
+  ;; wasm-as learn-wasm.wast -o learn-wasm.wasm
+
+  ;; We can apply Binaryen optimizations to that file with a command like the
+  ;; following:
+
+  ;; wasm-opt learn-wasm.wasm -o learn-wasm.opt.wasm -O3 --rse
+
+  ;; With our compiled WebAssembly, we can now load it into Node.js:
+  ;; const fs = require('fs')
+  ;; const instantiate = async function (inFilePath, _importObject) {
+  ;;  var importObject = {
+  ;;     console: {
+  ;;       log: (x) => console.log(x),
+  ;;     },
+  ;;     math: {
+  ;;       cos: (x) => Math.cos(x),
+  ;;     }
+  ;;   }
+  ;;  importObject = Object.assign(importObject, _importObject)
+  ;;
+  ;;  var buffer = fs.readFileSync(inFilePath)
+  ;;  var module = await WebAssembly.compile(buffer)
+  ;;  var instance = await WebAssembly.instantiate(module, importObject)
+  ;;  return instance.exports
+  ;; }
+  ;;
+  ;; const main = function () {
+  ;;   var wasmExports = await instantiate('learn-wasm.wasm')
+  ;;   wasmExports.print_args(1, 0)
+  ;; }
+
+  ;; The following snippet gets the functions from the importObject we defined
+  ;; in the JavaScript instantiate async function, and then exports a function
+  ;; "print_args" that we can call from Node.js
+
+  (import "console" "log" (func $print_i32 (param i32)))
+  (import "math" "cos" (func $cos (param f64) (result f64)))
+
+  (func $print_args (param $arg0 i32) (param $arg1 i32)
+    (call $print_i32 (local.get $arg0))
+    (call $print_i32 (local.get $arg1))
+  )
+  (export "print_args" (func $print_args))
+
+  ;; Loading in data from WebAssembly memory.
+  ;; Say that we want to apply the cosine function to a Javascript array.
+  ;; We need to be able to access the allocated array, and iterate through it.
+  ;; This example will modify the input array inplace.
+  ;; f64.load and f64.store expect the location of a number in memory *in bytes*.
+  ;; If we want to access the 3rd element of an array, we have to pass something
+  ;; like (i32.mul (i32.const 8) (i32.const 2)) to the f64.store function.
+
+  ;; In JavaScript, we would call `apply_cos64` as follows
+  ;; (using the instantiate function from earlier):
+  ;;
+  ;; const main = function () {
+  ;;   var wasm = await instantiate('learn-wasm.wasm')
+  ;;   var n = 100
+  ;;   const memory = new Float64Array(wasm.memory.buffer, 0, n)
+  ;;   for (var i=0; i<n; i++) {
+  ;;     memory[i] = i;
+  ;;   }
+  ;;   wasm.apply_cos64(n)
+  ;; }
+  ;;
+  ;; This function will not work if we allocate a Float32Array on the JavaScript
+  ;; side.
+
+  (memory (export "memory") 100)
+
+  (func $apply_cos64 (param $array_length i32)
+    ;; declare the loop counter
+    (local $idx i32)
+    ;; declare the counter that will allow us to access memory
+    (local $idx_bytes i32)
+    ;; constant expressing the number of bytes in a f64 number.
+    (local $bytes_per_double i32)
+
+    ;; declare a variable for storing the value loaded from memory
+    (local $temp_f64 f64)
+
+    (local.set $idx (i32.const 0))
+    (local.set $idx_bytes (i32.const 0)) ;; not entirely necessary
+    (local.set $bytes_per_double (i32.const 8))
+
+    (block
+      (loop
+        ;; this sets idx_bytes to bytes offset of the value we're interested in.
+        (local.set $idx_bytes (i32.mul (local.get $idx) (local.get $bytes_per_double)))
+
+        ;; get the value of the array from memory:
+        (local.set $temp_f64 (f64.load (local.get $idx_bytes)))
+
+        ;; now apply the cosine function:
+        (local.set $temp_64 (call $cos (local.get $temp_64)))
+
+        ;; now store the result at the same location in memory:
+        (f64.store
+          (local.get $idx_bytes)
+          (local.get $temp_64))
+
+        ;; do it all in one step instead
+        (f64.store
+          (local.get $idx_bytes)
+          (call $cos
+            (f64.load
+              (local.get $idx_bytes))))
+
+        ;; increment the loop counter
+        (local.set $idx (i32.add (local.get $idx) (i32.const 1)))
+
+        ;; stop the loop if the loop counter is equal the array length
+        (br_if 1 (i32.eq (local.get $idx) (local.get $array_length)))
+        (br 0)
+      )
+    )
+  )
+  (export "apply_cos64" (func $apply_cos64))
+)
+
+```
diff --git a/wolfram.html.markdown b/wolfram.html.markdown
index 4514006d..5fddbc82 100644
--- a/wolfram.html.markdown
+++ b/wolfram.html.markdown
@@ -123,8 +123,8 @@ myHash[["Green"]]                       (* 2, use it *)
 myHash[["Green"]] := 5                  (* 5, update it *)
 myHash[["Puce"]] := 3.5                 (* 3.5, extend it *)
 KeyDropFrom[myHash, "Green"]            (* Wipes out key Green *)
-Keys[myHash]                            (* {Red} *)
-Values[myHash]                          (* {1} *)
+Keys[myHash]                            (* {Red, Puce} *)
+Values[myHash]                          (* {1, 3.5} *)
 
 (* And you can't do any demo of Wolfram without showing this off *)
 Manipulate[y^2, {y, 0, 20}] (* Return a reactive user interface that displays y^2
diff --git a/yaml.html.markdown b/yaml.html.markdown
index 52658453..f1393c09 100644
--- a/yaml.html.markdown
+++ b/yaml.html.markdown
@@ -14,6 +14,8 @@ significant newlines and indentation, like Python. Unlike Python, however,
 YAML doesn't allow literal tab characters for indentation.
 
 ```yaml
+---  # document start
+
 # Comments in YAML look like this.
 
 ################
@@ -36,6 +38,8 @@ however: 'A string, enclosed in quotes.'
 'Keys can be quoted too.': "Useful if you want to put a ':' in your key."
 single quotes: 'have ''one'' escape pattern'
 double quotes: "have many: \", \0, \t, \u263A, \x0d\x0a == \r\n, and more."
+# UTF-8/16/32 characters need to be encoded
+Superscript two: \u00B2
 
 # Multiple-line strings can be written either as a 'literal block' (using |),
 # or a 'folded block' (using '>').
@@ -83,22 +87,22 @@ a_nested_map:
 # An example
 ? - Manchester United
   - Real Madrid
-: [ 2001-01-01, 2002-02-02 ]
+: [2001-01-01, 2002-02-02]
 
 # Sequences (equivalent to lists or arrays) look like this
 # (note that the '-' counts as indentation):
 a_sequence:
-- Item 1
-- Item 2
-- 0.5 # sequences can contain disparate types.
-- Item 4
-- key: value
-  another_key: another_value
--
-  - This is a sequence
-  - inside another sequence
-- - - Nested sequence indicators
-    - can be collapsed
+  - Item 1
+  - Item 2
+  - 0.5  # sequences can contain disparate types.
+  - Item 4
+  - key: value
+    another_key: another_value
+  -
+    - This is a sequence
+    - inside another sequence
+  - - - Nested sequence indicators
+      - can be collapsed
 
 # Since YAML is a superset of JSON, you can also write JSON-style maps and
 # sequences:
@@ -119,6 +123,10 @@ other_anchor: *anchor_name
 base: &base
   name: Everyone has same name
 
+# The regexp << is called Merge Key Language-Independent Type. It is used to
+# indicate that all the keys of one or more specified maps should be inserted
+# into the current map.
+
 foo: &foo
   <<: *base
   age: 10
@@ -165,14 +173,16 @@ set:
   ? item3
 or: {item1, item2, item3}
 
-# Like Python, sets are just maps with null values; the above is equivalent to:
+# Sets are just maps with null values; the above is equivalent to:
 set2:
   item1: null
   item2: null
   item3: null
+
+...  # document end
 ```
 
 ### More Resources
 
 + [YAML official website](http://yaml.org/)
-+ [Online YAML Validator](http://codebeautify.org/yaml-validator)
++ [Online YAML Validator](http://www.yamllint.com/)
diff --git a/zfs.html.markdown b/zfs.html.markdown
index fad6b62d..6795b1fa 100644
--- a/zfs.html.markdown
+++ b/zfs.html.markdown
@@ -221,7 +221,7 @@ Delete dataset
 
 ```bash
 # Datasets cannot be deleted if they have any snapshots
-zfs destroy tank/root/home
+$ zfs destroy tank/root/home
 ```
 
 Get / set properties of a dataset
@@ -294,6 +294,7 @@ tank/home/sarlalian@now       0      -   259M  -
 tank/home/alice@now           0      -   156M  -
 tank/home/bob@now             0      -   156M  -
 ...
+```
 
 Destroy snapshots
 
@@ -313,13 +314,13 @@ Renaming Snapshots
 $ zfs rename tank/home/sarlalian@now tank/home/sarlalian@today
 $ zfs rename tank/home/sarlalian@now today
 
-# zfs rename -r tank/home@now @yesterday
+$ zfs rename -r tank/home@now @yesterday
 ```
 
 Accessing snapshots
 
 ```bash
-# CD Into a snapshot directory
+# CD into a snapshot directory
 $ cd /home/.zfs/snapshot/
 ```
 
@@ -335,11 +336,11 @@ $ zfs send tank/home/sarlalian@now | zfs recv backups/home/sarlalian
 # Send a snapshot to a remote host
 $ zfs send tank/home/sarlalian@now | ssh root@backup_server 'zfs recv tank/home/sarlalian'
 
-# Send full dataset with snapshos to new host
+# Send full dataset with snapshots to new host
 $ zfs send -v -R tank/home@now | ssh root@backup_server 'zfs recv tank/home'
 ```
 
-Cloneing Snapshots
+Cloning Snapshots
 
 ```bash
 # Clone a snapshot
diff --git a/zh-cn/awk-cn.html.markdown b/zh-cn/awk-cn.html.markdown
new file mode 100644
index 00000000..8ee2db2c
--- /dev/null
+++ b/zh-cn/awk-cn.html.markdown
@@ -0,0 +1,327 @@
+---
+category: tool
+tool: awk
+contributors:
+     - ["Marshall Mason", "http://github.com/marshallmason"]
+translators:
+    - ["Tian Zhipeng", "https://github.com/tianzhipeng-git"]
+filename: learnawk-cn.awk
+lang: zh-cn
+---
+
+AWK是POSIX兼容的UNIX系统中的标准工具. 它像简化版的Perl, 非常适用于文本处理任务和其他脚本类需求.
+它有着C风格的语法, 但是没有分号, 没有手动内存管理, 没有静态类型. 
+他擅长于文本处理, 你可以通过shell脚本调用AWK, 也可以用作独立的脚本语言.
+
+为什么使用AWK而不是Perl, 大概是因为AWK是UNIX的一部分, 你总能依靠它, 而Perl已经前途未卜了.
+AWK比Perl更易读. 对于简单的文本处理脚本, 特别是按行读取文件, 按分隔符分隔处理, AWK极可能是正确的工具.
+
+```awk
+#!/usr/bin/awk -f
+
+# 注释使用井号
+
+# AWK程序由一系列 模式(patterns) 和 动作(actions) 组成. 
+# 最重要的模式叫做 BEGIN. 动作由大括号包围.
+BEGIN {
+
+    # BEGIN在程序最开始运行. 在这里放一些在真正处理文件之前的准备和setup的代码.
+    # 如果没有文本文件要处理, 那就把BEGIN作为程序的主入口吧.
+
+    # 变量是全局的. 直接赋值使用即可, 无需声明.
+    count = 0
+
+    # 运算符和C语言系一样
+    a = count + 1
+    b = count - 1
+    c = count * 1
+    d = count / 1 # 整数除法
+    e = count % 1 # 取余
+    f = count ^ 1 # 取幂
+
+    a += 1
+    b -= 1
+    c *= 1
+    d /= 1
+    e %= 1
+    f ^= 1
+
+    # 自增1, 自减1
+    a++
+    b--
+
+    # 前置运算, 返回增加之后的值
+    ++a
+    --b
+
+    # 注意, 不需要分号之类的标点来分隔语句
+
+    # 控制语句
+    if (count == 0)
+        print "Starting with count of 0"
+    else
+        print "Huh?"
+
+    # 或者三目运算符
+    print (count == 0) ? "Starting with count of 0" : "Huh?"
+
+    # 多行的代码块用大括号包围
+    while (a < 10) {
+        print "String concatenation is done" " with a series" " of"
+            " space-separated strings"
+        print a
+
+        a++
+    }
+
+    for (i = 0; i < 10; i++)
+        print "Good ol' for loop"
+
+    # 标准的比较运算符
+    a < b   # 小于
+    a <= b  # 小于或等于
+    a != b  # 不等于
+    a == b  # 等于
+    a > b   # 大于
+    a >= b  # 大于或等于
+
+    # 也有逻辑运算符
+    a && b  # 且
+    a || b  # 或
+
+    # 并且有超实用的正则表达式匹配
+    if ("foo" ~ "^fo+$")
+        print "Fooey!"
+    if ("boo" !~ "^fo+$")
+        print "Boo!"
+
+    # 数组
+    arr[0] = "foo"
+    arr[1] = "bar"
+    # 不幸的是, 没有其他方式初始化数组. 必须像这样一行一行的赋值.
+
+    # 关联数组, 类似map或dict的用法.
+    assoc["foo"] = "bar"
+    assoc["bar"] = "baz"
+
+    # 多维数组. 但是有一些局限性这里不提了.
+    multidim[0,0] = "foo"
+    multidim[0,1] = "bar"
+    multidim[1,0] = "baz"
+    multidim[1,1] = "boo"
+
+    # 可以检测数组包含关系
+    if ("foo" in assoc)
+        print "Fooey!"
+
+    # 可以使用in遍历数组
+    for (key in assoc)
+        print assoc[key]
+
+    # 命令行参数是一个叫ARGV的数组
+    for (argnum in ARGV)
+        print ARGV[argnum]
+
+    # 可以从数组中移除元素
+    # 在 防止awk把文件参数当做数据来处理 时delete功能很有用.
+    delete ARGV[1]
+
+    # 命令行参数的个数是一个叫ARGC的变量
+    print ARGC
+
+    # AWK有很多内置函数, 分为三类, 会在接下来定义的各个函数中介绍.
+
+    return_value = arithmetic_functions(a, b, c)
+    string_functions()
+    io_functions()
+}
+
+# 定义函数
+function arithmetic_functions(a, b, c,     d) {
+
+    # 或许AWK最让人恼火的地方是没有局部变量, 所有东西都是全局的, 
+    # 对于短的脚本还好, 对于长一些的就会成问题.
+
+    # 这里有一个技巧, 函数参数是对函数局部可见的, 并且AWK允许定义多余的参数, 
+    # 因此可以像上面那样把局部变量插入到函数声明中. 
+    # 为了方便区分普通参数(a,b,c)和局部变量(d), 可以多键入一些空格.
+
+    # 现在介绍数学类函数
+
+    # 多数AWK实现中包含标准的三角函数
+    localvar = sin(a)
+    localvar = cos(a)
+    localvar = atan2(a, b) # arc tangent of b / a
+
+    # 对数
+    localvar = exp(a)
+    localvar = log(a)
+
+    # 平方根
+    localvar = sqrt(a)
+
+    # 浮点型转为整型
+    localvar = int(5.34) # localvar => 5
+
+    # 随机数
+    srand() # 接受随机种子作为参数, 默认使用当天的时间
+    localvar = rand() # 0到1之间随机
+
+    # 函数返回
+    return localvar
+}
+
+function string_functions(    localvar, arr) {
+
+    # AWK, 作为字符处理语言, 有很多字符串相关函数, 其中大多数都严重依赖正则表达式.
+
+    # 搜索并替换, 第一个出现的 (sub) or 所有的 (gsub)
+    # 都是返回替换的个数
+    localvar = "fooooobar"
+    sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar"
+    gsub("e+", ".", localvar) # localvar => "m..t m. at th. bar"
+
+    # 搜索匹配正则的字符串
+    # index() 也是搜索, 不支持正则
+    match(localvar, "t") # => 4, 't'在4号位置. 
+    # (译者注: awk是1开始计数的,不是常见的0-base)
+
+    # 按分隔符分隔
+    split("foo-bar-baz", arr, "-") # a => ["foo", "bar", "baz"]
+
+    # 其他有用的函数
+    sprintf("%s %d %d %d", "Testing", 1, 2, 3) # => "Testing 1 2 3"
+    substr("foobar", 2, 3) # => "oob"
+    substr("foobar", 4) # => "bar"
+    length("foo") # => 3
+    tolower("FOO") # => "foo"
+    toupper("foo") # => "FOO"
+}
+
+function io_functions(    localvar) {
+
+    # 你已经见过的print函数
+    print "Hello world"
+
+    # 也有printf
+    printf("%s %d %d %d\n", "Testing", 1, 2, 3)
+
+    # AWK本身没有文件句柄, 当你使用需要文件的东西时会自动打开文件, 
+    # 做文件I/O时, 字符串就是打开的文件句柄. 这看起来像Shell
+    print "foobar" >"/tmp/foobar.txt"
+
+    # 现在"/tmp/foobar.txt"字符串是一个文件句柄, 你可以关闭它
+    close("/tmp/foobar.txt")
+
+    # 在shell里运行一些东西
+    system("echo foobar") # => prints foobar
+
+    # 从标准输入中读一行, 并存储在localvar中
+    getline localvar
+
+    # 从管道中读一行, 并存储在localvar中
+    "echo foobar" | getline localvar # localvar => "foobar"
+    close("echo foobar")
+
+    # 从文件中读一行, 并存储在localvar中
+    getline localvar <"/tmp/foobar.txt"
+    close("/tmp/foobar.txt")
+}
+
+# 正如开头所说, AWK程序由一系列模式和动作组成. 你已经看见了重要的BEGIN pattern, 
+# 其他的pattern在你需要处理来自文件或标准输入的的数据行时才用到.
+# 
+# 当你给AWK程序传参数时, 他们会被视为要处理文件的文件名, 按顺序全部会处理. 
+# 可以把这个过程看做一个隐式的循环, 遍历这些文件中的所有行.
+# 然后这些模式和动作就是这个循环里的switch语句一样
+
+/^fo+bar$/ {
+    
+    # 这个动作会在匹配这个正则(/^fo+bar$/)的每一行上执行. 不匹配的则会跳过.
+    # 先让我们打印它:
+    print
+
+    # 哦, 没有参数, 那是因为print有一个默认参数 $0.
+    # $0 是当前正在处理的行, 自动被创建好了.
+
+    # 你可能猜到有其他的$变量了. 
+    # 每一行在动作执行前会被分隔符分隔. 像shell中一样, 每个字段都可以用$符访问
+
+    # 这个会打印这行的第2和第4个字段
+    print $2, $4
+
+    # AWK自动定义了许多其他的变量帮助你处理行. 最常用的是NF变量
+    # 打印这一行的字段数
+    print NF
+
+    # 打印这一行的最后一个字段
+    print $NF
+}
+
+# 每一个模式其实是一个true/false判断, 上面那个正则其实也是一个true/false判断, 只不过被部分省略了.
+# 没有指定时默认使用当前处理的整行($0)进行匹配. 因此, 完全版本是这样:
+
+$0 ~ /^fo+bar$/ {
+    print "Equivalent to the last pattern"
+}
+
+a > 0 {
+    # 只要a是整数, 这块会在每一行上执行.
+}
+
+# 就是这样, 处理文本文件, 一次读一行, 对行做一些操作. 
+# 按分隔符分隔, 这在UNIX中很常见, awk都帮你做好了.
+# 你所需要做的是基于自己的需求写一些模式和动作.
+
+# 这里有一个快速的例子, 展示了AWK所擅长做的事.
+# 它从标准输入读一个名字, 打印这个first name下所有人的平均年龄.
+# 示例数据:
+#
+# Bob Jones 32
+# Jane Doe 22
+# Steve Stevens 83
+# Bob Smith 29
+# Bob Barker 72
+#
+# 示例脚本:
+
+BEGIN {
+
+    # 首先, 问用户要一个名字
+    print "What name would you like the average age for?"
+
+    # 从标准输入获取名字
+    getline name <"/dev/stdin"
+}
+
+# 然后, 用给定的名字匹配每一行的第一个字段.
+$1 == name {
+
+    # 这里我们要使用几个有用的变量, 已经提前为我们加载好的:
+    # $0 是整行
+    # $3 是第三个字段, 就是我们所感兴趣的年龄
+    # NF 字段数, 这里是3
+    # NR 至此为止的行数
+    # FILENAME 在处理的文件名
+    # FS 在使用的字段分隔符, 这里是空格" "
+    # ...等等, 还有很多, 在帮助文档中列出.
+
+    # 跟踪 总和以及行数
+    sum += $3
+    nlines++
+}
+
+# 另一个特殊的模式叫END. 它会在处理完所有行之后运行. 不像BEGIN, 它只会在有输入的时候运行.
+# 它在所有文件依据给定的模式和动作处理完后运行, 目的通常是输出一些最终报告, 做一些数据聚合操作.
+
+END {
+    if (nlines)
+        print "The average age for " name " is " sum / nlines
+}
+
+```
+更多:
+
+* [Awk 教程](http://www.grymoire.com/Unix/Awk.html)
+* [Awk 手册](https://linux.die.net/man/1/awk)
+* [The GNU Awk 用户指南](https://www.gnu.org/software/gawk/manual/gawk.html) GNU Awk在大多数Linux中预装
diff --git a/zh-cn/c++-cn.html.markdown b/zh-cn/c++-cn.html.markdown
index 87951bc3..e0d6b6fe 100644
--- a/zh-cn/c++-cn.html.markdown
+++ b/zh-cn/c++-cn.html.markdown
@@ -567,6 +567,6 @@ void doSomethingWithAFile(const std::string& filename)
 ```

 扩展阅读：

 

-<http://cppreference.com/w/cpp> 提供了最新的语法参考。

-

-可以在 <http://cplusplus.com> 找到一些补充资料。

+* [CPP Reference](http://cppreference.com/w/cpp) 提供了最新的语法参考。

+* 可以在 [CPlusPlus](http://cplusplus.com) 找到一些补充资料。

+* 可以在 [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FFb）上找到涵盖语言基础和设置编码环境的教程。

diff --git a/zh-cn/c-cn.html.markdown b/zh-cn/c-cn.html.markdown
index 1e10416e..8566e811 100644
--- a/zh-cn/c-cn.html.markdown
+++ b/zh-cn/c-cn.html.markdown
@@ -41,7 +41,7 @@ enum days {SUN = 1, MON, TUE, WED, THU, FRI, SAT};
 void function_1(char c);
 void function_2(void);
 
-// 如果函数出现在main()之后，那么必须在main()之前
+// 如果函数调用在main()之后，那么必须声明在main()之前
 // 先声明一个函数原型
 int add_two_ints(int x1, int x2); // 函数原型
 
diff --git a/zh-cn/clojure-macro-cn.html.markdown b/zh-cn/clojure-macro-cn.html.markdown
index 9324841e..23b2f203 100644
--- a/zh-cn/clojure-macro-cn.html.markdown
+++ b/zh-cn/clojure-macro-cn.html.markdown
@@ -142,11 +142,9 @@ lang: zh-cn
 
 ## 扩展阅读
 
-[Clojure for the Brave and True](http://www.braveclojure.com/)系列的编写宏
-http://www.braveclojure.com/writing-macros/
+[Clojure for the Brave and True](http://www.braveclojure.com/)
+[系列的编写宏](http://www.braveclojure.com/writing-macros/)
 
-官方文档
-http://clojure.org/macros
+[官方文档](http://clojure.org/macros)
 
-何时使用宏？
-http://dunsmor.com/lisp/onlisp/onlisp_12.html
+[何时使用宏？](https://lispcast.com/when-to-use-a-macro/)
diff --git a/zh-cn/dart-cn.html.markdown b/zh-cn/dart-cn.html.markdown
index b0287f0c..79db8e5c 100644
--- a/zh-cn/dart-cn.html.markdown
+++ b/zh-cn/dart-cn.html.markdown
@@ -176,23 +176,47 @@ example13() {
   match(s2);
 }
 
-// 布尔表达式必需被解析为 true 或 false，
-// 因为不支持隐式转换。
+// 布尔表达式支持隐式转换以及动态类型
 example14() {
-  var v = true;
-  if (v) {
-    print("Example14 value is true");
+  var a = true;
+  if (a) {
+    print("Example14 true, a is $a");
   }
-  v = null;
+  a = null;
+  if (a) {
+    print("Example14 true, a is $a");
+  } else {
+    print("Example14 false, a is $a"); // 执行到这里
+  }
+
+  // 动态类型的null可以转换成bool型
+  var b;// b是动态类型
+  b = "abc";
   try {
-    if (v) {
-      // 不会执行
+    if (b) {
+      print("Example14 true, b is $b");
     } else {
-      // 不会执行
+      print("Example14 false, b is $b");
     }
   } catch (e) {
-    print("Example14 null value causes an exception: '${e}'");
+    print("Example14 error, b is $b"); // 这段代码可以执行但是会报错
   }
+  b = null;
+  if (b) {
+    print("Example14 true, b is $b");
+  } else {
+    print("Example14 false, b is $b"); // 这行到这里
+  }
+
+  // 静态类型的null不能转换成bool型
+  var c = "abc";
+  c = null;
+  // 编译出错
+  // if (c) {
+  //   print("Example14 true, c is $c");
+  // } else {
+  //   print("Example14 false, c is $c");
+  // }
 }
 
 // try/catch/finally 和 throw 语句用于异常处理。
diff --git a/zh-cn/fortran95-cn.html.markdown b/zh-cn/fortran95-cn.html.markdown
new file mode 100644
index 00000000..e28d309f
--- /dev/null
+++ b/zh-cn/fortran95-cn.html.markdown
@@ -0,0 +1,435 @@
+---
+language: Fortran
+filename: learnfortran-cn.f95
+contributors:
+    - ["Robert Steed", "https://github.com/robochat"]
+translators:
+    - ["Corvusnest", "https://github.com/Corvusnest"]
+lang: zh-cn
+---
+
+Fortran 是最古老的计算机语言之一。它由IBM开发于1950年用于数值运算（Fortran 为 "Formula
+Translation" 的缩写）。虽然该语言已年代久远，但目前仍用于高性能计算，如天气预报。
+该语言仍在持续发展，并且基本保持向下兼容。知名的版本为 Fortran 77, Fortran 90,
+Fortran 95, Fortran 2003, Fortran 2008 与 Fortran 2015。
+
+这篇概要将讨论 Fortran 95 的一些特征。因为它是目前所广泛采用的标准版本，并且与最新版本的内容
+也基本相同（而 Fortran 77 则是一个非常不同的版本）。
+
+```fortran
+
+! 这是一行注释
+
+
+program example   !声明一个叫做 example 的程序
+
+    ! 代码只能放在程序、函数、子程序或者模块内部
+    ! 推荐使用缩进，但不是必须的。
+
+    ! 声明变量
+    ! ===================
+
+    ! 所有的声明必须放在语句与表达式之前
+
+    implicit none    !阻止变量的隐式声明 (推荐!)
+    ! Implicit none 必须在每一个 函数/程序/模块 中进行声明
+
+    ! 重要  - Fortran 对大小写不敏感
+    real z
+    REAL Z2
+
+    real :: v,x    ! 警告: 默认值取决于编译器!    
+    real :: a = 3, b=2E12, c = 0.01
+    integer :: i, j, k=1, m
+    real, parameter :: PI = 3.1415926535897931    !声明一个常量
+    logical :: y = .TRUE. , n = .FALSE.    !布尔值
+    complex :: w = (0,1)    !sqrt(-1) (译注: 定义复数，此为-1的平方根)
+    character (len=3) :: month    !长度为3的字符串
+
+    real :: array(6)     !声明长度为6的浮点数数组
+    real, dimension(4) :: arrayb    !声明数组的另一种方法
+    integer :: arrayc(-10:10)   !有着自定义索引的数组
+    real :: array2d(3,2)    !多维数组
+
+    ! 分隔符 '::' 并不总是必要的，但推荐使用
+
+    ! 还存在很多其他的变量特征:
+    real, pointer :: p    !声明一个指针
+
+    integer, parameter :: LP = selected_real_kind(20)
+    real (kind = LP) :: d    !长精度变量
+
+    ! 警告：在声明期间初始化变量将导致在函数内发生问题，因为这将自动具备了 “save” 属性，
+    ! 因此变量的值在函数的多次调用期间将被存储。一般来说，除了常量，应分开声明与初始化！
+
+    ! 字符串
+    ! =======
+
+    character :: a_char = 'i'
+    character (len = 6) :: a_str = "qwerty"
+    character (len = 30) :: str_b
+    character (len = *), parameter :: a_long_str = "This is a long string."
+    !可以通过使用 (len=*) 来自动判断长度，但只对常量有效
+
+    str_b = a_str // " keyboard"    !通过 // 操作符来连接字符串
+
+
+    ! 任务与计算
+    ! =======================
+
+    Z = 1    !向之前声明的变量 z 赋值 (大小写不敏感).
+    j = 10 + 2 - 3
+    a = 11.54  /  (2.3 * 3.1)
+    b = 2**3    !幂
+
+
+    ! 控制流程语句 与 操作符
+    ! ===================================
+
+    !单行 if 语句
+    if (z == a) b = 4  !判别句永远需要放在圆括号内
+
+    if (z /= a) then !z 不等于 a
+    ! 其他的比较运算符： < > <= >= == /=
+      b = 4
+    else if (z .GT. a) then !z 大于(Greater) a
+    ! 文本形式的比较运算符: .LT. .GT. .LE. .GE. .EQ. .NE.  
+      b = 6
+    else if (z < a) then !'then' 必须放在该行
+      b = 5 !执行部分必须放在新的一行里
+    else
+      b = 10
+    end if !结束语句需要 'if' (也可以用 'endif').
+
+
+    if (.NOT. (x < c .AND. v >= a .OR. z == z)) then   !布尔操作符
+      inner: if (.TRUE.) then    !可以为 if 结构命名
+        b = 1
+      endif inner    !接下来必须命名 endif 语句.
+    endif
+
+
+    i = 20
+    select case (i)
+      case (0)    !当 i == 0
+        j=0
+      case (1:10)    !当 i 为 1 到 10 之内 ( 1 <= i <= 10 )
+        j=1
+      case (11:)    !当 i>=11
+        j=2
+      case default
+        j=3
+    end select
+
+
+    month = 'jan'
+    ! 状态值可以为整数、布尔值或者字符类型
+    ! Select 结构同样可以被命名
+    monthly: select case (month)
+      case ("jan")
+         j = 0
+      case default
+         j = -1
+    end select monthly
+
+    do i=2,10,2    !从2到10(包含2和10)以2为步进值循环
+      innerloop: do j=1,3    !循环同样可以被命名
+        exit    !跳出循环
+      end do innerloop
+    cycle    !重复跳入下一次循环
+    enddo
+
+
+    ! Goto 语句是存在的，但强烈不建议使用
+    goto 10    
+    stop 1    !立即停止程序 (返回一个设定的状态码).
+10  j = 201    !这一行被标注为 10 行 （line 10）
+
+
+    ! 数组
+    ! ======
+    array = (/1,2,3,4,5,6/)
+    array = [1,2,3,4,5,6]    !当使用 Fortran 2003 版本.
+    arrayb = [10.2,3e3,0.41,4e-5]
+    array2d =  reshape([1.0,2.0,3.0,4.0,5.0,6.0], [3,2])
+
+    ! Fortran 数组索引起始于 1
+    ! (默认下如此，也可以为数组定义不同的索引起始)
+    v = array(1)    !获取数组的第一个元素
+    v = array2d(2,2)
+
+    print *, array(3:5)    !打印从第3到第五5之内的所有元素
+    print *, array2d(1,:)    !打印2维数组的第一列
+
+    array = array*3 + 2    !可为数组设置数学表达式
+    array = array*array    !数组操作支持元素级(操作) (element-wise)
+    !array = array*array2d    !这两类数组并不是同一个维度的
+
+    ! 有很多内置的数组操作函数
+    c = dot_product(array,array)    !点乘 (点积)
+    ! 用 matmul() 来进行矩阵运算.
+    c = sum(array)
+    c = maxval(array)
+    print *, minloc(array)
+    c = size(array)
+    print *, shape(array)
+    m = count(array > 0)
+
+    ! 遍历一个数组 (一般使用 Product() 函数).
+    v = 1
+    do i = 1, size(array)
+        v = v*array(i)
+    end do
+
+    ! 有条件地执行元素级操作
+    array = [1,2,3,4,5,6]
+    where (array > 3)
+        array = array + 1
+    elsewhere (array == 2)
+        array = 1
+    elsewhere
+        array = 0
+    end where
+
+    ! 隐式DO循环可以很方便地创建数组
+    array = [ (i, i = 1,6) ]    !创建数组 [1,2,3,4,5,6]
+    array = [ (i, i = 1,12,2) ]    !创建数组 [1,3,5,7,9,11]
+    array = [ (i**2, i = 1,6) ]    !创建数组  [1,4,9,16,25,36]
+    array = [ (4,5, i = 1,3) ]    !创建数组 [4,5,4,5,4,5]
+
+
+    ! 输入/输出
+    ! ============
+
+    print *, b    !向命令行打印变量 'b'
+
+    ! 我们可以格式化输出
+    print "(I6)", 320    !打印 '   320'
+    print "(I6.4)", 3    !打印 '  0003'
+    print "(F6.3)", 4.32    !打印 ' 4.320'
+
+
+    ! 该字母与数值规定了给定的数值与字符所用于打印输出的类型与格式
+    ! 字母可为 I (整数), F (浮点数), E (工程格式),
+    ! L (逻辑/布尔值), A (字符) ...
+    print "(I3)", 3200    !如果数值无法符合格式将打印 '***'
+
+    ! 可以同时设定多种格式
+    print "(I5,F6.2,E6.2)", 120, 43.41, 43.41
+    print "(3I5)", 10, 20, 30    !连续打印3个整数 (字段宽度 = 5).
+    print "(2(I5,F6.2))", 120, 43.42, 340, 65.3   !连续分组格式
+
+    ! 我们也可以从终端读取输入
+    read *, v
+    read "(2F6.2)", v, x    !读取2个数值
+
+    ! 读取文件
+    open(unit=11, file="records.txt", status="old")
+    ! 文件被引用带有一个单位数 'unit', 为一个取值范围在9-99的整数
+    ! 'status' 可以为 {'old','replace','new'} 其中之一
+    read(unit=11, fmt="(3F10.2)") a, b, c
+    close(11)
+
+    ! 写入一个文件
+    open(unit=12, file="records.txt", status="replace")
+    write(12, "(F10.2,F10.2,F10.2)") c, b, a
+    close(12)
+    ! 在讨论范围之外的还有更多的细节与可用功能，并于老版本的 Fortran 保持兼容
+
+
+    ! 内置函数
+    ! ==================
+
+    ! Fortran 拥有大约 200 个内置函数/子程序
+    ! 例子
+    call cpu_time(v)    !以秒为单位设置时间
+    k = ior(i,j)    !2个整数的位或运算
+    v = log10(x)    !以10为底的log运算
+    i = floor(b)    !返回一个最接近的整数小于或等于x (地板数)
+    v = aimag(w)    !复数的虚数部分
+
+
+    ! 函数与子程序
+    ! =======================
+
+    ! 一个子程序会根据输入值运行一些代码并会导致副作用 (side-effects) 或修改输入值
+    ! (译者注: 副作用是指对子程序/函数外的环境产生影响，如修改变量)
+
+    call routine(a,c,v)    !调用子程序
+
+    ! 一个函数会根据输入的一系列数值来返回一个单独的值
+    ! 但输入值仍然可能被修改以及产生副作用
+
+    m = func(3,2,k)  !调用函数
+
+    ! 函数可以在表达式内被调用
+    Print *, func2(3,2,k)
+
+    ! 一个纯函数不会去修改输入值或产生副作用
+    m = func3(3,2,k)
+
+
+contains ! 用于定义程序内部的副程序(sub-programs)的区域
+
+    ! Fortran 拥有一些不同的方法去定义函数
+
+    integer function func(a,b,c)    !一个返回一个整数的函数
+        implicit none   !最好也在函数内将含蓄模式关闭 (implicit none)
+        integer :: a,b,c !输入值类型定义在函数内部
+        if (a >= 2) then
+            func = a + b + c !返回值默认为函数名
+            return !可以在函数内任意时间返回当前值
+        endif
+        func = a + c
+        ! 在函数的结尾不需要返回语句
+    end function func
+
+
+    function func2(a,b,c) result(f)    !将返回值声明为 'f'
+        implicit none
+        integer, intent(in) :: a,b    !可以声明让变量无法被函数修改
+        integer, intent(inout) :: c
+        integer :: f     !函数的返回值类型在函数内声明
+        integer :: cnt = 0    !注意 - 隐式的初始化变量将在函数的多次调用间被存储
+        f = a + b - c
+        c = 4    !变动一个输入变量的值
+        cnt  = cnt + 1    !记录函数的被调用次数
+    end function func2
+
+
+    pure function func3(a,b,c)  !一个没有副作用的纯函数
+        implicit none
+        integer, intent(in) :: a,b,c
+        integer :: func3
+        func3 = a*b*c
+    end function func3
+
+
+    subroutine routine(d,e,f)
+        implicit none
+        real, intent(inout) :: f
+        real, intent(in) :: d,e
+        f = 2*d + 3*e + f
+    end subroutine routine
+
+
+end program example   ! 函数定义完毕 -----------------------
+
+! 函数与子程序的外部声明对于生成程序清单来说，需要一个接口声明（即使它们在同一个源文件内）(见下)
+! 使用 'contains' 可以很容易地在模块或程序内定义它们
+
+elemental real function func4(a) result(res)
+! 一个元函数(elemental function) 为一个纯函数使用一个标量输入值
+! 但同时也可以用在一个数组并对其中的元素分别处理，之后返回一个新的数组
+    real, intent(in) :: a
+    res = a**2 + 1.0
+end function func4
+
+
+! 模块
+! =======
+
+! 模块十分适合于存放与复用相关联的一组声明、函数与子程序
+
+module fruit
+    real :: apple
+    real :: pear
+    real :: orange
+end module fruit
+
+
+module fruity
+
+    ! 声明必须按照顺序: 模块、接口、变量
+    ! (同样可在程序内声明模块和接口)
+
+    use fruit, only: apple, pear    ! 使用来自于 fruit 模块的 apple 和 pear
+    implicit none    !在模块导入后声明
+
+    private    !使得模块内容为私有(private)(默认为公共 public)
+    ! 显式声明一些变量/函数为公共
+    public :: apple,mycar,create_mycar
+    ! 声明一些变量/函数为私有(在当前情况下没必要)(译注: 因为前面声明了模块全局 private)
+    private :: func4
+
+    ! 接口
+    ! ==========
+    ! 在模块内显式声明一个外部函数/程序
+    ! 一般最好将函数/程序放进 'contains' 部分内
+    interface
+        elemental real function func4(a) result(res)
+            real, intent(in) :: a
+        end function func4
+    end interface
+
+    ! 重载函数可以通过已命名的接口来定义
+    interface myabs
+        ! 可以通过使用 'module procedure' 关键词来包含一个已在模块内定义的函数
+        module procedure real_abs, complex_abs
+    end interface
+
+    ! 派生数据类型
+    ! ==================
+    ! 可创建自定义数据结构
+    type car
+        character (len=100) :: model
+        real :: weight    !(公斤 kg)
+        real :: dimensions(3)    !例: 长宽高(米)
+        character :: colour
+    end type car
+
+    type(car) :: mycar    !声明一个自定义类型的变量
+    ! 用法具体查看 create_mycar()
+
+    ! 注: 模块内没有可执行的语句
+
+contains
+
+    subroutine create_mycar(mycar)
+        ! 展示派生数据类型的使用
+        implicit none
+        type(car),intent(out) :: mycar
+
+        ! 通过 '%' 操作符来访问(派生数据)类型的元素
+        mycar%model = "Ford Prefect"
+        mycar%colour = 'r'
+        mycar%weight = 1400
+        mycar%dimensions(1) = 5.0    !索引默认起始值为 1 !
+        mycar%dimensions(2) = 3.0
+        mycar%dimensions(3) = 1.5
+
+    end subroutine
+
+    real function real_abs(x)
+        real :: x
+        if (x<0) then
+            real_abs = -x
+        else
+            real_abs = x
+        end if
+    end function real_abs
+
+    real function complex_abs(z)
+        complex :: z
+        ! 过长的一行代码可通过延续符 '&' 来换行
+        complex_abs = sqrt(real(z)**2 + &
+                                         aimag(z)**2)
+    end function complex_abs
+
+
+end module fruity
+
+```
+
+### 更多资源
+
+了解更多的 Fortran 信息:
+
++ [wikipedia](https://en.wikipedia.org/wiki/Fortran)
++ [Fortran_95_language_features](https://en.wikipedia.org/wiki/Fortran_95_language_features)
++ [fortranwiki.org](http://fortranwiki.org)
++ [www.fortran90.org/](http://www.fortran90.org)
++ [list of Fortran 95 tutorials](http://www.dmoz.org/Computers/Programming/Languages/Fortran/FAQs%2C_Help%2C_and_Tutorials/Fortran_90_and_95/)
++ [Fortran wikibook](https://en.wikibooks.org/wiki/Fortran)
++ [Fortran resources](http://www.fortranplus.co.uk/resources/fortran_resources.pdf)
++ [Mistakes in Fortran 90 Programs That Might Surprise You](http://www.cs.rpi.edu/~szymansk/OOF90/bugs.html)
diff --git a/zh-cn/git-cn.html.markdown b/zh-cn/git-cn.html.markdown
index 4ef3ffb8..d471ab5d 100644
--- a/zh-cn/git-cn.html.markdown
+++ b/zh-cn/git-cn.html.markdown
@@ -131,7 +131,7 @@ $ git help init
 
 
 ```bash
-# 显示分支，为跟踪文件，更改和其他不同
+# 显示分支，未跟踪文件，更改和其他不同
 $ git status
 
 # 查看其他的git status的用法
diff --git a/zh-cn/julia-cn.html.markdown b/zh-cn/julia-cn.html.markdown
index 1f91d52c..b350b6dc 100644
--- a/zh-cn/julia-cn.html.markdown
+++ b/zh-cn/julia-cn.html.markdown
@@ -2,16 +2,24 @@
 language: Julia
 filename: learn-julia-zh.jl
 contributors:
-    - ["Jichao Ouyang", "http://oyanglul.us"]
+    - ["Leah Hanson", "http://leahhanson.us"]
+    - ["Pranit Bauva", "https://github.com/pranitbauva1997"]
+    - ["Daniel YC Lin", "https://github.com/dlintw"]
 translators:
     - ["Jichao Ouyang", "http://oyanglul.us"]
+    - ["woclass", "https://github.com/inkydragon"]
 lang: zh-cn
 ---
 
-```ruby
-# 单行注释只需要一个井号
+Julia 是一种新的同像函数式编程语言(homoiconic functional language)，它专注于科学计算领域。
+虽然拥有同像宏(homoiconic macros)、一级函数(first-class functions)和底层控制等全部功能，但 Julia 依旧和 Python 一样易于学习和使用。
+
+示例代码基于 Julia 1.0.0
+
+```julia
+# 单行注释只需要一个井号「#」
 #= 多行注释
-   只需要以 '#=' 开始 '=#' 结束
+   只需要以「#=」开始「=#」结束
    还可以嵌套.
 =#
 
@@ -19,41 +27,41 @@ lang: zh-cn
 ## 1. 原始类型与操作符
 ####################################################
 
-# Julia 中一切皆是表达式。
-
-# 这是一些基本数字类型.
-3 # => 3 (Int64)
-3.2 # => 3.2 (Float64)
-2 + 1im # => 2 + 1im (Complex{Int64})
-2//3 # => 2//3 (Rational{Int64})
-
-# 支持所有的普通中缀操作符。
-1 + 1 # => 2
-8 - 1 # => 7
-10 * 2 # => 20
-35 / 5 # => 7.0
-5 / 2 # => 2.5 # 用 Int 除 Int 永远返回 Float
-div(5, 2) # => 2 # 使用 div 截断小数点
-5 \ 35 # => 7.0
-2 ^ 2 # => 4 # 次方, 不是二进制 xor
-12 % 10 # => 2
+# Julia 中一切皆为表达式
+
+# 这是一些基本数字类型
+typeof(3)       # => Int64
+typeof(3.2)     # => Float64
+typeof(2 + 1im) # => Complex{Int64}
+typeof(2 // 3)  # => Rational{Int64}
+
+# 支持所有的普通中缀操作符
+1 + 1      # => 2
+8 - 1      # => 7
+10 * 2     # => 20
+35 / 5     # => 7.0
+10 / 2     # => 5.0  # 整数除法总是返回浮点数
+div(5, 2)  # => 2    # 使用 div 可以获得整除的结果
+5 \ 35     # => 7.0
+2^2        # => 4    # 幂运算，不是异或 (xor)
+12 % 10    # => 2
 
 # 用括号提高优先级
 (1 + 3) * 2 # => 8
 
-# 二进制操作符
-~2 # => -3   # 非
-3 & 5 # => 1 # 与
-2 | 4 # => 6 # 或
-2 $ 4 # => 6 # 异或
-2 >>> 1 # => 1 # 逻辑右移
-2 >> 1  # => 1 # 算术右移
-2 << 1  # => 4 # 逻辑/算术 右移
-
-# 可以用函数 bits 查看二进制数。
-bits(12345)
+# 位操作符
+~2         # => -3 # 按位非 (not)
+3 & 5      # => 1  # 按位与 (and)
+2 | 4      # => 6  # 按位或 (or)
+xor(2, 4)  # => 6  # 按位异或 (xor)
+2 >>> 1    # => 1  # 逻辑右移
+2 >> 1     # => 1  # 算术右移
+2 << 1     # => 4  # 逻辑/算术左移
+
+# 可以用函数 bitstring 查看二进制数。
+bitstring(12345)
 # => "0000000000000000000000000000000000000000000000000011000000111001"
-bits(12345.0)
+bitstring(12345.0)
 # => "0100000011001000000111001000000000000000000000000000000000000000"
 
 # 布尔值是原始类型
@@ -61,40 +69,50 @@ true
 false
 
 # 布尔操作符
-!true # => false
-!false # => true
-1 == 1 # => true
-2 == 1 # => false
-1 != 1 # => false
-2 != 1 # => true
-1 < 10 # => true
-1 > 10 # => false
-2 <= 2 # => true
-2 >= 2 # => true
-# 比较可以串联
+!true   # => false
+!false  # => true
+1 == 1  # => true
+2 == 1  # => false
+1 != 1  # => false
+2 != 1  # => true
+1 < 10  # => true
+1 > 10  # => false
+2 <= 2  # => true
+2 >= 2  # => true
+
+# 链式比较
 1 < 2 < 3 # => true
 2 < 3 < 2 # => false
 
-# 字符串可以由 " 创建
+# 字符串可以由「"」创建
 "This is a string."
 
-# 字符字面量可用 ' 创建
+# 字符字面量可用「'」创建
 'a'
 
+# 字符串使用 UTF-8 编码
 # 可以像取数组取值一样用 index 取出对应字符
-"This is a string"[1] # => 'T' # Julia 的 index 从 1 开始 :(
-# 但是对 UTF-8 无效,
-# 因此建议使用遍历器 (map, for loops, 等).
+ascii("This is a string")[1]
+# => 'T': ASCII/Unicode U+0054 (category Lu: Letter, uppercase) 
+# Julia 的 index 从 1 开始 :(
+# 但只有在字符串仅由 ASCII 字符构成时，字符串才能够被安全的引索
+# 因此建议使用遍历器 (map, for loops, 等)
 
 # $ 可用于字符插值:
 "2 + 2 = $(2 + 2)" # => "2 + 2 = 4"
 # 可以将任何 Julia 表达式放入括号。
 
-# 另一种格式化字符串的方式是 printf 宏.
-@printf "%d is less than %f" 4.5 5.3 # 5 is less than 5.300000
+# 另一种输出格式化字符串的方法是使用标准库 Printf 中的 Printf 宏
+using Printf
+@printf "%d is less than %f\n" 4.5 5.3  # => 5 is less than 5.300000
 
 # 打印字符串很容易
-println("I'm Julia. Nice to meet you!")
+println("I'm Julia. Nice to meet you!") # => I'm Julia. Nice to meet you!
+
+# 字符串可以按字典序进行比较
+"good" > "bye" # => true
+"good" == "good" # => true
+"1 + 2 = 3" == "1 + 2 = $(1 + 2)" # => true
 
 ####################################################
 ## 2. 变量与集合
@@ -106,12 +124,12 @@ some_var # => 5
 
 # 访问未声明变量会抛出异常
 try
-    some_other_var # => ERROR: some_other_var not defined
+    some_other_var # => ERROR: UndefVarError: some_other_var not defined
 catch e
     println(e)
 end
 
-# 变量名需要以字母开头.
+# 变量名必须以下划线或字母开头
 # 之后任何字母，数字，下划线，叹号都是合法的。
 SomeOtherVar123! = 6 # => 6
 
@@ -122,66 +140,93 @@ SomeOtherVar123! = 6 # => 6
 
 # 注意 Julia 的命名规约:
 #
-# * 变量名为小写，单词之间以下划线连接('\_')。
+# * 名称可以用下划线「_」分割。
+#   不过一般不推荐使用下划线，除非不用变量名就会变得难于理解
 #
-# * 类型名以大写字母开头，单词以 CamelCase 方式连接。
+# * 类型名以大写字母开头，单词以 CamelCase 方式连接，无下划线。
 #
 # * 函数与宏的名字小写，无下划线。
 #
-# * 会改变输入的函数名末位为 !。
+# * 会改变输入的函数名末位为「!」。
 #   这类函数有时被称为 mutating functions 或 in-place functions.
 
-# 数组存储一列值，index 从 1 开始。
-a = Int64[] # => 0-element Int64 Array
+# 数组存储一列值，index 从 1 开始
+a = Int64[]  # => 0-element Array{Int64,1}
+
+# 一维数组可以以逗号分隔值的方式声明
+b = [4, 5, 6]  # => 3-element Array{Int64,1}: [4, 5, 6]
+b = [4; 5; 6]  # => 3-element Array{Int64,1}: [4, 5, 6]
+b[1]    # => 4
+b[end]  # => 6
 
-# 一维数组可以以逗号分隔值的方式声明。
-b = [4, 5, 6] # => 包含 3 个 Int64 类型元素的数组: [4, 5, 6]
-b[1] # => 4
-b[end] # => 6
+# 二维数组以分号分隔维度
+matrix = [1 2; 3 4]  # => 2×2 Array{Int64,2}: [1 2; 3 4]
 
-# 二维数组以分号分隔维度。
-matrix = [1 2; 3 4] # => 2x2 Int64 数组: [1 2; 3 4]
+# 指定数组的类型
+b = Int8[4, 5, 6]  # => 3-element Array{Int8,1}: [4, 5, 6]
 
 # 使用 push! 和 append! 往数组末尾添加元素
-push!(a,1)     # => [1]
-push!(a,2)     # => [1,2]
-push!(a,4)     # => [1,2,4]
-push!(a,3)     # => [1,2,4,3]
-append!(a,b) # => [1,2,4,3,4,5,6]
+push!(a, 1)    # => [1]
+push!(a, 2)    # => [1,2]
+push!(a, 4)    # => [1,2,4]
+push!(a, 3)    # => [1,2,4,3]
+append!(a, b)  # => [1,2,4,3,4,5,6]
 
-# 用 pop 弹出末尾元素
-pop!(b)        # => 6 and b is now [4,5]
+# 用 pop 弹出尾部的元素
+pop!(b)  # => 6
+b # => [4,5]
 
-# 可以再放回去
-push!(b,6)   # b 又变成了 [4,5,6].
+# 再放回去
+push!(b, 6)  # => [4,5,6]
+b # => [4,5,6]
 
-a[1] # => 1 #  永远记住 Julia 的 index 从 1 开始!
+a[1] # => 1 #  永远记住 Julia 的引索从 1 开始！而不是 0！
 
-# 用 end 可以直接取到最后索引. 可用作任何索引表达式
+# 用 end 可以直接取到最后索引。它可以用在任何索引表达式中
 a[end] # => 6
 
-# 还支持 shift 和 unshift
-shift!(a) # => 返回 1，而 a 现在时 [2,4,3,4,5,6]
-unshift!(a,7) # => [7,2,4,3,4,5,6]
+# 数组还支持 popfirst! 和 pushfirst!
+popfirst!(a)  # => 1 
+a # => [2,4,3,4,5,6]
+pushfirst!(a, 7)  # => [7,2,4,3,4,5,6]
+a # => [7,2,4,3,4,5,6]
 
 # 以叹号结尾的函数名表示它会改变参数的值
-arr = [5,4,6] # => 包含三个 Int64 元素的数组: [5,4,6]
-sort(arr) # => [4,5,6]; arr 还是 [5,4,6]
-sort!(arr) # => [4,5,6]; arr 现在是 [4,5,6]
+arr = [5,4,6]  # => 3-element Array{Int64,1}: [5,4,6]
+sort(arr)   # => [4,5,6]
+arr         # => [5,4,6]
+sort!(arr)  # => [4,5,6]
+arr         # => [4,5,6]
 
-# 越界会抛出 BoundsError 异常
+# 数组越界会抛出 BoundsError
 try
-    a[0] # => ERROR: BoundsError() in getindex at array.jl:270
-    a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270
+    a[0] 
+    # => ERROR: BoundsError: attempt to access 7-element Array{Int64,1} at 
+    # index [0]
+    # => Stacktrace:
+    # =>  [1] getindex(::Array{Int64,1}, ::Int64) at .\array.jl:731
+    # =>  [2] top-level scope at none:0
+    # =>  [3] ...
+    # => in expression starting at ...\LearnJulia.jl:203
+    a[end + 1] 
+    # => ERROR: BoundsError: attempt to access 7-element Array{Int64,1} at 
+    # index [8]
+    # => Stacktrace:
+    # =>  [1] getindex(::Array{Int64,1}, ::Int64) at .\array.jl:731
+    # =>  [2] top-level scope at none:0
+    # =>  [3] ...
+    # => in expression starting at ...\LearnJulia.jl:211
 catch e
     println(e)
 end
 
-# 错误会指出发生的行号，包括标准库
-# 如果你有 Julia 源代码，你可以找到这些地方
+# 报错时错误会指出出错的文件位置以及行号，标准库也一样
+# 你可以在 Julia 安装目录下的 share/julia 文件夹里找到这些标准库
 
 # 可以用 range 初始化数组
-a = [1:5] # => 5-element Int64 Array: [1,2,3,4,5]
+a = [1:5;]  # => 5-element Array{Int64,1}: [1,2,3,4,5]
+# 注意！分号不可省略
+a2 = [1:5]  # => 1-element Array{UnitRange{Int64},1}: [1:5]
 
 # 可以切割数组
 a[1:3] # => [1, 2, 3]
@@ -189,11 +234,13 @@ a[2:end] # => [2, 3, 4, 5]
 
 # 用 splice! 切割原数组
 arr = [3,4,5]
-splice!(arr,2) # => 4 ; arr 变成了 [3,5]
+splice!(arr, 2) # => 4 
+arr # => [3,5]
 
 # 用 append! 连接数组
 b = [1,2,3]
-append!(a,b) # a 变成了 [1, 2, 3, 4, 5, 1, 2, 3]
+append!(a, b) # => [1, 2, 3, 4, 5, 1, 2, 3]
+a # => [1, 2, 3, 4, 5, 1, 2, 3]
 
 # 检查元素是否在数组中
 in(1, a) # => true
@@ -201,240 +248,258 @@ in(1, a) # => true
 # 用 length 获得数组长度
 length(a) # => 8
 
-# Tuples 是 immutable 的
-tup = (1, 2, 3) # => (1,2,3) # an (Int64,Int64,Int64) tuple.
+# 元组(Tuples)是不可变的
+tup = (1, 2, 3)  # => (1,2,3)
+typeof(tup) # => Tuple{Int64,Int64,Int64}
 tup[1] # => 1
-try:
-    tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64)
+try
+    tup[1] = 3  
+    # => ERROR: MethodError: no method matching 
+    # setindex!(::Tuple{Int64,Int64,Int64}, ::Int64, ::Int64)
 catch e
     println(e)
 end
 
-# 大多数组的函数同样支持 tuples
+# 大多数组的函数同样支持元组
 length(tup) # => 3
-tup[1:2] # => (1,2)
-in(2, tup) # => true
+tup[1:2]    # => (1,2)
+in(2, tup)  # => true
 
-# 可以将 tuples 元素分别赋给变量
-a, b, c = (1, 2, 3) # => (1,2,3)  # a is now 1, b is now 2 and c is now 3
+# 可以将元组的元素解包赋给变量
+a, b, c = (1, 2, 3)  # => (1,2,3)  
+a # => 1
+b # => 2
+c # => 3
 
 # 不用括号也可以
-d, e, f = 4, 5, 6 # => (4,5,6)
+d, e, f = 4, 5, 6  # => (4,5,6)
+d # => 4
+e # => 5
+f # => 6
 
 # 单元素 tuple 不等于其元素值
 (1,) == 1 # => false
-(1) == 1 # => true
+(1) == 1  # => true
 
 # 交换值
-e, d = d, e  # => (5,4) # d is now 5 and e is now 4
+e, d = d, e  # => (5,4) 
+d # => 5
+e # => 4
 
 
-# 字典Dictionaries store mappings
-empty_dict = Dict() # => Dict{Any,Any}()
+# 字典用于储存映射(mappings)（键值对）
+empty_dict = Dict()  # => Dict{Any,Any} with 0 entries
 
 # 也可以用字面量创建字典
-filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3]
-# => Dict{ASCIIString,Int64}
+filled_dict = Dict("one" => 1, "two" => 2, "three" => 3)
+# => Dict{String,Int64} with 3 entries:
+# =>  "two" => 2, "one" => 1, "three" => 3
 
 # 用 [] 获得键值
 filled_dict["one"] # => 1
 
 # 获得所有键
 keys(filled_dict)
-# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# => Base.KeySet for a Dict{String,Int64} with 3 entries. Keys:
+# =>  "two", "one", "three"
 # 注意，键的顺序不是插入时的顺序
 
 # 获得所有值
 values(filled_dict)
-# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# => Base.ValueIterator for a Dict{String,Int64} with 3 entries. Values: 
+# =>  2, 1, 3
 # 注意，值的顺序也一样
 
 # 用 in 检查键值是否已存在，用 haskey 检查键是否存在
-in(("one", 1), filled_dict) # => true
-in(("two", 3), filled_dict) # => false
-haskey(filled_dict, "one") # => true
-haskey(filled_dict, 1) # => false
+in(("one" => 1), filled_dict)  # => true
+in(("two" => 3), filled_dict)  # => false
+haskey(filled_dict, "one")     # => true
+haskey(filled_dict, 1)         # => false
 
 # 获取不存在的键的值会抛出异常
 try
-    filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489
+    filled_dict["four"]  # => ERROR: KeyError: key "four" not found
 catch e
     println(e)
 end
 
 # 使用 get 可以提供默认值来避免异常
 # get(dictionary,key,default_value)
-get(filled_dict,"one",4) # => 1
-get(filled_dict,"four",4) # => 4
+get(filled_dict, "one", 4)   # => 1
+get(filled_dict, "four", 4)  # => 4
 
-# 用 Sets 表示无序不可重复的值的集合
-empty_set = Set() # => Set{Any}()
-# 初始化一个 Set 并定义其值
-filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4)
+# Set 表示无序不可重复的值的集合
+empty_set = Set()  # => Set(Any[])
+# 初始化一个带初值的 Set
+filled_set = Set([1, 2, 2, 3, 4])  # => Set([4, 2, 3, 1])
 
-# 添加值
-push!(filled_set,5) # => Set{Int64}(5,4,2,3,1)
+# 新增值
+push!(filled_set, 5)  # => Set([4, 2, 3, 5, 1])
 
-# 检查是否存在某值
-in(2, filled_set) # => true
-in(10, filled_set) # => false
+# 检查 Set 中是否存在某值
+in(2, filled_set)   # => true
+in(10, filled_set)  # => false
 
 # 交集，并集，差集
-other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3)
-intersect(filled_set, other_set) # => Set{Int64}(3,4,5)
-union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6)
-setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4)
-
+other_set = Set([3, 4, 5, 6])         # => Set([4, 3, 5, 6])
+intersect(filled_set, other_set)      # => Set([4, 3, 5])
+union(filled_set, other_set)          # => Set([4, 2, 3, 5, 6, 1])
+setdiff(Set([1,2,3,4]), Set([2,3,5])) # => Set([4, 1])
 
 ####################################################
-## 3. 控制流
+## 3. 控制语句
 ####################################################
 
 # 声明一个变量
 some_var = 5
 
-# 这是一个 if 语句，缩进不是必要的
+# 这是一个 if 语句块，其中的缩进不是必须的
 if some_var > 10
     println("some_var is totally bigger than 10.")
-elseif some_var < 10    # elseif 是可选的.
+elseif some_var < 10    # elseif 是可选的
     println("some_var is smaller than 10.")
-else                    # else 也是可选的.
+else                    # else 也是可选的
     println("some_var is indeed 10.")
 end
-# => prints "some var is smaller than 10"
+# => some_var is smaller than 10.
 
 
 # For 循环遍历
-# Iterable 类型包括 Range, Array, Set, Dict, 以及 String.
-for animal=["dog", "cat", "mouse"]
+# 可迭代的类型包括：Range, Array, Set, Dict 和 AbstractString
+for animal = ["dog", "cat", "mouse"]
     println("$animal is a mammal")
-    # 可用 $ 将 variables 或 expression 转换为字符串into strings
+    # 你可以用 $ 将变量或表达式插入字符串中 
 end
-# prints:
-#    dog is a mammal
-#    cat is a mammal
-#    mouse is a mammal
+# => dog is a mammal
+# => cat is a mammal
+# => mouse is a mammal
 
-# You can use 'in' instead of '='.
+# 你也可以不用「=」而使用「in」
 for animal in ["dog", "cat", "mouse"]
     println("$animal is a mammal")
 end
-# prints:
-#    dog is a mammal
-#    cat is a mammal
-#    mouse is a mammal
+# => dog is a mammal
+# => cat is a mammal
+# => mouse is a mammal
 
-for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
-    println("$(a[1]) is a $(a[2])")
+for pair in Dict("dog" => "mammal", "cat" => "mammal", "mouse" => "mammal")
+    from, to = pair
+    println("$from is a $to")
 end
-# prints:
-#    dog is a mammal
-#    cat is a mammal
-#    mouse is a mammal
+# => mouse is a mammal
+# => cat is a mammal
+# => dog is a mammal
+# 注意！这里的输出顺序和上面的不同
 
-for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
+for (k, v) in Dict("dog" => "mammal", "cat" => "mammal", "mouse" => "mammal")
     println("$k is a $v")
 end
-# prints:
-#    dog is a mammal
-#    cat is a mammal
-#    mouse is a mammal
+# => mouse is a mammal
+# => cat is a mammal
+# => dog is a mammal
 
 # While 循环
-x = 0
-while x < 4
-    println(x)
-    x += 1  # x = x + 1
+let x = 0
+    while x < 4
+        println(x)
+        x += 1  # x = x + 1 的缩写
+    end
 end
-# prints:
-#   0
-#   1
-#   2
-#   3
+# => 0
+# => 1
+# => 2
+# => 3
 
 # 用 try/catch 处理异常
 try
-   error("help")
+    error("help")
 catch e
-   println("caught it $e")
+    println("caught it $e")
 end
 # => caught it ErrorException("help")
 
-
 ####################################################
 ## 4. 函数
 ####################################################
 
-# 用关键字 'function' 可创建一个新函数
-#function name(arglist)
-#  body...
-#end
+# 关键字 function 用于定义函数
+# function name(arglist)
+#   body...
+# end
 function add(x, y)
     println("x is $x and y is $y")
 
-    # 最后一行语句的值为返回
+    # 函数会返回最后一行的值
     x + y
 end
 
-add(5, 6) # => 在 "x is 5 and y is 6" 后会打印 11
+add(5, 6)
+# => x is 5 and y is 6
+# => 11
+
+# 更紧凑的定义函数
+f_add(x, y) = x + y  # => f_add (generic function with 1 method)
+f_add(3, 4)  # => 7
+
+# 函数可以将多个值作为元组返回
+fn(x, y) = x + y, x - y # => fn (generic function with 1 method)
+fn(3, 4)  # => (7, -1)
 
 # 还可以定义接收可变长参数的函数
 function varargs(args...)
     return args
-    # 关键字 return 可在函数内部任何地方返回
+    # 使用 return 可以在函数内的任何地方返回
 end
 # => varargs (generic function with 1 method)
 
 varargs(1,2,3) # => (1,2,3)
 
-# 省略号 ... 被称为 splat.
+# 省略号「...」称为 splat
 # 刚刚用在了函数定义中
-# 还可以用在函数的调用
-# Array 或者 Tuple 的内容会变成参数列表
-Set([1,2,3])    # => Set{Array{Int64,1}}([1,2,3]) # 获得一个 Array 的 Set
-Set([1,2,3]...) # => Set{Int64}(1,2,3) # 相当于 Set(1,2,3)
+# 在调用函数时也可以使用它，此时它会把数组或元组解包为参数列表
+add([5,6]...)  # 等价于 add(5,6)
 
-x = (1,2,3)     # => (1,2,3)
-Set(x)          # => Set{(Int64,Int64,Int64)}((1,2,3)) # 一个 Tuple 的 Set
-Set(x...)       # => Set{Int64}(2,3,1)
+x = (5, 6)  # => (5,6)
+add(x...)  # 等价于 add(5,6)
 
-
-# 可定义可选参数的函数
-function defaults(a,b,x=5,y=6)
+# 可定义带可选参数的函数
+function defaults(a, b, x=5, y=6)
     return "$a $b and $x $y"
 end
+# => defaults (generic function with 3 methods)
 
-defaults('h','g') # => "h g and 5 6"
-defaults('h','g','j') # => "h g and j 6"
-defaults('h','g','j','k') # => "h g and j k"
+defaults('h', 'g')  # => "h g and 5 6"
+defaults('h', 'g', 'j')  # => "h g and j 6"
+defaults('h', 'g', 'j', 'k')  # => "h g and j k"
 try
-    defaults('h') # => ERROR: no method defaults(Char,)
-    defaults() # => ERROR: no methods defaults()
+    defaults('h')  # => ERROR: MethodError: no method matching defaults(::Char)
+    defaults()  # => ERROR: MethodError: no method matching defaults()
 catch e
     println(e)
 end
 
-# 还可以定义键值对的参数
-function keyword_args(;k1=4,name2="hello") # note the ;
-    return ["k1"=>k1,"name2"=>name2]
+# 还可以定义带关键字参数的函数
+function keyword_args(;k1=4, name2="hello")  # 注意分号 ';'
+    return Dict("k1" => k1, "name2" => name2)
 end
+# => keyword_args (generic function with 1 method)
 
-keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4]
-keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"]
-keyword_args() # => ["name2"=>"hello","k1"=>4]
+keyword_args(name2="ness")  # => ["name2"=>"ness", "k1"=>4]
+keyword_args(k1="mine")     # => ["name2"=>"hello", "k1"=>"mine"]
+keyword_args()              # => ["name2"=>"hello", "k1"=>4]
 
-# 可以组合各种类型的参数在同一个函数的参数列表中
+# 可以在一个函数中组合各种类型的参数
 function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo")
     println("normal arg: $normal_arg")
     println("optional arg: $optional_positional_arg")
     println("keyword arg: $keyword_arg")
 end
+# => all_the_args (generic function with 2 methods)
 
 all_the_args(1, 3, keyword_arg=4)
-# prints:
-#   normal arg: 1
-#   optional arg: 3
-#   keyword arg: 4
+# => normal arg: 1
+# => optional arg: 3
+# => keyword arg: 4
 
 # Julia 有一等函数
 function create_adder(x)
@@ -443,14 +508,16 @@ function create_adder(x)
     end
     return adder
 end
+# => create_adder (generic function with 1 method)
 
 # 这是用 "stabby lambda syntax" 创建的匿名函数
 (x -> x > 2)(3) # => true
 
-# 这个函数和上面的 create_adder 一模一样
+# 这个函数和上面的 create_adder 是等价的
 function create_adder(x)
     y -> x + y
 end
+# => create_adder (generic function with 1 method)
 
 # 你也可以给内部函数起个名字
 function create_adder(x)
@@ -459,18 +526,19 @@ function create_adder(x)
     end
     adder
 end
+# => create_adder (generic function with 1 method)
 
-add_10 = create_adder(10)
-add_10(3) # => 13
-
+add_10 = create_adder(10) # => (::getfield(Main, Symbol("#adder#11")){Int64}) 
+                          # (generic function with 1 method)
+add_10(3)  # => 13
 
 # 内置的高阶函数有
-map(add_10, [1,2,3]) # => [11, 12, 13]
-filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
+map(add_10, [1,2,3])  # => [11, 12, 13]
+filter(x -> x > 5, [3, 4, 5, 6, 7])  # => [6, 7]
 
-# 还可以使用 list comprehensions 替代 map
-[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13]
-[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
+# 还可以使用 list comprehensions 让 map 更美观
+[add_10(i) for i = [1, 2, 3]]   # => [11, 12, 13]
+[add_10(i) for i in [1, 2, 3]]  # => [11, 12, 13]
 
 ####################################################
 ## 5.  类型
@@ -482,248 +550,315 @@ filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
 typeof(5) # => Int64
 
 # 类型是一等值
-typeof(Int64) # => DataType
-typeof(DataType) # => DataType
+typeof(Int64)     # => DataType
+typeof(DataType)  # => DataType
 # DataType 是代表类型的类型，也代表他自己的类型
 
-# 类型可用作文档化，优化，以及调度
-# 并不是静态检查类型
+# 类型可用于文档化代码、执行优化以及多重派分(dispatch)
+# Julia 并不只是静态的检查类型
 
 # 用户还可以自定义类型
-# 跟其他语言的 records 或 structs 一样
-# 用 `type` 关键字定义新的类型
+# 就跟其它语言的 record 或 struct 一样
+# 用 `struct` 关键字定义新的类型
 
-# type Name
+# struct Name
 #   field::OptionalType
 #   ...
 # end
-type Tiger
-  taillength::Float64
-  coatcolor # 不附带类型标注的相当于 `::Any`
+struct Tiger
+    taillength::Float64
+    coatcolor  # 不带类型标注相当于 `::Any`
 end
 
-# 构造函数参数是类型的属性
-tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange")
+# 默认构造函数的参数是类型的属性，按类型定义中的顺序排列
+tigger = Tiger(3.5, "orange")  # => Tiger(3.5, "orange")
 
 # 用新类型作为构造函数还会创建一个类型
-sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire")
+sherekhan = typeof(tigger)(5.6, "fire")  # => Tiger(5.6, "fire")
 
-# struct 类似的类型被称为具体类型
-# 他们可被实例化但不能有子类型
+# 类似 struct 的类型被称为具体类型
+# 它们可被实例化，但不能有子类型
 # 另一种类型是抽象类型
 
-# abstract Name
-abstract Cat # just a name and point in the type hierarchy
+# 抽象类型名
+abstract type Cat end  # 仅仅是指向类型结构层次的一个名称
 
-# 抽象类型不能被实例化，但是可以有子类型
+# 抽象类型不能被实例化，但可以有子类型
 # 例如，Number 就是抽象类型
-subtypes(Number) # => 6-element Array{Any,1}:
-                 #     Complex{Float16}
-                 #     Complex{Float32}
-                 #     Complex{Float64}
-                 #     Complex{T<:Real}
-                 #     ImaginaryUnit
-                 #     Real
-subtypes(Cat) # => 0-element Array{Any,1}
-
-# 所有的类型都有父类型; 可以用函数 `super` 得到父类型.
+subtypes(Number)  # => 2-element Array{Any,1}:
+                  # =>  Complex
+                  # =>  Real
+subtypes(Cat)  # => 0-element Array{Any,1}
+
+# AbstractString，类如其名，也是一个抽象类型
+subtypes(AbstractString)  # => 4-element Array{Any,1}:
+                          # =>  String
+                          # =>  SubString
+                          # =>  SubstitutionString
+                          # =>  Test.GenericString
+
+# 所有的类型都有父类型。可以用函数 `supertype` 得到父类型
 typeof(5) # => Int64
-super(Int64) # => Signed
-super(Signed) # => Real
-super(Real) # => Number
-super(Number) # => Any
-super(super(Signed)) # => Number
-super(Any) # => Any
-# 所有这些类型，除了 Int64, 都是抽象类型.
-
-# <: 是类型集成操作符
-type Lion <: Cat # Lion 是 Cat 的子类型
-  mane_color
-  roar::String
+supertype(Int64)    # => Signed
+supertype(Signed)   # => Integer
+supertype(Integer)  # => Real
+supertype(Real)     # => Number
+supertype(Number)   # => Any
+supertype(supertype(Signed))  # => Real
+supertype(Any)      # => Any
+# 除了 Int64 外，其余的类型都是抽象类型
+typeof("fire")      # => String
+supertype(String)   # => AbstractString
+supertype(AbstractString) # => Any
+supertype(SubString)  # => AbstractString
+
+# <: 是子类型化操作符
+struct Lion <: Cat  # Lion 是 Cat 的子类型
+    mane_color
+    roar::AbstractString
 end
 
 # 可以继续为你的类型定义构造函数
-# 只需要定义一个同名的函数
-# 并调用已有的构造函数设置一个固定参数
-Lion(roar::String) = Lion("green",roar)
-# 这是一个外部构造函数，因为他再类型定义之外
-
-type Panther <: Cat # Panther 也是 Cat 的子类型
-  eye_color
-  Panther() = new("green")
-  # Panthers 只有这个构造函数，没有默认构造函数
+# 只需要定义一个与类型同名的函数，并调用已有的构造函数得到正确的类型
+Lion(roar::AbstractString) = Lion("green", roar)  # => Lion
+# 这是一个外部构造函数，因为它在类型定义之外
+
+struct Panther <: Cat # Panther 也是 Cat 的子类型
+    eye_color
+    Panther() = new("green")
+    # Panthers 只有这个构造函数，没有默认构造函数
 end
-# 使用内置构造函数，如 Panther，可以让你控制
-# 如何构造类型的值
-# 应该尽可能使用外部构造函数而不是内部构造函数
+# 像 Panther 一样使用内置构造函数，让你可以控制如何构建类型的值
+# 应该尽量使用外部构造函数，而不是内部构造函数
 
 ####################################################
 ## 6. 多分派
 ####################################################
 
-# 在Julia中, 所有的具名函数都是类属函数
-# 这意味着他们都是有很大小方法组成的
-# 每个 Lion 的构造函数都是类属函数 Lion 的方法
+# Julia 中所有的函数都是通用函数，或者叫做泛型函数(generic functions)
+# 也就是说这些函数都是由许多小方法组合而成的
+# Lion 的每一种构造函数都是通用函数 Lion 的一个方法
 
 # 我们来看一个非构造函数的例子
+# 首先，让我们定义一个函数 meow
 
-# Lion, Panther, Tiger 的 meow 定义为
+# Lion, Panther, Tiger 的 meow 定义分别为
 function meow(animal::Lion)
-  animal.roar # 使用点符号访问属性
+    animal.roar # 使用点记号「.」访问属性
 end
+# => meow (generic function with 1 method)
 
 function meow(animal::Panther)
-  "grrr"
+    "grrr"
 end
+# => meow (generic function with 2 methods)
 
 function meow(animal::Tiger)
-  "rawwwr"
+    "rawwwr"
 end
+# => meow (generic function with 3 methods)
 
 # 试试 meow 函数
-meow(tigger) # => "rawwr"
-meow(Lion("brown","ROAAR")) # => "ROAAR"
+meow(tigger)  # => "rawwwr"
+meow(Lion("brown", "ROAAR"))  # => "ROAAR"
 meow(Panther()) # => "grrr"
 
-# 再看看层次结构
-issubtype(Tiger,Cat) # => false
-issubtype(Lion,Cat) # => true
-issubtype(Panther,Cat) # => true
+# 回顾类型的层次结构
+Tiger   <: Cat  # => false
+Lion    <: Cat  # => true
+Panther <: Cat  # => true
 
-# 定义一个接收 Cats 的函数
+# 定义一个接收 Cat 类型的函数
 function pet_cat(cat::Cat)
-  println("The cat says $(meow(cat))")
+    println("The cat says $(meow(cat))")
 end
+# => pet_cat (generic function with 1 method)
 
-pet_cat(Lion("42")) # => prints "The cat says 42"
+pet_cat(Lion("42"))  # => The cat says 42
 try
-    pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,)
+    pet_cat(tigger)  # => ERROR: MethodError: no method matching pet_cat(::Tiger)
 catch e
     println(e)
 end
 
 # 在面向对象语言中，通常都是单分派
-# 这意味着分派方法是通过第一个参数的类型决定的
-# 在Julia中, 所有参数类型都会被考虑到
+# 这意味着使用的方法取决于第一个参数的类型
+# 而 Julia 中选择方法时会考虑到所有参数的类型
 
-# 让我们定义有多个参数的函数，好看看区别
-function fight(t::Tiger,c::Cat)
-  println("The $(t.coatcolor) tiger wins!")
+# 让我们定义一个有更多参数的函数，这样我们就能看出区别
+function fight(t::Tiger, c::Cat)
+    println("The $(t.coatcolor) tiger wins!")
 end
 # => fight (generic function with 1 method)
 
-fight(tigger,Panther()) # => prints The orange tiger wins!
-fight(tigger,Lion("ROAR")) # => prints The orange tiger wins!
+fight(tigger, Panther())  # => The orange tiger wins!
+fight(tigger, Lion("ROAR")) # => fight(tigger, Lion("ROAR"))
 
-# 让我们修改一下传入具体为 Lion 类型时的行为
-fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!")
+# 让我们修改一下传入 Lion 类型时的行为
+fight(t::Tiger, l::Lion) = println("The $(l.mane_color)-maned lion wins!")
 # => fight (generic function with 2 methods)
 
-fight(tigger,Panther()) # => prints The orange tiger wins!
-fight(tigger,Lion("ROAR")) # => prints The green-maned lion wins!
+fight(tigger, Panther())  # => The orange tiger wins!
+fight(tigger, Lion("ROAR"))  # => The green-maned lion wins!
 
-# 把 Tiger 去掉
-fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))")
+# 我们不需要一只老虎参与战斗
+fight(l::Lion, c::Cat) = println("The victorious cat says $(meow(c))")
 # => fight (generic function with 3 methods)
 
-fight(Lion("balooga!"),Panther()) # => prints The victorious cat says grrr
+fight(Lion("balooga!"), Panther())  # => The victorious cat says grrr
 try
-  fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion)
-catch
+    fight(Panther(), Lion("RAWR"))  
+    # => ERROR: MethodError: no method matching fight(::Panther, ::Lion)
+    # => Closest candidates are:
+    # =>   fight(::Tiger, ::Lion) at ...
+    # =>   fight(::Tiger, ::Cat) at ...
+    # =>   fight(::Lion, ::Cat) at ...
+    # => ...
+catch e
+    println(e)
 end
 
-# 在试试让 Cat 在前面
-fight(c::Cat,l::Lion) = println("The cat beats the Lion")
-# => Warning: New definition
-#    fight(Cat,Lion) at none:1
-# is ambiguous with
-#    fight(Lion,Cat) at none:2.
-# Make sure
-#    fight(Lion,Lion)
-# is defined first.
-#fight (generic function with 4 methods)
-
-# 警告说明了无法判断使用哪个 fight 方法
-fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The victorious cat says rarrr
-# 结果在老版本 Julia 中可能会不一样
-
-fight(l::Lion,l2::Lion) = println("The lions come to a tie")
-fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The lions come to a tie
-
-
-# Under the hood
-# 你还可以看看 llvm 以及生成的汇编代码
-
-square_area(l) = l * l      # square_area (generic function with 1 method)
-
-square_area(5) #25
-
-# 给 square_area 一个整形时发生什么
-code_native(square_area, (Int32,))
-    #       .section    __TEXT,__text,regular,pure_instructions
-    #   Filename: none
-    #   Source line: 1              # Prologue
-    #       push    RBP
-    #       mov RBP, RSP
-    #   Source line: 1
-    #       movsxd  RAX, EDI        # Fetch l from memory?
-    #       imul    RAX, RAX        # Square l and store the result in RAX
-    #       pop RBP                 # Restore old base pointer
-    #       ret                     # Result will still be in RAX
-
-code_native(square_area, (Float32,))
-    #       .section    __TEXT,__text,regular,pure_instructions
-    #   Filename: none
-    #   Source line: 1
-    #       push    RBP
-    #       mov RBP, RSP
-    #   Source line: 1
-    #       vmulss  XMM0, XMM0, XMM0  # Scalar single precision multiply (AVX)
-    #       pop RBP
-    #       ret
-
-code_native(square_area, (Float64,))
-    #       .section    __TEXT,__text,regular,pure_instructions
-    #   Filename: none
-    #   Source line: 1
-    #       push    RBP
-    #       mov RBP, RSP
-    #   Source line: 1
-    #       vmulsd  XMM0, XMM0, XMM0 # Scalar double precision multiply (AVX)
-    #       pop RBP
-    #       ret
-    #
-# 注意 只要参数中又浮点类型，Julia 就使用浮点指令
+# 试试把 Cat 放在前面
+fight(c::Cat, l::Lion) = println("The cat beats the Lion")
+# => fight (generic function with 4 methods)
+
+# 由于无法判断该使用哪个 fight 方法，而产生了错误
+try
+    fight(Lion("RAR"), Lion("brown", "rarrr"))
+    # => ERROR: MethodError: fight(::Lion, ::Lion) is ambiguous. Candidates:
+    # =>   fight(c::Cat, l::Lion) in Main at ...
+    # =>   fight(l::Lion, c::Cat) in Main at ...
+    # => Possible fix, define
+    # =>   fight(::Lion, ::Lion)
+    # => ...
+catch e
+    println(e)
+end
+# 在不同版本的 Julia 中错误信息可能有所不同
+
+fight(l::Lion, l2::Lion) = println("The lions come to a tie") 
+# => fight (generic function with 5 methods)
+fight(Lion("RAR"), Lion("brown", "rarrr"))  # => The lions come to a tie
+
+
+# 深入编译器之后
+# 你还可以看看 llvm 以及它生成的汇编代码
+
+square_area(l) = l * l  # => square_area (generic function with 1 method)
+square_area(5)  # => 25
+
+# 当我们喂给 square_area 一个整数时会发生什么？
+code_native(square_area, (Int32,), syntax = :intel)
+	#         .text
+	# ; Function square_area {
+	# ; Location: REPL[116]:1       # 函数序言 (Prologue)
+	#         push    rbp
+	#         mov     rbp, rsp
+	# ; Function *; {
+	# ; Location: int.jl:54
+	#         imul    ecx, ecx      # 求 l 的平方，并把结果放在 ECX 中
+	# ;}
+	#         mov     eax, ecx
+	#         pop     rbp           # 还原旧的基址指针(base pointer)
+	#         ret                   # 返回值放在 EAX 中
+	#         nop     dword ptr [rax + rax]
+	# ;}
+# 使用 syntax 参数指定输出语法。默认为 AT&T 格式，这里指定为 Intel 格式
+
+code_native(square_area, (Float32,), syntax = :intel)
+    #         .text
+    # ; Function square_area {
+    # ; Location: REPL[116]:1
+    #         push    rbp
+    #         mov     rbp, rsp
+    # ; Function *; {
+    # ; Location: float.jl:398
+    #         vmulss  xmm0, xmm0, xmm0  # 标量双精度乘法 (AVX)
+    # ;}
+    #         pop     rbp
+    #         ret
+    #         nop     word ptr [rax + rax]
+    # ;}
+
+code_native(square_area, (Float64,), syntax = :intel)
+    #         .text
+    # ; Function square_area {
+    # ; Location: REPL[116]:1
+    #         push    rbp
+    #         mov     rbp, rsp
+    # ; Function *; {
+    # ; Location: float.jl:399
+    #         vmulsd  xmm0, xmm0, xmm0  # 标量双精度乘法 (AVX)
+    # ;}
+    #         pop     rbp
+    #         ret
+    #         nop     word ptr [rax + rax]
+    # ;}
+
+# 注意！只要参数中有浮点数，Julia 就会使用浮点指令
 # 让我们计算一下圆的面积
-circle_area(r) = pi * r * r     # circle_area (generic function with 1 method)
-circle_area(5)                  # 78.53981633974483
-
-code_native(circle_area, (Int32,))
-    #       .section    __TEXT,__text,regular,pure_instructions
-    #   Filename: none
-    #   Source line: 1
-    #       push    RBP
-    #       mov RBP, RSP
-    #   Source line: 1
-    #       vcvtsi2sd   XMM0, XMM0, EDI          # Load integer (r) from memory
-    #       movabs  RAX, 4593140240              # Load pi
-    #       vmulsd  XMM1, XMM0, QWORD PTR [RAX]  # pi * r
-    #       vmulsd  XMM0, XMM0, XMM1             # (pi * r) * r
-    #       pop RBP
-    #       ret
-    #
-
-code_native(circle_area, (Float64,))
-    #       .section    __TEXT,__text,regular,pure_instructions
-    #   Filename: none
-    #   Source line: 1
-    #       push    RBP
-    #       mov RBP, RSP
-    #       movabs  RAX, 4593140496
-    #   Source line: 1
-    #       vmulsd  XMM1, XMM0, QWORD PTR [RAX]
-    #       vmulsd  XMM0, XMM1, XMM0
-    #       pop RBP
-    #       ret
-    #
+circle_area(r) = pi * r * r # => circle_area (generic function with 1 method)
+circle_area(5)  # => 78.53981633974483
+
+code_native(circle_area, (Int32,), syntax = :intel)
+    #         .text
+    # ; Function circle_area {
+    # ; Location: REPL[121]:1
+    #         push    rbp
+    #         mov     rbp, rsp
+    # ; Function *; {
+    # ; Location: operators.jl:502
+    # ; Function *; {
+    # ; Location: promotion.jl:314
+    # ; Function promote; {
+    # ; Location: promotion.jl:284
+    # ; Function _promote; {
+    # ; Location: promotion.jl:261
+    # ; Function convert; {
+    # ; Location: number.jl:7
+    # ; Function Type; {
+    # ; Location: float.jl:60
+    #         vcvtsi2sd       xmm0, xmm0, ecx     # 从内存中读取整数 r
+    #         movabs  rax, 497710928              # 读取 pi
+    # ;}}}}}
+    # ; Function *; {
+    # ; Location: float.jl:399
+    #         vmulsd  xmm1, xmm0, qword ptr [rax] # pi * r
+    #         vmulsd  xmm0, xmm1, xmm0            # (pi * r) * r
+    # ;}}
+    #         pop     rbp
+    #         ret
+    #         nop     dword ptr [rax]
+    # ;}
+
+code_native(circle_area, (Float64,), syntax = :intel)
+    #         .text
+    # ; Function circle_area {
+    # ; Location: REPL[121]:1
+    #         push    rbp
+    #         mov     rbp, rsp
+    #         movabs  rax, 497711048
+    # ; Function *; {
+    # ; Location: operators.jl:502
+    # ; Function *; {
+    # ; Location: promotion.jl:314
+    # ; Function *; {
+    # ; Location: float.jl:399
+    #         vmulsd  xmm1, xmm0, qword ptr [rax]
+    # ;}}}
+    # ; Function *; {
+    # ; Location: float.jl:399
+    #         vmulsd  xmm0, xmm1, xmm0
+    # ;}
+    #         pop     rbp
+    #         ret
+    #         nop     dword ptr [rax + rax]
+    # ;}
 ```
+
+## 拓展阅读材料
+
+你可以在 [Julia 中文文档](http://docs.juliacn.com/latest/) / [Julia 文档(en)](https://docs.julialang.org/)
+中获得关于 Julia 的更多细节。
+
+如果有任何问题可以去 [Julia 中文社区](http://discourse.juliacn.com/) / [官方社区(en)](https://discourse.julialang.org/) 提问，大家对待新手都非常的友好。
diff --git a/zh-cn/lambda-calculus-cn.html.markdown b/zh-cn/lambda-calculus-cn.html.markdown
new file mode 100644
index 00000000..7719ee71
--- /dev/null
+++ b/zh-cn/lambda-calculus-cn.html.markdown
@@ -0,0 +1,223 @@
+---
+category: Algorithms & Data Structures
+name: Lambda Calculus
+lang: zh-cn
+contributors:
+    - ["Max Sun", "http://github.com/maxsun"]
+    - ["Yan Hui Hang", "http://github.com/yanhh0"]
+translators:
+    - ["Maoyin Sun", "https://github.com/simonmysun"]
+---
+
+# Lambda 演算
+
+Lambda 演算(lambda calculus, λ-calculus),
+最初由[阿隆佐·邱奇][]([Alonzo Church][])提出,
+是世界上最小的编程语言.
+尽管没有数字, 字符串, 布尔或者任何非函数的数据类型,
+lambda 演算仍可以表示任何图灵机.
+
+[阿隆佐·邱奇]: https://zh.wikipedia.org/wiki/%E9%98%BF%E9%9A%86%E4%BD%90%C2%B7%E9%82%B1%E5%A5%87
+[Alonzo Church]: https://en.wikipedia.org/wiki/Alonzo_Church
+
+Lambda 演算由三种元素组成: **变量**(variables)、**函数**(functions)和**应用**(applications)。
+
+| 名称 | 语法                 | 示例      | 解释                                             |
+|------|----------------------|-----------|--------------------------------------------------|
+| 变量 | `<变量名>`           | `x`       | 一个名为"x"的变量                                |
+| 函数 | `λ<参数>.<函数体>`   | `λx.x`    | 一个以"x"(前者)为参数、以"x"(后者)为函数体的函数 |
+| 应用 | `<函数><变量或函数>` | `(λx.x)a` | 以"a"为参数调用函数"λx.x"                        |
+
+最基本的函数为恒等函数: `λx.x`, 它等价于`f(x) = x`.
+第一个"x"为函数的参数, 第二个为函数体.
+
+## 自由变量和约束变量:
+
+- 在函数`λx.x`中, "x"被称作约束变量因为它同时出现在函数体和函数参数中.
+- 在`λx.y`中, "y"被称作自由变量因为它没有被预先声明.
+
+## 求值:
+
+求值操作是通过[β-归约][]([β-Reduction][])完成的,
+它本质上是词法层面上的替换.
+
+[β-归约]: https://zh.wikipedia.org/wiki/%CE%9B%E6%BC%94%E7%AE%97#'%22%60UNIQ--postMath-0000006F-QINU%60%22'-%E6%AD%B8%E7%B4%84
+[β-Reduction]: https://en.wikipedia.org/wiki/Lambda_calculus#Beta_reduction
+
+当对表达式`(λx.x)a`求值时, 我们将函数体中所有出现的"x"替换为"a".
+
+- `(λx.x)a`计算结果为: `a`
+- `(λx.y)a`计算结果为: `y`
+
+你甚至可以创建高阶函数:
+
+- `(λx.(λy.x))a`计算结果为: `λy.a`
+
+尽管 lambda 演算传统上仅支持单个参数的函数,
+但我们可以通过一种叫作[柯里化][]([Currying][])的技巧创建多个参数的函数.
+
+[柯里化]: https://zh.wikipedia.org/wiki/%E6%9F%AF%E9%87%8C%E5%8C%96
+[Currying]: https://en.wikipedia.org/wiki/Currying
+
+- `(λx.λy.λz.xyz)`等价于`f(x, y, z) = ((x y) z)`
+
+有时`λxy.<body>`与`λx.λy.<body>`可以互换使用.
+
+----
+
+认识到传统的 **lambda 演算没有数字, 字符或者任何非函数的数据类型**很重要.
+
+## 布尔逻辑:
+
+在 lambda 演算中没有"真"或"假". 甚至没有 1 或 0.
+
+作为替换:
+
+`T`表示为: `λx.λy.x`
+
+`F`表示为: `λx.λy.y`
+
+首先, 我们可以定义一个"if"函数`λbtf`, 它当`b`为真时返回`t`,
+`b`为假时返回`f`
+
+`IF`等价于: `λb.λt.λf.b t f`
+
+通过`IF`, 我们可以定义基本的布尔逻辑运算符:
+
+`a AND b`等价于: `λab.IF a b F`
+
+`a OR b`等价于: `λab.IF a T b`
+
+`NOT a`等价于: `λa.IF a F T`
+
+*注意: `IF a b c`本质上指: `IF((a b) c)`*
+
+## 数字：
+
+尽管 lambda 演算中没有数字,
+我们还可以用[邱奇编码][]([Church numerals][])将数字嵌入到 lambda 演算中.
+
+[邱奇编码]: https://zh.wikipedia.org/wiki/%E9%82%B1%E5%A5%87%E7%BC%96%E7%A0%81
+[Church numerals]: https://en.wikipedia.org/wiki/Church_encoding
+
+对于任意数字 n: <code>n = λf.f<sup>n</sup></code> 所以:
+
+`0 = λf.λx.x`
+
+`1 = λf.λx.f x`
+
+`2 = λf.λx.f(f x)`
+
+`3 = λf.λx.f(f(f x))`
+
+要增加一个邱奇数, 我们使用后继函数`S(n) = n + 1`:
+
+`S = λn.λf.λx.f((n f) x)`
+
+使用后继函数, 我们可以定义加法:
+
+`ADD = λab.(a S)b`
+
+**挑战**: 试定义乘法函数!
+
+## 变得更小: SKI, SK 和 Iota
+
+### SKI 组合子演算
+
+令 S, K, I 为下列函数:
+
+`I x = x`
+
+`K x y =  x`
+
+`S x y z = x z (y z)`
+
+我们可以将 lambda 演算中的表达式转换为 SKI 组合子演算中的表达式:
+
+1. `λx.x = I`
+2. `λx.c = Kc`
+3. `λx.(y z) = S (λx.y) (λx.z)`
+
+以邱奇数 2 为例:
+
+`2 = λf.λx.f(f x)`
+
+对于里面的部分 `λx.f(f x)`:
+
+```
+  λx.f(f x)
+= S (λx.f) (λx.(f x))          (case 3)
+= S (K f)  (S (λx.f) (λx.x))   (case 2, 3)
+= S (K f)  (S (K f) I)         (case 2, 1)
+```
+
+所以:
+
+```
+  2
+= λf.λx.f(f x)
+= λf.(S (K f) (S (K f) I))
+= λf.((S (K f)) (S (K f) I))
+= S (λf.(S (K f))) (λf.(S (K f) I)) (case 3)
+```
+
+对于第一个参数`λf.(S (K f))`有:
+
+```
+  λf.(S (K f))
+= S (λf.S) (λf.(K f))       (case 3)
+= S (K S) (S (λf.K) (λf.f)) (case 2, 3)
+= S (K S) (S (K K) I)       (case 2, 3)
+```
+
+对于第二个参数`λf.(S (K f) I)`有：
+
+```
+  λf.(S (K f) I)
+= λf.((S (K f)) I)
+= S (λf.(S (K f))) (λf.I)             (case 3)
+= S (S (λf.S) (λf.(K f))) (K I)       (case 2, 3)
+= S (S (K S) (S (λf.K) (λf.f))) (K I) (case 1, 3)
+= S (S (K S) (S (K K) I)) (K I)       (case 1, 2)
+```
+
+综上:
+
+```
+  2
+= S (λf.(S (K f))) (λf.(S (K f) I))
+= S (S (K S) (S (K K) I)) (S (S (K S) (S (K K) I)) (K I))
+```
+
+如果展开这个表达式, 我们最终又会得到邱奇数 2 的相同的表达式.
+
+### SK 组合子演算
+
+SKI 组合子演算还可以进一步简化. 我们可以通过`I = SKK`移除 I 组合子.
+我们可以将所有的 `I` 替换为 `SKK`.
+
+### ι 组合子
+
+SK 组合子仍不是最简的. 定义:
+
+```
+ι = λf.((f S) K)
+```
+
+我们有:
+
+```
+I = ιι
+K = ι(ιI) = ι(ι(ιι))
+S = ι(K) = ι(ι(ι(ιι)))
+```
+
+## 更多阅读:
+
+1. [A Tutorial Introduction to the Lambda Calculus](http://www.inf.fu-berlin.de/lehre/WS03/alpi/lambda.pdf)(英文)
+2. [Cornell CS 312 Recitation 26: The Lambda Calculus](https://courses.cs.cornell.edu/cs312/2008sp/recitations/rec26.html)(英文)
+3. [Wikipedia - Lambda Calculus](https://en.wikipedia.org/wiki/Lambda_calculus)(英文)
+4. [Wikipedia - SKI combinator calculus](https://en.wikipedia.org/wiki/SKI_combinator_calculus)(英文)
+5. [Wikipedia - Iota and Jot](https://en.wikipedia.org/wiki/Iota_and_Jot)(英文)
+6. [λ演算 - 维基百科，自由的百科全书](https://zh.wikipedia.org/wiki/SKI%E7%BB%84%E5%90%88%E5%AD%90%E6%BC%94%E7%AE%97)
+7. [SKI组合子演算 - 维基百科，自由的百科全书](https://zh.wikipedia.org/wiki/SKI%E7%BB%84%E5%90%88%E5%AD%90%E6%BC%94%E7%AE%97)
diff --git a/zh-cn/make-cn.html.markdown b/zh-cn/make-cn.html.markdown
index 4cdf1e63..76dde941 100644
--- a/zh-cn/make-cn.html.markdown
+++ b/zh-cn/make-cn.html.markdown
@@ -1,5 +1,6 @@
 ---
-language: make
+category: tool
+tool: make
 contributors:
 - ["Robert Steed", "https://github.com/robochat"]
 - ["Jichao Ouyang", "https://github.com/jcouyang"]
@@ -38,7 +39,7 @@ Makefile 用于定义如何创建目标文件, 比如如何从源码到可执行
 # 	 …
 # prerequisites(依赖) 是可选的, recipe(做法) 也可以多个或者不给.
 
-# 下面这个任务没有给 prerequisites, 只会在目标文件 file0.txt 文件不存在是跑
+# 下面这个任务没有给 prerequisites, 只会在目标文件 file0.txt 文件不存在时执行
 file0.txt:
 	echo "foo" > file0.txt
 	# 试试 `make file0.txt`
@@ -46,12 +47,12 @@ file0.txt:
 	# 注意: 即使是这些注释, 如果前面有 TAB, 也会发送给 shell, 注意看 `make file0.txt` 输出
 
 # 如果提供 prerequisites, 则只有 prerequisites 比 target 新时会执行
-# 比如下面这个任务只有当 file1.txt 比 file0.txt 新时才会执行.
+# 比如下面这个任务只有当 file0.txt 比 file1.txt 新时才会执行.
 file1.txt: file0.txt
 	cat file0.txt > file1.txt
-	# 这里跟shell里的命令式一毛一样的.
+	# 这里跟shell里的命令式一模一样.
 	@cat file0.txt >> file1.txt
-	# @ 不会把命令往 stdout 打印.
+	# @ 不会把命令打印到 stdout.
 	-@echo 'hello'
 	# - 意思是发生错误了也没关系.
 	# 试试 `make file1.txt` 吧.
@@ -234,7 +235,7 @@ ls:	*
 # include foo.mk
 
 sport = tennis
-# 一些逻辑语句 if else 什么的, 顶个写
+# 流程控制语句 (如if else 等等) 顶格写
 report:
 ifeq ($(sport),tennis)
 	@echo 'game, set, match'
diff --git a/zh-cn/markdown-cn.html.markdown b/zh-cn/markdown-cn.html.markdown
index e9a8aeb2..9b3d96ab 100644
--- a/zh-cn/markdown-cn.html.markdown
+++ b/zh-cn/markdown-cn.html.markdown
@@ -4,45 +4,74 @@ contributors:
     - ["Dan Turkel", "http://danturkel.com/"]
 translators:
     - ["Fangzhou Chen","https://github.com/FZSS"]
+    - ["Luffy Zhong", "https://github.com/mengzhongshi"]
+    - ["Yuchen Liu", "https://github.com/smallg0at"]
 filename: learnmarkdown-cn.md
 lang: zh-cn
 ---
 
 Markdown 由 John Gruber 于 2004年创立. 它旨在成为一门容易读写的语法结构，并可以便利地转换成 HTML（以及其他很多）格式。
 
-欢迎您多多反馈以及分支和请求合并。
+在不同的解析器中，Markdown 的实现方法有所不同。
+此教程会指出哪些特征是通用，哪一些只对某一解析器有效。
 
+- [HTML标签](#HTML标签)
+- [标题](#标题)
+- [文本样式](#文本样式)
+- [段落](#段落)
+- [列表](#列表)
+- [代码块](#代码块)
+- [水平线分隔](#水平线分隔)
+- [链接](#链接)
+- [图片](#图片)
+- [杂项](#杂项)
+
+## HTML标签
+Markdown 是 HTML 的父集，所以任何 HTML 文件都是有效的 Markdown。
 
 ```md
-<!-- Markdown 是 HTML 的父集，所以任何 HTML 文件都是有效的 Markdown。
-这意味着我们可以在 Markdown 里使用任何 HTML 元素，比如注释元素，
+<!--这意味着我们可以在 Markdown 里使用任何 HTML 元素，比如注释元素，
 且不会被 Markdown 解析器所影响。不过如果你在 Markdown 文件内创建了 HTML 元素，
 你将无法在 HTML 元素的内容中使用 Markdown 语法。-->
+```
 
-<!-- 在不同的解析器中，Markdown 的实现方法有所不同。
-此教程会指出当某功能是否通用及是否只对某一解析器有效。 -->
+## 标题
 
-<!-- 标头 -->
-<!-- 通过在文本前加上不同数量的hash(#), 你可以创建相对应的 <h1> 
-到 <h6> HTML元素。-->
+通过在文本前加上不同数量的hash(#), 你可以创建相对应的 `<h1>` 到 `<h6>` HTML元素。
 
+```md
 # 这是一个 <h1>
 ## 这是一个 <h2>
 ### 这是一个 <h3>
 #### 这是一个 <h4>
 ##### 这是一个 <h5>
 ###### 这是一个 <h6>
+```
+
+实际效果（最终显示时会因设置而看起来不同）：
+# 这是一个
+## 这也是一个
+### 这还是一个
+#### 这依旧是一个
+##### 这真的是一个
+###### 这...是一个
+
 
-<!-- 对于 <h1> 和 <h2> 元素，Markdown 额外提供了两种添加方式。 -->
+对于 `<h1>` 和 `<h2>` 元素，Markdown 额外提供了两种添加方式。
+
+```md
 这是一个 h1
 =============
 
 这是一个 h2
 -------------
+```
 
-<!-- 简易文本样式 -->
-<!-- 文本的斜体，粗体，和删除线在 Markdown 中可以轻易地被实现。-->
+## 文本样式
 
+文本的*斜体*，**粗体**在 Markdown 中可以轻易实现。
+
+```md
 *此文本为斜体。*
 _此文本也是。_
 
@@ -52,40 +81,57 @@ __此文本也是__
 ***此文本是斜体加粗体。***
 **_或者这样。_**
 *__这个也是！__*
+```
 
-<!-- 在 GitHub 采用的 Markdown 中 -->
+GitHub 也支持 Markdown，在 GitHub 的 Markdown 解析器中，我们可以使用~~删除线~~：
 
+```md
 ~~此文本为删除线效果。~~
+```
+## 段落
 
-<!-- 单个段落由一句或多句邻近的句子组成，这些句子由一个或多个空格分隔。-->
+段落由一个句子或是多个中间没有空行的句子组成，每个段落由一个或是多个空行分隔开来。
+（注：部分解析器有无需空行就能换行的设置，这个主要看个人喜好）
 
+```md
 这是第一段落. 这句话在同一个段落里，好玩么？
 
 现在我是第二段落。
 这句话也在第二段落！
 
+
 这句话在第三段落！
+```
+
+如果你想插入一个 `<br />` 标签，你可以在段末加入两个以上的空格，然后另起一
+段。
 
-<!-- 如果你插入一个 HTML中的<br />标签，你可以在段末加入两个以上的空格，
-然后另起一段。-->
+(译者注：试了一下，很多解析器，并不需要空两个空格，直接换行就会添加一个`<br />`)
 
+```md
 此段落结尾有两个空格（选中以显示）。  
 
 上文有一个 <br /> ！
+```
 
-<!-- 段落引用可由 > 字符轻松实现。-->
+段落引用可由 `>` 字符轻松实现。
 
-> 这是一个段落引用. 你可以
-> 手动断开你的句子，然后在每句句子前面添加 “>” 字符。或者让你的句子变得很长，以至于他们自动得断开。
-> 只要你的文字以“>” 字符开头，两种方式无异。
+> 对的很轻松
 
-> 你也对文本进行
+```md
+> 这是一个段落引用。 你可以
+> 手动断开你的句子，然后在每句句子前面添加 `>` 字符。或者让你的句子变得很长，以至于他们自动得换行。
+> 只要你的文字以 `>` 字符开头，两种方式无异。
+
+> 你也可以对文本进行
 >> 多层引用
 > 这多机智啊！
+```
 
-<!-- 序列 -->
-<!-- 无序序列可由星号，加号或者减号来建立 -->
+## 列表
+- 无序列表可由星号，加号或者减号来创建
 
+```md
 * 项目
 * 项目
 * 另一个项目
@@ -102,139 +148,211 @@ __此文本也是__
 - 项目
 - 最后一个项目
 
-<!-- 有序序列可由数字加点来实现 -->
+```
+
+有序序列可由数字加上点 `.` 来实现
 
+```md
 1. 项目一
 2. 项目二
 3. 项目三
+```
 
-<!-- 即使你的标签数字有误，Markdown 依旧会呈现出正确的序号，
-不过这并不是一个好主意-->
+即使你的数字标签有误，Markdown 依旧会呈现出正确的序号，
+不过这并不是一个好主意
 
+```md
 1. 项目一
 1. 项目二
 1. 项目三
-<!-- (此段与前例一模一样) -->
+```
+(此段与上面效果一模一样)
 
-<!-- 你也可以使用子序列 -->
+你也可以使用子列表
 
+```md
 1. 项目一
 2. 项目二
 3. 项目三
     * 子项目
     * 子项目
 4. 项目四
+```
+
+你甚至可以使用任务列表，它将会生成 HTML 的选择框（checkboxes）标签。
+
+```md
+下面方框里包含 'x' 的列表，将会生成选中效果的选择框。
+- [ ] 任务一需要完成
+- [ ] 任务二需要完成
+下面这个选择框将会是选中状态
+- [x] 这个任务已经完成
+```
+- [ ] 你看完了这个任务（注：此选择框是无法直接更改的，即禁用状态。）
+
+## 代码块
 
-<!-- 代码段落 -->
-<!-- 代码段落（HTML中 <code>标签）可以由缩进四格（spaces）
-或者一个制表符（tab）实现-->
+代码块（HTML中 `<code>` 标签）可以由缩进四格（spaces）
+或者一个制表符（tab）实现
 
+```md
     This is code
-    So is this
+	So is this
+```
 
-<!-- 在你的代码中，你仍然使用tab可以进行缩进操作 -->
+在你的代码中，你仍然使用tab（或者四个空格）可以进行缩进操作
 
+```md
     my_array.each do |item|
         puts item
     end
+```
 
-<!-- 内联代码可由反引号 ` 实现 -->
+内联代码可由反引号 ` 实现
 
+```md
 John 甚至不知道 `go_to()` 方程是干嘛的!
+```
 
-<!-- 在GitHub的 Markdown中，对于代码你可以使用特殊的语法 -->
+在GitHub的 Markdown（GitHub Flavored Markdown）解析器中，你可以使用特殊的语法表示代码块
 
-\`\`\`ruby <!-- 插入时记得移除反斜线， 仅留```ruby ！ -->
+<pre>
+<code class="highlight">&#x60;&#x60;&#x60;ruby
 def foobar
     puts "Hello world!"
 end
-\`\`\` <!-- 这里也是，移除反斜线，仅留 ``` -->
+&#x60;&#x60;&#x60;</code></pre>
 
-<!-- 以上代码不需要缩进，而且 GitHub 会根据```后表明的语言来进行语法高亮 -->
+以上代码不需要缩进，而且 GitHub 会根据\`\`\`后指定的语言来进行语法高亮显示
 
-<!-- 水平线 （<hr />） -->
-<!-- 水平线可由三个或以上的星号或者减号创建，可带可不带空格。 -->
+## 水平线分隔
 
+水平线（`<hr/>`）可由三个或以上的星号或是减号创建，它们之间可以带或不带空格
+
+```md
 ***
 ---
 - - - 
 ****************
 
-<!-- 链接 -->
-<!-- Markdown 最棒的地方就是简易的链接制作。链接文字放在中括号[]内，
-在随后的括弧()内加入url。-->
+下面这个就是示例
+```
+---
+
+## 链接
 
+Markdown 最棒的地方就是便捷的书写链接。把链接文字放在中括号[]内，
+在随后的括弧()内加入url就可以了。
+
+```md
 [点我点我!](http://test.com/)
 
-<!-- 你也可以为链接加入一个标题：在括弧内使用引号 -->
+```
 
-[点我点我!](http://test.com/ "连接到Test.com")
+你也可以在小括号内使用引号，为链接加上一个标题（title）
 
-<!-- 相对路径也可以有 -->
+```md
+[点我点我!](http://test.com/ "连接到Test.com")
+```
+相对路径也可以有 
 
+```md
 [去 music](/music/).
+```
 
-<!-- Markdown同样支持引用样式的链接 -->
-
-[点此链接][link1]以获取更多信息！
-[看一看这个链接][foobar] 如果你愿意的话.
+Markdown同样支持引用形式的链接
 
-[link1]: http://test.com/ "Cool!"
-[foobar]: http://foobar.biz/ "Alright!"
+```md
+[点此链接][link1] 以获取更多信息！
+[看一看这个链接][foobar] 如果你愿意的话。
+[link1]: http://test.com/
+[foobar]: http://foobar.biz/
+```
 
-<!-- 链接的标题可以处于单引号中，括弧中或是被忽略。引用名可以在文档的任意何处，
-并且可以随意命名，只要名称不重复。-->
+对于引用形式，链接的标题可以处于单引号中，括弧中或是忽略。引用名可以在文档的任何地方，并且可以随意命名，只要名称不重复。
 
-<!-- “隐含式命名” 的功能可以让链接文字作为引用名 -->
+“隐含式命名” 的功能可以让链接文字作为引用名
 
+```md
 [This][] is a link.
+[This]: http://thisisalink.com/
+```
 
-[this]: http://thisisalink.com/
-
-<!-- 但这并不常用 -->
-
-<!-- 图像 -->
-<!-- 图像与链接相似，只需在前添加一个感叹号 -->
+但这并不常用
 
-![这是我图像的悬停文本(alt text)](http://imgur.com/myimage.jpg "可选命名")
+## 图片
+图片与链接相似，只需在前添加一个感叹号
 
-<!-- 引用样式也同样起作用 -->
+```md
+![这是alt,请把鼠标放在图片上](http://imgur.com/myimage.jpg "这是title")
+```
 
-![这是我的悬停文本.][myimage]
+引用形式也同样起作用
 
-[myimage]: relative/urls/cool/image.jpg "在此输入标题"
+```md
+![这是alt][myimage]
+[myimage]: relative/urls/cool/image.jpg
+```
 
-<!-- 杂项 -->
-<!-- 自动链接 -->
+## 杂项
+### 自动链接
 
+```md
 <http://testwebsite.com/> 与
 [http://testwebsite.com/](http://testwebsite.com/) 等同
+```
 
-<!-- 电子邮件的自动链接 -->
+### 电子邮件的自动链接
 
+```md
 <foo@bar.com>
+```
 
-<!-- 转义字符 -->
+### 转义字符
 
+```md
 我希望 *将这段文字置于星号之间* 但是我不希望它被
-斜体化, 所以我就: \*这段置文字于星号之间\*。
+斜体化, 这么做: \*这段置文字于星号之间\*。
+```
+对比一下：*将这段文字置于星号之间* 和 \*将这段文字置于星号之间\*
 
-<!-- 表格 -->
-<!-- 表格只被 GitHub 的 Markdown 支持，并且有一点笨重，但如果你真的要用的话: -->
+### 键盘上的功能键
 
-| 第一列        | 第二列    | 第三列       |
-| :----------   | :------:  | ----------:  |
-| 左对齐        | 居个中    | 右对齐       |
-| 某某某        | 某某某    | 某某某       |
+在 GitHub 的 Markdown 中，你可以使用 `<kbd>` 标签来表示功能键。
 
-<!-- 或者, 同样的 -->
+```md
+你的电脑死机了？试试
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
+```
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
 
-第一列 | 第二列 | 第三列
-:-- | :-: | --:
-这太丑了 | 药不能 | 停
+（译注：可能由于网站本身样式问题，效果不明显）
 
-<!-- 结束! -->
+### 表格
 
+下面示例的表格长这样：
+
+| 第一列        | 第二列    | 第三列       |
+| :----------- | :-------: | ----------: |
+| 我是左对齐    | 居个中    | 右对齐       |
+| 注意          | 冒       | 号           |
+
+工整一点的写法是这样的：
+
+```md
+| 第一列        | 第二列    | 第三列       |
+| :----------- | :-------: | ----------: |
+| 我是左对齐    | 居个中    | 右对齐       |
+| 注意          | 冒       | 号           |
 ```
+好吧，强行对齐字符是很难的。但是，至少比下面这种写法好一点——
+
+```md
+我是超级超级长的第一列 | 第二列 | 第三列
+:-- | :-: | --:
+这真的太丑了 | 药不能 | 停！！！！
+```
+真的是*看着令人头晕*
+
 
 更多信息, 请于[此处](http://daringfireball.net/projects/Markdown/syntax)参见 John Gruber 关于语法的官方帖子，及于[此处](https://github.com/adam-p/Markdown-here/wiki/Markdown-Cheatsheet) 参见 Adam Pritchard 的摘要笔记。
diff --git a/zh-cn/matlab-cn.html.markdown b/zh-cn/matlab-cn.html.markdown
index 2fbccfc4..d215755c 100644
--- a/zh-cn/matlab-cn.html.markdown
+++ b/zh-cn/matlab-cn.html.markdown
@@ -10,9 +10,12 @@ lang: zh-cn
 

 ---

 

-MATLAB 是 MATrix LABoratory （矩阵实验室）的缩写，它是一种功能强大的数值计算语言，在工程和数学领域中应用广泛。

+MATLAB 是 MATrix LABoratory（矩阵实验室）的缩写。

+它是一种功能强大的数值计算语言，在工程和数学领域中应用广泛。

 

-如果您有任何需要反馈或交流的内容，请联系本教程作者[@the_ozzinator](https://twitter.com/the_ozzinator)、[osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com)。

+如果您有任何需要反馈或交流的内容，请联系本教程作者：

+[@the_ozzinator](https://twitter.com/the_ozzinator) 

+或 [osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com)。

 

 ```matlab

 % 以百分号作为注释符

@@ -45,7 +48,7 @@ edit('myfunction.m')  % 在编辑器中打开指定函数或脚本
 type('myfunction.m')  % 在命令窗口中打印指定函数或脚本的源码

 

 profile on  % 打开 profile 代码分析工具

-profile of  % 关闭 profile 代码分析工具

+profile off % 关闭 profile 代码分析工具

 profile viewer  % 查看 profile 代码分析工具的分析结果

 

 help command    % 在命令窗口中显示指定命令的帮助文档

@@ -113,7 +116,7 @@ b(2)  % ans = 符
 % 元组（cell 数组）

 a = {'one', 'two', 'three'} 

 a(1)  % ans = 'one' - 返回一个元组

-char(a(1))  % ans = one - 返回一个字符串

+a{1}  % ans = one - 返回一个字符串

 

 

 % 结构体

@@ -210,8 +213,8 @@ size(A)  % 返回矩阵的行数和列数，ans = 3 3
 A(1, :) =[]  % 删除矩阵的第 1 行

 A(:, 1) =[]  % 删除矩阵的第 1 列

 

-transpose(A)  % 矩阵转置，等价于 A'

-ctranspose(A)  % 矩阵的共轭转置（对矩阵中的每个元素取共轭复数）

+transpose(A)  % 矩阵（非共轭）转置，等价于 A.' （注意！有个点）

+ctranspose(A)  % 矩阵的共轭转置（对矩阵中的每个元素取共轭复数），等价于 A'

 

 

 % 元素运算 vs. 矩阵运算

@@ -219,18 +222,20 @@ ctranspose(A)  % 矩阵的共轭转置（对矩阵中的每个元素取共轭复
 % 在运算符加上英文句点就是对矩阵中的元素进行元素计算

 % 示例如下：

 A * B  % 矩阵乘法，要求 A 的列数等于 B 的行数

-A .* B  % 元素乘法，要求 A 和 B 形状一致（A 的行数等于 B 的行数， A 的列数等于 B 的列数）

-% 元素乘法的结果是与 A 和 B 形状一致的矩阵，其每个元素等于 A 对应位置的元素乘 B 对应位置的元素

+A .* B  % 元素乘法，要求 A 和 B 形状一致，即两矩阵行列数完全一致

+        % 元素乘法的结果是与 A 和 B 形状一致的矩阵

+        % 其每个元素等于 A 对应位置的元素乘 B 对应位置的元素

 

 % 以下函数中，函数名以 m 结尾的执行矩阵运算，其余执行元素运算： 

 exp(A)  % 对矩阵中每个元素做指数运算

 expm(A)  % 对矩阵整体做指数运算

 sqrt(A)  % 对矩阵中每个元素做开方运算

-sqrtm(A)  % 对矩阵整体做开放运算（即试图求出一个矩阵，该矩阵与自身的乘积等于 A 矩阵）

+sqrtm(A)  % 对矩阵整体做开方运算（即试图求出一个矩阵，该矩阵与自身的乘积等于 A 矩阵）

 

 

 % 绘图

-x = 0:.10:2*pi;  % 生成一向量，其元素从 0 开始，以 0.1 的间隔一直递增到 2*pi（pi 就是圆周率）

+x = 0:0.1:2*pi; % 生成一向量，其元素从 0 开始，以 0.1 的间隔一直递增到 2*pi

+                % 其中 pi 为圆周率

 y = sin(x);

 plot(x,y)

 xlabel('x axis')

@@ -288,7 +293,10 @@ clf clear  % 清除图形窗口中的图像，并重置图像属性
 % 也可以用 gcf 函数返回当前图像的句柄 

 h = plot(x, y);  % 在创建图像时显式地保存图像句柄

 set(h, 'Color', 'r')

-% 颜色代码：'y' 黄色，'m' 洋红色，'c' 青色，'r' 红色，'g' 绿色，'b' 蓝色，'w' 白色，'k' 黑色

+% 颜色代码：

+%   'y' 黄色，'m' 洋红，'c' 青色

+%   'r' 红色，'g' 绿色，'b' 蓝色

+%   'w' 白色，'k' 黑色

 set(h, 'Color', [0.5, 0.5, 0.4])

 % 也可以使用 RGB 值指定颜色

 set(h, 'LineStyle', '--')

@@ -328,7 +336,8 @@ load('myFileName.mat')  % 将指定文件中的变量载入到当前工作空间
 % 与脚本文件类似，同样以 .m 作为后缀名

 % 但函数文件可以接受用户输入的参数并返回运算结果

 % 并且函数拥有自己的工作空间（变量域），不必担心变量名称冲突

-% 函数文件的名称应当与其所定义的函数的名称一致（比如下面例子中函数文件就应命名为 double_input.m）

+% 函数文件的名称应当与其所定义的函数的名称一致

+% 比如下面例子中函数文件就应命名为 double_input.m

 % 使用 'help double_input.m' 可返回函数定义中第一行注释信息

 function output = double_input(x) 

     % double_input(x) 返回 x 的 2 倍

@@ -463,14 +472,16 @@ triu(x)  % 返回 x 的上三角这部分
 tril(x)  % 返回 x 的下三角这部分

 cross(A, B)  % 返回 A 和 B 的叉积（矢量积、外积）

 dot(A, B)  % 返回 A 和 B 的点积（数量积、内积），要求 A 和 B 必须等长

-transpose(A)  % A 的转置，等价于 A'

+transpose(A)  % 矩阵（非共轭）转置，等价于 A.' （注意！有个点）

 fliplr(A)  % 将一个矩阵左右翻转

 flipud(A)  % 将一个矩阵上下翻转

 

 % 矩阵分解

-[L, U, P] = lu(A)  % LU 分解：PA = LU，L 是下三角阵，U 是上三角阵，P 是置换阵

-[P, D] = eig(A)  % 特征值分解：AP = PD，D 是由特征值构成的对角阵，P 的各列就是对应的特征向量

-[U, S, V] = svd(X)  % 奇异值分解：XV = US，U 和 V 是酉矩阵，S 是由奇异值构成的半正定实数对角阵

+[L, U, P] = lu(A)   % LU 分解：PA = LU，L 是下三角阵，U 是上三角阵，P 是置换阵

+[P, D]    = eig(A)  % 特征值分解：AP = PD

+                    %   D 是由特征值构成的对角阵，P 的各列就是对应的特征向量

+[U, S, V] = svd(X)  % 奇异值分解：XV = US

+                    %   U 和 V 是酉矩阵，S 是由奇异值构成的半正定实数对角阵

 

 % 常用向量函数

 max     % 最大值

@@ -489,5 +500,5 @@ perms(x) % x 元素的全排列
 

 ## 相关资料

 

-* 官方网页：[http://http://www.mathworks.com/products/matlab/](http://www.mathworks.com/products/matlab/)

-* 官方论坛：[http://www.mathworks.com/matlabcentral/answers/](http://www.mathworks.com/matlabcentral/answers/)

+* 官方网页：[MATLAB - 技术计算语言 - MATLAB & Simulink](https://ww2.mathworks.cn/products/matlab.html)

+* 官方论坛：[MATLAB Answers - MATLAB Central](https://ww2.mathworks.cn/matlabcentral/answers/)

diff --git a/zh-cn/python-cn.html.markdown b/zh-cn/python-cn.html.markdown
index deb94cdc..65f125d1 100644
--- a/zh-cn/python-cn.html.markdown
+++ b/zh-cn/python-cn.html.markdown
@@ -439,7 +439,7 @@ Human.grunt()  # => "*grunt*"
 
 # 我们可以导入其他模块
 import math
-print math.sqrt(16)  # => 4
+print math.sqrt(16)  # => 4.0
 
 # 我们也可以从一个模块中导入特定的函数
 from math import ceil, floor
diff --git a/zh-cn/python3-cn.html.markdown b/zh-cn/python3-cn.html.markdown
index 211ce0c5..fd962305 100644
--- a/zh-cn/python3-cn.html.markdown
+++ b/zh-cn/python3-cn.html.markdown
@@ -10,13 +10,13 @@ filename: learnpython3-cn.py
 lang: zh-cn
 ---
 
-Python是由吉多·范罗苏姆(Guido Van Rossum)在90年代早期设计。它是如今最常用的编程
-语言之一。它的语法简洁且优美，几乎就是可执行的伪代码。
+Python 是由吉多·范罗苏姆(Guido Van Rossum)在 90 年代早期设计。
+它是如今最常用的编程语言之一。它的语法简洁且优美，几乎就是可执行的伪代码。
 
-欢迎大家斧正。英文版原作Louie Dinh [@louiedinh](http://twitter.com/louiedinh)
-或着Email louiedinh [at] [谷歌的信箱服务]。中文翻译Geoff Liu。
+欢迎大家斧正。英文版原作 Louie Dinh [@louiedinh](http://twitter.com/louiedinh)
+邮箱 louiedinh [at] [谷歌的信箱服务]。中文翻译 Geoff Liu。
 
-注意：这篇教程是特别为Python3写的。如果你想学旧版Python2，我们特别有另一篇教程。
+注意：这篇教程是基于 Python 3 写的。如果你想学旧版 Python 2，我们特别有[另一篇教程](http://learnxinyminutes.com/docs/python/)。
 
 ```python
 
@@ -70,15 +70,15 @@ not True  # => False
 not False  # => True
 
 # 逻辑运算符，注意and和or都是小写
-True and False #=> False
-False or True #=> True
+True and False # => False
+False or True # => True
 
 # 整数也可以当作布尔值
-0 and 2 #=> 0
--5 or 0 #=> -5
-0 == False #=> True
-2 == True #=> False
-1 == True #=> True
+0 and 2 # => 0
+-5 or 0 # => -5
+0 == False # => True
+2 == True # => False
+1 == True # => True
 
 # 用==判断相等
 1 == 1  # => True
@@ -113,10 +113,11 @@ False or True #=> True
 
 # 可以重复参数以节省时间
 "{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick")
-#=> "Jack be nimble, Jack be quick, Jack jump over the candle stick"
+# => "Jack be nimble, Jack be quick, Jack jump over the candle stick"
 
 # 如果不想数参数，可以用关键字
-"{name} wants to eat {food}".format(name="Bob", food="lasagna") #=> "Bob wants to eat lasagna"
+"{name} wants to eat {food}".format(name="Bob", food="lasagna") 
+# => "Bob wants to eat lasagna"
 
 # 如果你的Python3程序也要在Python2.5以下环境运行，也可以用老式的格式化语法
 "%s can be %s the %s way" % ("strings", "interpolated", "old")
@@ -132,8 +133,8 @@ None is None  # => True
 # 所有其他值都是True
 bool(0)  # => False
 bool("")  # => False
-bool([]) #=> False
-bool({}) #=> False
+bool([]) # => False
+bool({}) # => False
 
 
 ####################################################
@@ -233,7 +234,8 @@ filled_dict = {"one": 1, "two": 2, "three": 3}
 filled_dict["one"]   # => 1
 
 
-# 用keys获得所有的键。因为keys返回一个可迭代对象，所以在这里把结果包在list里。我们下面会详细介绍可迭代。
+# 用 keys 获得所有的键。
+# 因为 keys 返回一个可迭代对象，所以在这里把结果包在 list 里。我们下面会详细介绍可迭代。
 # 注意：字典键的顺序是不定的，你得到的结果可能和以下不同。
 list(filled_dict.keys())   # => ["three", "two", "one"]
 
@@ -261,7 +263,7 @@ filled_dict.setdefault("five", 5)  # filled_dict["five"]设为5
 filled_dict.setdefault("five", 6)  # filled_dict["five"]还是5
 
 # 字典赋值
-filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4}
+filled_dict.update({"four":4}) # => {"one": 1, "two": 2, "three": 3, "four": 4}
 filled_dict["four"] = 4  # 另一种赋值方法
 
 # 用del删除
@@ -362,7 +364,7 @@ else:   # else语句是可选的，必须在所有的except之后
 
 filled_dict = {"one": 1, "two": 2, "three": 3}
 our_iterable = filled_dict.keys()
-print(our_iterable) # => range(1,10) 是一个实现可迭代接口的对象
+print(our_iterable) # => dict_keys(['one', 'two', 'three'])，是一个实现可迭代接口的对象
 
 # 可迭代对象可以遍历
 for i in our_iterable:
@@ -376,17 +378,17 @@ our_iterator = iter(our_iterable)
 
 # 迭代器是一个可以记住遍历的位置的对象
 # 用__next__可以取得下一个元素
-our_iterator.__next__()  #=> "one"
+our_iterator.__next__()  # => "one"
 
 # 再一次调取__next__时会记得位置
-our_iterator.__next__()  #=> "two"
-our_iterator.__next__()  #=> "three"
+our_iterator.__next__()  # => "two"
+our_iterator.__next__()  # => "three"
 
 # 当迭代器所有元素都取出后，会抛出StopIteration
 our_iterator.__next__() # 抛出StopIteration
 
 # 可以用list一次取出迭代器所有的元素
-list(filled_dict.keys())  #=> Returns ["one", "two", "three"]
+list(filled_dict.keys())  # => Returns ["one", "two", "three"]
 
 
 
diff --git a/zh-cn/ruby-cn.html.markdown b/zh-cn/ruby-cn.html.markdown
index 657a913d..9918c022 100644
--- a/zh-cn/ruby-cn.html.markdown
+++ b/zh-cn/ruby-cn.html.markdown
@@ -6,11 +6,25 @@ 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"]
+  - ["Ariel Krakowski", "http://www.learneroo.com"]
+  - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+  - ["Levi Bostian", "https://github.com/levibostian"]
+  - ["Rahil Momin", "https://github.com/iamrahil"]
+  - ["Gabriel Halley", "https://github.com/ghalley"]
+  - ["Persa Zula", "http://persazula.com"]
+  - ["Jake Faris", "https://github.com/farisj"]
+  - ["Corey Ward", "https://github.com/coreyward"]
+  - ["Jannik Siebert", "https://github.com/janniks"]
+  - ["Keith Miyake", "https://github.com/kaymmm"]
   - ["lidashuang", "https://github.com/lidashuang"]
   - ["ftwbzhao", "https://github.com/ftwbzhao"]
 translators:
   - ["Lin Xiangyu", "https://github.com/oa414"]
   - ["Jiang Haiyun", "https://github.com/haiiiiiyun"]
+  - ["woclass", "https://github.com/inkydragon"]
 ---
 
 ```ruby
@@ -18,26 +32,27 @@ translators:
 
 =begin
 这是多行注释
-没人用这个
-你也不该用
 =end
 
-# 首先，也是最重要的，所有东西都是对象
+# 在 Ruby 中，（几乎）所有东西都是对象
 
 # 数字是对象
-
-3.class #=> Fixnum
-
+3.class #=> Integer
 3.to_s #=> "3"
 
+# 字符串是对象
+"Hello".class #=> String
+
+# 甚至方法也是对象
+"Hello".method(:class).class #=> Method
 
-# 一些基本的算术符号
-1 + 1 #=> 2
-8 - 1 #=> 7
-10 * 2 #=> 20
-35 / 5 #=> 7
-2**5 #=> 32
-5 % 3 #=> 2
+# 一些基本的算术操作
+1 + 1   #=> 2
+8 - 1   #=> 7
+10 * 2  #=> 20
+35 / 5  #=> 7
+2 ** 5  #=> 32
+5 % 3   #=> 2
 
 # 位运算符
 3 & 5 #=> 1
@@ -48,6 +63,7 @@ translators:
 # 实际上是调用对象的方法
 1.+(3) #=> 4
 10.* 5 #=> 50 
+100.methods.include?(:/) #=> true
 
 # 特殊的值也是对象
 nil # 相当于其它语言中的 null
@@ -66,11 +82,11 @@ false.class #=> FalseClass
 1 != 1 #=> false
 2 != 1 #=> true
 
-# 除了false自己，nil是唯一的另一个值为false的对象
-
-!nil   #=> true
-!false #=> true
-!0     #=> false
+# 除了 false 自己，nil 是唯一的另一个值为 false 的对象
+!!nil   #=> false
+!!false #=> false
+!!0     #=> true
+!!""    #=> true
 
 # 更多比较
 1 < 10 #=> true
@@ -90,11 +106,11 @@ true || false #=> true
 !true #=> false
 
 # 也有优先级更低的逻辑运算符
-# 它们用于控制流结构中，用来串接语句，直到返回true或false。
+# 它们用于控制流结构中，用来串接语句，直到返回 true 或 false。
 
-# `do_something_else` 只当 `do_something` 返回true时才会被调用
+# `do_something_else` 只当 `do_something` 返回 true 时才会被调用
 do_something() and do_something_else()
-# `log_error` 只当 `do_something` 返回false时才会被调用
+# `log_error` 只当 `do_something` 返回 false 时才会被调用
 do_something() or log_error()
 
 
@@ -114,6 +130,7 @@ placeholder = "use string interpolation"
 'hello ' + 'world'  #=> "hello world"
 'hello ' + 3 #=> TypeError: can't convert Fixnum into String
 'hello ' + 3.to_s #=> "hello 3"
+"hello #{3}" #=> "hello 3"
 
 # 合并字符串及其运算符
 'hello ' * 3 #=> "hello hello hello "
@@ -141,7 +158,7 @@ x = y = 10 #=> 10
 x #=> 10
 y #=> 10
 
-# 按照惯例，使用类似snake_case风格的变量名
+# 按照惯例，使用类似 snake_case 风格的变量名
 snake_case = true
 
 # 使用有意义的变量名
@@ -174,6 +191,7 @@ array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
 # 数组可以被索引
 # 从前面开始
 array[0] #=> 1
+array.first #=> 1
 array[12] #=> nil
 
 # 像运算符一样，[var] 形式的访问
@@ -189,13 +207,13 @@ array.last #=> 5
 # 同时指定开始的位置和长度
 array[2, 3] #=> [3, 4, 5]
 
+# 或者指定一个区间
+array[1..3] #=> [2, 3, 4]
+
 # 将数组逆序
 a=[1,2,3]
 a.reverse! #=> [3,2,1]
 
-# 或者指定一个区间
-array[1..3] #=> [2, 3, 4]
-
 # 像这样往数组增加一个元素
 array << 6 #=> [1, 2, 3, 4, 5, 6]
 # 或者像这样
@@ -217,14 +235,18 @@ hash['number'] #=> 5
 # 查询一个不存在的键将会返回nil
 hash['nothing here'] #=> nil
 
-# 从Ruby 1.9开始，用符号作为键的时候有特别的记号表示:
+# 从 Ruby 1.9 开始，用符号作为键的时候有特别的记号表示:
 
 new_hash = { defcon: 3, action: true }
 
 new_hash.keys #=> [:defcon, :action]
 
+# 检查键值是否存在
+hash.key?(:defcon) #=> true
+hash.value?(3) #=> true
+
 # 小贴士：数组和哈希表都是可枚举的
-# 它们共享一些有用的方法，比如each,map,count等等
+# 它们共享一些有用的方法，比如 each, map, count 等等
 
 # 控制流
 
@@ -236,6 +258,8 @@ else
  "else, also optional"
 end
 
+# 循环
+
 for counter in 1..5
   puts "iteration #{counter}"
 end
@@ -246,14 +270,14 @@ end
 #=> iteration 5
 
 
-# 但是，没有人用for循环。
-# 你应该使用"each"方法，然后再传给它一个块。
-# 所谓块就是可以传给像"each"这样的方法的代码段。
-# 它类似于其它语言中的lambdas, 匿名函数或闭包。
+# 但是，没有人用 for 循环。
+# 你应该使用 "each" 方法，然后再传给它一个块。
+# 所谓块就是可以传给像 "each" 这样的方法的代码段。
+# 它类似于其它语言中的 lambdas, 匿名函数或闭包。
 #
-# 区间上的"each"方法会对区间中的每个元素运行一次块代码。
-# 我们将counter作为一个参数传给了块。
-# 调用带有块的"each"方法看起来如下：
+# 区间上的 "each" 方法会对区间中的每个元素运行一次块代码。
+# 我们将 counter 作为一个参数传给了块。
+# 调用带有块的 "each" 方法看起来如下：
 
 (1..5).each do |counter|
   puts "iteration #{counter}"
@@ -275,7 +299,7 @@ hash.each do |key, value|
   puts "#{key} is #{value}"
 end
 
-# 如果你还需要索引值，可以使用"each_with_index"，并且定义
+# 如果你还需要索引值，可以使用 "each_with_index"，并且定义
 # 一个索引变量
 array.each_with_index do |element, index|
   puts "#{element} is number #{index} in the array"
@@ -293,7 +317,7 @@ end
 #=> iteration 5
 
 # Ruby 中还有很多有用的循环遍历函数，
-# 如"map","reduce","inject"等等。
+# 如 "map", "reduce", "inject" 等等。
 # 以map为例，它会遍历数组，并根据你在
 # 块中定义的逻辑对它进行处理，然后返回
 # 一个全新的数组。
@@ -388,19 +412,26 @@ surround { puts 'hello world' }
 # {
 # hello world
 # }
+# => nil
 
 # 可以向函数传递一个块
 # "&"标记传递的块是一个引用
 def guests(&block)
-  block.call 'some_argument'
+  block.class #=> Proc
+  block.call(4)
 end
 
+guests { |n| "You have #{n} guests." }
+# => "You have 4 guests."
+
 # 可以传递多个参数，这些参数会转成一个数组，
 # 这也是使用星号符 ("*") 的原因：
 def guests(*array)
   array.each { |guest| puts guest }
 end
 
+# 结构
+
 # 如果函数返回一个数组，在赋值时可以进行拆分：
 def foods
     ['pancake', 'sandwich', 'quesadilla']
@@ -409,21 +440,42 @@ breakfast, lunch, dinner = foods
 breakfast #=> 'pancake'
 dinner #=> 'quesadilla'
 
-# 按照惯例，所有返回布尔值的方法都以?结尾
+# 有些情况下，你会想使用解构操作符 `*` 来解构数组
+ranked_competitors = ["John", "Sally", "Dingus", "Moe", "Marcy"]
+
+def best(first, second, third)
+  puts "Winners are #{first}, #{second}, and #{third}."
+end
+
+best *ranked_competitors.first(3) #=> Winners are John, Sally, and Dingus.
+
+# 结构操作符也可放在参数里面
+def best(first, second, third, *others)
+  puts "Winners are #{first}, #{second}, and #{third}."
+  puts "There were #{others.count} other participants."
+end
+
+best *ranked_competitors 
+#=> Winners are John, Sally, and Dingus.
+#=> There were 2 other participants.
+
+# 按照惯例，所有返回布尔值的方法都以 ? 结尾
 5.even? # false
 5.odd? # true
 
-# 如果方法名末尾有!，表示会做一些破坏性的操作，比如修改调用者自身。
-# 很多方法都会有一个!的版本来进行修改，和一个非!的版本
-# 只用来返回更新了的结果
+# 如果方法名末尾有感叹号 !，表示会做一些破坏性的操作，比如修改调用者自身。
+# 很多方法都会有一个 ! 的版本来进行修改，
+# 和一个只返回更新结果的非 ! 版本
 company_name = "Dunder Mifflin"
 company_name.upcase #=> "DUNDER MIFFLIN"
 company_name #=> "Dunder Mifflin"
-company_name.upcase! # we're mutating company_name this time!
+# 这次我们修改了 company_name
+company_name.upcase! #=> "DUNDER MIFFLIN"
 company_name #=> "DUNDER MIFFLIN"
 
+# 类
 
-# 用class关键字定义一个类
+# 用 class 关键字定义一个类
 class Human
 
   # 一个类变量，它被这个类的所有实例变量共享
@@ -431,30 +483,30 @@ class Human
   
   # 基本构造函数
   def initialize(name, age = 0)
-    # 将参数值赋给实例变量"name"
+    # 将参数值赋给实例变量 "name"
     @name = name
-    # 如果没有给出age,那么会采用参数列表中的默认值
+    # 如果没有给出 age,那么会采用参数列表中的默认值
     @age = age
   end
   
-  # 基本的setter方法
+  # 基本的 setter 方法
   def name=(name)
     @name = name
   end
   
-  # 基本地getter方法
+  # 基本地 getter 方法
   def name
     @name
   end
   
-  # 以上的功能也可以用下面的attr_accessor来封装
+  # 以上的功能也可以用下面的 attr_accessor 来封装
   attr_accessor :name
   
-  # Getter/setter方法也可以像这样单独创建
+  # Getter/setter 方法也可以像这样单独创建
   attr_reader :name
   attr_writer :name
   
-  # 类方法通过使用self与实例方法区别开来。
+  # 类方法通过使用 self 与实例方法区别开来。
   # 它只能通过类来调用，不能通过实例调用。
   def self.say(msg)
     puts "#{msg}"
@@ -468,7 +520,6 @@ end
 
 # 初始化一个类
 jim = Human.new("Jim Halpert")
-
 dwight = Human.new("Dwight K. Schrute")
 
 # 让我们来调用一些方法
@@ -483,15 +534,15 @@ dwight.name #=> "Dwight K. Schrute"
 Human.say('Hi') #=> "Hi"
 
 # 变量的作用域由它们的名字格式定义
-# 以$开头的变量具有全局域
+# 以 $ 开头的变量具有全局域
 $var = "I'm a global var"
 defined? $var #=> "global-variable"
 
-# 以@开头的变量具有实例作用域
+# 以 @ 开头的变量具有实例作用域
 @var = "I'm an instance var"
 defined? @var #=> "instance-variable"
 
-# 以@@开头的变量具有类作用域
+# 以 @@ 开头的变量具有类作用域
 @@var = "I'm a class var"
 defined? @@var #=> "class variable"
 
@@ -568,7 +619,6 @@ Book.foo       # => 'foo'
 Book.new.foo   # => NoMethodError: undefined method `foo'
 
 # 当包含或扩展一个模块时，相应的回调代码会被执行。
-
 module ConcernExample
   def self.included(base)
     base.extend(ClassMethods)
diff --git a/zh-cn/solidity-cn.html.markdown b/zh-cn/solidity-cn.html.markdown
new file mode 100644
index 00000000..ec684997
--- /dev/null
+++ b/zh-cn/solidity-cn.html.markdown
@@ -0,0 +1,825 @@
+---
+language: Solidity
+filename: learnSolidity-cn.sol
+lang: zh-cn
+contributors:
+  - ["Nemil Dalal", "https://www.nemil.com"]
+  - ["Joseph Chow", ""]
+  - ["Bhoomtawath Plinsut", "https://github.com/varshard"]
+  - ["Shooter", "https://github.com/liushooter"]
+translators:
+  - ["Bob Jiang", "https://github.com/bobjiang"]
+---
+
+Solidity 使你在[以太坊](https://www.ethereum.org/)上编程，一个基于区块链的虚拟机，
+允许创建和执行智能合约，无需中心化的或可信的一方。
+
+Solidity 是一种与 Javascript 和 C 的相似的、静态类型的合约编程语言。与OOP（面向对象）中
+的对象一样，每个合约都包含状态变量、函数和公共数据类型。合约特定功能包括修饰符（guard）子句，
+事件通知的侦听器及自定义的全局变量。
+
+以太坊合约的例子包括众筹、投票以及盲拍（私密拍卖）。
+
+Solidity 代码中存在高风险和高成本的错误，因此你必须非常小心地进行测试并慢慢地发布。**随着
+以太坊的快速变化，本文档不可能是最新的，所以你应该关注最新的的 solidity 聊天室和以太网博客。
+照搬这里的代码，会存在重大错误或弃用代码模式的风险。（说人话--别照抄例子中的代码）**
+
+与其他代码不同，可能还需要添加如暂停、弃用和限制使用的设计模式，来降低风险。本文档主要讨论语法，
+因此排除了许多流行的设计模式。
+
+由于 Solidity 和以太坊正在积极开发，通常会标记为实验或 beta 特性，并很可能会更改。因此欢迎
+提交更改请求。
+
+```javascript
+// 首先，一个简单的银行合约
+// 允许存款、取款、以及检查余额
+
+// simple_bank.sol (注意 .sol 后缀)
+/* **** 例子开始 **** */
+
+// 声明源文件的编译器版本
+pragma solidity ^0.4.19;
+
+// 开始 Natspec 注释（三个斜杠）
+// 用作文档 - 及UI元素、动作的描述性数据
+
+/// @title SimpleBank
+/// @author nemild
+
+/* 'contract' 和其他语言的 'class' 类似 (类变量、继承等) */
+contract SimpleBank { // 单词首字母大写
+    // 声明函数外的状态变量，合约生命周期内可用
+
+    // 地址映射到余额的字典，总是要小心数字的溢出攻击
+    mapping (address => uint) private balances;
+
+    // "private" 的意思是其他合约不能直接查询余额，但对于区块链上的其他方来说，数据仍然是可见的。
+
+    address public owner;
+    // 'public' 使用户或合约可以从外部读取（不可写）
+
+    // Events（事件） - 向外部监听器发布动作
+    event LogDepositMade(address accountAddress, uint amount);
+
+    // Constructor（构造函数）（译者注：solidity 从0.4.22开始使用 constructor() 作为构造函数）
+    function SimpleBank() public {
+        // msg 提供了发送给合约的消息详情
+        // msg.sender 是合约的调用者（这里是合约创建者的地址）
+        owner = msg.sender;
+    }
+
+    /// @notice 存款 ether (以太币)
+    /// @return 存款后用户的余额
+    function deposit() public payable returns (uint) {
+        // 使用 'require' 来检测用户的输入，'assert' 是内部常量
+        // 我们要确保不会发生溢出问题（上溢）
+        require((balances[msg.sender] + msg.value) >= balances[msg.sender]);
+
+        balances[msg.sender] += msg.value;
+        // 状态变量不需要 "this." 或 "self."
+        // 默认情况下，所有值都设置为数据类型的初始值
+
+        LogDepositMade(msg.sender, msg.value); // 触发事件
+
+        return balances[msg.sender];
+    }
+
+    /// @notice 从银行取款以太币 （ether）
+    /// @dev 不会返回任何多余的以太币（ether）
+    /// @param withdrawAmount 取款的数量
+    /// @return 用户还剩下的余额
+    function withdraw(uint withdrawAmount) public returns (uint remainingBal) {
+        require(withdrawAmount <= balances[msg.sender]);
+
+        // 注意在发送任何交易，即通过 .transfer .send 调用外部函数之前，马上减掉取款数量
+        // 这可以允许调用者使用递归请求大于其余额的金额。目标是在调用外部函数之前提交状态，
+        // 包括.transfer / .send
+        balances[msg.sender] -= withdrawAmount;
+
+        // 这会自动引发失败，也就是说还原了更新的余额
+        msg.sender.transfer(withdrawAmount);
+
+        return balances[msg.sender];
+    }
+
+    /// @notice 获取余额
+    /// @return 用户的余额
+    // 'view' 防止函数编辑状态变量；允许函数本地运行或链下运行
+    function balance() view public returns (uint) {
+        return balances[msg.sender];
+    }
+}
+// ** 例子结束 **
+
+
+// 下面， solidity 基础
+
+// 1. 数据类型与关联的方法
+// uint 类型用作现金数量（没有双浮点型或单浮点型）及日期（用 unix 时间）
+uint x;
+
+// 256字节的 int， 实例化后不能改变
+int constant a = 8;
+int256 constant a = 8; // 和上一行一样，这里256字节显性化了
+uint constant VERSION_ID = 0x123A1; // 16进制常量
+// 'constant' 关键字, 编译器在每个出现的地方替换为实际的值
+
+// 所有的状态变量（函数之外的那些），默认是 'internal' 的，只能在合约及所有继承的合约内
+// 可以访问。需要显性的设置为 'public' 才能允许外部合约访问。
+int256 public a = 8;
+
+// 对于 int 和 uint，可以显性的设置位数（从8位到256位，8位跳跃），如int8, int16, int24
+uint8 b;
+int64 c;
+uint248 e;
+
+// 当心不要溢出以及免收此类攻击，例如，对于加法最好这么做：
+uint256 c = a + b;
+assert(c >= a); // assert 测试内部不变的值；require 用来测试用户输入
+// 更多通用算法问题的例子，参考 Zeppelin's SafeMath library
+// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
+
+
+// 没有内建的随机函数，使用其他合约获得随机数
+
+// 类型转换
+int x = int(b);
+
+bool b = true; // 或 'var b = true;' 隐含的类型
+
+// 地址 - 20个字节或160位以太坊地址（16进制数字），不允许进行运算
+address public owner;
+
+// 账户类型：
+// 合约账户：在创建时设置地址（创建者地址函数，交易发送）
+// 外部账户：（个人账户）从公钥创建的地址
+
+// 'public' 的含义是自动创建的 getter 方法，而不是 setter 方法可以公开的、外部访问。
+
+// 所有地址都可以进行转账
+owner.transfer(SOME_BALANCE); // 失败后还原
+
+// 还可以调用较低级别的 .send ， 转账失败会返回 false
+if (owner.send) {}
+// 记住：用 'if' 包着 send 函数，因为合约地址执行这些函数转账时，可能会失败
+// 另外，确保转账前先减掉余额，因为存在递归调用的风险。
+
+// 检查余额
+owner.balance; // 所有者的余额（用户或合约）
+
+
+// 字符类型，从1到32位可用
+byte a; // byte 等同于 byte1
+bytes2 b;
+bytes32 c;
+
+// 动态大小的字符
+bytes m; // 特殊的数组，等同于 byte[]，比 byte1 到 byte32 更贵
+// 尽可能不用 bytes
+
+// 等同于 bytes，但不允许长度或索引的访问
+string n = "hello"; // UTF8存储，注意双引号而不是单引号
+// 字符功能未来会增加，推荐使用 bytes32 或 bytes
+
+// 推断类型
+// var 会根据第一次赋值决定类型，不能用来作为函数的参数
+var a = true;
+// 小心使用，推断可能带来错误的类型，例如，int8，而计数器需要的是 int16
+
+// 函数可以用 var 类型赋值给变量
+function a(uint x) returns (uint) {
+    return x * 2;
+}
+var f = a;
+f(22); // 调用
+
+// 默认的，所有值实例化后都设为 0
+
+// 大多数类型上可以调用删除（不会销毁值，而是设置为0，初始值）
+uint x = 5;
+
+
+// 集合
+(x, y) = (2, 7); // 多值的赋值
+
+
+// 2. 数据结构
+// 数组
+bytes32[5] nicknames; // 静态数组
+bytes32[] names; // 动态数组
+uint newLength = names.push("John"); // 添加返回数组的新长度
+// 长度
+names.length; // 获得数组长度
+names.length = 1; // 可以设定长度（仅针对 storage 中的动态数组）
+
+// 多维数组
+uint x[][5]; // 5个动态数组元素的数组(和多数语言的顺序相反)
+
+// 字典类型 (任一类型到其他类型的映射)
+mapping (string => uint) public balances;
+balances["charles"] = 1;
+// balances["ada"]得到 0, 所有没有设定key值的，返回0
+// 'public' 允许跟着（调用）另一份合约
+contractName.balances("charles"); // returns 1
+// 'public' 创建 getter （而不是 setter ）如下：
+function balances(string _account) returns (uint balance) {
+    return balances[_account];
+}
+
+// 内嵌的 mapping
+mapping (address => mapping (address => uint)) public custodians;
+
+// 删除
+delete balances["John"];
+delete balances; // 所有元素设为 0
+
+// 不像其他语言，不知道 keys 的话不能列出 mapping 中的所有元素 - 可以在这之上构建数据结构
+
+// 结构
+struct Bank {
+    address owner;
+    uint balance;
+}
+Bank b = Bank({
+    owner: msg.sender,
+    balance: 5
+});
+// 或
+Bank c = Bank(msg.sender, 5);
+
+c.balance = 5; // 设为新值
+delete b;
+// 设为初始值，结构内所有变量设为0，除了 mapping
+
+// 枚举
+enum State { Created, Locked, Inactive }; // 常常作为状态机
+State public state; // 声明枚举变量
+state = State.Created;
+// 枚举类型可以显性化的转换为 ints
+uint createdState = uint(State.Created); //  0
+
+// 数据位置：内存（Memory） vs. 存储（storage） vs. 调用数据（calldata）
+// 所有复杂类型（数据、结构）都有一个数据位置，内存数据不持久，而存储的数据是持久的。
+// 本地变量和状态变量默认是存储，函数参数默认是内存。堆栈存放较小的本地变量
+
+// 多数类型，可以显性化的设定使用的数据位置
+
+
+// 3. 简单操作符
+// solidity 提供了比较、位运算及数学运算的功能
+// 指数运算: **
+// 异或运算: ^
+// 按位取反: ~
+
+
+// 4. 值得注意的全局变量
+// ** this **
+this; // 合约的地址
+// 常常用在合约生命周期结束前，转走剩下的余额
+this.balance;
+this.someFunction(); // 通过 call 的方式而不是内部跳转的方式，从外部调用函数
+
+// ** msg - 合约收到的当前消息 ** **
+msg.sender; // 发送者的地址
+msg.value; // 该合约内的以太币数量（单位 wei），该函数应该标记为 "payable"
+msg.data; // 字符，完整的调用数据
+msg.gas; // 剩余 gas
+
+// ** tx - 交易信息 **
+tx.origin; // 本次交易的发送者地址
+tx.gasprice; // 本次交易的 gas price
+
+// ** block - 当前区块信息 **
+now; // 当前时间（大概）block.timestamp的别名 (采用的 Unix 时间)
+// 注意这个可能被矿工操纵，因此请小心使用
+
+block.number; // 当前区块号
+block.difficulty; // 当前区块难度
+block.blockhash(1); // 返回 bytes32，只对最近 256 个区块有效
+block.gasLimit();
+
+// ** 存储 - 持久化存储哈希 **
+storage['abc'] = 'def'; // 256 位单词 到 256 位单词的映射
+
+
+// 4. 函数及更多
+// A. 函数
+// 简单函数
+function increment(uint x) returns (uint) {
+    x += 1;
+    return x;
+}
+
+// 函数可以通过指定返回的参数名，来返回多个参数
+function increment(uint x, uint y) returns (uint x, uint y) {
+    x += 1;
+    y += 1;
+}
+// 调用前一个函数
+uint (a,b) = increment(1,1);
+
+// 'view' ('constant'的别名)
+// 表明函数不会改变持久化的变量，View函数会本地执行，而不是链上运行。
+// 注意：constant 关键字很快会废弃。
+uint y = 1;
+
+function increment(uint x) view returns (uint x) {
+    x += 1;
+    y += 1; // 这一行会失败
+    // y 是一个状态变量，不能在 view 的函数里改变 y
+}
+
+// 'pure' 比 'view' 或 'constant' 更加严格，甚至不允许读取状态变量
+// 具体的规则很复杂，请参考
+// view/pure:
+// http://solidity.readthedocs.io/en/develop/contracts.html#view-functions
+
+// '函数可见性指示器'
+// 'view'可以有以下修饰符，包括：
+// public - 内部及外部可见（函数的默认值）
+// external - 仅外部可见(包括 this 发起的调用)
+// private - 仅当前合约可见
+// internal - 仅当前合约及继承的合约可见
+
+// 通常，显性的标记每个函数是个好主意
+
+// 函数的挂起 - 可以将函数赋值给变量
+function a() {
+    var z = b;
+    b();
+}
+
+function b() {
+
+}
+
+// 所有接收 ether 的函数必须标记为 'payable'
+function depositEther() public payable {
+    balances[msg.sender] += msg.value;
+}
+
+
+// 首选循环来递归（最大的调用堆栈深度是 1024），另外不要设置没有限制的循环，
+// 因为这可能会达到 gas limit
+
+// B. 事件
+// 事件通知外部各方; 易于搜索和访问来自外部区块链（使用轻客户端）的事件
+// 通常在合约参数之后声明
+
+// 通常，首字母大写并在前面加上 Log ，防止与函数混淆
+
+// 声明
+event LogSent(address indexed from, address indexed to, uint amount); // 注意 capital first letter
+
+// 调用
+LogSent(from, to, amount);
+
+/*
+    // 对于外部方（合约或外部实体），使用 Web3 Javascript 库来监听
+    // 以下是javascript代码,不是solidity代码
+    Coin.LogSent().watch({}, '', function(error, result) {
+        if (!error) {
+            console.log("Coin transfer: " + result.args.amount +
+                " coins were sent from " + result.args.from +
+                " to " + result.args.to + ".");
+            console.log("Balances now:\n" +
+                "Sender: " + Coin.balances.call(result.args.from) +
+                "Receiver: " + Coin.balances.call(result.args.to));
+        }
+    }
+
+*/
+
+// 一个合约依赖另一个合约的共同范例（例如，合约取决于另一个合约提供的当前汇率）
+
+// C. 修饰器
+// 修饰器验证函数的输入，例如最小余额或用户身份验证; 类似于其他语言的保护子句
+
+// '_' （下划线）经常用在代码的最后一行，表明被调用的函数放在那里
+modifier onlyAfter(uint _time) { require (now >= _time); _; }
+modifier onlyOwner { require(msg.sender == owner) _; }
+// 常用于状态机
+modifier onlyIfStateA (State currState) { require(currState == State.A) _; }
+
+// 修饰器紧跟在函数声明之后
+function changeOwner(newOwner)
+onlyAfter(someTime)
+onlyOwner()
+onlyIfState(State.A)
+{
+    owner = newOwner;
+}
+
+// 下划线可以包含在代码结束之前，但明显地返回将跳过后面的代码，因此谨慎使用
+modifier checkValue(uint amount) {
+    _;
+    if (msg.value > amount) {
+        uint amountToRefund = amount - msg.value;
+        msg.sender.transfer(amountToRefund);
+    }
+}
+
+
+// 6. 判断和循环
+
+// 所有基本的逻辑判断都有效 - 包括 if else, for, while, break, continue
+// return - 但不跳转
+
+// 语法同 javascript, 但没有从非布尔值到布尔值的类型转换
+// (必须使用比较操作符获得布尔变量值)
+
+// 请注意由用户行为决定的循环 - 因为合约对于代码块具有最大量的 gas 限制 -
+// 如果超过限制该代码则将失败
+// 例如：
+for(uint x = 0; x < refundAddressList.length; x++) {
+    refundAddressList[x].transfer(SOME_AMOUNT);
+}
+
+// 上述两个错误:
+// 1. 转账失败会阻塞循环完成，钱被占用
+// 2. 该循环可能会很长（根据需要赔偿的用户数量而定），并且也可能由于超过一个区块最大 gas 限制
+// 而总是失败。你应该让人们自己从他们的子账户取款并标记取款完成
+// 例如，首选拉动式的付款，而不是推动式的付款
+
+
+// 7. 对象与合约
+
+// A. 调用外部合约
+contract InfoFeed {
+    function info() returns (uint ret) { return 42; }
+}
+
+contract Consumer {
+    InfoFeed feed; // 指向区块链上的一个合约
+
+    // 设置 feed 为已存在的合约实例
+    function setFeed(address addr) {
+        // 当心类型自动转换；不会调用构造函数
+        feed = InfoFeed(addr);
+    }
+
+    // 设置 feed 为一个合约的新实例
+    function createNewFeed() {
+        feed = new InfoFeed(); // 创建新实例，调用构造函数
+    }
+
+    function callFeed() {
+        // 最后的括号调用合约，可选择的增加自定义的 ether 或 gas 价格
+        feed.info.value(10).gas(800)();
+    }
+}
+
+// B. 继承
+
+// 和顺序有关，最后继承的合约（如 'def'）可以覆盖之前已继承合约的部分
+contract MyContract is abc, def("a custom argument to def") {
+
+// 覆盖函数
+    function z() {
+        if (msg.sender == owner) {
+            def.z(); // 调用覆盖的函数
+            super.z(); // 调用继承的上层合约的函数
+        }
+    }
+}
+
+// 抽象函数
+function someAbstractFunction(uint x);
+// 不可以编译，因此用在基础或抽象合约中，等待实现
+
+// C. 导入
+
+import "filename";
+import "github.com/ethereum/dapp-bin/library/iterable_mapping.sol";
+
+
+// 8. 其他关键字
+
+// A. 自毁
+// 自毁当前的合约，转账资金到一个地址（常常是创建者的地址）
+selfdestruct(SOME_ADDRESS);
+
+// 从当前或以后的区块中移除存储或代码，会帮助客户端瘦身，但之前的数据会永久在区块链中
+
+// 常见模式，让所有者结束合约并收回剩余的资金
+function remove() {
+    if(msg.sender == creator) { // 只有合约的创建者可以这么做
+        selfdestruct(creator); // 自毁合约，返还资金
+    }
+}
+
+// 可能希望手动停用合约，而不是自毁
+// (发送到自毁合约的 ether 会丢失掉)
+
+
+// 9. 注意合约的设计
+
+// A. 困惑
+// 区块链上所有变量都是公开可见的，因此任何私有的需求变得很困惑。(好比哈希的秘密)
+
+// 步骤: 1. 承诺某事, 2. 揭示承诺
+keccak256("some_bid_amount", "some secret"); // commit
+
+// 以后调用合约的 reveal 函数，展示出用 SHA3 哈希的 bid 加 secret
+reveal(100, "mySecret");
+
+// B. 存储优化
+// 写入区块链可能很昂贵，因为数据是永久存储的；鼓励用巧妙的方法使用内存
+//（最终，编译会更好，但现在有利于规划数据结构 - 并将最小数量存储在区块链中）
+
+// 多维数组这样的变量可能会成本很高
+// (成本用于存储数据 - 而不是声明未填充的变量)
+
+// C. 区块链中的数据访问
+// 不能限制人或计算机读取交易或交易状态的内容
+
+// 然而 'private' 可以防止其他*合约*直接读取数据 - 任意其他方仍然可以从区块链读取数据
+
+// 从开始的所有数据都存在区块链上，因此任何人都可以查看之前的所有数据和变化
+
+// D. 定时任务
+// 必须手动调用合约来处理时间相关的调度；也可以创建外部代码来定期的ping，
+// 或为其他人提供激励（以太）
+
+// E. 观察者模式
+//观察者模式允许您注册为订阅者，然后注册一个由oracle调用的函数
+//（注意，oracle 需要付费来运行此操作）。与 Pub / sub 中的订阅有些相似之处
+
+// 这是一个抽象合约，包括客户端和服务器端的类的导入，客户端应该要实现
+contract SomeOracleCallback {
+    function oracleCallback(int _value, uint _time, bytes32 info) external;
+}
+
+contract SomeOracle {
+    SomeOracleCallback[] callbacks; // 所有订阅者的数组
+
+    // 注册订阅者
+    function addSubscriber(SomeOracleCallback a) {
+        callbacks.push(a);
+    }
+
+    function notify(value, time, info) private {
+        for(uint i = 0;i < callbacks.length; i++) {
+            // 所有调用的订阅者必须实现 oracleCallback
+            callbacks[i].oracleCallback(value, time, info);
+        }
+    }
+
+    function doSomething() public {
+        // 实现的代码
+
+        // 通知所有的订阅者
+        notify(_value, _time, _info);
+    }
+}
+
+// 现在你的客户端合约可以通过 importing SomeOracleCallback 和注册某些 Oracle 来
+// addSubscriber 添加订阅者
+
+// F. 状态机
+// 参见如下的例子，枚举类型的 State 和 修饰器 inState
+
+
+// *** 例子: 众筹的例子（与 Kickstarter 大致相似）***
+// ** 开始例子 **
+
+// CrowdFunder.sol
+pragma solidity ^0.4.19;
+
+/// @title CrowdFunder
+/// @author nemild
+/// @translator bobjiang
+contract CrowdFunder {
+    // 由创建者创建的变量
+    address public creator;
+    address public fundRecipient; // 创建者可能和收件人不同
+    uint public minimumToRaise; // 需要提示，否则每个人都会得到退款
+    string campaignUrl;
+    byte constant version = 1;
+
+    // 数据结构
+    enum State {
+        Fundraising,
+        ExpiredRefund,
+        Successful
+    }
+    struct Contribution {
+        uint amount;
+        address contributor;
+    }
+
+    // 状态变量State variables
+    State public state = State.Fundraising; // 创建时实例化
+    uint public totalRaised;
+    uint public raiseBy;
+    uint public completeAt;
+    Contribution[] contributions;
+
+    event LogFundingReceived(address addr, uint amount, uint currentTotal);
+    event LogWinnerPaid(address winnerAddress);
+
+    modifier inState(State _state) {
+        require(state == _state);
+        _;
+    }
+
+    modifier isCreator() {
+        require(msg.sender == creator);
+        _;
+    }
+
+    // 允许合约销毁之前，最终合约状态后要等待24周
+    modifier atEndOfLifecycle() {
+    require(((state == State.ExpiredRefund || state == State.Successful) &&
+        completeAt + 24 weeks < now));
+        _;
+    }
+
+    function CrowdFunder(
+        uint timeInHoursForFundraising,
+        string _campaignUrl,
+        address _fundRecipient,
+        uint _minimumToRaise)
+        public
+    {
+        creator = msg.sender;
+        fundRecipient = _fundRecipient;
+        campaignUrl = _campaignUrl;
+        minimumToRaise = _minimumToRaise;
+        raiseBy = now + (timeInHoursForFundraising * 1 hours);
+    }
+
+    function contribute()
+    public
+    payable
+    inState(State.Fundraising)
+    returns(uint256 id)
+    {
+        contributions.push(
+            Contribution({
+                amount: msg.value,
+                contributor: msg.sender
+            }) // 采用数组，因此可以遍历
+        );
+        totalRaised += msg.value;
+
+        LogFundingReceived(msg.sender, msg.value, totalRaised);
+
+        checkIfFundingCompleteOrExpired();
+        return contributions.length - 1; // 返回 id
+    }
+
+    function checkIfFundingCompleteOrExpired()
+    public
+    {
+        if (totalRaised > minimumToRaise) {
+            state = State.Successful;
+            payOut();
+
+            // 可以激励在这里发起状态改变的人
+        } else if ( now > raiseBy )  {
+            state = State.ExpiredRefund; // 支持者可以通过调用 getRefund(id) 收取退款
+        }
+        completeAt = now;
+    }
+
+    function payOut()
+    public
+    inState(State.Successful)
+    {
+        fundRecipient.transfer(this.balance);
+        LogWinnerPaid(fundRecipient);
+    }
+
+    function getRefund(uint256 id)
+    inState(State.ExpiredRefund)
+    public
+    returns(bool)
+    {
+        require(contributions.length > id && id >= 0 && contributions[id].amount != 0 );
+
+        uint256 amountToRefund = contributions[id].amount;
+        contributions[id].amount = 0;
+
+        contributions[id].contributor.transfer(amountToRefund);
+
+        return true;
+    }
+
+    function removeContract()
+    public
+    isCreator()
+    atEndOfLifecycle()
+    {
+        selfdestruct(msg.sender);
+        // 创建者获得所有未被声明的钱
+    }
+}
+// ** 结束例子 **
+
+// 10. 其他原生的函数
+
+// 货币单位
+// 货币使用 wei 来定义，以太币的最小单位 = 1 wei;
+uint minAmount = 1 wei;
+uint a = 1 finney; // 1 ether == 1000 finney
+// 其他单位，请参阅: http://ether.fund/tool/converter
+
+// 时间单位
+1 == 1 second
+1 minutes == 60 seconds
+
+// 可以乘以带时间单位的变量，因为单位不会存储在变量中
+uint x = 5;
+(x * 1 days); // 5 天
+
+// 小心闰秒闰年与平等声明的时间
+// (相反，首选大于或小于)
+
+// 加密算法
+// 传递的所有字符串在哈希操作之前需要连接在一起
+sha3("ab", "cd");
+ripemd160("abc");
+sha256("def");
+
+// 11. 安全
+
+// 以太坊的合约中，错误可能是灾难性的 - 即使在 solidity 中是流行的模式，也可能发现是反模式的
+
+// 参见文档底部的安全链接
+
+// 12. 较低层次的函数
+// call - 较低层次，不会经常使用，不提供类型安全性
+successBoolean = someContractAddress.call('function_name', 'arg1', 'arg2');
+
+// callcode - 在调用合约的*上下文*中执行的目标地址上的代码
+// 提供库功能
+someContractAddress.callcode('function_name');
+
+
+// 13. 注意风格
+// 基于 Python 的 PEP8 风格指南
+// 全部风格指南: http://solidity.readthedocs.io/en/develop/style-guide.html
+
+// 快速总结:
+// 4个空格缩进
+// 两行隔开合约声明（和其他高级别的声明）
+// 避免括号内留出多余的空格
+// 可以省略一行语句的花括号 (if, for, 等)
+// else 应该单独一行
+
+
+// 14. NATSPEC 注释
+// 用于文档、注释和外部UI
+
+// 合约的 natspec - 总是在合约定义的上面
+/// @title 合约标题
+/// @author 作者名字
+
+// 函数的 natspec
+/// @notice 函数做什么的相关信息；展示什么时候执行该函数、
+/// @dev 开发者使用的函数文档
+
+// 函数参数、返回值的 natspec
+/// @param 有关参数用途的描述
+/// @return 返回值的描述
+```
+
+## 更多资源
+- [Solidity Docs](https://solidity.readthedocs.org/en/latest/)
+- [Smart Contract Best Practices](https://github.com/ConsenSys/smart-contract-best-practices)
+- [EthFiddle - The JsFiddle for Solidity](https://ethfiddle.com/)
+- [Browser-based Solidity Editor](https://remix.ethereum.org/)
+- [Gitter Solidity Chat room](https://gitter.im/ethereum/solidity)
+- [Modular design strategies for Ethereum Contracts](https://docs.erisindustries.com/tutorials/solidity/)
+
+## 重要的库文件
+- [Zeppelin](https://github.com/OpenZeppelin/zeppelin-solidity/): Libraries that provide common contract patterns (crowdfuding, safemath, etc)
+
+## 示例合约
+- [Dapp Bin](https://github.com/ethereum/dapp-bin)
+- [Solidity Baby Step Contracts](https://github.com/fivedogit/solidity-baby-steps/tree/master/contracts)
+- [ConsenSys Contracts](https://github.com/ConsenSys/dapp-store-contracts)
+- [State of Dapps](http://dapps.ethercasts.com/)
+
+## 安全
+- [Thinking About Smart Contract Security](https://blog.ethereum.org/2016/06/19/thinking-smart-contract-security/)
+- [Smart Contract Security](https://blog.ethereum.org/2016/06/10/smart-contract-security/)
+- [Hacking Distributed Blog](http://hackingdistributed.com/)
+
+## 风格
+- [Solidity Style Guide](http://solidity.readthedocs.io/en/latest/style-guide.html): Ethereum's style guide is heavily derived from Python's [PEP 8](https://www.python.org/dev/peps/pep-0008/) style guide.
+
+## 编辑器
+- [Emacs Solidity Mode](https://github.com/ethereum/emacs-solidity)
+- [Vim Solidity](https://github.com/tomlion/vim-solidity)
+- Editor Snippets ([Ultisnips format](https://gist.github.com/nemild/98343ce6b16b747788bc))
+
+## Future to Dos
+- 新关键字: protected, inheritable
+- 常见设计模式列表 (throttling, RNG, version upgrade)
+- 常见的安全反模式
+
+请随意发送 pull request 或者发邮件给作者  nemild -/at-/ gmail
+
+或者发邮件给译者 jiangxb -/at-/ gmail.com
diff --git a/zh-cn/sql.html.markdown b/zh-cn/sql.html.markdown
new file mode 100644
index 00000000..9d430bd1
--- /dev/null
+++ b/zh-cn/sql.html.markdown
@@ -0,0 +1,105 @@
+---
+language: SQL
+filename: learnsql.sql
+contributors:
+  - ["Bob DuCharme", "http://bobdc.com/"]
+translators:
+  - ["Shuxin Shu", "https://github.com/NamelessAshone"]
+lang: zh-cn
+---
+
+结构化查询语言(SQL)是一个ISO标准语言，用于创建和管理数据库，
+这种数据库存储一系列表。不同的实现通常会添加特有的语言扩展;
+[不同SQL实现的比较(Comparison of different SQL implementat-
+ions)](http://troels.arvin.dk/db/rdbms/)是一份很好的产品差
+异参考文档。
+
+不同的实现通常会提供一个命令行用于交互式键入命令和显示输出，
+同时这些实现也会提供一种执行脚本文件的方法。(如何退出命令行
+就是就是SQL中尚未被标准化部分的一个典型例子，绝大多数SQL实
+现支持关键字QUIT、EXIT或者两者。)
+
+本文的实例命令假设你已经加载了[github](https://github.com/datacharmer/test_db)上的[MySQL示例员工数据库](https://dev.mysql.com/doc/employee/en/)。
+运行脚本的语法取决于你使用的SQL实现。通常是一个命令行工具。
+
+```sql
+
+-- 注释以两个连字符开始。命令以分号结束。
+
+-- SQL关键字大小写不敏感。在下文的示例命令中关键字大写，
+-- 因为大写更容易区分数据库、表和列名。
+
+-- 创建和删除一个数据库。数据库名和表名是大小写敏感的。
+CREATE DATABASE someDatabase;
+DROP DATABASE someDatabase;
+
+-- 列出可用的数据库。
+SHOW DATABASES;
+
+-- 使用某个已经存在的数据库
+USE employees;
+
+-- 从当前的departments表，选择所有的行和列
+-- 解释器的默认行为是将结果打印在屏幕上。
+SELECT * FROM departments;
+
+-- 检索departments表中所有的行，但只取dept_no和dept_name列。
+-- 一条命令可以跨越多行
+SELECT dept_no,
+       dept_name FROM departments;
+
+-- 检索departments表中所有的行，但是只输出5行。
+SELECT * FROM departments LIMIT 5;
+
+-- 检索departments表中dept_name列包含子串'en'的行。
+SELECT dept_name FROM departments WHERE dept_name LIKE '%en%';
+
+-- 检索departmnets表中所有dept_name列值为'S'开头并且'S'后接4个字符的行。
+SELECT * FROM departments WHERE dept_name LIKE 'S____';
+
+-- 检索title表中所有行，不显示重复的行。
+SELECT DISTINCT title FROM titles;
+
+-- 和上面的查询相同，但是以title的值排序(大小写敏感)。
+SELECT DISTINCT title FROM titles ORDER BY title;
+
+-- 计算departments表的总行数。
+SELECT COUNT(*) FROM departments;
+
+-- 计算departments表中dept_name列以'en'字段开头的行的数量。
+SELECT COUNT(*) FROM departments WHERE dept_name LIKE '%en%';
+
+-- 不同表中信息的JOIN: titles表显示谁有什么工作，员工编号，
+-- 入职离职时间。检索这些信息，但是使用员工编号作为employees表
+-- 的交叉引用，而不是直接使用员工编号，来获得每个员工的名和姓。
+-- (同时只取10行)
+
+SELECT employees.first_name, employees.last_name,
+       titles.title, titles.from_date, titles.to_date
+FROM titles INNER JOIN employees ON
+       employees.emp_no = titles.emp_no LIMIT 10;
+
+-- 列出所有数据库中所有的表。不同实现通常提供各自的快捷命令
+-- 来列出当前使用数据库的所有表。
+SELECT * FROM INFORMATION_SCHEMA.TABLES
+WHERE TABLE_TYPE='BASE TABLE';
+
+-- 在当前使用的数据库中，创建一个名为tablename1的表，包含下
+-- 述两列。许多其它选项可用于定制列，比如列的数据类型。
+CREATE TABLE tablename1 (fname VARCHAR(20), lname VARCHAR(20));
+
+-- 向tablename1表插入一行数据。假设该表已经定义并且接受这些值。
+INSERT INTO tablename1 VALUES('Richard','Mutt');
+
+-- 更新tablename1表中lname为'Mutt'的行fname的值改为'John'。
+UPDATE tablename1 SET fname='John' WHERE lname='Mutt';
+
+-- 删除tablename1表lname列以'M'开头的行。
+DELETE FROM tablename1 WHERE lname like 'M%';
+
+-- 删除tablename1表的所有行，留下空表。
+DELETE FROM tablename1;
+
+-- 删除整个tablename1表。
+DROP TABLE tablename1;
+```
diff --git a/zh-cn/swift-cn.html.markdown b/zh-cn/swift-cn.html.markdown
index c25b2918..18bc52ed 100644
--- a/zh-cn/swift-cn.html.markdown
+++ b/zh-cn/swift-cn.html.markdown
@@ -110,7 +110,7 @@ anyObjectVar = "Changed value to a string, not good practice, but possible."
 
 
 //
-// Mark: 数组与字典（关联数组）
+// MARK: 数组与字典（关联数组）
 //
 
 /*
@@ -214,9 +214,9 @@ func greet(name: String, day: String) -> String {
 }
 greet("Bob", day: "Tuesday")
 
-// 第一个参数表示外部参数名和内部参数名使用同一个名称。
+// 第一个参数`_`表示不使用外部参数名，忽略`_`表示外部参数名和内部参数名使用同一个名称。
 // 第二个参数表示外部参数名使用 `externalParamName` ，内部参数名使用 `localParamName`
-func greet2(requiredName requiredName: String, externalParamName localParamName: String) -> String {
+func greet2(_ requiredName: String, externalParamName localParamName: String) -> String {
     return "Hello \(requiredName), the day is \(localParamName)"
 }
 greet2(requiredName:"John", externalParamName: "Sunday")    // 调用时，使用命名参数来指定参数的值
@@ -250,7 +250,7 @@ var increment = makeIncrementer()
 increment(7)
 
 // 强制进行指针传递 (引用传递)，使用 `inout` 关键字修饰函数参数
-func swapTwoInts(inout a: Int, inout b: Int) {
+func swapTwoInts(a: inout Int, b: inout Int) {
     let tempA = a
     a = b
     b = tempA
@@ -521,7 +521,7 @@ class MyShape: Rect {
 
         // 在 optional 属性，方法或下标运算符后面加一个问号，可以优雅地忽略 nil 值，返回 nil。
         // 这样就不会引起运行时错误 (runtime error)
-        if let reshape = self.delegate?.canReshape?() where reshape {
+        if let reshape = self.delegate?.canReshape?() {
             // 注意语句中的问号
             self.delegate?.reshape?()
         }
@@ -575,10 +575,10 @@ print(foundAtIndex == 2) // true
 // 自定义运算符可以以下面的字符打头:
 //      / = - + * % < > ! & | ^ . ~
 // 甚至是 Unicode 的数学运算符等
-prefix operator !!! {}
+prefix operator !!!
 
 // 定义一个前缀运算符，使矩形的边长放大三倍
-prefix func !!! (inout shape: Square) -> Square {
+prefix func !!! (shape: inout Square) -> Square {
     shape.sideLength *= 3
     return shape
 }
@@ -591,8 +591,8 @@ print(mySquare.sideLength) // 4
 print(mySquare.sideLength) // 12
 
 // 运算符也可以是泛型
-infix operator <-> {}
-func <-><T: Equatable> (inout a: T, inout b: T) {
+infix operator <->
+func <-><T: Equatable> (a: inout T, b: inout T) {
     let c = a
     a = b
     b = c
diff --git a/zh-cn/typescript-cn.html.markdown b/zh-cn/typescript-cn.html.markdown
index 032f89e4..5d6153da 100644
--- a/zh-cn/typescript-cn.html.markdown
+++ b/zh-cn/typescript-cn.html.markdown
@@ -9,97 +9,103 @@ filename: learntypescript-cn.ts
 lang: zh-cn
 ---
 
-TypeScript是一门为开发大型JavaScript应用而设计的语言。TypeScript在JavaScript的基础上增加了类、模块、接口、泛型和静态类型（可选）等常见的概念。它是JavaScript的一个超集：所有JavaScript代码都是有效的TypeScript代码，所以任何JavaScript项目都可以无缝引入TypeScript. TypeScript编译器会把TypeScript代码编译成JavaScript代码。
+TypeScript 是一门为开发大型 JavaScript 应用而设计的语言。TypeScript 在 JavaScript 的基础上增加了类、模块、接口、泛型和静态类型（可选）等常见的概念。它是 JavaScript 的超集：所有 JavaScript 代码都是有效的 TypeScript 代码，因此任何 JavaScript 项目都可以无缝引入 TypeScript，TypeScript 编译器最终会把 TypeScript 代码编译成 JavaScript 代码。
 
-本文只关注TypeScript额外增加的区别于[JavaScript](../javascript-cn/)的语法，.
+本文只关注 TypeScript 额外增加的区别于 [JavaScript](../javascript-cn/) 的语法，.
 
-如需测试TypeScript编译器，你可以在[Playground](http://www.typescriptlang.org/Playground)码代码，它会自动编译成JavaScript代码然后直接显示出来。
+如需测试 TypeScript 编译器，你可以到 [Playground](https://www.typescriptlang.org/play/) 编写代码，它会自动将你编写的 TypeScript 代码编译成 JavaScript 代码后，在右侧即时展示出来。
 
-```js
-// TypeScript有三种基本类型
-var isDone: boolean = false;
-var lines: number = 42;
-var name: string = "Anders";
+```ts
+// TypeScript 有三种基本类型，布尔类型、数值类型、字符串类型
+let isDone: boolean = false;
+let lines: number = 42;
+let name: string = 'Anders';
 
-// 如果不知道是什么类型，可以使用"any"(任意)类型
-var notSure: any = 4;
-notSure = "maybe a string instead";
-notSure = false; // 亦可，定义为布尔型
+// 如果不知道是什么类型，可以使用 "any" (任意)类型
+let notSure: any = 4;
+notSure = '可以重新赋值，转换为字符串类型';
+notSure = false; // 亦可，重新定义为布尔类型
 
-// 对于集合的声明, 有类型化数组和泛型数组
-var list: number[] = [1, 2, 3];
-// 另外一种，使用泛型数组
-var list: Array<number> = [1, 2, 3];
+// 使用 const 关键字将一个字面量修饰为常量
+const numLivesForCat = 9;
+numLivesForCat = 1; // 常量不能重新被赋值，所以这里会报错
+
+// TypeScript 中的 collection 有两种表示形式, 一种是有类型的数组，另一种是泛型数组
+let list: number[] = [1, 2, 3];
+// 或者，使用泛型数组
+let list: Array<number> = [1, 2, 3];
 
 // 枚举：
-enum Color {Red, Green, Blue};
-var c: Color = Color.Green;
+enum Color {Red, Green, Blue}
+let c: Color = Color.Green;
 
-// 最后，"void"用于函数没有任何返回的特殊情况下
+// 最后是 "void"，它用于表明函数没有任何返回值的特殊情况
 function bigHorribleAlert(): void {
-  alert("I'm a little annoying box!");
+  alert('我是个烦人的弹出框！');
 }
 
-// 函数是"第一等公民"(first class citizens), 支持使用箭头表达式和类型推断
-
-// 以下是相等的，TypeScript编译器会把它们编译成相同的JavaScript代码
-var f1 = function(i: number): number { return i * i; }
-// 返回推断类型的值
-var f2 = function(i: number) { return i * i; }
-var f3 = (i: number): number => { return i * i; }
-// 返回推断类型的值
-var f4 = (i: number) => { return i * i; }
-// 返回推断类型的值, 单行程式可以不需要return关键字和大括号
-var f5 = (i: number) =>  i * i;
-
-// 接口是结构化的，任何具有这些属性的对象都与该接口兼容
+// 函数是"一等公民"(first class citizens), 支持使用 lambda 胖箭头表达式和类型推断
+
+// 以下 f1-f5 五个函数是等价的，TypeScript 编译器会把它们编译成相同的 JavaScript 代码(可以到 Playground 验证)
+// 一般的函数
+let f1 = function(i: number): number { return i * i; };
+// 根据返回值推断函数返回类型
+let f2 = function(i: number) { return i * i; };
+// 胖箭头表达式
+let f3 = (i: number): number => { return i * i; };
+// 根据返回值推断返回类型的胖箭头表达式
+let f4 = (i: number) => { return i * i; };
+// 根据返回值推断返回类型的胖箭头表达式, 省略花括号的同时，可以同时省去 return 关键字
+let f5 = (i: number) =>  i * i;
+
+// 接口是结构化的，任何具备接口中声明的全部属性的对象，都与该接口兼容
 interface Person {
   name: string;
-  // 可选属性，使用"?"标识
+  // 使用 "?" 标识，表明该属性是一个非必需属性
   age?: number;
   // 函数
   move(): void;
 }
 
-// 实现"Person"接口的对象，当它有了"name"和"move"方法之后可被视为一个"Person"
-var p: Person = { name: "Bobby", move: () => {} };
-// 带了可选参数的对象
-var validPerson: Person = { name: "Bobby", age: 42, move: () => {} };
-// 因为"age"不是"number"类型所以这不是一个"Person"
-var invalidPerson: Person = { name: "Bobby", age: true };
+// 实现 "Person" 接口的对象，当它具备 "name" 属性和 "move" 方法之后可被视为一个 "Person"
+let p: Person = { name: 'Bobby', move: () => {} };
+// 带可选属性的对象
+let validPerson: Person = { name: 'Bobby', age: 42, move: () => {} };
+// 由于该对象 "age" 属性的类型不是 "number" ，所以这不是一个 "Person"
+let invalidPerson: Person = { name: 'Bobby', age: true };
 
 // 接口同样可以描述一个函数的类型
 interface SearchFunc {
   (source: string, subString: string): boolean;
 }
-// 参数名并不重要，参数类型才是重要的
-var mySearch: SearchFunc;
+// 参数名并不重要，参数类型才是最重要的
+let mySearch: SearchFunc;
 mySearch = function(src: string, sub: string) {
-  return src.search(sub) != -1;
-}
+  return src.search(sub) !== -1;
+};
 
-// 类 - 成员默认为公共的(public)
+// 类 - 成员访问权限默认都是公共的 (public)
 class Point {
-  // 属性
+  // 成员属性
   x: number;
 
-  // 构造器 - 这里面的public/private关键字会为属性生成样板代码和初始化值
-  // 这个例子中，y会被同x一样定义，不需要额外代码
-  // 同样支持默认值
+  // 构造器 - 在构造器中使用 public/private 关键字修饰的变量，会被声明为类的成员属性。
+  // 下面这个例子中，y 会像 x 一样被声明定义为类成员属性，而不再需要额外代码
+  // 声明时，同样支持指定默认值
 
   constructor(x: number, public y: number = 0) {
     this.x = x;
   }
 
-  // 函数
+  // 成员函数
   dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
 
   // 静态成员
   static origin = new Point(0, 0);
 }
 
-var p1 = new Point(10 ,20);
-var p2 = new Point(25); //y为0
+let p1 = new Point(10 , 20);
+let p2 = new Point(25); // y 为构造器中指定的默认值：0
 
 // 继承
 class Point3D extends Point {
@@ -107,14 +113,14 @@ class Point3D extends Point {
     super(x, y); // 必须显式调用父类的构造器
   }
 
-  // 重写
+  // 重写父类中的 dist() 函数
   dist() {
-    var d = super.dist();
+    let d = super.dist();
     return Math.sqrt(d * d + this.z * this.z);
   }
 }
 
-// 模块, "."可以作为子模块的分隔符
+// 模块, "." 符号可以作为子模块的分隔符
 module Geometry {
   export class Square {
     constructor(public sideLength: number = 0) {
@@ -125,12 +131,12 @@ module Geometry {
   }
 }
 
-var s1 = new Geometry.Square(5);
+let s1 = new Geometry.Square(5);
 
-// 引入模块并定义本地别名
+// 为模块创建一个本地别名
 import G = Geometry;
 
-var s2 = new G.Square(10);
+let s2 = new G.Square(10);
 
 // 泛型
 // 类
@@ -146,21 +152,21 @@ interface Pair<T> {
 }
 
 // 以及函数
-var pairToTuple = function<T>(p: Pair<T>) {
+let pairToTuple = function<T>(p: Pair<T>) {
   return new Tuple(p.item1, p.item2);
 };
 
-var tuple = pairToTuple({ item1:"hello", item2:"world"});
+let tuple = pairToTuple({ item1: 'hello', item2: 'world'});
 
 // 引用定义文件
 /// <reference path="jquery.d.ts" />
 
 // 模板字符串(使用反引号的字符串)
 // 嵌入变量的模板字符串
-var name = 'Tyrone';
-var greeting = `Hi ${name}, how are you?`
+let name = 'Tyrone';
+let greeting = `Hi ${name}, how are you?`;
 // 有多行内容的模板字符串
-var multiline = `This is an example
+let multiline = `This is an example
 of a multiline string`;
 
 ```
diff --git a/zh-cn/visualbasic-cn.html.markdown b/zh-cn/visualbasic-cn.html.markdown
index cdc2d808..e30041b3 100644
--- a/zh-cn/visualbasic-cn.html.markdown
+++ b/zh-cn/visualbasic-cn.html.markdown
@@ -8,7 +8,7 @@ lang: zh-cn
 filename: learnvisualbasic-cn.vb
 ---
 
-```vbnet
+```
 Module Module1
 
     Sub Main()
diff --git a/zh-cn/yaml-cn.html.markdown b/zh-cn/yaml-cn.html.markdown
index bbda20e9..3ba2afd8 100644
--- a/zh-cn/yaml-cn.html.markdown
+++ b/zh-cn/yaml-cn.html.markdown
@@ -23,18 +23,23 @@ YAML 根本不容许文字制表符。
 ################
 
 # 我们的根对象 (它们在整个文件里延续) 将会是一个映射，
-# 它等价于在别的语言里的一个字典，哈西表或对象。
+# 它等价于在别的语言里的一个字典，哈希表或对象。
 key: value
 another_key: Another value goes here.
 a_number_value: 100
-# 如果你想将数字 1 作为值，你必须要将它括在引号中。
-# 不然 YAML 解析器会假定它是一个布尔值 true。
+# 数字 1 会被解释为数值，而不是一个布尔值。
+# 如果你想要的是一个布尔值，使用 true。
 scientific_notation: 1e+12
 boolean: true
 null_value: null
 key with spaces: value
-# 注意到字符串不需要被括在引号中。但是，它们可以被括起来。
-"Keys can be quoted too.": "Useful if you want to put a ':' in your key."
+# 注意，字符串不必被括在引号中，但也可以被括起来。
+however: 'A string, enclosed in quotes.'
+'Keys can be quoted too.': "Useful if you want to put a ':' in your key."
+single quotes: 'have ''one'' escape pattern'
+double quotes: "have many: \", \0, \t, \u263A, \x0d\x0a == \r\n, and more."
+# UTF-8/16/32 字符需要被转义(encoded)
+Superscript two: \u00B2
 
 # 多行字符串既可以写成像一个'文字块'(使用 |)，
 # 或像一个'折叠块'(使用 '>')。
@@ -60,21 +65,21 @@ folded_style: >
 # 集合类型         #
 ####################
 
-# 嵌套是通过缩进完成的。
+# 嵌套是通过缩进完成的。推荐使用 2 个空格的缩进（但非必须）
 a_nested_map:
-    key: value
-    another_key: Another Value
-    another_nested_map:
-        hello: hello
+  key: value
+  another_key: Another Value
+  another_nested_map:
+    hello: hello
 
-# 映射的键值不必是字符串。
+# 映射的键不必是字符串。
 0.25: a float key
 
-# 键值也可以是复合型的，比如多行对象
+# 键也可以是复合型的，比如多行对象
 # 我们用 ? 后跟一个空格来表示一个复合键的开始。
 ? |
-    This is a key
-    that has multiple lines
+  This is a key
+  that has multiple lines
 : and this is its value
 
 # YAML 也允许使用复杂键语法表示序列间的映射关系。
@@ -85,20 +90,24 @@ a_nested_map:
 : [ 2001-01-01, 2002-02-02 ]
 
 # 序列 (等价于列表或数组) 看起来像这样：
+# 注意 '-' 算作缩进
 a_sequence:
-    - Item 1
-    - Item 2
-    - 0.5 # 序列可以包含不同类型。
-    - Item 4
-    - key: value
-      another_key: another_value
-    -
-        - This is a sequence
-        - inside another sequence
+  - Item 1
+  - Item 2
+  - 0.5 # 序列可以包含不同类型。
+  - Item 4
+  - key: value
+    another_key: another_value
+  -
+    - This is a sequence
+    - inside another sequence
+  - - - Nested sequence indicators
+      - can be collapsed
 
 # 因为 YAML 是 JSON 的超集，你也可以写 JSON 风格的映射和序列：
 json_map: {"key": "value"}
 json_seq: [3, 2, 1, "takeoff"]
+and quotes are optional: {key: [3, 2, 1, takeoff]}
 
 #######################
 # 其余的 YAML 特性    #
@@ -111,15 +120,18 @@ other_anchor: *anchor_name
 
 # 锚也可被用来复制/继承属性
 base: &base
-    name: Everyone has same name
+  name: Everyone has same name
+
+# The regexp << is called Merge Key Language-Independent Type.
+# 它表明指定映射的所有键值会插入到当前的映射中。
 
 foo: &foo
-    <<: *base
-    age: 10
+  <<: *base
+  age: 10
 
 bar: &bar
-    <<: *base
-    age: 20
+  <<: *base
+  age: 20
 
 # foo 和 bar 将都含有 name: Everyone has same name
 
@@ -146,22 +158,25 @@ date: 2002-12-14
 # 这个 !!binary 标签表明这个字符串实际上
 # 是一个用 base64 编码表示的二进制 blob。
 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=
+  R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
+  OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
+  +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
+  AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
 
 # YAML 还有一个集合类型，它看起来像这样：
 set:
-    ? item1
-    ? item2
-    ? item3
+  ? item1
+  ? item2
+  ? item3
+or: {item1, item2, item3}
 
-# 像 Python 一样，集合仅是值为 null 的映射；上面的集合等价于：
+# 集合只是值为 null 的映射；上面的集合等价于：
 set2:
-    item1: null
-    item2: null
-    item3: null
+  item1: null
+  item2: null
+  item3: null
+
+...  # document end
 ```
 
 ### 更多资源
diff --git a/zh-tw/pcre-tw.html.markdown b/zh-tw/pcre-tw.html.markdown
index c9cdc537..5f681d46 100644
--- a/zh-tw/pcre-tw.html.markdown
+++ b/zh-tw/pcre-tw.html.markdown
@@ -13,7 +13,9 @@ lang: zh-tw
 相容Perl正規表達式(Perl Compatible Regular Expressions, PCRE)是一個實作正規表達式的C語言函式庫。此函式庫在1997年被開發出來，在當時面對複雜字串處理時大多會選擇使用Perl。也因為如此，PCRE大多的正規表達式語法都很酷似Perl。PCRE語法被廣泛運用在許多大專案中，包括PHP、Apache、R等。
 
 PCRE中的超字元(metacharacter)主要可以分為以下兩類:
+
 * 在中括號外會被辨識的字元
+
 ```
   \      通用跳脫字元
   ^      字串開頭 或 行首
@@ -33,18 +35,17 @@ PCRE中的超字元(metacharacter)主要可以分為以下兩類:
 ```
 
 * 在中括號內會被辨識的超字元，在中括號外會被視為字元集合使用
- 
+
 ```
- 
   \      通用跳脫字元
   ^      非字元集合的字，但只會抓到第一個符合的字元
   -      字元範圍
   [      POSIX字元集合(若後面接POSIX格式)
   ]      字元集合定義結束
-  
-```  
+```
 
 PCRE提供了一些通用的字元類型，可被當作字元集合使用
+
 ```
   \d     任何數字字元
   \D     任何非數字字元
diff --git a/zh-tw/python-tw.html.markdown b/zh-tw/python-tw.html.markdown
index 553181d8..cd7481d7 100644
--- a/zh-tw/python-tw.html.markdown
+++ b/zh-tw/python-tw.html.markdown
@@ -627,7 +627,7 @@ i.age  # => raises an AttributeError
 
 # 你可以引入模組來做使用
 import math
-print math.sqrt(16)  # => 4
+print math.sqrt(16)  # => 4.0
                      # math.sqrt()為取根號
 
 # 你可以只從模組取出特定幾個函式