text
stringlengths 2
104M
| meta
dict |
|---|---|
# Convert your Raspberry into a VPN
If you want to be able to access your homelab from the outside of your network without the need of opening your network to the world and dealing with all the security issues that this means.
Turning your Raspberry into a VPN is pretty easy thanks to the folks developing [PiVPN](https://www.pivpn.io/). The simplest way to setup and manage a VPN, designed for Raspberry Pi. But as everything in these docs, it also works with any kind of server like Ubuntu Server.
If you are running a Raspberry, it is recommended to run Raspbian Lite.
I had an old Raspberry Pi 3b+ at home which was unused for ages. I will be using this RPI3 as my PiVPN and I will also setup a second PiHole as a backup of the main one.
To install [PiVPN](https://www.pivpn.io/) you just need to run:
- `curl -L https://install.pivpn.io | bash`
This will guide you though a step-by-step process which will help you configure your PiVPN. I strongly recommend you to use Wireguard as it is **much** more efficient than OpenVPN.
Once you have set up your PiVPN don't forget to forward the port you set up (default is `51820`) from your router to your PiVPN local IP. You can do this from your router configuration, probably under a section called `Port Forwarding`.
Your configuration should look like somtething like this:
| Name | Type | Port Start | Port End | NAT interface | Private IP | Private Port |
| --- | --- | --- | --- | --- | --- | --- |
| Wireguard | Port-Range | 51820 | 51820 | TPC or UDP (Both) | eth0.vxxx | 192.168.1.223 |
## Add a new device
To add a new device is quite easy, just run `pivpn add` on your PiVPN server, give it a name, and you are good to go.
## Connect to PiVPN
Once you have created your PiVPN client profile (using `pivpn add`) you can connect form various devices.
Install the Wireguard client on your machine (Android app, iOS app, Linux CLI client, etc). If you are on a desktop machine, import your configuration following [the PiVPN guide](https://github.com/pivpn/pivpn/wiki/WireGuard#importing-profiles-on-client-machines), which should be pretty easy.
If you are on Android or iOS you can just run `pivpn -qr`, then select the client profile and scan the QR code from the Wireguard app. That's it, connected!
| {
"repo_name": "pluja/Selfhosted-Google-Photos-Alternative",
"stars": "153",
"repo_language": "None",
"file_name": "README.md",
"mime_type": "text/plain"
} |
# Set up the RPI4 server
Download Ubuntu Server image or Raspbian for Raspberry Pi. It is recommended to get the LTS version.
- Ubuntu Server: https://ubuntu.com/download/raspberry-pi
- Raspbian: https://www.raspberrypi.org/software/operating-systems/
Raspbian is more lightweight and more suitable for Raspberry.
Burn the image on the SD card using [**Balena Etcher**](https://www.balena.io/etcher/) (or [Rufus](https://rufus.ie/en_US/)).
Insert the SD card to the Raspberry and connect your Raspberry to a power supply so it will boot. You should connect your Raspberry to some kind of display using the HDMI ports for the first configurations (at least until SSH is ready).
Once booted, log in using the default credentials for your server:
- User: `ubuntu` Password: `ubuntu` if we are on **Ubuntu Server**.
- User: `pi` Password: `raspberry` if we are on **Raspbian**.
Once logged in, change the password. It should automatically ask you to change it. If not, use `passwd` to change it.
Depending on what OS you chose, you can jump to:
- [Raspbian config](https://github.com/pluja/Selfhosted-Google-Photos-Alternative/blob/main/01-Setting-Up-The-Server.md#raspbian-config)
- [Ubuntu config](https://github.com/pluja/Selfhosted-Google-Photos-Alternative/blob/main/01-Setting-Up-The-Server.md#ubuntu-config)
## Raspbian config
> The `sudo raspi-config` command comes very handy for basic configuration. Use it to enable SSH server and change keyboard layout before proceding.
Now we will configure the internet connections for the RPI. We will be setting up the Wi-Fi connection with DHCP4 (will assign an IP dynamically; this is for the first updates and so) and then we will be configuring the Ethernet port with a static IP for when we set up the RPI as a server.
To setup the WiFi connection use `sudo raspi-config` and search through the menus for the WiFi configuration. There, enter the SSID (network name) and Password to connect to your network. Once done, reboot the RPI.
Now update all packages with:
`sudo apt-get update && sudo apt-get upgrade`
Now let's configure the static IP for the `eth0` port.
For this we will need to edit the `/etc/dhcpcd.conf` file:
- `sudo nano /etc/dhcpcd.conf`
Add the following lines at the end of the file:
```
interface eth0
static ip_address=192.168.1.222/24
static routers=192.168.1.1
static domain_name_servers=192.168.1.1 9.9.9.9
```
This way we are assigning the static ip `192.168.1.222` to the raspberry pi `eth0` port. Also we are using `9.9.9.9` as the DNS provider (Quad9). You can change this to suit your needs.
Now shut down the RPI with `shutdown now` and connect the Ethernet cable. Once booted, try to SSH to the RPI-4 with the assigned IP:
`ssh username@ip`
Once you have `ssh` to the RPI, you can proceed to secure the SSH configuration. To do so we will deactivate the password and root login for SSH for security.
To generate a private+public key pair on * NIX systems, launch this command on the local machine (your workstation, not the server):
`ssh-keygen -t ed25519 -C "comment" `
You need to specify the path for the keys when you choose the keys filename. You can use the default folder destination for the keys. Then you will need to copy the generated keys to the remote machine (RPI):
`ssh-copy-id -i $HOME/.ssh/keyname.pub username@ip`
Now you can try to `ssh` again to the server and see that you are no longer prompted for a password:
`ssh username@server`
> NOTE: make sure to back up your ssh keys (`$HOME/.ssh/` directory)
Now we will edit the SSH config to make it more secure:
`sudo nano /etc/ssh/sshd_config`
You will need to find the following variables and set the values to the ones you can see here. This will disable the root login and the password prompt. You will **only** be able to login to your server via SSH with a pair of valid keys.
```
ChallengeResponseAuthentication no
PasswordAuthentication no
UsePAM no
PermitRootLogin no
```
Once done, restart the SSH service:
`sudo systemctl reload ssh`
And finally, install a basic firewall protection:
`sudo apt install fail2ban`
Fail2ban will ban the IPs that try to intrude your system, it will ban them after 5 tries with an exponentially increasing time ban.
Activate Fail2Ban:
`sudo systemctl start fail2ban && sudo systemctl enable fail2ban`
If you want to check the jailed IPs use:
`fail2ban-client status`
It is recommended to further configure it [with this guide](https://linuxhandbook.com/fail2ban-basic/) if you wish to learn more about fail2ban.
You are done with setting up your server. Now you can proceed to the second step of the guide.
## Ubuntu config
Now we will configure the internet connections for the RPI. We will be setting up the Wi-Fi connection with DHCP4 (will assign an IP dynamically; this is for the first updates and so) and then we will be configuring the Ethernet port with a static IP for when we set up the RPI-4 as a server.
To do so we will need to edit the file `50-cloud-init.yaml`
- `sudo vim /etc/netplan/50-cloud-init.yaml`
Once we are editing it we will paste this configuration (replacing whatever is in the file):
```
network:
version: 2
ethernets:
eth0:
dhcp4: no
addresses:
- 192.168.1.221/24
gateway4: 192.168.1.1
nameservers:
addresses: [9.9.9.9, 1.1.1.1]
wifis:
wlan0:
optional: true
access-points:
"<SSID>":
password: "<YourW1f1PassW0rD"
dhcp4: true
```
Now we will save using `ESC` and then the command `:wq` to exit and save Vim. Make sure to change anything that is between `<>` to suit your network. Also check that the `gateway4` (router) is the same for your network. And assign the IP of your choice: with this config the RPI-4 IP will be `192.168.1.221`.
Once done, apply this config with `sudo netplan apply`.
Now we will configure SSH so we can control the RPI from another computer; and we will also deactivate the password and root login for SSH for security.
To generate a private+public key pair on *NIX systems, launch this command on the local machine (not RPI):
`ssh-keygen -t ed25519 -C "raspberrypi" `
You can use the default folder destination for the keys. Then you will need to copy the generated keys to the remote machine (RPI):
`ssh-copy-id -i $HOME/.ssh/id_rsa.pub ubuntu@192.168.1.221`
Now you are ready to connect via SSH to the RPI:
`ssh ubuntu@192.168.1.221`
Now we will edit the SSH config to make it more secure:
`sudo vim /etc/ssh/sshd_config`
You will need to find the following variables and set the values to the ones you can see here:
```
ChallengeResponseAuthentication no
PasswordAuthentication no
UsePAM no
PermitRootLogin no
```
Once done, restart the ssh service:
`sudo systemctl reload ssh`
And finally, install a basic firewall protection:
`sudo apt install fail2ban`
Fail2ban will ban the IPs that try to intrude your system, it will ban them after 5 tries with an exponentially increasing time ban.
Activate Fail2Ban:
`sudo systemctl start fail2ban && sudo systemctl enable fail2ban`
If you want to check the jailed IPs use:
`fail2ban-client status`
It is recommended to further configure it (with this guide)[https://linuxhandbook.com/fail2ban-basic/] if you wish to learn more about fail2ban.
You are done with setting up your server. Now you can proceed to the second step of the guide.
| {
"repo_name": "pluja/Selfhosted-Google-Photos-Alternative",
"stars": "153",
"repo_language": "None",
"file_name": "README.md",
"mime_type": "text/plain"
} |
# Replacing Google Photos
To replace google photos I will be using a combination of programs and scripts that will end by giving me the very same functionallity I got when I was using Google Photos.
These technologies will be:
- [PiGallery2](https://github.com/bpatrik/pigallery2) - A simple and lightweight gallery with all that you expect. Read only.
- You can also use [PhotoView](https://github.com/photoview/photoview) instead if you want to be able to do the Face Recognition on the Raspberry itself. I personally prefer not to carry this workload on the RPI.
- [Syncthing](https://syncthing.net/) - A simple, fast, peer-to-peer syncing tool.
- [Phockup](https://github.com/ivandokov/phockup) - Script to organize your Photos.
- [Czkawka](https://github.com/qarmin/czkawka) - Find duplicates for your photos really fast.
- [SSHFS](https://github.com/libfuse/sshfs) - Manage remote Gallery folder locally.
- [DigiKam](https://www.digikam.org/) - Face Recognition and Metadata management.
- rsync - Efficient backup tool.
- rclone - Rsync for cloud services.
I will be synching my Phone photos using Syncthing to my Raspberry Pi 4 server. There I will run a serires of scripts to help me organize the photos by Year and Month. Then I will make use of DigiKam locally to have the ability to run Face tagging and recogntion along with metadata tweaking.
Then, once done, I will encrypt and backup everything to MEGA using `rclone` so I have an online and encrypted backup of everything. I will also keep a local copy of everything using `rsync` on a separate HDD that will automatically turn on when needed. Let's go.
## Preparation
### Folder Structure
I will have a 3TB HDD connected to my Raspberry Pi where I will be synching all my photos. This HDD is automatically mounted on the `/data/3TB` folder on boot. To do this automation, connect your Storage device on the RPI and run the following command:
`sudo blkid`
You will get a list where you should find your storage device listed:
```shell
/dev/sdb1: LABEL="3TB" UUID="16955984-34c8-435d-b646-6578a3bab016" TYPE="ext4" PARTUUID="ba10c453-2297-5f49-9886-fd76517576cd"
```
You will need to copy the **UUID** label. Then edit the fstab:
- `sudo nano /etc/fstab`
And add the following line usign the UUID and mountpoint for your drive and system:
`UUID=16955984-34c8-435d-b646-6578a3bab016 /data/3Tera auto nosuid,nodev,nofail 0 0`
Save it. Now your External storage will be mounted on boot.
Inside my 3TB storage I have a folder called Photos, just for organization. You can skip this folder if you don't think it is useful. I created it because i may be using the storage for other kinds of media like Music or Films.
Now, inside this folder I have the `tmp` folder for pigallery2 and the `images` folder. Inside images I have two more folders the first one is `Imports` which contains two more folders: `Phone` and `PC`. Here is where all the images will be uploaded from my devices without any kind of Sorting or deduplication. Then I have the `Gallery` folder, here is where all my photos will be kept sorted and perfectly ordered.
The folder structure insidte the 3 TB drive looks like this:
```
Photos/
├── tmp/
└── images/
├── Imports/
│ ├── Phone/
│ └── PC/
└── Gallery/
```
## Installing programs
First we need to install the main programs that are needed for everything to work.
### Rust:
Rust is a secure compiled programming language which allows for very efficient applications. We will use it for deleting exact-image duplicates on our Gallery.
```bash
sudo apt install build-essential
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```
### Syncthing
Syncthing is a very powerful open-source synchronization tool:
> Syncthing is a continuous file synchronization program. It synchronizes files between two or more computers in real time, safely protected from prying eyes. Your data is your data alone and you deserve to choose where it is stored, whether it is shared with some third party, and how it's transmitted over the internet. - From [Syncthing.net](https://syncthing.net)
On your raspberry server run:
- `sudo apt install syncthing`
Now you have installed syncthing. On a web browser on any computer on your network visit `192.168.1.222:8384` (if you changed the static IP for your server previously use the one you chose).
[Install Syncthing on all the devices you want to connect](https://syncthing.net/downloads/)
It is important that you read [this 'Getting Started' page](https://docs.syncthing.net/intro/getting-started.html) if you have never used Syncthing before. Using this guide connect your devices (for example your Phone and your Raspberry server) and understand how all works. I also recommend you to [read this page](https://docs.syncthing.net/intro/gui.html) to get introduced to Syncthing GUI. It is important that you understand how it works as you don't want to mess things up as you could end up losing your files somehow.
In the following section we will configure the folder synchronization between hosts.
#### Syncthing Folders
As we have seen before, I will show you how I configured the above folder structure with syncthing so I can sync my photo sources (Phone and computer). If you have more sources you can just add more folders.
##### Phone Camera
This folder must sync one way. I want to be able to delete the photos from my phone without losing them on my server too. This is why we will set up IgnoreDelete and Send-Only folders.
- *SERVER* Destination Folder: /data/images/Imports/Phone
- *PHONE* Source Folder: /DCIM/Camera
The *PHONE* folder will be of type **Send-Only** and the *SERVER* folder will be **Recieve-Only.**
It is also very important that we set the **IgnoreDelete** setting to **True** on the server for our Phone folder so we can free up space on the Phone by deleting the photos without them getting delete on the server too. This can be done from the **Syncthing Advanced Folders settings** (See the following image to find out where this option resides):
##### Computer Folder
If we have enough space on our computer, we can save a copy of the **Sorted** folder we will have on our Server so we can move and create new Folders and Albums. We can use **Digikam** from the computer in order to organize all the photos locally and then propagate these changes to the server using Syncthing.
*SERVER*: /data/images/Gallery
*COMPUTER*: /Pictures/Gallery
We will set both folders as Send-Recieve, we may want to have the "IgnoreDelete" form the PC to the Server just in case, but this is optional.
### PiGallery2
This will be the app we will be using to display our Gallery folder. Installing PiGallery2 on our Raspberry is pretty easy, you just need to follow the [app instructions on their README.md](https://github.com/bpatrik/pigallery2/blob/master/docker/README.md). I really recommend using Docker-Compose.
---
Now we have our Syncronization method set up. It was quite easy, we will have our photos from our Phone synced to our server in a matter of minutes and in a peer-to-peer way. How nice and how private!
## The Scripts
Now we will work on different scripts. The IMPORT script, that will handle the sorting, de-duplication and deletion of files and the BACKUP that, as the name already clarifies, will handle the cloud-backup of our photos to any cloud-provider of our choice.
Let's go. I want to have my photos sorted by Year/MM-Month folder structure (eg. 2021/01-January) automatically. This will let me have a very organized gallery from the very beggining. To do this I will be using a very nice script called [Phockup](https://github.com/ivandokov/phockup). This scripts allows us to do exactly what we want to do. To install it we will use the following commands on our server:
```bash
sudo apt-get install python3 libimage-exiftool-perl -y
curl -L https://github.com/ivandokov/phockup/archive/latest.tar.gz -o phockup.tar.gz
tar -zxf phockup.tar.gz
sudo mv phockup-* /opt/phockup
sudo ln -s /opt/phockup/phockup.py /usr/local/bin/phockup
```
Now we have installed Phockup. The command I will be using to Sort my folder will be the following:
`phockup /source/folder /destination/folder --move --date YYYY/MM-M --date-field=FileModifyDate`
This command will take the contents of the source folder and **move** them to the destination folder. If you want to keep a copy of the original uploaded files without being sorted, you can remove the `--move` flag. The `--date YYYY/MM-M` specifies the folder structure we want in this case YEAR/XX-Month. we also have an additional flag called `date-field` that specifies the date field from exiftool that needs to be taken if there is no date specified.
Now we need to install Czkawka in order to achieve the de-duplication of exact same images, videos, etc. To do this we will need to have previously correctly installed Rust and be able to make use of the **cargo** command. Once done, we will:
```bash
git clone https://github.com/qarmin/czkawka.git
cd czkawka
cargo run --release --bin czkawka_cli
```
This will compile Czkawka CLI version so we can use it.
The script for the Import of the files will be the following:
```bash
#!/bin/bash
sourceFolder="/data/3Tera/photos/Imports"
sortedFolder="/data/3Tera/photos/Gallery"
if [ `ls $sourceFolder/Phone $sourceFolder/PC | wc -l` -gt 0 ]
then
phockup $sourceFolder $sortedFolder --move --date YYYY/MM-M --date-field=FileModifyDate
~/czkawka/target/release/czkawka_cli dup -d $sortedFolder -x IMAGE VIDEO -s hashmb -f results-dup.txt --delete-method AEO
fi
```
I am sure you can come up with a better script, if you do don't doubt opening an issue and I will replace it. As I am lazy, and for my setup this is OK I won't be thinking for a better syntax for this. Maybe you could just
This script lets us have imports from both the Computer and the Phone in separate folders to avoid conflicts and strange synchronization issues. You might be able to use a unique folder on the server but I prefer using it this way.
It checks if the Imports directory is empty. If not, then it does the import. If is empty it does nothing.
We need to create a cronjob to run this script every hour (for example) to check if there are new imports, if there are we will sort them and move them to our Gallery and then remove any duplicates. To do this open your crontab with
- `crontab -e`
And paste this (change the IMPORT.sh script path) for running the IMPORT script every 15 minutes.
```
*/15 * * * * /home/pi/IMPORT.sh
```
I run it every 15 minutes as I don't take too much photos along a day (I take ~10 photos a day). If you take a lot of photos you may want to do it more regularly. Or if you are not interested on having your photos in your gallery almost instantly, you can just do it once a day, for example overnight.
### Remote Folder on local machine: Using Digikam for Metadata completion and Face Recognition
You can mount the remote Gallery folder on your local machine so you can work with it. To do it you can make use of `SSH FILESYSTEM` which allows you to mount a remote filesystem to your machine and use it as if it was a regular folder.
This will also allow us to set up DigiKam wiht this mounted folder as a Local Collection and then, for example, scan the collection for faces. Using this method we can keep our Raspberry free of the heavy-workload that face recoginition means and derive this work on our local machine. The only drawback is that we will need to manually run the face recognition from DigiKam.
If you have a **large collection** of photos, I recommend you to get your photos on an SSD on your local machine and scan your collection for faces from there. Once scanned, tagged and written to the metadata upload them to the raspberry pi (or use that same SSD there) as this will make the process much faster.
For me, I started a new gallery from the ground up this year. My old (2TB) photos are kept in an old HDD but I don't need them on my daily gallery for now.
I scanned over 1000 full-quality photos from `sshfs` on the folder mounted on the RPI 3TB HDD in about 25 minutes. I assume that this same process on a local SSD would have taken half the time.
If you want to set the Face Tags and other useful metadata (or edit metada), or just edit the remote Gallery from your desktop computer You need to install `sshfs`:
- `sudo apt install sshfs`
And then mount the remote folder to a local folder like this:
- `sshfs pi@192.168.1.222:/data/3Tera/images/Gallery /home/pluja/Pictures/PiGallery -o idmap=user -o ui d=1000 -o gid=1000`
You can [Download DigiKam AppImage](https://www.digikam.org/download/). DigiKam is an awesome photo management tool. You can do many things there like creating albums or editing metadata, but the most interesting one is the face detection and recognition. Using this you can scan your gallery for faces. You will be able to tag some faces and once done, you can recognize them based on the already tagged faces:
Now go to **Settings > Configure DigiKam** and navigate to the **Metadata** section. In the first section on the **Behaviour** tab called "Write this information to the Metadata" select the information you want. If you are tagging faces, select the **Face Tags** so this information is written to the files.
After you have tagged the faces, select a face (for example "Albert Einstein" in the photo) and now you can go to **Album > Write Metadata To Files** to write face Metadata to the files so PiGallery2 can read it.
If you want to unmount the folder, you can use:
- `fusermount -u /home/pluja/Pictures/PiGallery`
## Backing up everything
I want to backup everything and have several copies for all. I want a local copy on a separate HDD which will automatically turn on at night with a timer switch and an additional encrypted copy to be uploaded to a Cloud service like MEGA.
For now, I will just use the local backup and in the near future I will update this file with how to backup to a cloud service. For the cloud backups you can use **rclone** (the tool I will use in the future tutorial), you can investigate about it. In a few words, is just like **rsync** but for cloud services.
### Local Backup
I will be using a very simple yet efficient method for backing everything up. I won't do any compression or packing of files. I will just sync the folders using `rsync`. This command lets you have incremental copies for a folder to a remote host (or locally). As I have a second Raspberry Pi, I will be backing up to a HDD connected to my second server for increased backup security.
The `rsync` command reads a source folder and only writes the differences to the destination folder. The first time it will copy everything, so if you have a big gallery it will take a considerable ammount of time depending on if you are using an HDD or SSD or if you are copying to a remote host. But after that first upload, every backup will only upload the files that have changed or that are new. So it will be much more efficient and fast than copying the whole folder every time.
Here is the BACKUP.sh file:
```bash
#!/bin/bash
sourceFolder = /data/3Tera/pigallery2/images/Gallery
destinationFolder = pi@192.168.1.223:/data/backup/backup/
logPath = /data/3Tera
(echo "------`date`------" && rsync -ai $sourceFolder $destinationFolder) &>> $backupPath/backup.log
```
This will generate a `backup.log` file at the `logPath` destination. It will print the date of the backup and then thanks to the `-i` flag it will only write the newly backed up files. The `-a` flag will copy the Gallery folder structure as is and will keep all files properties among other things. You should definitely use the `-a` flag.
As we said, after the first time, it will only backup the new and the changed images so for this reason you can make the backup more regularly. For example every 3 or 6 hours. Edit you crontab with `crontab -e` to suit your needs. I used the following syntax:
```
20 7-23/4 * * * /home/pi/BACKUP.sh
```
This will make a backup *at minute 30 past every 4th hour from 7 through 23*. I make it start at the 45th minute so it does not conflict with the IMPORT.sh script that takes place every 15 minutes.
| {
"repo_name": "pluja/Selfhosted-Google-Photos-Alternative",
"stars": "153",
"repo_language": "None",
"file_name": "README.md",
"mime_type": "text/plain"
} |
## <p align="center"> Replacing Google Photos </p>
# <p align="center"> Self-Hosted Photo Storage Solution </p>
After testing a lot (almost all of them) of alternatives and solutions. Finally I came up with the definitive solution, the one that gives me everything I want in an easy (once set up is done), cheap, secure and lightweight way.
At the end of this tutorial we will have a Photo Storage solution that will allow us to:
- [x] Sync our photos from any device.
- [x] Remove exact-photo duplicates efficiently.
- [x] Automatically organize our Gallery by Year and Month.
- [x] Manually run Face Recognition and Face Scanning.
- [x] Manage our gallery from DigiKam.
- [x] Have an online gallery with a map, faces, tags, ratings and other filters.
- [x] Upload an encrypted backup of our gallery to any cloud service.
- [x] Locally generate a backup on a separated drive.
- [x] Securelly access our Gallery from anywhere outside our network.
This can be achieved using a Raspberry Pi 4 and a HDD Storage drive. Pretty cheap!
The stack we will be using is the following:
- [PiGallery2](https://github.com/bpatrik/pigallery2) - A simple and lightweight gallery with all that you expect. Read only.
- You can also use [PhotoView](https://github.com/photoview/photoview) instead if you want to be able to do the Face Recognition on the Raspberry itself. I personally prefer not to carry this workload on the RPI.
- [Syncthing](https://syncthing.net/) - A simple, fast, peer-to-peer syncing tool.
- [Phockup](https://github.com/ivandokov/phockup) - Script to organize your Photos.
- [Czkawka](https://github.com/qarmin/czkawka) - Find duplicates for your photos really fast.
- [SSHFS](https://github.com/libfuse/sshfs) - Manage remote Gallery folder locally.
- [DigiKam](https://www.digikam.org/) - Face Recognition and Metadata management.
- rsync - Efficient backup tool.
- rclone - Rsync for cloud services.
## The Guide
1. [Set up the server](https://github.com/pluja/simple-selfhosting/blob/main/01-Setting-Up-The-Server.md#setup-rpi4-server)
2. [Setting up the Google Photos replacement](https://github.com/pluja/simple-selfhosting/blob/main/02-Photo-Storage-Solution.md#replacing-google-photos)
3. [Outside access: PiVPN](https://github.com/pluja/simple-selfhosting/blob/main/03-PiVPN-Convert-Raspi-Into-VPN.md#convert-your-raspberry-into-a-vpn)
| {
"repo_name": "pluja/Selfhosted-Google-Photos-Alternative",
"stars": "153",
"repo_language": "None",
"file_name": "README.md",
"mime_type": "text/plain"
} |
## Heuristics for Vendoring MIT Licensed Code
Disclaimer: I am not a lawyer, but I've helped maintain a dependency manager for a decade and this is stuff that comes up.
> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
Is what you are trying to conform to in the MIT license.
Prefer video? [An overview of different code licenses](https://www.youtube.com/watch?v=0r7JcN3Q_LY) and how to use them in your code in a talk I gave at Artsy 2015. There's a few cool new licenses since then, but nothing you would be using in everyday code.
### So, you want to vendor some code.
There are roughly 5 ways in which you would do it. It doesn't matter if your code is OSS or closed-source, as the license still applies:
1. **Let your package manager do it for you**. You're always doing this all the time. This works because the package manager includes the license file or references it in the package manifest.
Not all package managers ensure licensing info exists, so even then you may need to _manually_ verify the license is referenced in their code (I used to use [danger-plugin-yarn](https://github.com/orta/danger-plugin-yarn) to highlight this)
2. **You are copying a few lines of code** or a function. Add a reference comment going back to the original:
```ts
// Originally taken from shikijs because it was not exported, I've sent a PR upstream
// https://github.com/shikijs/shiki/blob/33ae6b97eda78484460ac05b3338bc72a605194a/packages/shiki/src/highlighter.ts#L210
// License MIT: https://github.com/shikijs/shiki/blob/33ae6b97eda78484460ac05b3338bc72a605194a/LICENSE
function isPlaintext(lang: string | null | undefined) {
return !lang || ['plaintext', 'txt', 'text'].includes(lang)
}
```
> Note: this is what you're meant to do with code from StackOverflow.
> Note 2: Referencing the git commit and the original LOC is optional, you **only** need the reference to the license. That said, licenses can change - so this is future-proofing.
```ts
// Originally from shikijs https://github.com/shikijs/shiki/blob/main/LICENSE
function isPlaintext(lang: string | null | undefined) {
return !lang || ['plaintext', 'txt', 'text'].includes(lang)
}
```
Is totally OK.
3. **You are copying a whole file**. You can either:
1. Add a reference comment going back to the original. For example in shikijs we have auto-updating themes based on other people's repos. What we do there is:
```json
{
"_copyright": "The MIT License (MIT)\nCopyright (c) 2015-2022 spgennard\nSource: https://github.com/spgennard/vscode_cobol/blob/main/syntaxes/COBOL.tmLanguage.json",
"$schema": "https://raw.githubusercontent.com/spgennard/vscode_cobol/main/schemas/tmlanguage.json",
"fileTypes": [
"ccp",
"scbl",
"cobol",
```
2. Make a folder which includes a full copy of the license, and that specific file:
```
tree .
vendor/COBOL
├── LICENSE
└── COBOL.tmLanguage.json
```
I'd recommend making sure that the license file contains a HTTP link to the original repo also, if it doesn't add a new file for it.
4. **You took some code but you changed it so much** that you just want to cover your butt. I did this for [RedwoodJS here](https://github.com/redwoodjs/redwood/blob/0e9754beaaee7fea21cb4f85027f49a41a679795/packages/web/src/components/DevFatalErrorPage.tsx) after taking a library's code, re-writing it to React, making it make sense for Redwood while still kept note of its origins and license:
```ts
// This file is a hard fork of panic-overlay for RedwoodJS. The original code
// is licensed under The Unlicense - https://github.com/xpl/panic-overlay/blob/master/LICENSE
// making it fine for embedding inside this project.
import { useState } from 'react'
```
5. **You have a substantial set of files, or are vendoring a whole project**. You want to put it in its own folder, ensure there is the original license and a link to the original codebase and what commit you took it from (I think you can technically argue that `git submodules` handles this referential part for you if you use that) but something like:
Then it is totally enclosed, and obvious where this code has come from and who was the original authors:
```sh
tree .
vendor/shikijs-monochrome
├── LICENSE
├── index.ts
└── README.md
```
For MIT you _do not_ need to keep track of changes (some licenses do, in those cases use a repo fork with git submodules IMO) you just keep the original reference around.
### Things worth keeping in mind
The code you vendor is licensed at the time you import it. So, make sure to link to the commit at which you vendored the code if you think it may change. For example if v0 -> v8 are MIT and then v9 is GPL, then you can vendor (as MIT) any version prior to the v9 switch.
As the 'legality' here is about lawyer-work on interpreting how credit is given, there's a possible argument that you _dont_ even need to link to the license as we collectively agreed upon a [standardized notation](https://spdx.org/licenses/) for licenses ([SPDX](https://spdx.dev)) which means you can write `// MIT (author)` and that _should_ conform to the license for small usage. This works because there's no other "version" of the MIT license making it unambiguous, and because contextually we know that this comment is refering to the SPDX shortcut name.
I don't think that level of minimalism is too useful though.
| {
"repo_name": "orta/Heuristics-for-vendoring-MIT-code",
"stars": "57",
"repo_language": "None",
"file_name": "README.md",
"mime_type": "text/plain"
} |
# Homebrew-tiny-scripts
Homebrew tap to install scripts from [vitorgalvao](https://github.com/vitorgalvao/), notably [tiny-scripts](https://github.com/vitorgalvao/tiny-scripts).
## Usage
You’ll need [Homebrew](http://brew.sh/) installed to run these.
[Tap](https://github.com/Homebrew/brew/blob/master/docs/Taps.md) this repository by running:
```bash
brew tap vitorgalvao/tiny-scripts
```
Afterwards, install them as any other formula. For example, to install `ringtonemaker`, run:
```bash
brew install ringtonemaker
```
#### License
The Unlicense (Public Domain, essentially)
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class Podbook < Formula
desc "Generate a podcast RSS feed for audiobooks"
homepage "https://github.com/vitorgalvao/tiny-scripts"
url "https://github.com/vitorgalvao/tiny-scripts.git"
version "2022.1"
depends_on "exiftool"
depends_on "vitorgalvao/tiny-scripts/human-media-time"
def install
bin.install "podbook"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class PinboardBackup < Formula
desc "Backup all bookmarks from a pinboard account"
homepage "https://github.com/vitorgalvao/tiny-pinboard-scripts"
url "https://github.com/vitorgalvao/tiny-pinboard-scripts.git"
version "2022.1"
def install
bin.install "pinboard-backup"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class Gfv < Formula
desc "Make animated gifs from a video file"
homepage "https://github.com/vitorgalvao/tiny-scripts"
url "https://github.com/vitorgalvao/tiny-scripts.git"
version "2022.1"
depends_on "ffmpeg"
depends_on "gifski" => :optional
def install
bin.install "gfv"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class SetupPhpContactForm < Formula
desc "Setup for easy start of a PHP contact form"
homepage "https://github.com/vitorgalvao/setup-php-contact-form"
url "https://github.com/vitorgalvao/setup-php-contact-form.git"
version "2022.1"
def install
bin.install "setup-php-contact-form"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class RssItemSort < Formula
desc "Sort RSS items by number in title and upload the result to temporary hosting"
homepage "https://github.com/vitorgalvao/tiny-scripts"
url "https://github.com/vitorgalvao/tiny-scripts.git"
version "2022.1"
def install
bin.install "rss-item-sort"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class CaskAnalytics < Formula
desc "Show analytics information for casks in the main taps"
homepage "https://github.com/vitorgalvao/tiny-scripts"
url "https://github.com/vitorgalvao/tiny-scripts.git"
version "2022.1"
def install
bin.install "cask-analytics"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class MtgWallpapers < Formula
desc "Download Magic: The Gathering wallpapers"
homepage "https://github.com/vitorgalvao/tiny-scripts"
url "https://github.com/vitorgalvao/tiny-scripts.git"
version "2022.2"
def install
bin.install "mtg-wallpapers"
man1.install "manpages/mtg-wallpapers.1"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class Pingpong < Formula
desc "Stitch a video with its reversed version, for continuous loops"
homepage "https://github.com/vitorgalvao/tiny-scripts"
url "https://github.com/vitorgalvao/tiny-scripts.git"
version "2022.1"
depends_on "ffmpeg"
def install
bin.install "pingpong"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class Makeicns < Formula
desc "Make an icns file from a png"
homepage "https://github.com/vitorgalvao/tiny-scripts"
url "https://github.com/vitorgalvao/tiny-scripts.git"
version "2022.1"
def install
bin.install "makeicns"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class Ringtonemaker < Formula
desc "Convert a video or audio file to an iPhone ringtone"
homepage "https://github.com/vitorgalvao/tiny-scripts"
url "https://github.com/vitorgalvao/tiny-scripts.git"
version "2022.1"
depends_on "ffmpeg"
def install
bin.install "ringtonemaker"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class CaskRepair < Formula
desc "Quickly repair outdated/broken Casks from homebrew-cask"
homepage "https://github.com/vitorgalvao/tiny-scripts"
url "https://github.com/vitorgalvao/tiny-scripts.git"
version "2022.1"
depends_on "hub"
depends_on "hr" => :recommended
def install
bin.install "cask-repair"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class Progressbar < Formula
desc "Overlay a progress bar on videos or gifs"
homepage "https://github.com/vitorgalvao/tiny-scripts"
url "https://github.com/vitorgalvao/tiny-scripts.git"
version "2022.1"
depends_on "ffmpeg"
depends_on "gfv"
depends_on "imagemagick"
def install
bin.install "progressbar"
man1.install "manpages/progressbar.1"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class PkgExtract < Formula
desc "Extract pkg files in a logical hierarchy"
homepage "https://github.com/vitorgalvao/tiny-scripts"
url "https://github.com/vitorgalvao/tiny-scripts.git"
version "2022.2"
def install
bin.install "pkg-extract"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class UploadFile < Formula
desc "Upload paths, with support for several file hosts"
homepage "https://github.com/vitorgalvao/tiny-scripts"
url "https://github.com/vitorgalvao/tiny-scripts.git"
version "2023.3"
def install
bin.install "upload-file"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class PinboardDeleteUnread < Formula
desc "Delete Pinboard unread bookmarks older than X days"
homepage "https://github.com/vitorgalvao/tiny-pinboard-scripts"
url "https://github.com/vitorgalvao/tiny-pinboard-scripts.git"
version "2022.1"
def install
bin.install "pinboard-delete-unread"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class LinuxUsb < Formula
desc "Facilitate installing Linux on a USB stick, from macOS"
homepage "https://github.com/vitorgalvao/tiny-scripts"
url "https://github.com/vitorgalvao/tiny-scripts.git"
version "2022.1"
def install
bin.install "linux-usb"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class LosslessCompress < Formula
desc "Losslessly compress files"
homepage "https://github.com/vitorgalvao/tiny-scripts"
url "https://github.com/vitorgalvao/tiny-scripts.git"
version "2022.1"
depends_on "gifsicle"
depends_on "jpeg"
depends_on "optipng"
def install
bin.install "lossless-compress"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class PinboardWaybackmachine < Formula
desc "Add to the Wayback Machine links saved to a pinboard account"
homepage "https://github.com/vitorgalvao/tiny-pinboard-scripts"
url "https://github.com/vitorgalvao/tiny-pinboard-scripts.git"
version "2023.1"
def install
bin.install "pinboard-waybackmachine"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class Tape < Formula
desc "Backup and restore software settings on macOS"
homepage "https://github.com/vitorgalvao/tape"
url "https://github.com/vitorgalvao/tape.git", branch: "main"
version "2022.4"
depends_on "ruby"
def install
bin.install "tape"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class PinboardUrlUpdate < Formula
desc "Substitute URLs of pinboard bookmarks"
homepage "https://github.com/vitorgalvao/tiny-pinboard-scripts"
url "https://github.com/vitorgalvao/tiny-pinboard-scripts.git"
version "2022.1"
def install
bin.install "pinboard-url-update"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class AppIconExtract < Formula
desc "Extract app bundle icon as png"
homepage "https://github.com/vitorgalvao/tiny-scripts"
url "https://github.com/vitorgalvao/tiny-scripts.git"
version "2022.1"
def install
bin.install "app-icon-extract"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class PinboardLinkCheck < Formula
desc "Check the status code of links saved to a pinboard account"
homepage "https://github.com/vitorgalvao/tiny-pinboard-scripts"
url "https://github.com/vitorgalvao/tiny-pinboard-scripts.git"
version "2022.1"
def install
bin.install "pinboard-link-check"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class Seren < Formula
desc "Rename files in a numerical sequence"
homepage "https://github.com/vitorgalvao/tiny-scripts"
url "https://github.com/vitorgalvao/tiny-scripts.git"
version "2022.1"
def install
bin.install "seren"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
class HumanMediaTime < Formula
desc "Calculate and present total running time of media files in a human-readable way"
homepage "https://github.com/vitorgalvao/tiny-scripts"
url "https://github.com/vitorgalvao/tiny-scripts.git"
version "2022.1"
depends_on "media-info"
def install
bin.install "human-media-time"
end
end
| {
"repo_name": "vitorgalvao/homebrew-tiny-scripts",
"stars": "37",
"repo_language": "Ruby",
"file_name": "human-media-time.rb",
"mime_type": "text/x-ruby"
} |
# to-do-notifications
> **NOTE:** This repository has been archived and the content is now maintained as part of the [dom-examples](https://github.com/mdn/dom-examples/) repository.
Enhanced version of the to-do app, which stores to-do items via IndexedDB, and then also aims to provide notifications when to-do item deadlines are up, via the Notification and Vibration APIs.
| {
"repo_name": "mdn/to-do-notifications",
"stars": "380",
"repo_language": "JavaScript",
"file_name": "style.css",
"mime_type": "text/plain"
} |
<!DOCTYPE HTML>
<html lang="en-US">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=380">
<script src="scripts/todo.js"></script>
<title>To-do list with Notifications</title>
<!-- Icon originated from design by Sabine Wollender: http://thenounproject.com/wosamo/ -->
<link rel="icon" type="image/png" href="img/icon-128.png">
<link href='https://fonts.googleapis.com/css?family=Donegal+One|Lily+Script+One' rel='stylesheet' type='text/css'>
<link href="style/style.css" type="text/css" rel="stylesheet">
</head>
<body>
<h1>To-do list</h1>
<div class="task-box">
<ul id="task-list">
</ul>
</div>
<div class="form-box">
<h2>Add new to-do item.</h2>
<form id="task-form" action="index.html">
<div class="full-width"><label for="title">Task title:</label><input type="text" id="title" required></div>
<div class="half-width"><label for="deadline-hours">Hours (hh):</label><input type="number" id="deadline-hours" required></div>
<div class="half-width"><label for="deadline-minutes">Mins (mm):</label><input type="number" id="deadline-minutes" required></div>
<div class="third-width"><label for="deadline-day">Day:</label>
<select id="deadline-day" required>
<option value="01">01</option>
<option value="02">02</option>
<option value="03">03</option>
<option value="04">04</option>
<option value="05">05</option>
<option value="06">06</option>
<option value="07">07</option>
<option value="08">08</option>
<option value="09">09</option>
<option value="10">10</option>
<option value="11">11</option>
<option value="12">12</option>
<option value="13">13</option>
<option value="14">14</option>
<option value="15">15</option>
<option value="16">16</option>
<option value="17">17</option>
<option value="18">18</option>
<option value="19">19</option>
<option value="20">20</option>
<option value="21">21</option>
<option value="22">22</option>
<option value="23">23</option>
<option value="24">24</option>
<option value="25">25</option>
<option value="26">26</option>
<option value="27">27</option>
<option value="28">28</option>
<option value="29">29</option>
<option value="30">30</option>
<option value="31">31</option>
</select></div>
<div class="third-width"><label for="deadline-month">Month:</label>
<select id="deadline-month" required>
<option value="January">January</option>
<option value="February">February</option>
<option value="March">March</option>
<option value="April">April</option>
<option value="May">May</option>
<option value="June">June</option>
<option value="July">July</option>
<option value="August">August</option>
<option value="September">September</option>
<option value="October">October</option>
<option value="November">November</option>
<option value="December">December</option>
</select></div>
<div class="third-width"><label for="deadline-year">Year:</label>
<select id="deadline-year" required>
<option value="2025">2025</option>
<option value="2024">2024</option>
<option value="2023">2023</option>
<option value="2022">2022</option>
<option value="2021">2021</option>
<option value="2020">2020</option>
<option value="2019">2019</option>
<option value="2018">2018</option>
</select></div>
<div><input type="submit" id="submit" value="Add Task"></div>
<div></div>
</form>
</div>
<div id="toolbar">
<ul id="notifications">
</ul>
<button id="enable">
Enable notifications
</button>
</div>
</body>
</html>
| {
"repo_name": "mdn/to-do-notifications",
"stars": "380",
"repo_language": "JavaScript",
"file_name": "style.css",
"mime_type": "text/plain"
} |
to-do-notifications
===================
This is an Enhanced version of my basic to-do app, which stores to-do items via IndexedDB, and then also aims to provide notifications when to-do item deadlines are up, via the Notification and Vibration APIs.
The IndexedDB and Notification API functionality all works on Firefox desktop, Firefox Android, Firefox OS, Chrome, and IE 10+.
The Vibration API stuff works on Firefox OS and Firefox for Android.
You can [try it out live](https://mdn.github.io/to-do-notifications/).
| {
"repo_name": "mdn/to-do-notifications",
"stars": "380",
"repo_language": "JavaScript",
"file_name": "style.css",
"mime_type": "text/plain"
} |
window.onload = () => {
const MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'];
// Hold an instance of a db object for us to store the IndexedDB data in
let db;
// Create a reference to the notifications list in the bottom of the app; we will write database messages into this list by
// appending list items as children of this element
const note = document.getElementById('notifications');
// All other UI elements we need for the app
const taskList = document.getElementById('task-list');
const taskForm = document.getElementById('task-form');
const title = document.getElementById('title');
const hours = document.getElementById('deadline-hours');
const minutes = document.getElementById('deadline-minutes');
const day = document.getElementById('deadline-day');
const month = document.getElementById('deadline-month');
const year = document.getElementById('deadline-year');
const notificationBtn = document.getElementById('enable');
// Do an initial check to see what the notification permission state is
if (Notification.permission === 'denied' || Notification.permission === 'default') {
notificationBtn.style.display = 'block';
} else {
notificationBtn.style.display = 'none';
}
note.appendChild(createListItem('App initialised.'));
// Let us open our database
const DBOpenRequest = window.indexedDB.open('toDoList', 4);
// Register two event handlers to act on the database being opened successfully, or not
DBOpenRequest.onerror = (event) => {
note.appendChild(createListItem('Error loading database.'));
};
DBOpenRequest.onsuccess = (event) => {
note.appendChild(createListItem('Database initialised.'));
// Store the result of opening the database in the db variable. This is used a lot below
db = DBOpenRequest.result;
// Run the displayData() function to populate the task list with all the to-do list data already in the IndexedDB
displayData();
};
// This event handles the event whereby a new version of the database needs to be created
// Either one has not been created before, or a new version number has been submitted via the
// window.indexedDB.open line above
//it is only implemented in recent browsers
DBOpenRequest.onupgradeneeded = (event) => {
db = event.target.result;
db.onerror = (event) => {
note.appendChild(createListItem('Error loading database.'));
};
// Create an objectStore for this database
const objectStore = db.createObjectStore('toDoList', { keyPath: 'taskTitle' });
// Define what data items the objectStore will contain
objectStore.createIndex('hours', 'hours', { unique: false });
objectStore.createIndex('minutes', 'minutes', { unique: false });
objectStore.createIndex('day', 'day', { unique: false });
objectStore.createIndex('month', 'month', { unique: false });
objectStore.createIndex('year', 'year', { unique: false });
objectStore.createIndex('notified', 'notified', { unique: false });
note.appendChild(createListItem('Object store created.'));
};
function displayData() {
// First clear the content of the task list so that you don't get a huge long list of duplicate stuff each time
// the display is updated.
while (taskList.firstChild) {
taskList.removeChild(taskList.lastChild);
}
// Open our object store and then get a cursor list of all the different data items in the IDB to iterate through
const objectStore = db.transaction('toDoList').objectStore('toDoList');
objectStore.openCursor().onsuccess = (event) => {
const cursor = event.target.result;
// Check if there are no (more) cursor items to iterate through
if (!cursor) {
// No more items to iterate through, we quit.
note.appendChild(createListItem('Entries all displayed.'));
return;
}
// Check which suffix the deadline day of the month needs
const { hours, minutes, day, month, year, notified, taskTitle } = cursor.value;
const ordDay = ordinal(day);
// Build the to-do list entry and put it into the list item.
const toDoText = `${taskTitle} — ${hours}:${minutes}, ${month} ${ordDay} ${year}.`;
const listItem = createListItem(toDoText);
if (notified === 'yes') {
listItem.style.textDecoration = 'line-through';
listItem.style.color = 'rgba(255, 0, 0, 0.5)';
}
// Put the item item inside the task list
taskList.appendChild(listItem);
// Create a delete button inside each list item,
const deleteButton = document.createElement('button');
listItem.appendChild(deleteButton);
deleteButton.textContent = 'X';
// Set a data attribute on our delete button to associate the task it relates to.
deleteButton.setAttribute('data-task', taskTitle);
// Associate action (deletion) when clicked
deleteButton.onclick = (event) => {
deleteItem(event);
};
// continue on to the next item in the cursor
cursor.continue();
};
};
// Add listener for clicking the submit button
taskForm.addEventListener('submit', addData, false);
function addData(e) {
// Prevent default, as we don't want the form to submit in the conventional way
e.preventDefault();
// Stop the form submitting if any values are left empty.
// This should never happen as there is the required attribute
if (title.value === '' || hours.value === null || minutes.value === null || day.value === '' || month.value === '' || year.value === null) {
note.appendChild(createListItem('Data not submitted — form incomplete.'));
return;
}
// Grab the values entered into the form fields and store them in an object ready for being inserted into the IndexedDB
const newItem = [
{ taskTitle: title.value, hours: hours.value, minutes: minutes.value, day: day.value, month: month.value, year: year.value, notified: 'no' },
];
// Open a read/write DB transaction, ready for adding the data
const transaction = db.transaction(['toDoList'], 'readwrite');
// Report on the success of the transaction completing, when everything is done
transaction.oncomplete = () => {
note.appendChild(createListItem('Transaction completed: database modification finished.'));
// Update the display of data to show the newly added item, by running displayData() again.
displayData();
};
// Handler for any unexpected error
transaction.onerror = () => {
note.appendChild(createListItem(`Transaction not opened due to error: ${transaction.error}`));
};
// Call an object store that's already been added to the database
const objectStore = transaction.objectStore('toDoList');
console.log(objectStore.indexNames);
console.log(objectStore.keyPath);
console.log(objectStore.name);
console.log(objectStore.transaction);
console.log(objectStore.autoIncrement);
// Make a request to add our newItem object to the object store
const objectStoreRequest = objectStore.add(newItem[0]);
objectStoreRequest.onsuccess = (event) => {
// Report the success of our request
// (to detect whether it has been succesfully
// added to the database, you'd look at transaction.oncomplete)
note.appendChild(createListItem('Request successful.'));
// Clear the form, ready for adding the next entry
title.value = '';
hours.value = null;
minutes.value = null;
day.value = 01;
month.value = 'January';
year.value = 2020;
};
};
function deleteItem(event) {
// Retrieve the name of the task we want to delete
const dataTask = event.target.getAttribute('data-task');
// Open a database transaction and delete the task, finding it by the name we retrieved above
const transaction = db.transaction(['toDoList'], 'readwrite');
transaction.objectStore('toDoList').delete(dataTask);
// Report that the data item has been deleted
transaction.oncomplete = () => {
// Delete the parent of the button, which is the list item, so it is no longer displayed
event.target.parentNode.parentNode.removeChild(event.target.parentNode);
note.appendChild(createListItem(`Task "${dataTask}" deleted.`));
};
};
// Check whether the deadline for each task is up or not, and responds appropriately
function checkDeadlines() {
// First of all check whether notifications are enabled or denied
if (Notification.permission === 'denied' || Notification.permission === 'default') {
notificationBtn.style.display = 'block';
} else {
notificationBtn.style.display = 'none';
}
// Grab the current time and date
const now = new Date();
// From the now variable, store the current minutes, hours, day of the month, month, year and seconds
const minuteCheck = now.getMinutes();
const hourCheck = now.getHours();
const dayCheck = now.getDate(); // Do not use getDay() that returns the day of the week, 1 to 7
const monthCheck = now.getMonth();
const yearCheck = now.getFullYear(); // Do not use getYear() that is deprecated.
// Open a new transaction
const objectStore = db.transaction(['toDoList'], 'readwrite').objectStore('toDoList');
// Open a cursor to iterate through all the data items in the IndexedDB
objectStore.openCursor().onsuccess = (event) => {
const cursor = event.target.result;
if (!cursor) return;
const { hours, minutes, day, month, year, notified, taskTitle } = cursor.value;
// convert the month names we have installed in the IDB into a month number that JavaScript will understand.
// The JavaScript date object creates month values as a number between 0 and 11.
const monthNumber = MONTHS.indexOf(month);
if (monthNumber === -1) throw new Error('Incorrect month entered in database.');
// Check if the current hours, minutes, day, month and year values match the stored values for each task.
// The parseInt() function transforms the value from a string to a number for comparison
// (taking care of leading zeros, and removing spaces and underscores from the string).
let matched = parseInt(hours) === hourCheck;
matched &&= parseInt(minutes) === minuteCheck;
matched &&= parseInt(day) === dayCheck;
matched &&= parseInt(monthNumber) === monthCheck;
matched &&= parseInt(year) === yearCheck;
if (matched && notified === 'no') {
// If the numbers all do match, run the createNotification() function to create a system notification
// but only if the permission is set
if (Notification.permission === 'granted') {
createNotification(taskTitle);
}
}
// Move on to the next cursor item
cursor.continue();
};
};
// Ask for permission when the 'Enable notifications' button is clicked
function askNotificationPermission() {
// Function to actually ask the permissions
function handlePermission(permission) {
// Whatever the user answers, we make sure Chrome stores the information
if (!Reflect.has(Notification, 'permission')) {
Notification.permission = permission;
}
// Set the button to shown or hidden, depending on what the user answers
if (Notification.permission === 'denied' || Notification.permission === 'default') {
notificationBtn.style.display = 'block';
} else {
notificationBtn.style.display = 'none';
}
};
// Check if the browser supports notifications
if (!Reflect.has(window, 'Notification')) {
console.log('This browser does not support notifications.');
} else {
if (checkNotificationPromise()) {
Notification.requestPermission().then(handlePermission);
} else {
Notification.requestPermission(handlePermission);
}
}
};
// Check whether browser supports the promise version of requestPermission()
// Safari only supports the old callback-based version
function checkNotificationPromise() {
try {
Notification.requestPermission().then();
} catch(e) {
return false;
}
return true;
};
// Wire up notification permission functionality to 'Enable notifications' button
notificationBtn.addEventListener('click', askNotificationPermission);
function createListItem(contents) {
const listItem = document.createElement('li');
listItem.textContent = contents;
return listItem;
};
// Create a notification with the given title
function createNotification(title) {
// Create and show the notification
const img = '/to-do-notifications/img/icon-128.png';
const text = `HEY! Your task "${title}" is now overdue.`;
const notification = new Notification('To do list', { body: text, icon: img });
// We need to update the value of notified to 'yes' in this particular data object, so the
// notification won't be set off on it again
// First open up a transaction
const objectStore = db.transaction(['toDoList'], 'readwrite').objectStore('toDoList');
// Get the to-do list object that has this title as its title
const objectStoreTitleRequest = objectStore.get(title);
objectStoreTitleRequest.onsuccess = () => {
// Grab the data object returned as the result
const data = objectStoreTitleRequest.result;
// Update the notified value in the object to 'yes'
data.notified = 'yes';
// Create another request that inserts the item back into the database
const updateTitleRequest = objectStore.put(data);
// When this new request succeeds, run the displayData() function again to update the display
updateTitleRequest.onsuccess = () => {
displayData();
};
};
};
// Using a setInterval to run the checkDeadlines() function every second
setInterval(checkDeadlines, 1000);
}
// Helper function returning the day of the month followed by an ordinal (st, nd, or rd)
function ordinal(day) {
const n = day.toString();
const last = n.slice(-1);
if (last === '1' && n !== '11') return `${n}st`;
if (last === '2' && n !== '12') return `${n}nd`;
if (last === '3' && n !== '13') return `${n}rd`;
return `${n}th`;
};
| {
"repo_name": "mdn/to-do-notifications",
"stars": "380",
"repo_language": "JavaScript",
"file_name": "style.css",
"mime_type": "text/plain"
} |
/* Basic set up + sizing for containers */
html,
body {
margin: 0;
}
html {
width: 100%;
height: 100%;
font-size: 10px;
font-family: Georgia, "Times New Roman", Times, serif;
background: #111;
}
body {
width: 50rem;
position: relative;
background: #d88;
margin: 0 auto;
border-left: 2px solid #d33;
border-right: 2px solid #d33;
}
h1,
h2 {
text-align: center;
background: #d88;
font-family: Arial, Helvetica, sans-serif;
}
h1 {
font-size: 6rem;
margin: 0;
background: #d66;
}
h2 {
font-size: 2.4rem;
}
/* Bottom toolbar styling */
#toolbar {
position: relative;
height: 6rem;
width: 100%;
background: #d66;
border-top: 2px solid #d33;
border-bottom: 2px solid #d33;
}
#enable,
input[type="submit"] {
line-height: 1.8;
font-size: 1.3rem;
border-radius: 5px;
border: 1px solid black;
color: black;
text-shadow: 1px 1px 1px black;
border: 1px solid rgba(0, 0, 0, 0.1);
box-shadow: inset 0px 5px 3px rgba(255, 255, 255, 0.2),
inset 0px -5px 3px rgba(0, 0, 0, 0.2);
}
#enable {
position: absolute;
bottom: 0.3rem;
right: 0.3rem;
}
#notifications {
margin: 0;
position: relative;
padding: 0.3rem;
background: #ddd;
position: absolute;
top: 0rem;
left: 0rem;
height: 5.4rem;
width: 50%;
overflow: auto;
line-height: 1.2;
}
#notifications li {
margin-left: 1.5rem;
}
/* New item form styling */
.form-box {
background: #d66;
width: 85%;
padding: 1rem;
margin: 2rem auto;
box-shadow: 2px 2px 5px rgba(0, 0, 0, 0.7);
}
form div {
margin-bottom: 1rem;
}
form .full-width {
margin: 1rem auto 2rem;
width: 100%;
}
form .half-width {
width: 50%;
float: left;
}
form .third-width {
width: 33%;
float: left;
}
form div label {
width: 10rem;
float: left;
padding-right: 1rem;
font-size: 1.6rem;
line-height: 1.6;
}
form .full-width input {
width: 30rem;
}
form .half-width input {
width: 8.75rem;
}
form .third-width select {
width: 13.5rem;
}
form div input[type="submit"] {
clear: both;
width: 20rem;
display: block;
height: 3rem;
margin: 0 auto;
position: relative;
top: 0.5rem;
}
/* || tasks box */
.task-box {
width: 85%;
padding: 1rem;
margin: 2rem auto;
font-size: 1.8rem;
}
.task-box ul {
margin: 0;
padding: 0;
}
.task-box li {
list-style-type: none;
padding: 1rem;
border-bottom: 2px solid #d33;
}
.task-box li:last-child {
border-bottom: none;
}
.task-box li:last-child {
margin-bottom: 0rem;
}
.task-box button {
margin-left: 2rem;
font-size: 1.6rem;
border: 1px solid #eee;
border-radius: 5px;
box-shadow: inset 0 -2px 5px rgba(0, 0, 0, 0.5) 1px 1px 1px black;
}
/* setting cursor for interactive controls */
button,
input[type="submit"],
select {
cursor: pointer;
}
/* media query for small screens */
@media (max-width: 32rem) {
body {
width: 100%;
border-left: none;
border-right: none;
}
form div {
clear: both;
}
form .full-width {
margin: 1rem auto;
}
form .half-width {
width: 100%;
float: none;
}
form .third-width {
width: 100%;
float: none;
}
form div label {
width: 36%;
padding-left: 1rem;
}
form input,
form select,
form label {
line-height: 2.5rem;
font-size: 2rem;
}
form .full-width input {
width: 50%;
}
form .half-width input {
width: 50%;
}
form .third-width select {
width: 50%;
}
#enable {
right: 1rem;
}
}
| {
"repo_name": "mdn/to-do-notifications",
"stars": "380",
"repo_language": "JavaScript",
"file_name": "style.css",
"mime_type": "text/plain"
} |
# Como escrever?
Para escrever sua resposta deverá ser no formato Markdown, caso você não conheça **POR FAVOR LEIA** [markdowntutorial.com](http://www.markdowntutorial.com/), pois se você não enviar com a formatação correta para códigos eu não podderei aceitar seu exercício.
# [Grupo do Telegram](https://telegram.me/joinchat/BJ_gtz49o2OSzTU90SKp-A)
Para entrar no grupo oficial do Be mean no Telegram basta seguir o link [https://telegram.me/joinchat/BJ_gtz49o2OSzTU90SKp-A](https://telegram.me/joinchat/BJ_gtz49o2OSzTU90SKp-A), lembrando que só é permitido postagens e discussões sobre dúvidas e/ou assuntos pertinentes ao curso, aquele que não respeitar essas regras será banido.
## O Envio
Caso você faça um `pull` antes de fazer o seu `Pull Request` por favor **COMITE APENAS SEU ARQUIVO, NÃO FAÇA `git add .`!!**
**Faça:**
- `git add nome_do_meu_arquivo.md`
- `git commit -m 'SEU NOME - NodeJS - Exercício XX resolvido'`
- `git push origin master`
## Padrão do arquivo
Favor sempre usar: **class-X-resolved-githubuser-nome-completo-com-hifens.md**
class-01-resolved-suissa-Jean-Carlo-Nascimento.md
**NENHUM ARQUIVO FORA DESSE PADRÃO SERÁ ACEITO!!!**
## Prazo
O prazo final é antes de entregar o **seu** projeto final, que também não tem um prazo final, pois o curso acontecerá sem um tempo definido devido aos futuros alunos.
## Obrigatório entregar **TODOS** antes do seu projeto final.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**Autor:** Rafael Crispim Ignácio
**Data:** 1451444633263
## 1. Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```js
function print(name, callback) {
if (typeof name == "string") {
return callback(null, name);
} else {
var err = new Error("Tipo inválido, você deve informar uma String.");
return callback(err, null);
}
}
print("Rafael", function(err, name) {
if (err) throw err;
console.log(name);
});
```
## 2. Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
function sum(x, y, callback) {
if (typeof x == "number" && typeof y == "number") {
return callback(null, (x + y));
} else {
var err = new Error("Tipo inválido, você deve informar somente números.");
return callback(err, null);
}
}
sum(10, 20, function(err, result){
if (err) throw err;
console.log("SUM Result: " + result);
});
```
## 3. Criar uma que calcular a média de dois valores e imprima essa média uma outra função, como continuação da execução da mesma.
```js
function avg(x, y, callback) {
var err = null;
if (typeof x != "number" || typeof y != "number") {
err = new Error("Tipo inválido, você deve informar somente números.");
} else if (y === 0) {
err = new Error("O divisor não pode ser igual a 0.");
}
return (err) ? callback(err, null) : callback(null, (x / y));
}
avg(10, 20, function(err, result){
if (err) throw err;
console.log("AVG Result: " + result);
});
```
## 4. Explicar a definição de continuação de uma função.
Até onde eu entendi, a continuação de uma função pode ser definida como uma função que será executada a partir de outra, ou seja, é uma função passada como parâmetro(`callback`) em uma função principal e é chamada no momento de execução deste método.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**user:** [tuchedsf](https://github.com/tuchedsf)
**autor:** Diego Santos Ferreira
**Date:** 1457270740092
## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```js
function sayName (name, callback){
if (typeof name !=== 'string'){
var err = new Error('nome invalido');
return callback(err, null);
}
return callback(null, name);
}
sayName('Diego', function(err,name){
if (err){
console.log(err);
}else{
console.log(name);
}
});
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
function calculo (valor1,valor2,callback){
if (typeof valor1 !== 'number' || typeof valor2 !== 'number'){
var err = new Error('Valores devem ser numericos');
return callback(err, null);
}
var soma = valor1 + valor2;
return callback(null, soma);
}
calculo(1,2, function(err,result){
if (err){
console.log(err);
}else{
console.log(result);
}
});
```
## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma.
```js
function calculoMedia (valor1,valor2,callback){
if (typeof valor1 !== 'number' || typeof valor2 !== 'number'){
var err = new Error('Valores devem ser numericos');
return callback(err, null);
}
var media = (valor1 + valor2) /2;
return callback(null, media);
}
calculoMedia(2,2, function(err,result){
if (err){
console.log(err);
}else{
console.log(result);
}
});
```
## Explicar a definição de continuação de uma função.
A continuação de uma função se da quando uma função é passada como parametro para outra função. Quando isso ocorre a função passada como paramtro é processada e retorna o fluxo para a função que realizou a chamada continuar o processamento dando continuidade a mesma.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 04 - Exercícios
**user:** [Geriel](https://github.com/geriel)
**autor:** Geriel Castro
## 1. Criar uma função com **uma entrada** para nome e **imprimir** está entrada em uma outra função, como continuação da execução da mesma.
```js
function getNome(name, callback) {
if (typeof name === 'string') {
callback(null, name);
}else{
var err = new Error('Infelizmente deu Erro, reveja seu codigo.');
callback(err, null);
}
};
getNome('João Ubaldo', function(err, name) {
if (err) {
console.log('Erro: ' + err);
} else {
console.log('Resultado = ' + name);
}
});
Resultado = João Ubaldo
```
## 2. Criar uma função que **calcula a soma** de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
function calculaSoma( num1, num2, callback){
if(typeof num1 == "number" && typeof num2 == "number"){
var result = num1 + num2;
callback(null, result);
}else{
var err = new Error("Por favor, passe um número válido!");
callback(err, null);
}
}
calculaSoma(12, 14, function(err, result){
if(err){
console.log("Erro: " + err);
}else{
console.log("Resultado = " + result);
}
});
Resultado = 26
```
## 3. Criar uma função que **calcula a média** de dois valores e imprima essa média em uma outra função, como continuação da execução da mesma.
```js
function calculaMedia(num1, num2, callback){
setTimeout(function(){
if(typeof num1 == "number" && typeof num2 == "number"){
var result = (num1 + num2)/2;
callback(null, result);
}else{
var err = new Error("Por favor, passe um número válido");
callback(err, null);
}
})
}
calculaMedia(140, 60, function(err, result){
if(err){
console.log("Erro: "+ err);
}else{
console.log("Resultado = " + result);
}
})
Resultado = 100
```
## 4. Explicar a definição de **continuação de uma função**.
Podemos dizer que é uma função executada que recebe outra função como parametro retornando valores.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**user:** [victorvoid](https://github.com/victorvoid)
**autor:** Victor Igor
## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```js
'use strict'
function printName(name, callback){
if (typeof name === 'string')
return callback(null, name);
let err = new Error('Invalid type argument!!!');
return callback(err, null);
}
printName('Victor Igor', (err, result)=>{
if(err)
console.log(err);
else
console.log(result);
});
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
'use strict'
function sum(n1, n2, callback){
if (typeof n1 === 'number' && typeof n2 === 'number')
return callback(null, (n1+n2));
let err = new Error('Invalid type argument!!!');
return callback(err, null);
}
sum(2,3,(err, result)=>{
if(err)
console.log(err);
else
console.log(result);
});
```
## Criar uma que calcular a média de dois valores e imprima essa média uma outra função, como continuação da execução da mesma.
```js
'use strict'
function avg(n1, n2, callback){
if(typeof n1 === 'number' && typeof n2 === 'number')
return callback(null, ((n1+n2)/2));
let err = new Error('Invalid type argument!!!');
callback(err, null);
}
avg(4,16,(err, result)=>{
if(err)
console.log(err);
else
console.log(result);
})
```
## Explicar a definição de continuação de uma função.
```
Ela se baseia em você criar uma função1 que vai ter um objetivo e
nela, vem uma função2 passada por parâmetro para que a funcao2 possa ser chamada ali dentro, assim podendo passar por parâmetro qualquer valor a funcao2, para que a partir dali a funcao2 __continue__.
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**user:** [hc3](https://github.com/hc3)
**autor:** Eliel das Virgens
**date:** 20/03/2016
##01.Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da mesma.
```
function criaNome(nome,callback){
if (typeof nome === 'string') {
return callback(null,nome);
} else {
erro = new Error('Nome inválido!');
return callback(erro,null);
}
}
criaNome('Eliel', function(err, result){
if (err) console.log(err);
else console.log(result);
});
```
##02.Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```
function soma(a, b, callback){
if (typeof a === 'number' && typeof b === 'number'){
var resultado = a + b;
return callback(null,resultado);
} else {
var erro = new Error('deu Zika');
return callback(erro, null);
}
}
soma(20,50,function(err,result){
if (err) console.log(err);
else console.log(result);
});
```
##03.Criar uma que calcular a média de dois valores e imprima essa média em uma outra função, como continuação da execução da mesma.
```
function calcularMedia(a, b, callback){
if (typeof a === 'number' && typeof b === 'number'){
var resultado = (a + b) / 2;
return callback(null,resultado);
} else {
var erro = new Error('Valores inválidos');
return callback(erro, null);
}
}
calcularMedia(20,30,function(err,result){
if (err) console.log(err);
else console.log(result);
});
```
##04.Explicar a definição de continuação de uma função.
-A continuação de uma função, também chamado de callback é o ato de passar uma função como parâmetro de outra, isso acontecer porque as funções javascript são high order functions, e com isso podem ser atribuidas a variáveis ou passadas como parâmetro de outras funções ou seja se juntarmos isso as closures temos os callbacks vão seguir um padrão com o erro no primeiro parâmetro e o resultado no segundo, e com os callbacks podemos criar aplicações não blocantes.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**User:** [DouglasHennrich](https://github.com/DouglasHennrich)
**Autor:** Douglas Hennrich
**Date:** 1450670429154
## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```js
function sayMyName(name, callback){
if(typeof name !== 'string'){
var err = 'O primeiro parâmetro precisa ser uma \'String\'';
return callback(err, null);
}
return callback(null, name);
}
sayMyName('Douglas Hennrich', function(err, result){
if(err){
console.log(err);
return
}
console.log(result);
});
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
function AplusB(A, B, callback){
if( typeof A !== 'number' || typeof B !== 'number'){
var err = 'Os parâmetros precisam ser \'Number\'';
return callback(err, null);
}
var result = A + B;
return callback(null, result);
}
AplusB(2, 4, function(err, result){
if(err){
console.log(err);
return;
}
console.log(result);
});
```
## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma.
```js
function media(A, B, callback){
if( typeof A !== 'number' || typeof B !== 'number'){
var err = 'Os parâmetros precisam ser \'Number\'';
return callback(err, null);
}
var result = ( A + B )/ 2;
return callback(null, result);
}
media(2, 6, function(err, result){
if(err){
console.log(err);
return;
}
console.log(result);
});
```
## Explicar a definição de continuação de uma função.
É quando passamos uma `function A` como parâmetro para `function B` que em determinado momento, a `function B` vai retornar alguma coisa para a `function A`, dando continuidade no fluxo do código.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**Autor:** Gabriel Kalani
**Data:** 1454213678365
## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```js
function name(nome, callback){
if (typeof nome === 'string') {
return callback(null, nome);
} else {
const err = new Error("Opa! Parece que você não digitou uma string.");
return callback(err, null);
}
}
name("Gabriel Kalani", (err, nome) => {
if (err) {
console.log(err);
} else {
console.log(nome);
}
});
```
Saída que apareceu no Console.
```
Desktop\Gabriel\workshop-be-mean\nodejs\callbacks>node name.js
Gabriel Kalani
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
function sum (num1, num2, callback) {
setTimeout(() => {
if (typeof num1 == "number" && typeof num2 == "number") {
const result = num1 + num2;
callback(null, result);
} else {
const error = new Error("Ué?! Cadê o número?");
return callback(error, null);
}
}, 30);
}
sum(4, 4, (err, result) => {
if (err) {
console.log(err);
} else {
console.log(result);
}
});
```
Saída:
```
Desktop\Gabriel\workshop-be-mean\nodejs\callbacks>node numbers.js
8
```
## Criar uma que calcular a média de dois valores e imprima essa média uma outra função, como continuação da execução da mesma.
```js
function sum (num1, num2, callback) {
setTimeout(() => {
if (typeof num1 == "number" && typeof num2 == "number") {
const result = (num1 + num2)/ 2;
callback(null, result);
} else {
const error = new Error("Ué?! Cadê o número?");
return callback(error, null);
}
}, 30);
}
sum(4, 4, (err, result) => {
if (err) {
console.log(err);
} else {
console.log(result);
}
});
```
Saída do Console:
```
\Desktop\Gabriel\workshop-be-mean\nodejs\callbacks>node numbers.js
4
```
## Explicar a definição de continuação de uma função.
Uma `function` que recebe no parâmetro, outra `function` ou dizendo `callback`.
A função passada como parâmetro vai enviar algo para a outra função para continuar com a execução do código. | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**user:** [fauker](http://github.com/fauker)
**autor:** LUCAS DA SILVA MOREIRA
## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma
```
function sayMyName(nome, callback) {
if (typeof nome === 'string') {
return callback(null, nome);
} else {
return callback(new Error('O parâmetro passado não é uma String!'), null);
}
}
sayMyName('Lucas', function(erro, resposta) {
if (erro) console.log(erro);
else console.log(resposta);
});
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula
```
function sum(num1, num2, callback) {
if (typeof num1 === 'number' && typeof num2 === 'number') {
var result = num1 + num2;
return callback(null, result);
} else {
return callback(new Erro('Somente números são suportados'), null);
}
}
sum(1, 2, function(error, result) {
if (error) console.log(error);
else console.log(result);
});
```
## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma
```
function media(num1, num2, callback) {
if (typeof num1 === 'number' && typeof num2 === 'number') {
var result = num1 + num2 / 2;
return callback(null, result);
} else {
return callback(new Erro('Somente números são suportados'), null);
}
}
media(1, 2, function(error, result) {
if (error) console.log(error);
else console.log(result);
});
```
## Explicar a definição de continuação de uma função
Na programação funcional, **Continuation-passing style** é um estilo de
programação que o controle é passado explicitamente em forma de
continuação.
A função escrita com este padrão tem um argumento extra: uma função que
será a continuação.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**User:** [daniofilho](https://github.com/daniofilho)
**Autor:** Dânio Filho
**Date:** 1452804479379
# 1. Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
~~~ js
function nome(name, cb){
if(typeof name === 'string'){
return cb(null, name);
} else {
var err = new Error('Por favor, insira uma string.');
return cb(err, null);
}
}
nome('Dânio', function(err, result){
if(err){
console.log(err);
} else {
console.log(result);
}
});
~~~
# 2. Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
~~~ js
function soma(v1, v2, cb){
if(typeof v1 === 'number' && typeof v2 === 'number'){
return cb(null, v1 + v2);
} else {
var err = new Error('Por favor, utilize números.');
return cb(err, null);
}
}
soma(2, 3, function(err, result){
if(err){
console.log(err);
} else {
console.log(result);
}
});
~~~
# 3. Criar uma função que calcula a média de dois valores e imprima essa média numa outra função, como continuação da execução da mesma.
~~~ js
function media(v1, v2, cb){
if(typeof v1 === 'number' && typeof v2 === 'number'){
return cb(null, (v1 + v2)/2);
} else {
var err = new Error('Por favor, utilize números.');
return cb(err, null);
}
}
media(10, 3, function(err, result){
if(err){
console.log(err);
} else {
console.log(result);
}
});
~~~
# 4. Explicar a definição de continuação de uma função.
Usar a técnica de continuação de uma função garante que você consiga executar as funções e processar sua saída de forma contínua, ou seja, em sequência, como se fossem síncronas, mesmo que as funções sejam assíncronas.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**user:** [airton](https://github.com/airton)<br>
**autor:** Airton Vancin Junior<br>
**date:** 1456328185817
## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma
```js
function sayName (name, callback){
if (typeof name === 'string') {
return callback(null, name);
} else {
var err = new Error("Error, não é string");
return callback(err, null);
}
}
sayName("Airton Vancin", function(err, name){
if (err) {
console.log(err);
} else {
console.log(name);
}
});
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula
```js
function sum (num1, num2, callback) {
if (typeof num1 == "number" && typeof num2 == "number") {
var result = num1 + num2;
callback(null, result);
} else {
var error = new Error("Passe um número, por favor!! ");
return callback(error, null);
}
}
sum(10, 10, function(err, result){
if (err) {
console.log(err);
} else {
console.log(result);
}
});
```
## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma
```js
function sum (num1, num2, callback) {
if (typeof num1 == "number" && typeof num2 == "number") {
var result = (num1 + num2) / 2;
callback(null, result);
} else {
var error = new Error("Passe um número, por favor!! ");
return callback(error, null);
}
}
sum(50, 100, function(err, result){
if (err) {
console.log(err);
} else {
console.log(result);
}
});
```
## Explicar a definição de continuação de uma função
Para estendermos a execução de uma função basta que passamos para essa função um outra função com parâmentro.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 04 - Exercícios
**User:** [ajoao1988](https://github.com/ajoao88)
**Autor:** João Paulo S de Araújo
**Date:** 1456710048954
## 1. Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da mesma.
```js
function imprimirNome(nome,callback){
if (typeof nome === 'string') {
return callback(null,nome);
} else {
erro = new Error('Nome inválido!');
return callback(erro,null);
}
}
imprimirNome('João Paulo', function(err, result){
if (err) console.log(err);
else console.log(result);
});
```
## 2. Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
function soma(val1, val2, callback){
if (typeof val1 === 'number' && typeof val2 === 'number'){
var resultado = val1 + val2;
return callback(null,resultado);
} else {
var erro = new Error('Valores inválidos');
return callback(erro, null);
}
}
soma(12,13,function(err,result){
if (err) console.log(err);
else console.log(result);
});
```
## 3. Criar uma que calcular a média de dois valores e imprima essa média em uma outra função, como continuação da execução da mesma.
```js
function calcularMedia(val1, val2, callback){
if (typeof val1 === 'number' && typeof val2 === 'number'){
var resultado = (val1 + val2) / 2;
return callback(null,resultado);
} else {
var erro = new Error('Valores inválidos');
return callback(erro, null);
}
}
calcularMedia(12,13,function(err,result){
if (err) console.log(err);
else console.log(result);
});
```
## 4. Explicar a definição de continuação de uma função.
Continuação de uma função é a técnica de chamar uma função dentro de outra e ter o retorno da função chamada em forma de callback para a função chamadora e assim fazer a continuação do código após a chamada.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**user:** [augustoody](https://github.com/AugustoOdy)
**autor:** Augusto Ody
**date:** 1455192903275
## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma
```js
'use strict';
function sayMyName(name, callback){
if(typeof name == 'string'){
callback(null, name);
}else{
var err = new Error('O name não é uma string')
callback(err, null);
}
}
sayMyName('Augusto', function(err, name){
if(err){
console.log(err);
}else{
console.log(name);
}
});
```
Resposta:
```
Augusto
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula
```js
'use strict';
function sum(n1, n2, callback){
if(typeof n1 == 'number' && typeof n2 == 'number'){
callback(null, n1+n2);
}else{
var err = new Error('O primeiro ou o segundo valor não é/são números.')
callback(err, null);
}
}
sum(1, 2, function(err, result){
if(err){
console.log(err);
}else{
console.log(`Resultado: ${result}`);
}
});
```
Resposta:
```
Resultado: 3
```
## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma
```js
'use strict';
function sum(n1, n2, callback){
setTimeout(function() {
if(typeof n1 == 'number' && typeof n2 == 'number'){
callback(null, (n1+n2)/2);
}else{
var err = new Error('O primeiro ou o segundo valor não é/são números.')
callback(err, null);
}
}, 30);
}
sum(1, 2, function(err, result){
if(err){
console.log(err);
}else{
console.log(`Resultado: ${result}`);
}
});
```
Resposta:
```
Resultado: 1.5
```
## Explicar a definição de continuação de uma função
Denominado continuation-passing style, um dos argumentos da função é uma outra função que trata da continuação de sua execução. Como exemplificado nos exercícios acima.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**user:** https://github.com/paulosilva92
**autor:** Paulo Roberto da Silva
**date:** Sat Mar 05 2016 00:51:06 GMT-0300 (BRT)
## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```js
function name(name) {
if (typeof(name) !== 'string') {
var err = new Error('Não é uma String');
arguments[1](err, null)
} else {
arguments[1](null,name);
}
}
name("paulo", function(err,name){
if (err) {
console.log(err);
} else {
console.log(name);
}
});
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
function soma(num1, num2 , callback) {
if (typeof(num1) === 'number' && typeof(num2) === 'number') {
callback(null,num1+num2);
} else {
var err = new Error('Parametros inválidos');
callback(err, null)
}
};
soma(1,2, function(err,resultado){
if (err) {
console.log(err);
} else {
console.log(resultado);
}
});
```
## Criar uma função que calcula a média de dois valores e imprima essa média uma outra função, como continuação da execução da mesma.
```js
function media(num1, num2 , callback) {
if (typeof(num1) === 'number' && typeof(num2) === 'number') {
var med = (num1+num2)/2
callback(null,med);
} else {
var err = new Error('Parametros inválidos');
callback(err, null)
}
};
media(1,2, function(err,resultado){
if (err) {
console.log(err);
} else {
console.log(resultado);
}
});
```
## Explicar a definição de continuação de uma função
Quando estendemos a funcionalidade de uma função para outra função, dizemos que a segunda função é continuação da primeira. | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 04 - Exercício
autor: Wellerson Roberto
# Exercícios de File System
## 1) Criar um arquivo
```
'use strict';
const fs = require('fs');
fs.writeFile('./novo-arquivo.txt', '', (err) => {
if (err)
console.log(err);
});
```
## 2) Ler um arquivo
```
'use strict';
const fs = require('fs');
fs.readFile('./novo-arquivo.txt', 'utf8', (err, result) => {
if (err)
console.log(err);
else
console.log(result);
});
```
## 3) Editar conteúdo desse arquivo
```
'use strict';
const fs = require('fs');
let writeFileStream = fs.createWriteStream('./novo-arquivo.txt');
writeFileStream.write('Escrevendo novas coisas!');
```
## 4) Deletar arquivo
```
'use strict';
const fs = require('fs');
fs.unlink('./novo-arquivo.txt', (err) => {
if (err)
console.log(err);
});
```
## 5)Renomear o arquivo
```
'use strict';
const fs = require('fs');
fs.rename('./novo-arquivo.txt', 'renomeado.txt', (err) => {
if (err)
console.log(err);
});
```
## DESAFIO: Criar um servidor web de arquivos estáticos: .css, .html, .js e etc...
```
'use strict';
const http = require('http')
, fs = require('fs')
, buildHTML = text => {
let html = '<!doctype html>' +
'<html>' +
'<head><title>Servidor de Arquivos Estáticos</title><meta charset="utf-8"/></head>' +
'<body>' + text + '</body>' +
'</html>';
return html;
};
http.createServer((req, res) => {
let url = req.url;
if (url.indexOf('/request') > -1) {
url = url.substring(9);
fs.readFile('./' + url, 'utf8', (err, result) => {
if (err) {
res.writeHead(200, { 'Content-Type': 'text/html' });
res.write(buildHTML('Erro' + err));
res.write(err);
}
else{
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.write(result);
}
res.end();
});
}
else {
res.writeHead(200, { 'Content-Type': 'text/html' });
res.write(buildHTML('Servidor de Arquivos Estáticos -> Use a URL "request/NOME DO ARQUIVO" para requerer seu arquivo!'));
res.end();
}
}).listen(3000, () => {
console.log('Estou pronto!')
})
```
# Exercícios de Callback
## 1) Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```
'use strict';
const name = (name, callback) => {
callback(name);
};
name('Wellerson Roberto', name => console.log(name));
```
## 2) Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado na aula.
```
'use strict';
const soma = (valor1, valor2, callback) => {
if (typeof valor1 == 'number' && typeof valor2 == 'number')
callback(null, (valor1 + valor2));
else {
var err = new Error('Você deve passar dois números filho da puta!');
callback(err, null);
}
};
soma(7, 2, (err, value) => {
if (err) {
console.log(err);
}
else {
console.log(value);
}
});
```
## 3) Criar uma função para calcular a média de dois valores e imprima essa média em uma outra função, como continuação da execução da mesma.
```
'use strict';
const media = (valor1, valor2, callback) => {
if (typeof valor1 == 'number' && typeof valor2 == 'number'){
let media = (valor1 + valor2) / 2
callback(null, media);
}
else {
var err = new Error('Você deve passar dois números filho da puta!');
callback(err, null);
}
};
media(7, 2, (err, value) => {
if (err) {
console.log(err);
}
else {
console.log(value);
}
});
```
## 4) Explicar a definição de continuação de uma função.
É uma forma de se obter funções sendo executada após a outra, mesmo que essas funções sejam assíncronas. Isso é obtivo passando-se a função por parâmetro para uma função assíncrona. Assim que essa função assíncrona terminar de ser executava, ela chamará a função passada como parâmetro, obtendo a mesma continuidade que você obtem se executar isso de forma síncrona.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Parte 1 - Exercício
**User:** [angelorubin](https://github.com/angelorubin)
**Autor:** Angelo Rogério Rubin
**Date:** 1451048271400
## Criar uma função com uma entrada para o nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
'use strict';
function firstName(firstName, callback) {
if(typeof firstName === 'string') {
return callback(firstName, null);
}
else {
var error = new Error('Digite seu primeiro nome.');
return callback(error, null);
}
}
firstName(2, (error, firstName) => {
if(error) {
console.log(error);
}
else {
console.log(firstName);
}
});
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
'use strict';
function addTwoNumbers(num1, num2, callback){
if( typeof num1 !== 'number' || typeof num2 !== 'number'){
let error = new Error('São permitidos apenas números');
return callback(error, null);
}
let result = num1 + num2;
return callback(null, result);
}
addTwoNumbers(20, 1.78, (error, result) => {
if(error){
console.log(error);
return;
}
console.log(result);
});
## Criar uma função que calcula a média de dois valores e imprima essa média uma outra função. como continuação da execução da mesma.
'use strict';
function media(val1, val2, callback) {
if( typeof val1 != 'number' || typeof val2 != 'number'){
var error = new Error('São permitidos apenas números.');
return callback(error, null);
}
var result = ( val1 + val2 )/ 2;
return callback(null, result);
}
media(2, 1.45, (error, result) => {
if(error){
console.log(error);
return;
}
console.log(result);
});
## Explicar a definição de continuação de uma função.
Na programação funcional, continuation-passing style (CPS) é um estilo de programação em que o controle é passado explicitamente na forma de uma continuação.
Uma função escrita em continuation-passing style recebe um argumento extra: uma "continuação" explícita, ou seja, uma função de um argumento.
Os exemplos desenvolvidos acima demonstram claramente o uso de continuation-passing style. | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
# Node.js - Aula 04 - Exercício
**user:** [fernandobd42](https://github.com/fernandobd42)
**autor:** Fernando Lucas
**date:**
## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma
```
const name = (nome, callback) => {
if (typeof nome === 'string') {
return callback(null, 'O nome é: '+ nome);
} else {
let err = new Error("Tipo de dado incorreto, digite uma string por favor.");
return callback(err, null);
}
}
const printName = (err, nome) => {
if (err) {
console.log(err);
} else {
console.log(nome);
}
};
name('Fernando Lucas', printName); // 'O nome é: Fernando Lucas'
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula
```
const sum = (a, b, callback) => {
if (typeof a === 'number' && typeof b === 'number') {
let sum = a + b;
return callback(null, 'A soma é: '+ sum);
} else {
let err = new Error('Tipo de dado incorreto, digite apenas números por favor.');
return callback(err, null);
}
}
const printSum = (err, sum) => {
if (err) {
console.log(err);
} else {
console.log(sum);
}
}
sum(3,6, printSum); // A soma é: 9
```
## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma
```
const av = (a, b, callback) => {
if (typeof a === 'number' && typeof b === 'number') {
let average = (a + b) / 2;
return callback(null, 'A média é: '+ average);
} else {
let err = new Error('Tipo de dado incorreto, digite apenas números por favor.');
return callback(err, null);
}
}
const printAv = (err, average) => {
if (err) {
console.log(err);
} else {
console.log(average);
}
}
av(3,6, printAv); // A média é: 4.5
```
## Explicar a definição de continuação de uma função
O termo continuação de uma função consiste em passar uma função como parâmetro de outra função, que ao ser invocada dependerá do retorno da função que foi passada como argumento para continuar o processo. Ou seja, a função A que possui o callback (chamada de retornorno) executa as instruções necessárias e passa os argumentos para a função B, que é responsável pelo retorno.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**user:** [Pauloxt1](https://github.com/Pauloxt1)<br>
**autor:** Paulo Roberto
## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```js
// file: name.js
function setName(name, callback){
callback(name);
}
setName('paulo', function(name){
console.log(name);
});
```
```js
paulo@Paulo:~/workshop-be-mean/nodejs/4$ node name.js
paulo
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
// file: sum.js
function sum(num1, num2, callback){
if(typeof num1 == "number" && typeof num2 == "number"){
var resultado = num1+num2;
callback(null, resultado);
} else {
callback("Passe um número por favor", null);
}
}
sum(2,2,function(err, result){
if(err){
console.log(err);
}else{
console.log(result);
}
});
```
```js
paulo@Paulo:~/workshop-be-mean/nodejs/4$ node sum.js
4
```
## Criar uma que calcular a média de dois valores e imprima essa média uma outra função, como continuação da execução da mesma.
```js
// file: media.js
function media(num1, num2, callback){
if(typeof num1 == "number" && typeof num2 == "number"){
var resultado = (num1+num2)/2;
callback(null, resultado);
} else {
callback("Passe um número por favor", null);
}
}
media(2,2,function(err, result){
if(err){
console.log(err);
}else{
console.log(result);
}
});
```
```js
paulo@Paulo:~/workshop-be-mean/nodejs/4$ node media.js
2
```
## Explicar a definição de continuação de uma função.
Uma função que recebe como parâmetro outra função<b>(callback)</b>, e executa essa função recebida passando para ela
seu resultado como parâmetro.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 04 - Exercício
**Autor**: Igor luíz
**Github**: [Halfeld](https://github.com/Halfeld)
**Data**: 1457359592117
## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```js
'use strict';
function input(name, callback) {
if (typeof name === 'string') {
return callback(null, name);
} else {
let error = new Error('Pow passa um string aí véi');
return callback(error, null);
}
}
input("Igor", (err, name) => {
if (err) {
console.log(err);
} else {
console.log(name);
}
});
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
'use strict';
function sum(num1, num2, callback) {
if(typeof num1 === 'number' && typeof num2 === 'number') {
let result = num1 + num2;
return callback(null, result);
} else {
let error = new Error("Passe um numero");
return callback(error, null);
}
}
sum(2, 4, (err, result) => {
if (err) {
console.log(err);
} else {
console.log(result);
}
});
```
## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma.
```js
'use strict';
function sum(num1, num2, callback) {
if(typeof num1 === 'number' && typeof num2 === 'number') {
let result = (num1 + num2) / 2;
return callback(null, result);
} else {
let error = new Error("Passe um numero");
return callback(error, null);
}
}
sum(4, 8, (err, result) => {
if (err) {
console.error(err);
} else {
console.log(result);
}
});
```
## Explicar a definição de continuação de uma função.
É simplesmente quando passamos um função como parametro de outra função.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**Autor:** Ednilson Amaral
**Data:** 1450748289337
## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```js
function meuNome(nome, callback){
if (typeof nome === 'string') {
return callback(null, nome);
} else {
var err = new Error("Digite uma string, parça!");
return callback(err, null);
}
}
meuNome("Ednilson Amaral", function (err, nome){
if (err) {
console.log(err);
} else {
console.log(nome);
}
});
```
Saída:
```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/exercicios-callbacks$ node exercicio_01.js
Ednilson Amaral
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
function soma(n1, n2, callback){
if (typeof arguments[0] == "number" && typeof arguments[1] == "number") {
var result = n1 + n2;
return callback(null, result);
} else {
var err = new Error("Digite um número, parça!");
return callback(err, null);
}
}
soma(5, 5, function (err, result) {
if (err) {
console.log(err);
} else {
console.log(result);
}
});
```
Saída:
```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/exercicios-callbacks$ node exercicio_02.js
10
```
## Criar uma que calcular a média de dois valores e imprima essa média uma outra função, como continuação da execução da mesma.
```js
function soma(n1, n2, callback){
if (typeof arguments[0] == "number" && typeof arguments[1] == "number") {
var result = (n1 + n2) / 2;
return callback(null, result);
} else {
var err = new Error("Digite um número, parça!");
return callback(err, null);
}
}
soma(8, 4, function (err, result) {
if (err) {
console.log(err);
} else {
console.log(result);
}
});
```
Saída:
```
ednilson@EDNILSON-NB:/var/www/be-mean-instagram-nodejs/exercicios-callbacks$ node exercicio_03.js
6
```
## Explicar a definição de continuação de uma função.
A continuação de função é quando ao chamar determinada função, chamamos outra função nela como parâmetro. Ou seja, em algum momento, A função passada como parâmetro vai enviar algo para a outra função para continuar com a execução do código. | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**user:** [filipe1309](https://github.com/filipe1309)
**autor:** Filipe Leuch Bonfim
## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma
```js
function readName(name, printCallback) {
if (typeof name == "string") {
return printCallback(null, name);
} else {
var error = new Error("informe uma string!!!");
return printCallback(error, null);
}
}
function printCallback(err, result) {
if (err) {
console.log(err);
} else {
console.log(result)
}
}
readName("nome_teste", printCallback); // nome_teste
readName(1, printCallback); // [Error: informe uma string!!!]
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula
```js
function sumValues(value1, value2, printCallback) {
if (typeof value1 == "number" && typeof value2 == "number") {
var result = value1 + value2;
return printCallback(null, result);
} else {
var error = new Error("informe somente números!!!");
return printCallback(error, null);
}
}
function printCallback(err, result) {
if (err) {
console.log(err);
} else {
console.log(result)
}
}
sumValues("nome_teste", 2, printCallback); // [Error: informe somente números!!!]
sumValues(1, 2, printCallback); // 3
```
## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma
```js
function average(value1, value2, printCallback) {
if (typeof value1 == "number" && typeof value2 == "number") {
var result = (value1 + value2)/2;
return printCallback(null, result);
} else {
var error = new Error("informe somente números!!!");
return printCallback(error, null);
}
}
function printCallback(err, result) {
if (err) {
console.log(err);
} else {
console.log(result)
}
}
average("nome_teste", 2, printCallback); // [Error: informe somente números!!!]
average(1, 2, printCallback); // 1.5
```
## Explicar a definição de continuação de uma função
Continuação de uma função, também conhecido como `continuation-passing style (CPS)` na programação funcional, é um estilo de programação em quem uma função recebe uma outra função como parâmetro (conhecida como função de **callback**), e ao final de sua execução, a função que foi passada como parâmetro é executada.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**User:** [sergiokopplin](https://github.com/sergiokopplin)
**Autor:** Sergiokopplin
**Date:** 1450670429154
## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```js
function imprimiNome(name, callback) {
"use strict";
if(typeof name === "string"){
var str = "Seu nome é: " + name;
return callback(null, str);
} else {
var erro = new Error("Você precisa passar uma string com o seu nome.");
return callback(erro, null);
}
};
imprimiNome("Sérgio Aragão Kopplin", function(erro, name) {
"use strict";
if (erro) {
console.log(erro);
} else {
console.log(name);
}
});
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
function somaValores(num1, num2, callback) {
"use strict";
if(typeof num1 === "number" && typeof num2 === "number"){
var res = num1 + num2;
return callback(null, res);
} else {
var erro = new Error("Você precisa passar apenas números para a função.");
return callback(erro, null);
}
};
somaValores(13, 76, function(erro, name) {
"use strict";
if (erro) {
console.log(erro);
} else {
console.log(name);
}
});
```
## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma.
```js
function calculaMedia(num1, num2, callback) {
"use strict";
if(typeof num1 === "number" && typeof num2 === "number"){
var res = ( num1 + num2 ) / 2;
return callback(null, res);
} else {
var erro = new Error("Você precisa passar apenas números para a função.");
return callback(erro, null);
}
};
calculaMedia(1, 5, function(erro, name) {
"use strict";
if (erro) {
console.log(erro);
} else {
console.log(name);
}
});
```
## Explicar a definição de continuação de uma função.
A continuação de uma função consiste em chamar otura função como parâmetro dentro de uma função principal. Essa função parâmetro será, em determinado momento, chamada em forma de callback, sendo assim, quando o código executar a primeira função terá como callback o resultado de outra função.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**User:** charles7421
**Autor:** Charles de Freitas Garcia
**Date:** 03/04/2016
## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```js
function sayMyName(name, callback) {
if (typeof name === 'string') {
return callback(null, name);
} else {
var err = new Error('Informe ');
return callback(err, null);
}
}
sayMyName("Heisenberg", function(err, name){
if (err){
console.log(err);
} else {
console.log(name);
}
});
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
function soma(num1, num2, callback){
if (typeof num1 == "number" && typeof num2 == "number") {
var result = num1 + num2;
callback(null, result);
} else {
var err = new Error("Informe um número");
return callback(err, null);
}
}
soma(1,1, function(err, result){
if (err){
console.log(err);
} else {
console.log(result);
}
})
```
## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma.
```js
function media(num1, num2, callback){
if (typeof num1 == "number" && typeof num2 == "number") {
var result = (num1 + num2) / 2;
callback(null, result);
} else {
var err = new Error("Informe um número");
return callback(err, null);
}
}
media(5,10, function(err, result){
if (err){
console.log(err);
} else {
console.log(result);
}
})
```
## Explicar a definição de continuação de uma função.
A continuação de uma função ou CPS (Continuation-Passion style) é quando uma função é passada como parametro na chamada de uma função. Quando isso ocorre é processada e retorna o resultado para a função que realizou a chamada.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**user:** [felipelopesrita](https://github.com/felipelopesrita)
**autor:** Felipe José Lopes Rita
## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma
```js
'use strict';
function showName( name, callback ) {
if( typeof name === "string" )
return callback(null, name);
else {
var error = new Error("Tipo de dados inesperado, insira uma string");
return callback(error, null);
}
}
showName("Felipe", (err, resul)=>{
if(err)
console.log(err);
else
console.log(resul);
});
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula
```js
'use strict';
function sum( x, y, callback ) {
if( typeof x === "number" && typeof y == "number" )
return callback(null, x+y);
else {
var error = new Error("Tipo de dados inesperado, insira números");
return callback(error, null);
}
}
sum(14, 6, (err, resul)=>{
if(err)
console.log(err);
else
console.log(resul);
});
```
## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma
```js
'use strict';
function average( x, y, callback ) {
if( typeof x === "number" && typeof y == "number" )
return callback(null, (x+y)/2);
else {
var error = new Error("Tipo de dados inesperado, insira números");
return callback(error, null);
}
}
average(10, 6, (err, resul)=>{
if(err)
console.log(err);
else
console.log(resul);
});
```
## Explicar a definição de continuação de uma função
É o conceito de funções que recebem funções como parametro (First-class citizen). A função então retorna a execução da função que foi passada como parametro. Dessa forma, ocorre uma continuidade da execução através das funções. | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**User:** [matheusjkweber](https://github.com/matheusjkweber)
**Autor:** Matheus José Krumenauer Weber
**Date:** 1456691485032
## Criar uma função com uma entrada para o nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```js
function sayName(name, callback){
if(typeof name === 'string'){
callback(null, name);
}else{
var err = new Error("It is not a string");
return callback(err, null);
}
}
sayName("Matheus", function(err,name){
if (err){
console.log(err);
}else{
console.log(name);
}
});
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
function sum(num1, num2, callback){
if(typeof arguments[0] == "number" && typeof arguments[1] == "number"){
var result = num1 + num2;
callback(null, result);
} else{
var error = new Error("Arguments are not numbers.");
return callback(error, null)
}
}
sum(1,2, function(err,result){
if (err){
console.log(err);
}else{
console.log(result);
}
});
```
## Criar uma função que calcula a média de dois valores e imprima essa média uma outra função. como continuação da execução da mesma.
```js
function average(num1, num2, callback){
if(typeof arguments[0] == "number" && typeof arguments[1] == "number"){
var result = (num1 + num2)/2;
callback(null, result);
} else{
var error = new Error("Arguments are not numbers.");
return callback(error, null)
}
}
average(1,2, function(err,result){
if (err){
console.log(err);
}else{
console.log(result);
}
});
```
## Explicar a definição de continuação de uma função.
```js
Continuation-passing style é quando um dos argumentos de uma função é outra função que trata da continuação dela. Por exemplo, no average acima o argumento callback foi passado para a segunda função e tratada como erro ou resultado.
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**user:** [diegolopesdev](http://www.github.com/diegolopesdev)
**autor:** Diego Lopes do Nascimento
## Exercícios de File System
## Criar um arquivo.
```
'use strict';
const fs = require('fs');
fs.writeFile('ola-mundo.txt', 'É o meu primeiro Olá Mundo.', (err) => {
if(err) throw err;
console.log('O arquivo foi criado com sucesso.');
});
```
## Ler um arquivo.
```
'use strict';
const fs = require('fs');
fs.readFile('ola-mundo.txt', (err, data) => {
if(err) throw err;
console.log(data.toString());
});
```
## Editar conteúdo desse arquivo.
```
'use strict';
const fs = require('fs');
var writeFileStream = fs.createWriteStream('./ola-mundo.txt');
writeFileStream.write('Inserindo um novo olá mundo!');
```
## Deletar arquivo.
```
'use strict';
const fs = require('fs');
fs.unlink('ola-mundo.txt', (err => {
if(err) throw err;
console.log('O arquivo foi deletado com sucesso.');
}));
```
## Renomear o arquivo.
```
'use strict';
const fs = require('fs');
fs.rename('./ola-mundo.txt', './ola-mundo-2.txt', (err) => {
if(err) throw err;
console.log('O arquivo foi renomeado com sucesso.');
});
```
## **Desafio: Criar um servidor web de arquivos estáticos: .css, .html, .js e etc...**
Challenge Accepted! Mãos na massa.
Para não poluir muito o código do meu mini servidor web de arquívos estáticos **sem usar express**, eu decidi por criar dois arquivos HTML: o **index.html** e o **404.html**, que serão nossos dois arquivos HTML padrões.
A lógica do servidor é baseada no client tentar acessar /nome-do-arquivo.extensao e, se o arquivo existir, carregará no browser e para caso não exista, retornar um error genérico 404.
**index.html**
```
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<h1>Bem vindo ao meu servidor estático!</h1>
</body>
</html>
```
**404.html**
```
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
</head>
<body>
<h1>Error 404 - Nada encontrado!</h1>
</body>
</html>
```
**http-server.js**
```
'use strict';
const http = require('http')
, fs = require('fs');
http.createServer((req, res) => {
let url = req.url;
if(url == '/' || url == '/favicon.ico') url = 'index.html';
const file = './' + url;
fs.readFile(file, (err, data) => {
if(err) {
res.writeHead(404, {'Content-type': 'text/html; charset=utf-8'});
res.write( fs.readFileSync('404.html') );
} else {
res.writeHead(200, {'Content-type': 'text/html; charset=utf-8'});
res.write(data);
}
res.end();
});
}).listen(8000, () => {
console.log('O servidor está em localhost:8000');
});
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**user:** [FranciscoValerio](https://github.com/FranciscoValerio)
**autor:** Francisco Henrique Ruiz Valério
## 1. Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
var fileSytem = require('fs');
function sayName(name, callback){
setTimeout(function(){
if ( typeof name === 'string' ){
return callback(null, name);
} else {
var error = new Error("O parâmetro passado não é do tipo string!");
return callback( error, null);
}
}, 20 );
}
function printName(name){
setTimeout(function(){
if ( typeof name === 'string' ){
console.log( name );
}
}, 10 );
}
sayName( "Francisco Valerio", function( error, result ){
if ( error ){
console.log( error );
}
printName(result);
});
## 2. Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
var fileSytem = require('fs');
function sum(numero1, numero2, callback){
setTimeout(function(){
if( typeof numero1 == "number" && typeof numero2 == "number" ){
var result = numero1 + numero2;
callback(null, result);
} else {
var error = new Error("Algum dos parâmetros passados não foi do tipo numérico.");
return callback(error, null);
}
}, 20);
}
function printResult(result){
setTimeout(function(){
if ( typeof result === 'number' ){
console.log( result );
}
}, 10 );
}
sum(4, 4, function( error, result ){
if (error){
console.log(error);
}
printResult(result);
});
## 3. Criar uma que calcular a média de dois valores e imprima essa média uma outra função, como continuação da execução da mesma.
var fileSytem = require('fs');
function average(numero1, numero2, callback){
setTimeout(function(){
if( typeof numero1 == "number" && typeof numero2 == "number" ){
var media = ( numero1 + numero2 ) / 2;
callback(null, media);
} else {
var error = new Error("Ops passe números.");
return callback(error, null);
}
}, 20);
}
function printResult(result){
setTimeout(function(){
if ( typeof result === 'number' ){
console.log( result );
}
}, 10 );
}
average(4, 4, function( error, result ){
if (error){
console.log(error);
}
printResult(result);
});
## 4. Explicar a definição de continuação de uma função.
Um forma simples de explicar essa definição é pensarmos em uma função que possa ser traçada em uma folha sem retirar a caneta do papel. Caso a função se interrompa e começe em outro local do papel, ocorre uma "descontinuidade". Ou seja, essa função não pode ser termina e iniciada em outra local "chamada".
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
autor: Bruno Lima da Silva
## 1. Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma.
```js
'use strict';
function callback (err, result) {
if (err) throw new Error (err);
console.log ('Meu nome é ', result);
}
function sayName (name, callback) {
if (typeof name === 'string') return callback (null, name);
const err = 'Você precisa passar uma STRING para name';
return callback (err, null);
}
```
## 2. Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
'use strict';
function callback (err, result) {
if (err) throw new Error (err);
console.log ('A soma é ', result);
}
function sum (value1, value2, callback) {
if (typeof value1 === 'number' && typeof value2 === 'number') return callback (null, (value1+value2));
const err = 'Você precisa informar dois números';
return callback (err, null);
}
```
## 3. Criar uma que calcular a média de dois valores e imprima essa média uma outra função, como continuação da execução da mesma.
```js
'use strict';
function callback (err, result) {
if (err) throw new Error (err);
console.log ('A média é ', result);
}
function media (value1, value2, callback) {
if (typeof value1 === 'number' && typeof value2 === 'number') return callback (null, ((value1+value2)/2));
const err = 'Você precisa informar dois números';
return callback (err, null);
}
```
## 04.Explicar a definição de continuação de uma função.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 04.01 - Exercícios
**User:** [carloshenriqueribeiro](https://github.com/carloshenriqueribeiro)
**Autor:** Carlos Henrique Ribeiro
**Date:** 1501763351107
## 1. Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da mesma.
```js
function imprimirNome(nome,callback){
if (typeof nome === 'string') {
return callback(null,nome);
} else {
erro = new Error('Nome inválido!');
return callback(erro,null);
}
}
imprimirNome('Carlos Ribeiro', function(err, result){
if (err) console.log(err);
else console.log(result);
});
```
## 2. Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função que imprima-o, de acordo com o padrão apresentado em aula.
```js
function soma(val1, val2, callback){
if (typeof val1 === 'number' && typeof val2 === 'number'){
var resultado = val1 + val2;
return callback(null,resultado);
} else {
var erro = new Error('Valores inválidos');
return callback(erro, null);
}
}
soma(666,333,function(err,result){
if (err) console.log(err);
else console.log(result);
});
```
## 3. Criar uma que calcular a média de dois valores e imprima essa média em uma outra função, como continuação da execução da mesma.
```js
function calcularMedia(val1, val2, callback){
if (typeof val1 === 'number' && typeof val2 === 'number'){
var resultado = (val1 + val2) / 2;
return callback(null,resultado);
} else {
var erro = new Error('Valores inválidos');
return callback(erro, null);
}
}
calcularMedia(666,333,function(err,result){
if (err) console.log(err);
else console.log(result);
});
```
## 4. Explicar a definição de continuação de uma função.
Continuação de uma função é a técnica de chamar uma função dentro de outra função. O retorno da função chamada deve estar no formato de callback para a função chamadora. Podendo ser Async ou Sync.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
#NodeJS - Aula 04 - Exercícios
autor: Dariano Soares
##1. Criar uma função com **uma entrada** para nome e **imprimir** está entrada em uma outra função, como continuação da execução da mesma.
```js
function imprimirNome(nome, callback) {
if (typeof nome === 'string') {
callback(null, nome);
} else {
var err = new Error('Opa, deu erro');
callback(err, null);
}
};
imprimirNome('Dariano', (err, nome) => {
if(err) {
console.log('erro', err);
}else
{
console.log('nome = ', nome);
}
});
nome = Dariano
```
##2. Criar uma função que **calcula a soma** de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula.
```js
function soma (num1, num2, callback) {
if(typeof num1 === 'number' && typeof num2 === 'number'){
var result = num1 + num2;
callback(null, result);
} else{
var error = new Error('Passe o número valido');
callback(error, null);
}
};
soma(5, 5, (err, result) => {
if(err){
console.log('error', err);
}
else{
console.log('soma = ', result);
}
});
soma = 10
```
##3. Criar uma função que **calcula a média** de dois valores e imprima essa média em uma outra função, como continuação da execução da mesma.
```js
function media(num1, num2, callback) {
setTimeout(() => {
if (typeof num1 === 'number' && typeof num2 === 'number') {
var result = (num1 + num2) / 2;
callback(null, result);
} else {
var error = new Error('Passe o número valido');
callback(error, null);
}
}, 1000);
};
media(30, 20, (err, result) => {
if (err) {
console.log('error', err);
} else {
console.log('media', result);
}
});
media 25
```
##4. Explicar a definição de **continuação de uma função**.
**Continuação de uma função** é a execução de uma função que pode receber outra função por parâmetro e logo após executar um procedimento e invocar a função passada por parâmentro. Ou pode ser uma função que executa um procedimento e logo após essa execução invoca outra função que pode executar seu fluxo e chamar outra função e assim sucessivamente. Isso também pode se chamadar de **funções aninhadas** ou **callback hell**.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 04 - Exercício
**User:** [Cerezini](https://github.com/Cerezini)
**Autor:** Mateus Cerezini Gomes
## Criar uma função com uma entrada para nome e imprimir esta entrada em uma outra função, como continuação da execução da mesma
```js
function printName(name, callback) {
if (typeof name == 'string') {
callback(name);
} else {
callback('Você deve passar uma string');
}
}
printName('Pedro pão de batata', function(txt) {
console.log(txt);
});
printName(3, function(txt) {
console.log(txt);
});
```
```js
Pedro pão de batata
Você deve passar uma string
```
## Criar uma função que calcula a soma de dois valores e passe o resultado em uma outra função e imprima-o, de acordo com o padrão apresentado em aula
```js
function sum(num1, num2, callback) {
if (typeof num1 == 'number' && typeof num2 == 'number') {
callback(null, num1 + num2);
} else {
var err = new Error('Você deve passar dois parêmetros numéricos');
callback(err, null);
}
};
sum(9, 9, function(err, value) {
if (err) {
console.log(err);
} else {
console.log('Soma = ', value);
}
});
sum('9', 9, function(err, value) {
if (err) {
console.log(err);
} else {
console.log('Soma = ', value);
}
});
```
```js
Soma = 18
[Error: Você deve passar dois parêmetros numéricos]
```
## Criar uma função que calcula a média de dois valores e imprima essa média em outra função, como continuação da execução da mesma
```js
function avg(num1, num2, callback) {
if (typeof num1 == 'number' && typeof num2 == 'number') {
callback(null, (num1 + num2)/2);
} else {
var err = new Error('Você deve passar dois parêmetros numéricos');
callback(err, null);
}
};
avg(3, 9, function(err, value) {
if (err) {
console.log(err);
} else {
console.log('Média = ', value);
}
});
avg('9', 9, function(err, value) {
if (err) {
console.log(err);
} else {
console.log('Média = ', value);
}
});
```
```js
Média = 6
[Error: Você deve passar dois parêmetros numéricos]
```
## Explicar a definição de continuação de uma função
Significa que a execução de um função é extendida pela execução de outra função, a qual é responsável pelo retorno da função original.
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 01 - Exercício
####Robson Fagundes - [http://robsonfagundes.github.io](robsonfagundes.github.io) - robsonfagundes@gmail.com
## 1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Node é uma aplicação single threaded, mas suporta a simultaneidade via conceito de eventos e callbacks. Como cada API do Node são assíncronas e sendo um único segmento, ele usa a função async chamadas para manter a simultaneidade. Node usa observador padrão. Node mantém um ciclo de eventos e sempre que qualquer tarefa de ficar concluída, ele aciona o evento correspondente que sinaliza a função de ouvinte de evento para obter executado.
## 2. Como o V8 executa o JavaScript? Demonstre 1 exemplo com código ou imagem.
[](https://raw.githubusercontent.com/robsonfagundes/be-mean-instagram-nodejs-exercises/master/imgs/nodejs-event-loop.png "Como o V8 executa o JavaScript")
## 3. Qual a diferença entre sistema single para um multi-thread?
#####Antes de mais nada... O que é uma Thread?
Uma Thread é uma sequencia de instruções sendo executadas em um programa. Uma thread pode ser interpretada como uma sequencia de instruções sendo executadas em um programa. Quando múltiplas thread são executadas em uma mesma entidade (no nosso caso, um processo), ela é chamada de multithreading.
[](https://raw.githubusercontent.com/robsonfagundes/be-mean-instagram-nodejs-exercises/master/imgs/thread.png "Thread")
#####Single-Threaded vs. Multithreaded
- Um sitema **singlethread** (thread única) inicia na etapa 1 e continua seqüencialmente (etapa 2, etapa 3, o passo 4) até atingir a etapa final.
- Já um sistema **multithread** (multiplas threads) permitem que você execute várias threads ao mesmo tempo, cada uma executando um passo por exemplo. Cada thread é executada em seu próprio processo, então, teoricamente, você pode executar o passo 1 em uma thread e, ao mesmo tempo executar o passo 2 em outra thread e assim por diante. Isso significa que a etapa 1, etapa 2, etapa 3 e etapa 4 podem ser executadas simultaneamente.
## 4. Como a Thread Pool tem tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
O processo do Node é single-thread, ou seja, um processo por instância. O **Event-Loop** fica recepcionando os eventos [(Reactor Pattern)](https://en.wikipedia.org/wiki/Reactor_pattern), e assim que recebido o evento, o mesmo é direcionado para um **Thread-Pool** que executará as tarefas em background liberando assim o event loop, e assim que as tarefas vão sendo concluídas, o Node acionará o callback que foi passado no início da execução do evento. Quando houver um numero de eventos que executa uma **Intensive-Operation** maior á 4, estes serão incluídos ao **Idle-Thread** que nada mais são, eventos que ficam aguardando um dos outros 4 eventos que estão na thread pool serem executadas para ser executado.
## 5. Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
#####Por que Node?
O objetivo declarado do Node é “fornecer uma maneira fácil de criar programas de rede escaláveis”. Qual é o problema com os programas de servidor atuais? Vamos fazer as contas. Em linguagens como Java™ e PHP, cada conexão inicia um novo encadeamento que, potencialmente, é acompanhado de 2 MB de memória. Em um sistema que tenha 8 GB de RAM, isto define o número máximo teórico de conexões simultâneas em cerca de 4.000 usuários.
À medida que sua base de clientes cresce, você deseja que seu aplicativo da Web suporte mais usuários e, portanto, será necessário adicionar mais servidores. É claro, isso se soma a custos de negócios, especificamente custos de servidor, custos de tráfego e custos de mão de obra. Adicione a esses custos o problema técnico potencial de que um usuário poderá usar diferentes servidores para cada solicitação, de forma que quaisquer recursos compartilhados deverão ser compartilhados por todos os servidores. Por exemplo, no Java, variáveis estáticas e caches precisam ser compartilhados entre as JVMs em cada servidor. Este é o gargalo de toda a arquitetura de aplicativos da web, o número máximo de conexões simultâneas que um servidor pode tratar.
O Node soluciona o problema mudando a forma como uma conexão é feita no servidor. Em vez de iniciar um novo encadeamento do SO para cada conexão (e alocar a memória correspondente com ele), cada conexão cria um processo, que não requer que o bloco de memória o acompanhe. O Node alega que nunca ocorrerá um impasse de bloqueios, pois não são permitidos bloqueios e ele não bloqueia diretamente para realizar chamadas de E/S. O Node também alega que um servidor que o execute pode suportar dezenas de milhares de conexões simultâneas. De fato, o Node altera o panorama do servidor ao mudar o gargalo do sistema inteiro do número máximo de conexões para a capacidade de tráfego de um único sistema.
[](https://www.youtube.com/watch?v=vR8CP0gE-No "Convencendo meu Chefe!!! Placar UOL Copa do Mundo e Eleições com Node js")
## 6. Qual a versão do NodeJS que utilizo?
```
robsonfagundes@R1:~/Personal-Projects/WebSchool.io/be-mean-instagram-mongodb-excercises$ node -v
v5.2.0
```
## 7. Qual a versão do npm que utilizo?
```
robsonfagundes@R1:~/Personal-Projects/WebSchool.io/be-mean-instagram-mongodb-excercises$ npm -v
3.3.12
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [PabloDinella](https://github.com/PabloDinella/)
**autor:** Pablo Rocha Dinella
**date:** 1453989977071
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Um processo síncrono é quando um conjunto de tarefas (funções) são chamadas e são executadas uma por vez, então a próxima tarefa tem que esperar a primeira terminar.
### Exemplo
```
var foo = $.getSync('//foo.com');
var bar = $.getSync('//bar.com');
var qux = $.getSync('//qux.com');
console.log(foo);
console.log(bar);
console.log(qux);
```
Já o processo assíncrono é quando um conjunto de tarefas são executadas, e o stack manda a tarefa para a webapi com um callback, e já executa a próxima sem esperar pela primeira. Quando a webapi termina a tarefa ela manda o callback para o task queue, e daí o event loop pega o callback e manda pro stack (quando este estiver vazio).
### Exemplo
```JavaScript
console.log("Isso");
setTimeout(function(){
console.log('assíncrono');
}, 5000);
console.log('é');
// Isso
// é
// assíncrono
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 compila o JavaScript para formato nativo de máquina para rodar mais rápido.
## Qual a diferença entre um sistema single para um multi-thread?
O multi-thread cria diversos processos, o single-thread não.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
A quinta requisição fica numa idle thread até o event loop poder mandar ela pro stack.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Apresentaria cases de grandes empresas que migraram para o nodejs.
## Qual a versão do seu `node`?
```
╭─owner@Pablos-MacBook-Air ~/Projetos/be-mean/be-mean-instagram-nodejs ‹›
╰─$ node -v v5.5.0
```
## Qual a versão do seu `npm`?
```
╭─owner@Pablos-MacBook-Air ~/Projetos/be-mean/be-mean-instagram-nodejs ‹›
╰─$ npm -v
3.3.12
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [carlosmachel](https://github.com/carlosmachel)
**autor:** Carlos Machel
**date:** 1457839126351
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Um processo `assíncrono` no Nodejs é baseado em eventos. a função é chamada junto com um parâmetro de callback (uma função de retorno). Esse processo entra no ciclo do event loop que por sua vez repassa o método para o Thread Pool. E o event loop continua o seu ciclo. Quando o processamento do método asincrono for finalizado a função de callback vai lidar com a informação e retornar para a pilha, sem paralizar o sistema.
O processo `síncrono` vai paralizar o sistema inteiro até ser executado. Seria como as pessoas subindo num carrossel, cada um por vez. E o carrossel tem que parar cada vez.
### Asincrono
- Código
```js
var fs = require('fs');
console.log("Rodando readFile...");
fs.readFile("index.txt", (error,resultado) => {
console.log("Conteudo : " + resultado);
});
console.log("Se o método readFile é sincrono eu só vou rodar depois ops! parece que eu rodo antes...");
```
- Resultado
```js
(aula-01) ➜ () ➜ node fsAsync.js
Rodando readFile...
Se o método readFile é sincrono eu só vou rodar depois ops! parece que eu rodo antes...
Conteudo : BE MEAN!
```
### Sincrono
- Código
```js
var fs = require('fs');
console.log("Rodando readFileSync...");
var resultado = fs.readFileSync("index.txt");
console.log("Conteudo : " + resultado);
console.log("Se o método readFileSync é sincrono eu só vou rodar depois... entendeu?");
```
- Resultado
```js
(aula-01) ➜ () ➜ node fsSync.js
Rodando readFileSync...
Conteudo : BE MEAN!
Se o método readFileSync é sincrono eu só vou rodar depois... entendeu?
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
0 V8 é uma engine Javascript escrita em C++. Ele vai compilar o código de JavaScript para o código nativo de máquina implementando um compilador Just-In-Time.
Por baixo dos panos o V8 recebe o código JavaScript e tenta otimizá-lo. A maioria dos compiladores cria uma estrutura tipo dicionario que armazena as propriedades dos objetos e faz uma pesquisa dinamica para resolver a localização da propriedade. Isso acaba sendo lento. No caso do V8 ele cria "hidden classes" em runtime gerando assim uma representação do tipo que aquele objeto representa.
Assim se você cria dois objetos com as mesmas propriedades e com os mesmos nomes, ele vai ser representado pelo V8 como objetos pertencentes a uma classe apenas.
Ai você diz:
- Mas em JavaScript o objeto pode receber propriedades ou deixar de ter propriedades dinamicamente.
Sim o V8 armazena todos os processos de mudanças seguindo uma sequencia. Imaginando uma orientação a objetos seria como se o V8 fizesse uma classe genérica e fosse criando classes filhas dessa com mais especializações.
O V8 tem dois tipos de compiladores, um que compila rapidamente, mas que não gera códigos muito eficientes e um outro que é lento, mas gera códigos eficientes. A engine gera o código não muito eficiente e fica verificando se em algum ponto ocorre um prejuizo, ele coleta a informação daquele ponto e gera uma versão otimizada daquele ponto.
Código em JavaScript:
```js
function g () { return 1; }
function f () {
var ret = 0;
for (var i = 1; i < 10000000; i++) {
ret += g ();
}
return ret;
}
```
Um pedaço do código gerado em assembly referente a execução do código acima:
```
133 movq rdx,[rdx+0x27] ;; Another redundant load.
137 cmpl rbx,0x989680 ;; 10000000, you see.
143 jge 178 ;; If i >= 10000000, break.
149 movq rdx,rax ;; tmp = ret
152 addl rdx,0x1 ;; tmp += 1
155 jo 384 ;; On overflow, deoptimize.
161 addl rbx,0x1 ;; i++
164 movq rax,rdx ;; ret = tmp
167 cmpq rsp,[r13+0x0] ;; Reload stack limit.
171 jnc 137 ;; Loop if no interrupt,
173 jmp 306 ;; Otherwise bail out.
178 shlq rax,32 ;; Tag rax as a small integer.
182 movq rsp,rbp ;; Restore stack pointer.
185 pop rbp ;; Restore frame pointer.
186 ret 0x8 ;; Return, popping receiver.
```
O.o Assembly. Mas a ideia aqui é que simplesmente ele está rodando o loop da função f. E está sempre checando pra ver se a função deve ser otimizada ou não. Taggear a função com int32 é uma maneira de identificar qual o tipo pra otimizar.
Esse exemplo foi retirado do texto [what does v8 do with that loop?](http://wingolog.org/archives/2011/06/08/what-does-v8-do-with-that-loop). E sobre tag [value representation in javascript implementations](http://wingolog.org/archives/2011/05/18/value-representation-in-javascript-implementations)
Essa imagem é de um artigo chamado [Instrumenting V8 to Measure the Efficacy of Dynamic Optimizations on Production Code](http://www.cs.cmu.edu/~ishafer/compilers/) que analisou essa otimização do código em runtime.
### Referência
[thibaultlaurens](http://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/)
## Qual a diferença entre um sistema single para um multi-thread?
Um sistema single-thread utiliza apenas uma thread para a aplicação toda, as tarefas são executadas uma por vez. Um sistema multi-thread utiliza várias threads para distribuir as tarefas, executando mais de uma tarefa por vez.
Imaginando um cenário onde você tenha uso intensivo de I/O. Um sistema de uma thread por requisicao (multi-thread) a requisição vai passar a maior parte do tempo esperando esse evento de I/O ser completado. E os recursos do computador associados aquela thread ficam presos. Além de ter o cuidado de sincronizar as threads de maneira que não gere problemas como deadlocks.
Numa estratégia `single thread` o event loop vai gerenciar e direcionar os eventos. A thread vai receber a requisição e repassar para o thread pool que vai executar a função e depois retornar o `callback` para o ciclo do event loop. Ou seja o Node é single thread, mas possui `worker thread` que vai receber os eventos, esperar a resposta e depois devolver a função de callback dessa forma a thread não fica parada esperando a tarefa terminar.
### Referência
[Codingeek](http://www.codingeek.com/tutorials/nodejs/is-nodejs-single-threaded/)
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Além de poder alterar o tamanho padrão alterando a variável de ambiente `UV_THREADPOOL_SIZE` para até o máximo de 128. As requisições vão sendo enviadas para cada Thread. Se todas as threads estão ocupadas, as requisições seguintes vão para o `Task Queue` até liberar threads.
### Referência
[How Nodejs's internal threadpool works exactly?](http://stackoverflow.com/questions/29404784/how-nodejss-internal-threadpool-works-exactly)
[libuv](http://docs.libuv.org/en/latest/threadpool.html)
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Eu geralmente uso casos de sucesso como o do walmart que colocaram na Black Friday todo o seu trafico de mobile pelo Nodejs que não teve mais que 1% da utilização da CPU com mais de 200 milhoes de usuários online.
E o paypal que dobrou o seu números de requisicoes por segundo e reduziu a resposta em 35%.
Além de que utiliza JavaScript. Utilizar apenas uma linguagem tanto no Frontend quando no Backend é um aumento absurdo de produtividade para a equipe e facilita o trabalho do desenvolvedor.
### Referência
[NodeCrunch](http://www.nearform.com/nodecrunch/node-js-becoming-go-technology-enterprise/)
## Qual a versão do seu `node`?
```
(aula-01) ➜ () ➜ node -v
v5.8.0
```
## Qual a versão do seu `npm`?
```
(aula-01) ➜ () ➜ npm -v
3.7.3
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 01 - Exercício #
**User**: [daniofilho](https://github.com/daniofilho)
**Autor**: Dânio Aparecido Mendonça Filho
**Data**: 1450704879520
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada. ##
Um processo síncrono dentro do Node bloqueia a execução de qualquer outro processo enquanto o processo atual não for finalizado.
Exemplo, lendo um arquivo de forma síncrona:
~~~ js
var file = readFile()
processFile(file)
~~~
Já um processo assíncrono não bloqueia nenhum outro processo esperando a resposta do atual, ao invés disso ele continua executando os demais processos e, quando houver uma resposta, ai sim ele continua a execução.
Reescrevendo o mesmo exemplo, mas de forma assíncrona:
~~~ js
var fs = require('fs')
fs.readFile('movie.mp4', finishedReading)
function finishedReading(error, movieData) {
if (error) return console.error(error)
// faça algo com os dados em movieData
}
~~~
ref: [Node BR - Callbacks em Node](http://nodebr.com/callbacks-em-node/)
Com isso, enquanto o arquivo movie.mp4 está sendo lido, o Node vai executando os demais processos que vierem na sequência e, quando terminar de ler, o Node é avisado e continua a execução daquele processo.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem. ##
O V8 é um interpretador de Javascript que foi criado pela Google para interpretar códigos em Javascript que fossem executados no Google Chrome. O V8 interpreta o código em Javascript e o converte para linguagem da máquina em que está instalado.
A arquitetura do Node com o V8 funciona da seguinte forma.
Retirado de: [Pedro Franceschi - NodeJS no Pagarme](http://pt.slideshare.net/PedroFranceschi/nodejs-no-pagarme)
## Qual a diferença entre um sistema single para um multi-thread? ##
Um sistema Single thread, como o Node JS, roda em apenas uma thread, ou seja, economiza processamento e memória e ganha performance. Já um sistema Multi Thread cria um processo para cada usuário que se conecta, aumentando significativamente o uso do processador.
Em um Sistema Single Thread, em casos onde os processos não são assíncronos, temos a desvantagem de que aquele processo vai ficar "pindurado" no processador e bloqueando qualquer outro novo processo que queira rodar. Já em Sistemas Multi Threads isso é facilmente corrigido com a criação de uma nova Thread para outro processo.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco? ##
Uma quinta requisição em um banco gera uma task que se chama **Idle Thread*. Esta task é uma thread que vai ficar esperando para ser incluida na fila do Thread Pool e em seguida executada.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção? ##
Primeiramente mostrando grandes cases, como por exemplo o Pay Pal e o Netflix. Com resultados concretos e vindos de empresas do porte dessas, já é um grande item para se chamar a atenção de empresários. Depois disso faria uma análise de performance do sistema atual e levantaria os principais problemas dele, e com base nesses problemas, mostraria onde o Node poderia entrar para resolve-los. Em seguida para concluir, explicaria as vantagens de agilidade de desenvolvimento que teriamos na migração do sistema.
## Qual a versão do seu `node`? ##
~~~
daniofilho$ node -v
v5.3.0
~~~
## Qual a versão do seu `npm`? ##
~~~
daniofilho$ npm -v
3.3.12
~~~
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [pedrohills](http://github.com/pedrohills)
**autor:** Pedro Henrique
**date:** 1454517126551
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
R- Um processo síncrono no NodeJS segue como um garçom de um restaurante que está atendendo um cliente e ele só atende um segundo cliente caso o primeiro já tenha sido totalmente atendido. Em um processo assíncrono no NodeJS, usando o mesmo exemplo do restaurante, o garçom atende os clientes e seus pedidos são entregues assim que eles estão prontos.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 na verdade não executa código JavaScript puro, ele primeiramente compila, em tempo de execução, o código que foi escrito em JavaScript em Código de Máquina. Para isso, ele utiliza um compilador JIT (Just-In-Time).
## Qual a diferença entre um sistema single para um multi-thread?
Uma thread permite, por exemplo, que o usuário de um programa utilize uma funcionalidade do ambiente enquanto outras linhas de execução realizam outros cálculos e operações.
Em hardwares equipados com uma única CPU, cada thread é processada de forma aparentemente simultânea, pois a mudança entre uma thread e outra é feita de forma tão rápida que para o utilizador, isso está acontecendo paralelamente. Em hardwares com múltiplos CPUs ou multi-cores, as threads são realizadas realmente de forma simultânea.
Os sistemas que suportam uma única thread (em real execução) são chamados de monothread enquanto que os sistemas que suportam múltiplas threads são chamados de multithread.
Fonte: https://pt.wikipedia.org/wiki/Thread_(ci%C3%AAncia_da_computa%C3%A7%C3%A3o)
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Elas serão incluías na Idle-Thread e ficarão aguardando a Thread Pool liberar espaço para poderem irem para lá.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Equipe, ao utilizarmos NodeJS em nossos sistemas estaremos resultando em um menor gasto com equipamentos quando formos trabalhar sua escalabilidade.
Trabalharemos com tecnologia de ponta que atendeu grandes corporações que recebem milhares de requisições por minuto. Tenho a certeza de estarmos preparados para o sucesso e o NodeJS será a ferramenta que nos levará até ele mais rápido.
## Qual a versão do seu `node`?
v5.2.0
## Qual a versão do seu `npm`?
3.3.12
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [gkal19](https://github.com/gkal19)
**autor:** Gabriel Kalani
**date:** 1454162282817
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
**Processo síncrono** é executado apenas uma função por vez e em um **processo assíncrono**, é possível executar várias funções por vez.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
Na aula do Tio Suissa, vemos que o V8 é o motor de JavaScript da Google que possui bibliotecas que ajudam no Gerenciamento dos Processos.
Ou seja ele é como um interpretador do JavaScript.
Seu código é compilado para formato nativo de máquina para rodar mais rápido.
## Qual a diferença entre um sistema single para um multi-thread?
No **Single Thread** é executado apenas uma tarefa por vez. Já no **Multi Thread** são executadas varias tarefas simultaneamente.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Em casos com este, a quinta requisição irá aguardar a liberação de uma das quatros primeiras.
Apos 1 das quatro ser executada, a quinta requisição é mandada para a **Thread Pool**, para ser executada.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
É simples, só dizer que foi o @suissa que mandou hahaha Brincadeira...
Acredito que a melhor forma seria apresentando `cases` de empresas que migraram para o Node.JS
## Qual a versão do seu `node`?
```
gkal19:~/workspace $ node --version
v4.2.4
```
## Qual a versão do seu `npm`?
```
gkal19:~/workspace $ npm --version
n2.14.12
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** https://github.com/maurienefirmino
**autor:** Mauriene Firmino do Nascimento Júnior
**date:** Qua Ago 31 10:50:54 BRT 2016
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Síncrono:
Cada processo requisitado entra em uma fila, e o processamento só passa para outro quando termina este.
Neste exemplo vemos um código síncrono, o sistema espera o arquivo ser lido para continuar:
var fs = require("fs");
fs.readFileSync(‘arquivo.txt’,function(err,data){
if(!err) {
console.log(data);
}
});
console.log("Arquivo Lido com sucesso!");
Assíncrono:
Varios processo são atendidos ao mesmo tempo e media que vão terminando, mandam uma notificação por meio de um callback.
Neste exemplo vemos um código assíncrono, o sistema não espera o arquivo ser lido para continuar:
var fs = require("fs");
fs.readFile(‘arquivo.txt’,function(err,data){
if(!err) {
console.log(data);
}
});
console.log("Arquivo Lido com sucesso!");
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
Ele transforma o código em linguagem nativa da maquina antes de executar.
http://i751.photobucket.com/albums/xx160/logiprats/imageaxd-1.png
## Qual a diferença entre um sistema single para um multi-thread?
Um sistema single-thread usa apenas uma unica thread para executar seus processos, o que pode ocasionar travamentos caso um processo tenho que esperar outros processos por exemplo. O multi-thread usa tantas threads forem necessárias. O nodeJS usa single, porém de uma forma otimizada para que não ocorra problemas com frequência.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
A quinta requisição ficaria em espera, aguardando um das 4 requisições serem completadas para dar espaço a mesma.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Uma boa maneira seria mostrar os dados que já vimos na aula sobre as vantagens do nodeJS, tais como ses exemplos. O nodeJS é mais adequado e rapido do que arquiteturas back-end feitas em JAVA ou PHP, um exemplo disso é o Wordpress(arquitetura em PHP) está se mudando para o nodeJS.
## Qual a versão do seu `node`?
```
mauriene@mauriene-J1800NH:~$ node -v
v6.4.0
```
## Qual a versão do seu `npm`?
```
mauriene@mauriene-J1800NH:~$ npm -v
3.10.3
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [lucasduarte](https://github.com/lucasduarte/)
**autor:** Lucas Duarte Anício
**date:** 1457312116944
## **Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.**
No Node.js por padrão todos os processão são assíncronos. Quando ele depende de algum processo externo, como por exemplo ler um arquivo no disco, ele "chama" a execução do processo e continua a executar outras requisições enquanto o arquivo é lido no disco. Somente quando a leitura é finalizada é executado um callback de retorno para o Node.js.
**Processo Síncrono**
```js
function foo(){
console.log("foo");
}
function bar(){
console.log("bar");
}
function baz(){
console.log("baz");
}
foo();
bar();
baz();
```
**Processo Assíncrono**
```js
function foo(){
console.log("Executando algo assíncrono aqui");
}
function bar(){
setTimeout(foo, 0);
console.log("Alguma coisa por aqui");
console.log("...");
}
bar();
```
## **Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.**
O trabalho desse motor é o de compilar código JavaScript para código nativo de máquina e posteriormente executá-lo.
## **Qual a diferença entre um sistema single para um multi-thread?**
Em um sistema multi-thread são executados vários processos diferentes, o que muita das vezes requer uma maior quantidade de memória e processamento, já um sistema single-thread é executado em apenas um processo, diminuindo assim a necessidade de recursos.
## **Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?**
Caso isso aconteça uma das threads ficará aguardando na `Task Queue` aguardando até que uma das outras 4 threads sejam finalizadas e liberem espaço na `Thread Pool`
## **Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?**
Utilizaria como exemplo algum estudo de caso de alguma empresa que trocou recentemente por Node.js. E dessa forma demonstrar para o chefe as melhorias que tiveram com diminuição de recursos do servidor, melhoria no tempo de respostas a requisições e diminuição na carga de trabalho e linhas de código para o desenvolvimento.
## **Qual a versão do seu `node`?**
```
lucas@lucas-pc:~/Dropbox/price_bot$ node -v
v5.6.0
```
## **Qual a versão do seu `npm`?**
```
lucas@lucas-pc:~/Dropbox/price_bot$ npm -v
3.6.0
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [joseasousa](https://github.com/joseasousa/)
**autor:** Jose Alves De Sousa Neto
## 1- Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Processos síncronos são processos que executam um passo por vez, um processo só ira começar assim que o anterior for terminado
```js
for(int i = 0; i<1000; i++){
console.log(i);
}
```
Processos assíncronos não dependem do termino do processo anterior, então eles seguem executando, e quando
uma requisição é terminada ela volta e executa uma fução de resposta(callback)
```js
Contatos.find().exec()
.then(
function (contatos) {
res.json(contatos);
},
function (erro) {
res.status(500).json(erro);
}
);
```
## 2- Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
V8 que é o motor de JavaScript da Google e que roda no seu Chrome, além disso ele conta
com outras bibliotecas que o auxiliam no gerenciamento dos processos.
Ele é nada menos que o interpretador de JavaScript, tipo uma máquina virtual,
desenvolvido pelo Google e usado no Chrome. Feito em C++ e open-source.
O trabalho dele é basicamente compilar o código de JavaScript para o código nativo de
máquina para depois executá-lo.
Ele levou a velocidade dos códigos compilados para o JavaScript.
## 3- Qual a diferença entre um sistema single para um multi-thread?
Um Sistema single thread possui apenas um processo (Thread) rodando por vez.
Em Sistemas multi-threads a 2 ou mais threads rodando em paralelo
## 4- Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Executaram 4 e uma ira ficar experando pelomenos uma delas terminar, para assim poder executar
## 5- Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Mostrando users cases como o do [PayPal](https://www.paypal-engineering.com/2013/11/22/node-js-at-paypal/), demonstrando os ganhos de perfomace e produtividade
## 6- Qual a versão do seu `node`?
v7.2.0
## 7- Qual a versão do seu `npm`?
3.10.9
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [xereda](https://github.com/xereda)
**autor:** Jackson Ricardo Schroeder
**date:** 1464838528755
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Um processo **síncrono** sofre execução linear e logicamente sequencial, sendo que a próxima iteração somente é executada após a efetiva conclusão da rotina anterior. Trazendo para o mundo real, é como se fossemos levar nossos filhos ao colégio e após deixá-los, no lugar de continuarmos com nossa vida normal, ficassemos os esperando até a aula terminar, lá parados, durante 4 longas horas. Estariamos adotando um processo síncrono de levar e buscar nossos filhos. Durante esse intervalo, nada mais por nós seria feito.
### Exemplo de execução síncrona usando o nodeJS:
```js
// criamos um arquivo com o nome "sincrono.js" e com a seguinte estrutura interna
var fs = require("fs");
var data = fs.readFileSync('/tmp/exemplo.txt');
console.log(data.toString());
console.log("Encerrado!");
// depois no console do sistema operacional,
// executamos o node passando como parametro o script "sincrono.js" criado acima
node sincrono.js
Este eh o conteudo do arquivo txt.
Encerrado!
```
_Você pode observar que o javascript aguardou o leitura do arquivo, depois a conversão para string e somente após esses dois processos ele foi para a próxima iteração que é a impressão, no console, do texto `"Encerrado!"`._
Já uma rotina **assíncrona** é enviada para o _Event Loop_ do NodeJS e o script principal segue sendo executado normalmente. Reutilizando o exemplo no mundo real citado acima, com um processo assíncrono, deixamos nossos filhos no colégio, mas continuamos com nossa vida normal, como por exemplo, indo trabalhar. Durante as 4 horas que nossos filhos estão na escola, podemos realizar outras atividades, preocupando-nos em buscá-los somente no horário de encerramento das aulas.
### Exemplo de execução assíncrona usando o nodeJS:
EX:
```js
// criamos outro arquivo, agora chamado de "assincrono.js", com as seguintes linhas internas
var fs = require("fs");
fs.readFile('exemplo.txt', function (err, data) {
if (err) return console.error(err);
console.log(data.toString());
});
console.log("Encerrado!");
// agora executamos o node passando como parâmetro este novo script
node assincrono.js
Encerrado!
Este eh o conteudo do arquivo txt.
```
_Observe que agora a string "Encerrado!" veio por primeiro, ignorando a execução pendente anterior. Isso ocorreu, pois executamos a função fs.readFile() de forma assíncrona. A leitura do arquivo exemplo.txt foi enviada para a fila Event Loop, mas a execução do próxima rotina, ou seja, a impressão da string "Encerrado!" foi muito mais rápida._
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
V8 é um motor javascript, desenvolvido pela Google e open source, de alta performance e escrito em linguagem C++. É o motor de javascript padrão do navegador Google Chrome. Ele implementa ECMAScript e pode ser executado nos sistema operacionais Windows, MAC OS X e em diferentes distribuições Linux. O V8 pode ser utilizado de forma independente ou ainda ser incorporado em aplicações C++.
## Qual a diferença entre um sistema single para um multi-thread?
Um sistema single thread, tem em suas rotinas, uma execução baseada em um único agente de processamento.
Já em sistemas multi thread, para cada requisição de processamento, um novo agenda é consumido para tal finalidade.
No caso do nodeJS, seu single thread é mantida baseando-se numa fila chamada "Event Loop" e esta tem como principal caracaterística ser non-blocking (sem bloqueio de execução) e assíncrona. Tanto o event loop como o tread pool são mantidos pela [Libuv](http://libuv.org/). **Libuv** é uma biblioteca com suporte a multi-platormas e com foco em I/O assíncrono.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Neste caso, a quinta requisição aguardará, na _Event Queue_ (fila de eventos da Libuv), até que uma das 4 requisições que estão consumindo as _Thread Pool_ disponíveis encerre sua rotina de execução. Embora, por padrão, o nodeJS defina 4 tread pools disponíveis, este número pode ser incrementado em até 128 threads (variável de ambiente UV_THREADPOOL_SIZE), inclusive em tempo de execução com o parâmetro `process.env.UV_THREADPOOL_SIZE`.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Inicialmente faria um comparativo entre o nodeJS e outros principais servidores de aplicação do mercado, enfatizando as vantagens de adoção. Ressaltaria suas principais caractéricas, como baixo consumo de recursos físicos e a fácil e ampla possibilidade de escalabilidade. Finalizaria citando as principais empresas que usam o nodeJS e focaria num case de sucesso, como por exemplo o caso do Paypal, ou ainda, o da NetFlix.
## Qual a versão do seu `node`?
```
xereda@macminixereda:~$ node -v
v6.2.0
```
## Qual a versão do seu `npm`?
```
xereda@macminixereda:~$ npm -v
3.8.9
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [Zowder](https://github.com/Zowder)
**autor:** Emídio de Paiva Neto
**date:** 1450035612253
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Vamos supor que você tem 1000 conexões ao vivo, e um pacote é entrego a cada milissegundo, e o processamento de cada pacote leva 1 microssegundo. Vamos supor também que cada conexão envia 5 pacotes.
Em um aplicativo single-thread síncrono, cada ligação será tratada em série. O tempo total necessário é (5 + 5 * 1 * 0.001) * 1000 milissegundos, ou ~ 5005 milissegundos.
Em um aplicativo single-thread, assíncrono, cada ligação será tratada em paralelo. Uma vez que cada pacote leva um milésimo de segundo, e processamento de cada pacote leva 0.001 milissegundos, podemos processar pacote de cada ligação entre os pacotes, então a nossa fórmula torna-se: (1000 * 001 * 1) + 5 milissegundos, ou ~ 6 milissegundos.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
## Qual a diferença entre um sistema single para um multi-thread?
>**Single-thread**
Apenas uma tarefa pode ser feito em um tempo e o programa espera até que uma tarefa é concluída antes de iniciar outra.
>**Multi-thread**
Aplicações multi-thread permitem que você execute várias threads ao mesmo tempo, cada uma executando uma etapa por exemplo.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
A quinta requisição vai para o Idle Thread, e espera até ser colocada no thread pool. Digamos que a primeira requisição foi executada, então a quinta requisição poderá ir para o thread pool.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
> * Com Node.js iríamos trabalhar com javascript no server-side utilizando o Google v8. Assim seria mais fácil manter um projeto de fácil manutenção visto que será a mesma linguagem JavaScript no client-side.
> * Comunidade ativa.
> * Orientado a evento - I/O não bloqueante.
> * Event Loop
> * LinkedIn, Wallmart, Groupon, Microsoft e Paypal são algumas das empresas usando Node.js.
## Qual a versão do seu `node`?
v5.2.0
## Qual a versão do seu `npm`?
3.3.12
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 01 - Exercício
**User**: [@marcelohmdias](https://github.com/marcelohmdias)
**Autor**: Marcelo H M Dias
**Date**: Sun Dec 13 2015 21:35:35 GMT-0200 (BRST)
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
- **Síncrono**: Em NodeJS, os processos sincronos são bloqueantes, ou seja, caso exista uma lista de processos a serem executados, o nodejs aguarda o termino do anterior para executar o próximo.
```js
//text_sync.js
var fs = require( 'fs' );
for (var i = 0; i <= 5; i++) {
var file = 'sync-txt' + i + '.txt'
, out = fs.writeFileSync(file, 'Hello Node.js!');
console.log(out);
}
//Exemplo retirado do livro - Aplicação web real-time com Node.js - Caio Ribeiro Pereira
```
- **Assíncrono**: Os processos assíncronos por outro lado, realizam os processos de forma paralela.
```js
//text_async.js
var fs = require( 'fs' );
for (var i = 0; i <= 5; i++) {
var file = 'async-txt' + i + '.txt'
, fs.writeFile(file, 'Hello Node.js!', function (err, out) {
console.log(out);
});
}
//Exemplo retirado do livro - Aplicação web real-time com Node.js - Caio Ribeiro Pereira
```
Se compararmos os dois códigos, podemos ver a diferença na *timeline* de execução de ambos. Enquanto o primeiro levou 1000 milissegundos para executar, o segundo código levou um quinto deste tempo (200 milissegundos). Isso nos mostra as vantagens em relação ao desempenho do nodeJS ao utilizar processos não bloqueantes.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 é o motor de renderização do NodeJS, ou seja, ele realiza um bind do código JS para C++, convertendo todo o nosso código para funções do próprio V8. Isso permite a posterior conversão deste código para linguagem de máquina.
## Qual a diferença entre um sistema single para um multi-thread?
Thread é o fluxo de execução de um processo. Em sistemas sigle threads, existe apenas um fluxo de execução, dessa maneira, os processos são executados em filas, um por vez. Já em sistemas multi threads, existe mais de uma fila de execução dos processos. Em cada fila os processos ainda são executados um por vez, porém com mais filas os processos podem ser executados de forma simultânea.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Devido ao fato da Libuv possuir este valor em default a quinta requisição deve aguardar a liberação para a execução.
Porém é possível aumentar o tamanho limite da Thread Pool (até um máximo de 128), alterando o valor da variável de ambiente UV_THREADPOOL_SIZE, o que também exigira um uso maior de mémoria para a execução da aplicação.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Para alterarar uma tecnologia adotada em uma empresa, não basta apenas apresentar o que determinada linguagem possui de bom, é necessário realizar um comparativo entre ambas as opções, além de, estudos de Benchmarking (processo ou técnica de gestão através do qual as empresas ou organizações avaliam o desempenho dos seus processos, sistemas e procedimentos de gestão comparando-o com os melhores desempenhos encontrados noutras organizações).
Levando isso em consideração, é possível determinar alguns pontos:
- Demonstrar as principais características do NodeJS e o que elas impactariam nos processos da empresa;
- Apresentar cases em que o Node foi adotado e tornou o fluxo de trabalho mais produtivo;
- Buscar possíveis soluções e alternativas (bibliotecas e frameworks) para atender as demandas da empresa.
## Qual a versão do seu `node`?
```bash
marcelohmidas :: ~/ » node -v
v5.1.1
marcelohmidas :: ~/ »
```
## Qual a versão do seu `npm`?
```bash
marcelohmidas :: ~/ » node -v
3.3.12
marcelohmidas :: ~/ »
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [Cerezini](https://github.com/Cerezini)
**autor:** Mateus Cerezini Gomes
**date:** 1457365864582
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Um processo síncrono é executado comando a comando, logo o comando 2 só pode ser executado quando o comando 1 for concluído. Ex:
```js
function init() {
var html = getHTML();
var css = getCSS(); //Só executará quando getHTML() finalizar
var js = getJS(); //Só executará quando getCSS() finalizar
}
```
Um processo assíncrono é executado sem que um comando possa bloquear outro, logo o comando 2 pode ser executado sem que o comando 1 tenha concluído. Ex:
```js
function init() {
getHTML(setHTML());
getCSS(setCSS()); //Executará após getHTML() independente se ele finalizou
getJS(setJS()); //Executará após getCSS() independente se ele finalizou
}
```
Em geral, uma função assíncrona recebe como parâmetro uma função chamada de callback, que será executada quando a função assíncrona for concluída.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 é um motor JavaScript escrito em C++ que compila e executa códigos JavaScript, gerando códigos de máquina mais eficientes que um interpretador. Ele compila o código
Javascript durante a execução, não produzindo qualquer código intermediário.
O Javascript é uma linguagem de tipagem dinâmica e não existem classes, logo o V8 cria **hidden classes** para representar os tipos e ter uma forma eficiente de acesso às
propriedades, diferente de outras engines que criam uma estrutura semelhante a um dicionário. Se o layout dessa **hidden class** for semelhante em diferentes objetos, o V8
pode agrupar estes objetos e reutilizar o código. Caso uma propriedade seja adicionada ao objeto depois que ele já foi criado, o V8 criará uma nova **hidden class**.
```js
function Point(x, y) {
this.x = x;
this.y = y;
}
var p1 = new Point(11, 22);
var p2 = new Point(33, 44);
// Neste ponto p1 e p2 compartilham a mesma hidden class
p2.z = 55;
// P1 e p2 possuem diferentes hidden classes
```
V8 também possui eficientes sistemas de geração de código de máquina dinâmico e coletor de lixo. O coletor de lixo interrompe a execução dos programas para sua execução,
processa somente parte da *memória heap* dos objetos o que minimiza o impacto na execução da aplicação, e o V8 sempre tem conhecimento da localização em memória dos objetos
e ponteiros o que evita problemas de vazamento de memória.
Os objetos possuem a *memória heap* divida em duas partes, uma parte para criação de novos objetos, e a outra parte onde ficam os objetos que permanecem após a execução
do coletor de lixo. Se o objeto criado sobrevive ao coletor de lixo, ele é promovido a outra parte da *heap* e o V8 atualiza todos os ponteiros que o referenciam.
## Qual a diferença entre um sistema single para um multi-thread?
Um sistema single thread é um processo que executa comando a comando de maneira síncrona. Um sistema multi-thread por sua vez é um processo que divide
sua execução em diferentes threads que executam paralelamente, se o processador possuir mais de um núcleo.
Um sistema multi-thread permite um melhor uso do processador e uma computação mais rápida. Entretanto, o gerenciamento das threads e as trocas de contexto
exigem maior consumo de recursos de memória e computação.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
As requisições de acesso ao banco serão colocadas numa fila de espera. Como o tamanho da thread pool é 4, se todas estiverem disponíveis, as 4 primeiras requisições
presentes na fila de espera receberão uma thread cada e serão executas, e a 5º aguardará até que uma das threads conclua e esteja novamente disponível.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Os sistemas web na sua maioria trabalham com multi-thread, criando uma nova thread para cada requisição, logo quando o número de requisições é maior que o
número de threads disponíveis, essas requisições ficarão numa fila de espera. A execução de uma thread pode levar um longo tempo caso ela tenha que esperar por
algum recurso, como acessar o disco rígido ou a rede, logo maior será o tempo de espera das requisições aguardando pela liberação das threads. A criação e gerenciamento
das threads demanda consumo extra de processamento (CPU) e memória.
O NodeJS utiliza um sistema single thread com event loop, dessa forma consegue escalar de maneira eficiente com o aumento de requisições, consumindo menos recursos do
sistema. Esta eficiência combinada com outros benefícios da linguagem e arquitetura tem feito com que grandes sites/sistemas webs adotem o NodeJs, como: PayPal, Netflix,
New York Times, Uber, Linkdin, além de muitas outras como pode ser checado [aqui](https://github.com/nodejs/node-v0.x-archive/wiki/Projects,-Applications,-and-Companies-Using-Node)
## Qual a versão do seu `node`?
```js
>node -v
v5.7.1
```
## Qual a versão do seu `npm`?
```js
>npm -v
3.6.0
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [fernandobd42](https://github.com/fernandobd42)
**autor:** Fernando Lucas
**date:** 1467347548312
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Processo assíncrono é quando é executado apenas um processo por vez, onde o Node ficará limitado aquele processo ate que o mesmo termina, para só aṕos finalizar a execução daquele determinado processo, poder iniciar a execução novo processo.
EX:
```
function test(){
console.log("test");
}
function test2(){
console.log("test2");
}
test();
test2();
```
Já o processo assíncrono que é utilizado pelo Node por padrão, é capaz de executar vários processos de uma só vez, em 'paralelo'
mas o que acontece na verdade não é que ele executa varios processos simultaneos, ele simplesmente manda executar o processo com um callback e já vai para o próximo processo, quando qualquer um dos processos que já foi mandado executar terminar seu processo ele manda o callback de retorno para o Node finalizar aquele processo.
EX:
```
function test(){
console.log("Assíncrono");
}
function test2(){
setTimeout(test, 0);
console.log("Assíncrono");
console.log("Foda");
}
test2();
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 é o motor de renderização do javaScript que funcioná como uma máquina virtual que compila o código em js para o formato nativo de máquina antes de executá-lo, tendo como propósito aumentar o desempenho da aplicação.
http://4.bp.blogspot.com/-_KJudoqPHLY/UdajBp74xaI/AAAAAAAAAqI/v6nk60ycZ0w/s1023/Node_Architecture.png
## Qual a diferença entre um sistema single para um multi-thread?
O single thread como o nome ja diz utiliza um único segmento para executar os processos, ou seja, executa um de cada vez. Já o multi-thread como o nome também descreve, é capaz de ter mais de um segmento sendo capaz de executar alguns processos simultaneamente, porém quanto mais segmentos, mais recursos serão utilizados.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Devido ao fato de a thread pool suportar apenas 4 requisições, caso acontece de a quantidade de requisição ultrapassar o tamanho padrão da thread pool, as requisições suplentes vão para a 'Task Queue'(fila de tarefas) e aguarda até que umas das threads sejam liberadas.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Explicando que é uma maneira mais fácil, rápida e melhor para o desenvolvimento e mostrando o seu potencial citando algumas empresas que estão utilizando o Nodejs.
## Qual a versão do seu `node`?
➜ NODE_JS git:(master) ✗ node -v
v6.0.0
## Qual a versão do seu `npm`?
➜ NODE_JS git:(master) ✗ npm -v
3.8.6
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** gpanassol
**autor:** Gabriel Panassol
**date:** 1449708572443
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Por padrão qualquer função é assíncrona por esse motivo é necessário uma função que executará após a finalização do processo. Esse função é chamada de callback. Já os processos síncronos não espera seu processo finalizar podendo assim a função continuar com a execução do script. Esse processo continua executando paralelamente.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
Como vimos na aula e slides o V8 nada mais é que um interpretador de javascript. Ele é como uma JVM do Java. O V8 é usado no Goole Chrome. Foi criado em C++ e é open-source.
No site <a href="https://developers.google.com/v8/get_started#hello-world">Developers Google</a> podemos ver um exemplo de como um Hello Word é executado. Veja:
```
// Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "include/libplatform/libplatform.h"
#include "include/v8.h"
using namespace v8;
class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
public:
virtual void* Allocate(size_t length) {
void* data = AllocateUninitialized(length);
return data == NULL ? data : memset(data, 0, length);
}
virtual void* AllocateUninitialized(size_t length) { return malloc(length); }
virtual void Free(void* data, size_t) { free(data); }
};
int main(int argc, char* argv[]) {
// Initialize V8.
V8::InitializeICU();
V8::InitializeExternalStartupData(argv[0]);
Platform* platform = platform::CreateDefaultPlatform();
V8::InitializePlatform(platform);
V8::Initialize();
// Create a new Isolate and make it the current one.
ArrayBufferAllocator allocator;
Isolate::CreateParams create_params;
create_params.array_buffer_allocator = &allocator;
Isolate* isolate = Isolate::New(create_params);
{
Isolate::Scope isolate_scope(isolate);
// Create a stack-allocated handle scope.
HandleScope handle_scope(isolate);
// Create a new context.
Local<Context> context = Context::New(isolate);
// Enter the context for compiling and running the hello world script.
Context::Scope context_scope(context);
// Create a string containing the JavaScript source code.
Local<String> source =
String::NewFromUtf8(isolate, "'Hello' + ', World!'",
NewStringType::kNormal).ToLocalChecked();
// Compile the source code.
Local<Script> script = Script::Compile(context, source).ToLocalChecked();
// Run the script to get the result.
Local<Value> result = script->Run(context).ToLocalChecked();
// Convert the result to an UTF8 string and print it.
String::Utf8Value utf8(result);
printf("%s\n", *utf8);
}
// Dispose the isolate and tear down V8.
isolate->Dispose();
V8::Dispose();
V8::ShutdownPlatform();
delete platform;
return 0;
}
```
## Qual a diferença entre um sistema single para um multi-thread?
O Node.js trabalha apenas com uma theard, podendo ser criada outras. Ele é um exemplo claro de um sistema single. Devido o fato dele trabalha com um numero menor de thread suas performance é superior ao sistemas multi-thread. O Node possui um sistema chamado Event Loop que gerencia todas as requisições evitando assim a criação de diversas thread.
Um sistema multi-thread como o próprio nome diz ele trabalha com diversas threads como o apache que cria diversas threads ao longo do seus processo tendo problema de alocação de memória e com isso lentidão no sistema.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Essa requisição ficará na minha Task Queue e após o ciclo "libera um espaço" ele passa para o meu Thread Pool e consequentemente para o Completed Tasks.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
O Node.js é muito mais performatico e eu consigo criar um sistema com menos pessoas. Podemos usar o case da PayPal que conseguiu diminuir 30% o número de código e 40% menos arquivos. Ele conseguiu diminuir em 35% a requisição das paginas de testes.
## Qual a versão do seu `node`?
```
Gabriel@gabriel MINGW64 ~
$ node -v
v5.0.0
```
## Qual a versão do seu `npm`?
```
Gabriel@gabriel MINGW64 ~
$ npm -v
3.3.6
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [felipelopesrita](https://github.com/felipelopesrita)
**autor:** Felipe José Lopes Rita
**date:** 1455900905381
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Processos síncronos são processos que seguem uma sincronia, isso é, processos que seguem uma order de execução e que realiza outro processo apenas após o término de um processo. Isso significa que cria-se uma espécie de fila de execução de processos, o que além de consumir uma memórica considerável, pode ocasionar lentidão na execução e resposta, uma vez que funções podem demorar a serem executadas.
Como exemplo de função síncrona, temos:
```js
// Faz a leitura do arquivo e escreve no console de maneira sequencial
var oi = fs.readFileSync('./oi.txt', 'utf8');
console.log(oi);
```
Funções assíncronas, por sua vez, executam processos simultaneamente, executando funções e processos paralelos ao mesmo tempo. Isso significa que numa fila com 4 processos a serem executados, por exemplo, meu motor executaria os 4 processos ao mesmo tempo, o que garante uma agilidade redução do consumo da memória.
Como os processos são rodados em paralelo, para definir o que será feito depois que o processo é concluído, utilizam-se callbacks, ou seja, funções que fazem alguma coisa depois que o processo terminou.
Abaixo, segue um exemplo que função assíncrona em javascript:
```js
/* Define um callback a ser executado depois que a função é executada */
fs.readFile('./oi.txt', (err, result) => {
// Caso ocorra algum erro escreve ele no console
if (err) console.log(err);
console.log(result.toString());
});
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 é um motor desenvolvido pelo Google e também utilizado no Chrome que interpreta códigos de javascript e os compila para códigos nativos da máquina (instruções e comandos) para só depois executá-los.
Open source e escrito em C++, é um dos principais fatores que possibilitam a existência do Node.Js
Como demonstra a imagem abaixo, o V8 é responsável pelo eventloop, trabalhando de forma assíncrona e traduzindo o código javascript para as threads.
## Qual a diferença entre um sistema single para um multi-thread?
Em aplicações multi-thread, diversas threads são criadas para cada processo que deseja-se executar, o que demanda considerável quantidade de memória e processamento. Visando agilizar e reduzir o consume de memória, foram criadas as aplicações single thread, que utilizam apenas uma thread para executar seus processos de maneira assíncrona.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Antes de serem enviadas à Thread Pool, as requisições ficam "presas" em um event-loop. Com isso, dado esse exemplo, enquanto as 4 requisições são executadas na Thread Pool, a requisição restante aguarda no event loop até que um "espaço" seja liberado para que sua requisição possa ser atendida.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Acredito que a principal maneira de convencer um chefe é apresentando números e casos distintos sobre empresas que utilizam node em seus sistemas (como Netflix e Paypal, citados na aula), além de gráficos comparativos com as linguagens utilizadas na empresa em que me encontro.
## Qual a versão do seu `node`?
`v5.5.0 `
## Qual a versão do seu `npm`?
`3.6.0` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [filipe1309](https://github.com/filipe1309)
**autor:** Filipe Leuch Bonfim
**date:** 1455935357730
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
O Node utiliza um mecanismo interno chamado **Event Loop**, que é a parte responsável pela característica de I/O assíncrono do Node. Mas nem sempre é desejado que uma determinada tarefa seja executada de forma assíncrona. Por isso existem diversas funções nativas do Node que possuem uma contra-parte síncrona da mesma.
### processo síncrono
Quando um processo síncrono ocorre, o próximo processo terá de esperar o atual terminar, para poder então ser executado.
```js
console.log(“Olá ”);
var fs = require('fs');
fs.readFileSync('/etc/passwd');
console.log(“Arquivo lido!”);
console.log(“mundo!!!”);
// Saída
Olá
Arquivo lido!
mundo!!!
```
### processo assíncrono
Neste caso, quando um processo é executado, o próximo já pode ser executado em seguida, não necessitando esperar o atual terminar. Desta maneira, os processos terminam não necessariamente de forma linear. Assim que um processo termina, ele executa a sua respectiva função de ``callback`` , que foi passada como parâmetro.
```js
console.log(“Olá ”);
var fs = require('fs');
fs.readFile('/etc/passwd', (err, data) => {
if (err) throw err;
console.log(“Arquivo lido!”);
});
console.log(“mundo!!!”);
// Saída
Olá mundo!!!
Arquivo lido!
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 interpreta o código JavaScript, e o converte em linguagem de máquina para que o mesmo possa ser executado.
Fora isto existem diversos mecanismos que foram implementados no V8 com o intuito de melhorar a *performance*, como é o caso das **hidden classes**, que são classes ocultas, contendo otimizações de código, criadas internamente para os objetos em tempo de execução, e podem ser compartilhadas entre vários objetos com a mesma estrutura.
## Qual a diferença entre um sistema single para um multi-thread?
#### Single-Thread
Um sistema *single-threaded* roda em apenas um processo no sistema operacional.
Geralmente sistemas deste tipo são mais fáceis de programar e debugar, além de terem um menor **overhead** (carga, em português) de processamento em comparação a outro *multi-threaded*, pois realizam menos trocas de contexto para executar o mesmo sistema.
#### Multi-Thread
Um sistema *multi-threaded* roda em vários processos no sistema operacional.
Neste tipo de sistema há um ganho de performance, se este for executado em uma máquina com múltiplos núcleos, pois cada thread pode ser executada em um núcleo diferente, ou seja, de maneira paralela.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Neste caso, uma das requisições ficará em uma fila de requisições, aguardando terminar a primeira das 4 requisições, que conseguiram entrar na `Thread Pool`.
Mas este limite de quantidade de `threads` pode ser alterado, através da variável de ambiente UV_THREADPOOL_SIZE, bantando alterar seu valor antes que a `Thread Pool` seja criada e utilizada.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Primeiramente eu destacaria o Ganho de performance, com alguns exemplos, apresentando isto em números, e depois mostraria algum caso de uso (como o do Paypal), e destacaria as empresas que já adotam esta tecnologia, como por exemplo Netflix, Linkedin, Soundcloud, Uber, Cloud9, Yahoo, Microsoft, Trello, Pagar.me, Walmart, Rdio, etc.
Então, abordaria que o foco das aplicações desenvolvidas com Node.js é de obter alta concorrência, alta escalabilidade e de criar aplicações `real-time`. E que no Node.js o
Backend e Frontend possuem mesma linguagem, permitindo uma integração total do sistema, e facilitando o desenvolvimento.
E por fim, faria um comparativo entre as linguagens já adotas na empresa, com o Node.js, apontando as vantagens e desvantagens entre estas tecnologias.
## Qual a versão do seu `node`?
```
node -v
v5.4.0
```
## Qual a versão do seu `npm`?
```
npm -v
3.3.12
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [hc3](https://github.com/hc3)
**autor:** Eliel das Virgens
**date:** 20/03/2016
##01.Explique como um processo síncrono e assíncrono roda no Node.js e dê uma exemplo
para cada .
-O processo síncrono ele aguarda o fim do processo para poder iniciar outro processo , enquanto
o processo assíncrono não ele consegue receber outras requisiçoes e quando terminar ele chama um callback e com isso temos uma alta escalabilidade com Node.js
##02.como o v8 executa javascript? demonstre 1 exemplo com código ou imagem.
-Quando fazemos uma chamada de função ela entra no event loop já registra um callback que interage com o servidor e quando a operação está completa o event loop retorna o callback para a
função que o chamou.
##03.qual a diferença entre um sistema single para um multi-thread
-um sistema single thread tem apenas uma thread que quando é feita uma solicição fica bloqueada
até que a tarefa que a thread está executando termine para que seja feita outra solicitaçãço
o multi thread depois de feita uma solicitação pode-se fazer outra sendo assim criada uma nova thread.
##04.como a thread pool tem um tamanho padrão de 4 , o que acontece se você enviar 5 requisições ao banco.
-a quinta requisição fica aguardando alguma das 4 terminarem.
##05.como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção
-explicaria os benefícios iria começar com projetos pequenos , mostrar como a comunidade está inclinada ao javascript , dar exemplos de grandes coorporaçoes que adotaram a tecnologia.
##06.qual a versão do seu node?
```
hc3@darkSide:~/Bemean/Repositorios/be-mean-instagram-nodejs-exercises/class-01$ node -v
v5.6.0
```
##07.qual a versão do seu npm?
```
hc3@darkSide:~/Bemean/Repositorios/be-mean-instagram-nodejs-exercises/class-01$ npm -v
3.6.0
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [victorvoid](https://github.com/VictorVoid)
**autor:** Victor Igor Gomes Martins
**date:** 1453957583405
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
###Sícrono
O processo sícrono no Node.js é muito simples de entender, e pode ser resumido em uma palavra: **fila**.
Isso mesmo, sabe aquela fila desgraçada do banco que você precisa esperar ? Isso acontece porque não tem
como atender todos de uma vez quando só se tem uma ou duas pessoa para atender. Quando uma função só é executada depois que anterior for finalizada, é um processo asícrono.
####Exemplo?
```js
function calango (){
console.log("Olá calanguito");
}
function crocodilo(){
console.log("vou te lamber calanguito");
}
calango();
crocodilo();
```
###Assícrono
Qualquer função por padrão do nodejs é assícrono! Mas o que é esse assícrono ?
Nenhuma leitura ou escrita vai esperar terminar seu processo pra continuar fazendo o resto do script, que loucura não ?
Ele vai fazer várias coisas possível ao mesmo tempo. Pense em um salão de cabeleireiro, sabe quando a mulher vai pra lá e passa horas ? ali pode acontecer alguma coisa assícrono, paralelamente, por exemplo, fazendo escova no cabelo, outra pessoa fazendo a unha da mão e outra do pé, ou seja, ela não espera a pessoa secar seu cabelo para fazer as unhas, enquanto o cabelo termina de ser secado, ela já está fazendo as unhas. Isso acontece no Node.js através de callbacks, e enquanto estão sendo executados, o script seguinte também já estão.
####Como acontece ?
Uma das características dele é que trabalha com single thread, isso economiza muita memória por exemplo, isso é gerenciado
através do *Event Loop*, que é uma fila de processo infinita, sabe a fila de processo que quer ser executada ? cada um entra no event loop, e não faz a execução por completo, ele manda executar (lembra das callback ? isso mesmo), e assim não fica esperando nada, manda pra quem é responsável, e como o processo é assícrono não deixa o processo seguinte bloqueado.
####Exemplo ?
```js
'use strict';
var fs = require('fs');
fs.exists('./index.txt', (exist)=> {
console.log(exist ? 'existe': 'não existe');
});
/*como acontece de forma assícrono, ele mandou verificar se o arquivo existe, enquanto isso ele
já executou o console abaixo:*/
console.log("ola");
```
Veja essa pequena demonstração do uso das duas e perceba a diferença de velocidade:
[Síncrono X assíncrono](https://www.youtube.com/watch?v=-43EEc3C3cA)
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
## Qual a diferença entre um sistema single para um multi-thread?
Uma Thread é um caminho de execução através do programa, e com a single thread, há sempre um único caminho
de execução e a multi-thread existem dois ou mais encadeamentos.
`Single Thread`: Essa é a característica do Node.js, pois trabalha apenas com single thread, e assim economizando muito mais memória e CPU que o sistema multi-thread, pois por exemplo você não precisa ficar criando um processo novo para cada usuário
conectado. Quem gerencia essa bruxaria é o *Event Loop* de quem já falei sobre.
`Multi Thread` : Ele tem capacidade de executar vários processos(aplicações) ao mesmo tempo, o sistema operacional por exemplo que cuida disso. O que *Multi-Thread* permite é simultaneidade dentro de um aplicativo.
####Exemplo na programação:
*Single Thread*:
Faça X
Faça Y
Faça Z
*Multi-Thread*:
Faça X e Y
Faça Z
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Sempre que ultrapassar ele ficará no Idle Thread esperando a libeção de alguma requisição para aí sim
ir para a Thread Pool.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Chefe, você quer fazer algo mais rápido com menos programadores e ainda sim ter uma aplicação 2 vezes mais rápida ?
Conhece a PaylPal não é ? Um simples sistema que roda no mundo todo (^___^), jogou todo seu sistema de java fora
e fizeram em Node.js mas depois deram dados de que ficou 2 vezes mais rápido e com menos pessoas trabalhando no projeto
que loucura não é ? E tem várias empresas por ae trocando pro Node.js, uma das últimas ae foi a Netflix que trocou tudo pra Node. O LinkedIn, Skype, Walmart, e muitas outras usam Node.
## Qual a versão do seu `node`?
> node -v
v5.4.1
## Qual a versão do seu `npm`?
> npm --version
3.3.12
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [vitorcapretz](https://github.com/vitorcapretz)
**autor:** Vitor Capretz
**date:** 1465753167158
## 1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
No processo síncrono, há uma espera para que o processo seja finalizado antes que outros processamentos se iniciem.
```js
// Exemplo Síncrono
fs.writeFileSync('teste.txt', 'Teste de síncrono');
console.log('Função síncrona já foi executada e finalizada antes desse disparo');
```
No processo assíncrono não há uma espera para que o processo seja finalizado, o código é responsável por enviar uma requisição, por exemplo, e ficar aguardando um sinal de que o processo foi concluído. Durante este tempo de espera outros processos são executados em paralelo.
```js
// Exemplo assíncrono (Mongoose)
Model.findOne(query, function (err, retorno){
console.log('Função executada e callback (retorno) disparado.');
});
```
## 2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 funciona quase que como uma máquina virtual. Ele compila o código JavaScript em linguagem de máquina para ser executado de forma mais eficiente/rápida.
## 3. Qual a diferença entre um sistema single para um multi-thread?
O sistema single-thread trabalha com uma tarefa por vez, as tarefas posteriores deverão esperar o término das anteriores para que sejam executadas.
Quanto ao sistema multi-thread, ele funciona dividindo as tarefas no processamento, de forma a executar mais delas simultaneamente.
Exemplo:
* Single Thread (todas as tarefas no mesmo processador)
```
Tarefa 1
Tarefa 2
Tarefa 3
Tarefa 4
Tarefa 5
Tarefa 6
```
* Multi Thread (tarefas divididas no processador)
```
Tarefa 1
Tarefa 2
Tarefa 3
Tarefa 4
Tarefa 5
Tarefa 6
```
## 4. Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
No caso da requisição 5 e possíveis requisições subsequentes, estas ficariam na fila de Tasks (`Task Queue`) até que uma das outras tarefas em execução seja finalizada, liberando outro espaço na Thread Pool.
## 5. Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
O Node.js já começa com a vantagem de que (muito provavelmente) o desenvolvedor já conhece Javascript, seja para validações de formulário, seja por meio da biblioteca jQuery ou por alguma outra framework front-end. Muitas aplicações hoje em dia já possuem uma API REST-ful e com isso, dados em formato de JSON sendo enviados/recebidos. Dessa forma, o desenvolvedor poderia usar Node para facilitar na "tradução" desse JSON, já que server e client-side entenderiam o mesmo tipo de objeto.
Como o Node funciona com a engine V8, que compila o código em linguagem de máquina, ele é muito rápido. E além de ser rápido, o processamento assíncrono para requisições I/O favorece a execução do código de forma mais eficaz.
O Node possui o `npm`, que é um gerenciador de pacotes com vários deles desenvolvidos pela comunidade para facilitar e disponibilizar muitos recursos para o desenvolvimento mais eficiente.
Para que a facilidade de comunicação se torne ainda melhor, há a possibilidade de usar Mongo, e com isso, você terá um sistema completo usando apenas uma linguagem de programação. Ajudando na economia de tempo e dinheiro.
## 6. Qual a versão do seu `node`?
```
vitor@vitor-ThinkPad-T440:~$ node -v
v6.2.0
```
## 7. Qual a versão do seu `npm`?
```
vitor@vitor-ThinkPad-T440:~$ npm -v
3.8.9
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [ajoao88](https://github.com/ajoao88)
**autor:** João Paulo S de Araújo
**date:** 2016-02-07T09:40:00
##1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
De forma geral um processamento síncrono é uma fila única de processos, ou seja, um novo processo só começa quando o atual termina.
Já no processamento assíncrono não existe essa fila única, após responder a requisição de um processo o mesmo se inicia e o próximo já é atendido e iniciada execução, trazendo ganhos enormes de desempenho e eficiência. Para que seja gerenciado o termino dos processos, que não vai ocorrer na mesma ordem que foram iniciados, cada processo possui um callback que ao terminar o dispara, seu término é tratado como se deve e é dada continuidade ao processos.
Abaixo exemplos de uma execução síncrona e uma assíncrona de leitura de arquivos.
**Síncrona:**
```js
var fs = require('fs');
var conteudo = fs.readFileSync('./arq.txt', "utf8");
console.log(conteudo);
console.log('Leitura do primeiro arquivo terminou');
console.log('Ler próximo arquivo');
```
Retorno da execução:
> "1. Primeira linha do primeiro arquivo"
> "2. Segunda linha do primeiro arquivo"
> "3. Terceira linha do primeiro arquivo"
> "4. Quarta linha do primeiro arquivo"
> "Leitura do primeiro arquivo terminou"
> "Ler próximo arquivo"
**Assíncrona**
```js
'use strict'
var fs = require('fs');
fs.readFile('./index.txt',(err, result) => { //err e result são os callbacks de falha e sucesso, respectivamente
if(err) console.log(err);
console.log(result.toString());
console.log('Leitura do primeiro arquivo terminou');
})
console.log('Ler próximo arquivo');
```
Retorno da execução:
> "Ler próximo arquivo"
> "1. Primeira linha do primeiro arquivo"
> "2. Segunda linha do primeiro arquivo"
> "3. Terceira linha do primeiro arquivo"
> "4. Quarta linha do primeiro arquivo"
> "Leitura do primeiro arquivo terminou"
Como foi possível notar, na execução síncrona só foi iniciada a leitura do próximo arquivo após acabar a leitura do primeiro, já na assícrona a leitura do próximo arquivo foi iniciada antes mesmo da leitura de cada linha do primeiro.
##2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
- Quando V8 recebe o código em JavaScript, ele o analisa para criar árvore de sintaxe abstrata (AST - Abstract Syntax Tree), uma espécie de preparação para o gerador de byte code.
- Em seguida, a AST é alimentado no gerador de byte code para produzir byte code.
- O ambiente de execução V8 então interpreta esse byte code e com a ajuda de um compilador JIT (Just-In-Time) produz o código de máquina nativo que é executado.
Na imagem abaixo confira o fluxograma desse funcionamento:
##3. Qual a diferença entre um sistema single para um multi-thread?
Um sistema `single-thread` executa tarefas em uma única thread. Dessa forma, é necessário esperar o termino de uma tarefa para executar outra.
Um sistema `multi-thread` possui várias threads para execução de tarefas, podendo realiza-las simultaneamente.
##4. Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
A quinta requisição fica aguardando uma das quatro primeiras terminar para entrar na `Thread Pool`.
##5. Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
- Necessita de bem menos investimento em hardware por ser muito mais eficiente que seus concorrentes.
- Possui Inúmeras biblicotecas open-source e mais sendo criada a cada dia, eliminando custos com software.
- O NodeJS é em linguagem JavaScript que é um linguagem muito bem difundida e conhecida pela comunidade.
- É uma plataforma extremamente eficiente, possui bibliotecas assíncronas, que com investimento em hardware muito baixo em relação a concorrentes pode atender a milhões de requisioções
##6. Qual a versão do seu `node`?
> $ node -v
> v5.0.0
##7. Qual a versão do seu `npm`?
> $ npm -v
> 3.3.6
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [gilsondev](https://github.com/gilsondev)
**autor:** Gilson da Silva Borges Filho
**date:** 1457204302220
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
**Processo Síncrono**: É quando o processo é enviado para execução, e o Node.js espera
finalizar sua execução. Enquanto aguarda, outros processos fica em modo de suspensão,
esperando sua vez.
**Processo Assíncrono:** Nesse caso é o padrão do Node.js, quando o Event Loop ao receber
os processos, envia para executá-las, mas diferente do assincrono, as mesmas precisam
ter uma função de callback, para executar quando o processamento for finalizado. Assim,
o event loop é notificado e retorna o seu resultado para quem a requisitou. Isso, libera
o mecanismo de receber processos depois de enviar cada uma delas para execução.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
Ele compila o código para o código nativo de máquina para assim executá-lo. Do contrário,
que o código era interpretado, sua compilação aumenta a performance da aplicação Javascript.
Seguindo as boas praticas em uma VM, o V8 possui dois tipos de compiladores: Full compiler e Optimizing Compiler
**Full Compiler**: É aonde inicia a compilação do código Javascript. Ele não faz
análise de tipo, já que ele usa a estratégia de Inline Cache enquanto executa o
mesmo. Quando precisa de mais performance é usado o segundo compilador
**Optimizing Compiler**: É aqui onde ele produz um código performático, recompilando
funções que estão tendo alto índice de uso.
Segue um exemplo de como funciona: http://runtimejs.org/jsconf/img/runtimejs-arch.png
## Qual a diferença entre um sistema single para um multi-thread?
**Single-Thread**: É uma aplicação que roda em uma thread, e que oferece uma
vantagem de de economizar memória e processamento.
**Multi-thread**: É uma aplicação que criar várias threads, que normalmente são
criadas para executar tarefas distintas como requisição de cada usuário que
acessa, conexão com o banco de dados.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
As 4 primeiras requisições enviadas será alocadas na thread pool, mas a quinta estará
no queue list. Mas esse tamanho pode ser mudado passando o valor para uma variável de
ambiente com o nome `UV_THREADPOOL_SIZE`, em que vai ser o tamanho desse pool. Lembrando,
que na documentação mostra que o máximo suportado é de 128.
## Como você venderia o peixe do **Node.js** na sua empresa para tentar convencer seu chefe da sua adoção?
1 - O Node.js traz uma unidade no quesito de linguagem de programação. Agora podemos trabalhar com
Javascript em praticamente todas as camadas de uma aplicação;
2 - Trabalha de forma assíncrona por padrão: Dessa forma evitaria possíveis gargalos em grandes
execuções de processos, assim sem deixar que a aplicação congele por exemplo.
3 - Com ele você possui soluções de real-time altamente abstraídos.
4 - Comunidade ativa e com criação de ferramentas cada vez mais performáticas e fáceis de trabalhar,
gerando novos conhecimentos, cases para serem usadas no dia a dia.
5 - E temos cases muito bem seguros de pesquisar, e ver o lado bom e ruim de usar o Node.js e analisar
os relatórios de mudança, para concluir qual ganho teremos ao usar. E como percebe-se, os ganhos são
consideráveis no quesito de performance, escalabilidade e produtividade no desenvolvimento.
## Qual a versão do seu `node`?
```bash
$ node --version
v.5.7.0
```
## Qual a versão do seu `npm`?
```bash
$ npm --version
v3.7.5
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [augustoody](https://github.com/AugustoOdy)
**autor:** Augusto Ody
**date:** 1454431830404
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Em um processo assíncrono, a função recebe uma função callback para que após sejá executado o processo, seja chamada está função, causando assim o não travamento da aplicação pra sua execução.
```js
var fs = require("fs");
fs.readFile("myfirstexample.txt", "utf8", function(error, data) {
console.log(data);
});
```
Já no síncrono, a execução espera para que seja feito todo aquele processo, não possibilitando outras ações. Como no exemplo, após iniciar a leitura, toda ela deve ser feita para que então seja passado para próxima linha e executado um `console.log()`.
```js
var fs = require("fs");
var data = filesystem.readFileSync("myfirstexample.txt", "utf8");
console.log(data);
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
Com a single thread do V8, é executado o Event loop, que ainda serve todos o usuários. A parte de I/O é passada para a `libeio` (susbtituida agora pela `libuv`), que pode acaba retornando os dados necessários.
## Qual a diferença entre um sistema single para um multi-thread?
**Single Thread :** As requisições são lançadas em uma única thread, gerando uma fila para sua execução, gerando um processamento mais rápido.
**Multi Thread :** Cada requisição gera uma nova thread, diferentemente da Single, podendo assim então gerar mais processamento.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Segunda a documentação da `libuv`, o tamanho *default* da Thread Pool é 4, porem podendo ser alterado para até o máximo de 128. No caso de enviado mais requisições que o valor suportado, as requisições ficam aguardando para que uma "vaga" seja liberada, para a sua execução.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Mostraria os cases do Paypal e Netflix, aonde a performance, o número de programadores, e a velocidade de desenvolvimento foram melhoradas, incluindo ainda o fato da possibilidade de unir mais a equipe do front-end e do back-end, se não cabar juntando-as para um melhor aproveitamento da tecnologia.
## Qual a versão do seu `node`?
```sh
$ node -v
v5.2.0
```
## Qual a versão do seu `npm`?
```sh
$ npm -v
3.3.12
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
Autor: Juliano Padilha | julianopadilha
Data: Date.now()
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
- Processo Síncrono: O processo síncrono se caracteriza pela necessidade de se aguardar o término
de um processo para que outro se inicie, podendo ser descrito como uma fila, onde os processos subsequentes se manterão em espera até que o processo corrente seja finalizado. Um exemplo de um processo síncrono é um lavajato de carros, onde formasse uma fila e um novo carro só começa a ser lavado após o atual ter finalizado.
```
function dataAtual() {
var date = new Date();
console.log(date);
}
function meuNome() {
var nome = 'Juliano Padilha'
console.log(nome);
}
dataAtual();
meuNome();
```
- Processo Assíncrono: O processo assíncrono se caracteriza pela execução de um Callback após a finalização do processo. Em um processo assíncrono os processos ocorrem de forma independentes, não sendo necessário que um processo seja finalizado para que outro comece a ser executado. Um exemplo de um processo assíncrono é
```
function confirmacaoPagamento(){
console.log("Sua operadora de cartão confirmou o pagamento da sua compra.");
}
function compra(){
setTimeout(confirmacaoPagamento, 0);
console.log("Obrigado por comprar com a gente!");
console.log("Volte sempre!");
}
compra();
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
- o V8 executa Javascript através da sua interpretação, similar à JVM do Java. O trabalho dele é basicamente compilar o código de Javascript para o código nativo de máquina para depois executá-lo.
```
```
## Qual a diferença entre um sistema single para um multi-thread?
- Uma das características do Node é a forma como trabalha com threads, sendo apenas um, mas podendo ser criadas outras. Um sistema single thread tem como vantagem o consumo de mémoria e a não necessida de criar uma nova thread para um novo processo. O Node controla tudo com apenas uma thread utilizando o Event Loop.
* Um sistema Single Thread é capaz de executar apenas uma tarefa por vez. Enquanto a tarefa é executada, todo o sistema aguarda que a thread finalize para que possa seguir adiante.
* Um sistema Multi Thread consegue executar várias tarefas simultaneamente. Cada solicitação vira uma thread e o servidor consegue trabalhar com ela isoladamente, sem intereferir nas outras
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
- Neste caso, a quinta requisição ficara no Idle Thread aguardando a liberação de uma das quatro primeiras. Na sequência, ela é jogada para a Thread Pool para ser executada. @geriel
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
- Acredito que primeiramente eu iria atrás de adquirir uma boa base em Node.js para mostrar para meu chefe que não iniciaríamos do zero no quesito conhecimento. Eu também levaria comparações do Node com a tecnologia atual da empresa para compararmos juntos os pros e contras. Eu também iria me dispor a facilitar a inclusão dos outros desenvolvedores em Node por meio de treinamentos.
## Qual a versão do seu node?
```
Julianos-MacBook-Pro:~ julianopadilha$ node -v
v6.2.2
```
## Qual a versão do seu npm?
```
Julianos-MacBook-Pro:~ julianopadilha$ npm -v
3.9.5
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**User:** ronal2do
**Author:** Ronaldo Lima
**Date:** 1467987772532
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Os processos síncronos espera a finalização de uma tarafa para dar início a próxima.
Por padrão no Node.js qualquer função é assíncrona sendo que um processo não precisa acabar para dar início ao próximo, quando a função assíncrona for concluída como retorno ela recebe uma função chamada de callback, enquanto isso os demais processos continuam sendo executandos paralelamente.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
o V8 é um interpretador de JavaScript, ele compila o JS para o código nativo da máquina e depois executalo. Elevando em muito a velocidade de leitura com esse motor.
No Motor do Node funcinária assim.
Application => V8 => Node API => EVENT LOOP => WORKER THREAD / Retorna o Callback => EVENT LOOP => Node API => V8 => Application.
Como usado nos slides.
## Qual a diferença entre um sistema single para um multi-thread?
O Apache é um sistema multi-thread ele gera uma nova thread para cada processo diferente do Node.js que é single-thread trabalhando apenas com uma thread, evitando o grande problema de alocação de memória e usao de CPU.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
A quinta requisição vai ficar no Idle Thread (Thread em pré-execução que mitiga o custo de memória) até que haja liberação no ciclo de tasks dentro da Thread Pool.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Ciente que cada caso é um caso, usaria o ótimo exemplo do Paypal passado em aula.
Runtime Google V8 - Explicaria como funciona o processo e criaria uma comparação do produto/mercado atual da empresa e os números($$$) de ganho em performance.
O Node.js trabalha com o modelo de IO não-bloqueante
Grandes cases. LinkedIn, Wallmart, Groupon, Microsoft e Paypal são algumas das empresas usando Node.js atualmente.
[Fonte:] (https://udgwebdev.com/6-motivos-para-usar-nodejs).
## Qual a versão do seu `node`?
```
sh-3.2# node -v
v5.10.1
```
## Qual a versão do seu `npm`?
```
sh-3.2# npm -v
3.8.3
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
autor: **Sergio Diniz Correia**
# 1 - Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Em um processo **Síncrono**, uma requisição é enviada e o processo remetente permanecesse bloqueado até que ocorra uma resposta, isso significa que não é possível enviar novas requisições até que a primeira requisição enviada, a que se encontra em processo, seja finalizado. Desta forma, podemos dizer que existe sincronismo entre as requisições.
Para entendermos melhor esse processo, imagine uma fila que vende ingressos de cinema. Quando você está na fila, você precisa esperar que a pessoa que esta na sua frente escolha qual filme ela quer assistir, quantas entradas, qual a sala e o horário, pagar e finalmente a atendente entregar, como resposta, o bilhete de entrada. Neste caso, a atendente só pode atender um cliente na fila por vez.
Em um processo **Assíncrono**, não existe sincronismo, ou seja, o processo não ficará bloqueado por já esta atendendo uma requisição, isso quer dizer que podemos enviar várias requisições em paralelo, neste caso, cada resposta é enviada quando estiver pronta.
Para entendermos melhor esse processo, imagine que você está em um bar e quer comer um espetinho e carne, você chama o garçom, faz o pedido e ele vai para o churrasqueiro dizer que precisa de um espetinho de carne, e então o churrasqueiro começa a ajeitar o pedido, porem, enquanto isso acontece, o garçom esta livre apara atender outras mesas e, da mesma forma, entregar o pedido ao churrasqueiro. Quando o espetinho finalmente estiver pronto, o churrasqueiro repassa o espetinho para o garçom que entrega o pedido.
# 2 - Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O interpretador V8, ou maquina virtual javascript, é uma ferramenta desenvolvida em c++ e tem como função, acelerar o desempenho da aplicação compilando código javascript para linguagem de maquina.
# 3 - Qual a diferença entre um sistema single para um multi-thread?
A característica de sistema **Singlethread** é que ele só consegue suporta apena um programa no seu espaço de endereçamento, ou seja, o sistema fica bloqueado ate o seu termino, isso pode ser um problema pois demanda muito consumo de diversos recursos do sistema. Sempre que um processo é criado, o sistema deve alocar recursos para cada processo, consumindo tempo de processador neste trabalho.
Já em um sistema **Multithread**, cada processo pode responder a várias solicitações concorrentemente ou mesmo simultaneamente, caso haja mais de um processador.
# 4 - Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Caso haja um numero maior de requisições do que o espaço alocado para a Thread Pool, as requisições sobressalentes são colocadas em uma espece de fila de esperara, onde ficam aguardando que uma thread seja liberada para receber uma nova requisição.
Apesar do valor padrão ser 4, esse numero pode ser alterado ate 128.
```
Its default size is 4, but it can be changed at startup time by setting the UV_THREADPOOL_SIZE environment variable to any value (the absolute maximum is 128).
```
referencia: [libuv](http://docs.libuv.org/en/v1.x/threadpool.html)
# 5 - Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Para poder mostrar as vantagens e o poder do Node.js, eu faria:
+ uma pesquisa com comparações entre o Node e a linguagem principal que a empresa usa,
+ mostra também o quando a linguem pode ter um desenvolvimento ágil,
+ ter um alto desempenho,
+ ter uma comunidade ativa e crescente,
+ diversos materiais na internet,
+ ter uma linguagem que pode ser usada tanto no back como no front-end
+ e um curso gratuito e muito foda na Webschool.io para treinamento.
# 6 - Qual a versão do seu node?
```javascript
Sergios-MacBook-Pro:~ sergiodiniz$ node -v
v5.5.0
```
# 7 - Qual a versão do seu npm?
```javascript
Sergios-MacBook-Pro:~ sergiodiniz$ npm -v
3.3.12
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
## 1. Explique como um processo síncrono e assíncrono roda no Nodejs, dê um exemplo para cada.
No processo síncrono só temos o retorno da função quando a mesma é executa de forma total, com isso o processo aguarda o termino de cada função e executa uma de cada vez. Ex: [fs.readFileSync](https://nodejs.org/api/fs.html#fs_fs_readfilesync_file_options).
No processo assíncrono premite que o programa continue executando enquanto a função faz determinada tarefa e chama um *callback* quando é finalizada. Ex: [fs.readFile](https://nodejs.org/api/fs.html#fs_fs_readfile_file_options_callback).
## 2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
Ele basicamente compila o código "JavaScript" para linguagem de máquina utilizando "C++".
> Confesso que não domino o funcionamento do V8, segue no link o artigo das imagens para melhor entendimento. [How the V8 engine works?](http://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/)
## 3. Qual a diferença entre um sistema single para um multi-thread?
No sistema Single-Thread consiste em somente um processo sendo excutado por vez dentro de uma quantidade especifica de tempo, onde em seu termino é executado o próximo processo agendado. Já no processo multithread, cada thread tem o seu próprio contexto compartilhando recursos do processo.
## 4. Como a Thread Poll tem um tamanho padrão de 4, o que acontece se enviar 5 requisiçoes ao banco?
A requisição 5 entra em uma estado de espera e aguarda o termino das primeiras 4 requisições.
## 5. Como você venderia o peixe do Nodejs na sua empresa para tentar convencer seu chefe da sua adoção?
O Node.js é uma tecnologia de vanguarda que rompe um pouco com a programação tradicional, exitem situações onde o desenvolvimento se torma mais simples e com melhor desempenho. Além de usar JavaScript, que é uma linguagem fácil de aprender e com uma grande comunidade que cria novas soluções em uma velocidade incrível.
## 6. Qual a versão do seu `node`?
```
~ λ node --version
v5.12.0
```
## 7. Qual a versão do seu `npm`?
```
~ λ npm --version
3.8.6
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**Autor:** Diego Ferreira
**Data:** 23/02/2016 - 10:00
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
##### Processo Síncrono
É executada apenas uma função por vez, ou seja, os recursos ficam todos disponívels para determinada tarefa e somente são liberados após a tarefa ser completamente finalizada e respondida ao usuário. Ou seja, neste momento "travando" o Node e impedindo naquele instante que o mesmo continue o processamento de outras tarefas. Por exemplo, se essa função fizer um I/O em disco, ele vai bloquear o sistema inteiro, deixando o processador ocioso enquanto ele usa outros re-cursos de hardware, como por exemplo, leitura em disco, utilização da rede etc, e somente liberará os recuros após a finalização da tarefa.
##### Processo Assíncrono
Em um processo assíncrono o servidor não bloqueia os recursos da máquina durante o processamento de uma requisição neste momento apenas o recurso que esta sendo utilizado fica bloqueado e os demais ficam liberados para o processamento de outras requisições, o node utiliza do recurso de callbacks ou seja, o cliente envia a requisição o nodejs responde a primeira requisição e aguarda a chamada de retorno, ao mesmo tempo atende outras requisições e fica escutando a chamada de CALLBACK das outras requisições enviadas. E com isto vai processando todas as requisições, e a medida que os CALLBACKS são acionados ele vai devolvendo as respostas para o cliente, compartilhando assim os recursos da máquina, e processando várias requisições ao mesmo tempo.
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 funciona como uma máquina virtual, ele recebe e lê o script escrito em javascript compila o código para linguagem de máquina quando é executado pela primeira vez. Ele cria classes ocultas para o determinado objeto prevendo que o mesmo irá ser utilizado por todos os objetos futuros acessados na mesma sessão de código, e utiliza estas informações para atualizar o cache interno que contém a classe.
Se V8 prever corretamente o valor da propriedade, é atribuído (ou forçado) em uma única operação. Se a previsão estiver incorreto, V8 corrige o código para remover a otimização.
Por exemplo, o código JavaScript para acessar a propriedade x de um objeto Teste é:
```
teste.x
```
Na V8, o código de máquina gerado para acessar x é:
```
# ebx = o objeto teste
cmp [ebx,<hidden class offset>],<cached hidden class>
jne <inline cache miss>
mov eax,[ebx, <cached x offset>]
```
Se classe oculta do objeto não corresponde à classe oculta em cache, a execução salta para o sistema de execução V8que lida com erros de cache em linha realiza correções no código de cache embutido. Se houver uma correspondência, o que é o caso comum, o valor da propriedade x é simplesmente recuperado.
A combinação de uso de: classes ocultas para acessar propriedades, caching embutido e geração de código de máquina, otimiza a forma com a qual os objetos são criados e acessados e com isso melhora gradativamente a velocidade com que o código javascript é executado.
## Qual a diferença entre um sistema single para um multi-thread?
##### Single-Thread
Em um sistema single-thread uma única tarefa é executada por vez, funcionando como se fosse uma fila, chega a tarefa um o sistema executa, responde, pega a tarefa 2 executa e responde e assim por diante. Uma tarefa somente é executada após a finalização da execução da tarefa anterior.
#### Multi-Thread
Em um sistema multi-thread, as tarefas são executadas em paralelo, enquanto uma tarefa esta aguardando em um processo de IO, as outras podem fazer uso da(s) CPU's disponíveis, e com isso gerando a impressão para o usuário que as tarefas estão sendo executas mais rápidas.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se enviar 5 requisições ao banco?
Quando é enviado um número de requisições a mais do que a thread pool suporta, estas requisições "adicionais" são colocadas na Task Queue, que é uma fila de espera onde as tarefas ficam até que a thread pool libere espaço para que as mesmas possam ser executadas.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Atualmente trabalho com Java para Web, então para a adoção do Node, seria necessário fazer um estudo comparativo mostrando ao gerente a performance de uma app java e uma app node, e mostraria que o node economizaria também em recursos operacionais para a empresa. Caso ele ainda não acreditasse, pegaria alguma funcionalidade de algum projeto existente e faria a mesma em node, como prova de conceito e para tirar as dúvidas existentes.
## Qual a versão do seu `node`?
```
node --version
v5.4.1
```
## Qual a versão do seu `npm`?
```
npm --version
3.5.3
```
## Bibliografia
```
https://developers.google.com/v8/design#mach_code
Node.js - Aplicações web real-time com Node.js
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 01 - Exercício
**Autor:** Rafael Crispim Ignácio
**Data** 1451226657631
# 1. Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
- Processos Síncronos
Nos processos síncronos, exste uma dependencia da finalização de um método com a utilização deste retorno após o mesmo. Neste caso não podemos dar prosseguimento em uma rotina até que determinado método tenha terminado. Isto leva ao enfileiramento de processos, onde estes são executados em fila.
```js
// Exemplo na forma síncrona
var files = fs.readdirSync("/home/user");
console.log(files);
```
- Processos assíncronos
Nos processos assíncronos utilizamos funções de retorno chamadas de `callback`. Estas funções nos permitem chamar métodos sem esperar o seu término, pois quando isto ocorrer a função de retorno será executada e a rotina será concluída ou dará prosseguimento ao processo. É bastante indicada para recursos que são mais lentos com por exemplo um acesso ao disco.
```js
// Exemplo na forma assíncrona
var fs = require("fs");
fs.readdir("/home/user", function(err, files){
console.log(files);
});
```
# 2. Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 compila o javaScript diretamente em código de máquina na primeira vez que é executado. Não existe bytecode intermediário nem interpretador. Ao executar ele cria estruturas ocultas dos objetos conforme necessário e utiliza um cache embutido para facilitar o acessos aos mesmos. Conforme a necessidade estes objetos são atualizados ou descartados.
Por exemplo, o código abaixo demonstra um código em javascript onde uma determinada propriedade de uma classe é acessada.
```js
point.x
```
O código acima gera a seguinte interpretação no V8:
```c++
# ebx = ponteiro para o objeto
cmp [ebx,<hidden class offset>],<cached hidden class>
jne <inline cache miss>
mov eax,[ebx, <cached x offset>]
```
# 3. Qual a diferença entre um sistema single para um multi-thread?
A diferença está na quantidade de threads que o sistema pode utilizar simultaneamente. No single somente é possível utilizar 1 thread e no multi é possível utilizar 1 ou mais.
# 4. Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Neste caso a quinta requisição deve aguardar até que uma das 4 threads seja concluída.
# 5. Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Acredito que a melhor maneira de `vender o peixe` é criando um protótipo e comparando com a outra solução. Não creio que exista uma bala de prata onde todos os problemas devem ser solucionados com apenas uma ferramenta, desta forma precisamos demonstrar as vantagens conforme as opções disponíveis.
# 6. Qual a versão do seu `node`?
```
~:$ node -v
v5.0.0
```
# 7. Qual a versão do seu `npm`?
```
:~$ npm -v
3.3.6
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# NodeJS - Aula 01 - Exercício
autor: Wellerson Roberto
## 1) Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
### Processo síncrono
Em um processo síncrono, a execução fica parada esperando o término do método para continuar.
```
var contents = fs.readFileSync('test.txt').toString();
console.log(contents);
```
O método **readFileSync** faz a leitura de um arquivo de maneira síncrona. Então, a execução será parada e só voltará assim que o arquivo terminar de ser lido.
### Processo assíncrono
É no processo assíncrono que está a grande magia do Node.js, pois a execução não será parada e o resultado de tal função será passada através de um **callback**.
```
fs.readFile('/etc/hosts', 'utf8', function (err,data) {
if (err) {
return console.log(err);
}
console.log(data);
});
```
Neste caso, o método **readFile** é assíncrono. Mesmo fazendo a leitura de um arquivo, o sistema não irá parar. Quando o método finalizar a leitura do arquivo, a função passada no terceiro parâmetro será executada passando um possível erro ou o resultado da leitura.
Pode-se fazer ainda a analogia de um restaurante. Imagine um restaurante trabalhando de modo síncrono vs assíncrono:
Modo síncrono -> Após um cliente fazer um pedido, todo o restaurante será bloqueado. Apenas a comida dele será feita, enquanto todos os outros clientes posterior terão que esperar o término do pedido dele para o seu pedido finalmente iniciar. Após o pedido desse cliente ser executado, o restaurante atende outro pedido e assim vai...
Modo assíncrono -> O restaurante irá atender vários pedidos por vez.
## 2) Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O V8 é bastante rápido pois basicamente compila o código JavaScript para o código nativo da máquina antes de executá-lo, permitindo que ele rode na velocidade de um código binário compilado. O código compilado ainda é reotimizado em tempo de execução.
## 3) Qual a diferença entre um sistema single para um multi-thread?
O sistema single-thread usa apenas um único processo para ser executado, enquanto o multi-thread faz uso de dois ou mais processos. Embora o sistema multi-thread possa ser mais rápido, pois pode fazer o uso dos múltiplos cores do processador para executar mais de uma tarefa ao mesmo tempo, ele acaba também fazendo mais uso de memória.
## 4) Como o Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Das 5 requisições, 4 irão ser executadas enquanto uma irá ficar no estado **idle** (dormindo), esperando uma dessas terminar para então ser executada. É importante ressaltar que é possível aumentar o número do Thread Pool para até 128.
## 5) Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Mostraria primeiramente onde o Node.JS é usado e como ele melhorou a produção em grandes empresas, como o Paypal e o Linkedin. Diria também que o custo seria diminuído, visto que precisariamos de servidores menos potentes, e portanto mais baratos, para ter o mesmo número de acessos que a gente tem com os servidores atuais. Além disso, citaria o fato de usar apenas uma única linguagem no back-end e no front-end, o que facilitaria demais aqueles que são especializados mais no front-end a também ajudarem no back-end, e se tornarem mais independentes.
## 6) Qual a versão do seu Node?
```
D:\Developer\BlogBeMean>node -v
v5.0.0
```
## 7) Qual a versão do seu NPM?
```
D:\Developer\BlogBeMean>npm -v
3.3.6
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [jeffersondanielss](https://github.com/jeffersondanielss)
**autor:** Jefferson Daniel Santos Silva
**date:** 1449708675195
#### Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
O processo síncrono se caracteriza pela necessidade de um processo acabar para poder executar um próximo processo.
Já o assíncrono pode executar vários processos ao mesmo tempo enquanto espera a resposta dos mesmos para quando estiverem prontos.
Podemos pegar como exemplo uma transportadora.
Em um processo síncrono ela só poderia ter um caminhão na rua entregando uma mercadoria por vez para que quando voltasse ele recebesse outra mercadoria e assim voltasse para a rua.
Já com um processo assíncrono a transportadora poderia enviar vários caminhões a rua fazendo suas entregas e quando a transportadora receber a informação que a mercadoria foi entregue com sucesso ela pode reabastecer esse caminhão e envia-lo novamente as ruas.
#### Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
O fluxo de compilação de javascript para o código nativo da máquina, no v8 do nodejs:
#### Qual a diferença entre um sistema single para um multi-thread?
Uma single thread trata apenas uma requisição por vez já o multi-thread cria uma nova thread por requisição podendo tratar várias requisições ao mesmo tempo.
#### Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Ela não será executada até que umas das quatro anteriores sejam finalizadas.
#### Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Explicaria as vantagens que
+ Linha de aprendizado é muito mais rápida já que js é requisito pra trabalhar na web.
+ A vantagem de investir em uma linguagem que está em constante ascensão.
+ [Empresas grandes usam nodejs](https://github.com/nodejs/node-v0.x-archive/wiki/Projects%2C-Applications%2C-and-Companies-Using-Node)
#### Qual a versão do seu `node`?
v5.2.0
#### Qual a versão do seu `npm`?
3.3.12 | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 02 - Exercício
**user:** [dayvsonsales]https://github.com/dayvsonsales
**autor:** Dayvson Sales
**date:** Sex Dez 11 22:39:07 BRT 2015
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Suponhamos que tenhamos uma lista de tarefas
Assíncrono:
Se executarmos de forma assíncrona, essas tarefas irão ser executadas de forma concorrente, simultaneamente. Uma não dependerá da outra para finalizar, podendo assim, a primeira ser a última a retornar ou a última ser a primeira e vice-versa.
Sempre que utilizarmos assíncrono no node.js devemos passar uma função callback que será executada assim que a tarefa terminar sua execução.
Exemplo:
```
db.query(sql, function(err, data){
if(err){
throw err;
}
console.log("inserido " + data);
});
console.log("essa mensagem pode vir antes ou depois do inserido ou error")
```
Síncrono:
Quando uma tarefa é executado de forma síncrona, a thread principal irá esperar a tarefa ser executada e aguardar seu retorno para dar continuidade a outras tarefas.
```
var data = db.querySync(sql);
console.log(data);
console.log("essa mensagem só aparecerá depois da execução da função acima");
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
http://runtimejs.org/jsconf/img/runtimejs-arch.png
http://jbcdn2.b0.upaiyun.com/2012/05/11.jpg
## Qual a diferença entre um sistema single para um multi-thread?
Um sistema single thread se caracteriza por executar tarefas na mesma thread. Dessa forma, é necessário esperar o termino de uma tarefa para executar outra.
Um sistema multi-thread se caracteriza por criar várias threads para execuções de tarefas, podendo realiza-as simultaneamente.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
A quinta só será executada após a finalização das uma das quatro primeiras. Mas é possível aumentar esse número até 128.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Mostraria o Node.js em si, suas vantagens e desvantagens em relação ao negócio da empresa e mostraria casos de sucesso com ele, como o da Netflix (que mudou seu core de Java para Node).
## Qual a versão do seu `node`?
dayvs0n in ~/be-mean-instagram-nodejs-exercises λ-> node -v
v5.2.0
## Qual a versão do seu `npm`?
dayvs0n in ~/be-mean-instagram-nodejs-exercises λ-> npm -v
3.3.12
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
```md
# Node.js - Aula 01 - Exercício
**user:** [josecarloweb](https://github.com/josecarlosweb)
**autor:** JOSÉ CARLOS DA SILVA DE CARVALHO
**date:** Tue Dec 15 2015 14:56:53 GMT-0300 (BRT)
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
Um processo síncrono bloueia todo o ciclo de eventos, parando execução de seu código até que haja as saídas de processo gerado.
Chamadas síncronas são principalmente úteis para a execução de tarefas gerais e para simplificar o carregamento/processamento de configuração do aplicativo na inicialização. Uma vez que utilizado um processo síncrono no NodeJs, o processo principal será bloqueado até que a chamda síncrona seja executada (tenha uma saída).
Ex. Inicialização de uma aplicação, como um jogo que precisa carregar aquivos. O processo principal deve ser bloqueado até que todos os arquivos tenham sido carregados.
Processos assíncronos ocorrem independentemente do fluxo de programa principal. Ações assíncronas são ações executadas em um esquema de não bloqueio, permitindo que o fluxo de programa principal para continuar o processamento. Esse é o tipo de processo padrão do NodeJS.
Ex. Uma aplicação exibe um vídeo em tempo real (streaming) enquanto um processo de chat é executado ao mesmo tempo.
Detalhes e fonte: <http://kikobeats.com/synchronously-asynchronous/>
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
V8 compila JavaScript para código de máquina(IA-32, x86-64, ARM, ou MIPS ISA, também foi portado para PowerPC e IBM s390 para uso em servidores) antes de executá-lo, em vez de técnicas mais tradicionais, como a interpretação de bytecode ou compilar todo o programa para código de máquina e executá-lo a partir de um sistema de arquivos. O código compilado é adicionalmente otimizado (e re-optimized) dinamicamente em tempo de execução, com base em heurísticas de perfil de execução do código. Mais informações <http://thibaultlaurens.github.io/javascript/2013/04/29/how-the-v8-engine-works/>
```
```c++
#include <v8.h>
using namespace v8;
int main(int argc, char* argv[]) {
// Create a stack-allocated handle scope.
HandleScope handle_scope;
// Create a new context.
Handle<Context> context = Context::New();
// Enter the created context for compiling and
// running the hello world script.
Context::Scope context_scope(context);
// Create a string containing the JavaScript source code.
Handle<String> source = String::New("'Hello' + ', World!'");
// Compile the source code.
Handle<Script> script = Script::Compile(source);
// Run the script to get the result.
Handle<Value> result = script->Run();
// Convert the result to an ASCII string and print it.
String::AsciiValue ascii(result);
printf("%s\n", *ascii);
return 0;
}
```
```
## Qual a diferença entre um sistema single para um multi-thread?
Tem mais arquiteturas além de single-thread (ST) e multi-thread (MT). Basicamente o ST só pode tratar uma requisição de cada vez, então o processamento de cada uma não pode ser demorado, nem pode bloquear (por exemplo, ficar esperando pelo banco de dados). O MT, assumindo que se crie uma thread por requisição, pode tratar várias requisições em paralelo, mesmo que demorem ou bloqueiem.
Um servidor ST pode ser eficaz, desde que nunca bloqueie. O Node.js é assíncrono de modo a não bloquear. Qualquer processamento demorado deve ser delegado a um outro processo, o que também pode ser feito no Node com subprocess.
Outra forma de abordar o problema: o prefork do Apache cria um pool de subprocessos, e delega as requisições para cada subprocesso conforme elas chegam. Isto garante o paralelismo e evita as complexidades de programação MT. Isto pode ser implementado também no Node mas o Apache entrega isto de fábrica, o que facilita a vida do desenvolvedor PHP por exemplo, pois ele não precisa se preocupar se está bloqueando.
coletado em: <http://pt.stackoverflow.com/questions/75144/diferen%C3%A7a-entre-multi-e-single-thread>
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
Caso seja feita a quinta requisição ao banco, essa requisição será incluída no **Idle Thread** e ficará aguardando para ser inserida na **Thread Pool** e ser executada.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Hoje em uma empresa que presto serviço, há uma API em PHP que sofre constantes modificações e já consome de infraestrutura o valor de 2 salários de desenvolvedores pleno. O primeiro argumento é o menor custo de infraestrutura, uma vez que o SGBD atual é postgres e o serviço RDS na aws custa bem caro, diferente do mongo ou cassandra. Os custos com infra poderiam cair até 40%.
É desejável que uma nova versão seja criada para corrigir os erros de implementação existentes. Logo uma nova versão da API com o Node/Express seria muito mais produtiva (rápida) e muito mais econômica.
## Qual a versão do seu `node`?
carlos@carlos-pc:~/Documentos/be-mean-instagram-node$ node -v
v5.2.0
## Qual a versão do seu `npm`?
carlos@carlos-pc:~/Documentos/be-mean-instagram-node$ npm -v
3.3.12
``` | {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |
# Node.js - Aula 01 - Exercício
**user:** [souzacristsf](https://github.com/souzacristsf)<br/>
**autor:** Michel Ferreira Souza<br/>
**date:** 1457272367278<br/>
## Explique como um processo síncrono e assíncrono roda no Node.js, dê um exemplo para cada.
**Sync:** no processo síncrono temos que aguarda a execução de um por um, nesse caso para a execução de varias tarefas, temos que aguardar o processo final de cada um.
```js
var fs = require('fs');
var file = "síncrono.txt";
fs.writeFileSync(file, "Hello Node.js!");
console.log("Criando arquivo sincrono: " + file);
```
**Async:** no processo assíncrono, não temos que ficar aguardando, pois enquanto a tarefa é realizada a proxima tarefa é chamada e assim por diante.
```js
var fs = require('fs');
var file = "síncrono.txt";
fs.writeFile(file, "Hello Node.js!", function(err, out) {
console.log("Criando arquivo assincrono: " + file);
});
```
## Como o V8 executa JavaScript? Demonstre 1 exemplo com código ou imagem.
V8 é uma ferramenta desenvolvida na linguagem C++ e open source. O `v8` compila o código javaScript para o formato nativo de máquina antes de executá-lo, obtendo uma grande performance.<br/>
## Qual a diferença entre um sistema single para um multi-thread?
**multi-thread:** varios processos criado.<br/>
**single-thread:** apenas um processo.
## Como a Thread Pool tem um tamanho padrão de 4, o que acontece se você enviar 5 requisições ao banco?
A `libuv` tem um tamanho de *threads pool* padrão de 4, e se dispõe de uma fila para gerenciar o acesso a thread pool. O interessante é que se você tem 5 requisição de consulta ao banco e todos indo ao mesmo tempo, um deles e qualquer outra ação assíncrona estará esperando por essas consultas para começar seu processo.
## Como você venderia o peixe do Node.js na sua empresa para tentar convencer seu chefe da sua adoção?
Primeiramente, mostrar quais empresas estão adotando essa nova ferramenta e em seguida comparar e implementar alguns testes de exemplo em relação ao produto da organização.
## Qual a versão do seu `node`?
```js
michel@souzacrists:~$ node -v
v5.0.0
```
## Qual a versão do seu `npm`?
```js
michel@souzacrists:~$ npm -v
3.3.6
```
| {
"repo_name": "Webschool-io/be-mean-instagram-nodejs-exercises",
"stars": "33",
"repo_language": "JavaScript",
"file_name": "index.jade",
"mime_type": "text/plain"
} |