1. Download Ubuntu 18.04 MinimalCD

Go to the download page, scroll to “64-bit PC…” section and click on “Ubuntu 18.04 “Bionic Beaver” 64MB” to get it.

2. Create USB boot

Get Etcher or alternative tools.

Choose Ubuntu 18.04 mini.iso, and specify USB flash disk to create bootable device.

3. Boot the computer from USB

Ensure that your computer can boot from USB. Legacy boot is recommended. However, advanced users should consider UEFI boot mode.

4. Follow the installation process

Open the slideshow here to see how to install step by step. While viewing, you can press spacebar or click on “Info” icon to see the explanation.

5. Install the stuff

At the first time logging into the OS, you may need to install several must-have tools:

sudo apt update
sudo apt install — no-install-recommends -y \
 software-properties-common ca-certificates build-essential \
 make curl wget htop git nginx inetutils-tools \
 geany vim vim-gnome \
 thunar-archive-plugin file-roller \
 viewnior gthumb mugshot \
 gnome-disk-utility \
 software-center

It’s possible to install them and other utils via Software Center too.

That’s it. We’ve got a very clean system for development. I often pick Xubuntu Minimal because it’s one of the most lightweight desktop environments and it’s so flexible, easy to customize the appearance to fit my own aesthetic point of view.

Sometimes I install DE at the first login instead of during Ubuntu installation. In this case, I like to choose xfce4, which is even more lightweight than Xubuntu Minimal:

sudo apt install xfce4

The rest is your business.

1, Hardware

For a small project, we just need a set as below:

• Intel(R) Core(TM) i5–7600 CPU @ 3.50GHz
• 240 GB hard drive (SSD)
• 8 GB RAM (DDR4)
• nVidia GP106 [GeForce GTX 1060 6GB]

Of course, it also requires a case, power supply, keyboard, mouse and monitor. Total cost about $1500.

2, OS & platform

In this machine we install:

• Ubuntu 17.10 “Artful Aardvark” 58MB
• Xubuntu minimal

Note that the 240GB of SSD drive is being separated to 3 parts:

• 4 GB for swap
• 80 GB mounted as /storage to store persistent data
• The rest mounted as / to install Ubuntu

After the system is ready, we login as root and run the following commands to install several useful tools:

sudo apt update
sudo apt install — no-install-recommends -y \
 software-properties-common build-essential \
 make curl wget \
 ccze inetutils-tools \
 python-minimal git nginx htop vim

While other libs are quite familiar, ccze may be strange. It is used to color the logs output with journalctl.

Lastly, we chmod storage to share to all users:

sudo chmod 0777 /storage

3. Python and Pip

We love to work with Python 3 only, but some system libs may require Python 2. That’s why we have installed python-minimal, then we simply forget it.

The following script will install Python v3.6.4 from source:

export PYTHON_VERSION=3.6.4
export PYTHON_DOWNLOAD_URL=https://www.python.org/ftp/python/$PYTHON_VERSION/Python-$PYTHON_VERSION.tgz

sudo apt install --no-install-recommends -y libssl-dev libreadline-dev libbz2-dev libsqlite3-dev

wget "$PYTHON_DOWNLOAD_URL" -O python.tar.tgz
tar -zxvf python.tar.tgz
cd Python-$PYTHON_VERSION
./configure --enable-optimizations --enable-loadable-sqlite-extensions
make
sudo make install

pip3 install --upgrade pip

The libs libbz2-dev, libsqlite3-dev, etc are required to get later tools such as Jupyter or TensorBoard stability work. Ignoring them would cause the unpleasant errors.

When we build Python 3 from source, pip3 is also installed too. It’s good to put these lines into ~/.bash_aliases or ~/.bash_profile:

alias python=python3
alias pip=pip3

To remember, the general rule is:

• ~/.bash_profile is being activated just one time when you login (GUI or SSH)
• ~/.bash_aliases is being activated every time when you open the terminal (window or tab)

However this behavior can be changed by modifying ~/.bashrc, ~/.profile, or /etc/bash.bashrc, etc.

4. NVIDIA driver

There is two available versions for NVIDIA graphic card’s driver: Nouveau driver and Nvidia driver. The first one is open source, by community. The last one is close source, by NVIDIA.

Normally, Nvidia driver is default. For Ubuntu 17.1 0, it’s nvidia-384. We can check it with:

cat /proc/driver/nvidia/version

If it’s not there for some reason, just install it.

From GUI, you can choose it via Drivers Management tool. It will be downloaded and installed automatically.

You can install Nvidia driver via terminal too. For this case, many experts suggest to add Nouveau to blacklist first:

sudo nano /etc/modprobe.d/blacklist.conf

Then paste the following lines into then save it:

blacklist vga16fb
blacklist nouveau
blacklist rivafb
blacklist nvidiafb
blacklist rivatv

And install:

sudo add-apt-repository ppa:graphics-drivers/ppa
sudo apt update
sudo apt install nvidia-384 nvidia-384-dev

Recheck it using the above cat command or nvidia-smi for more detail.

5. CUDA v9.0

TensorFlow team just released v1.7 that has been built with CUDA 9.0, so unless you have plan to build TensorFlow from source, you should not install CUDA v9.1 to avoid the unexpected issues.

IMHO, it’s always best practice to install pip modules into the virtual environments, and use TensorFlow from PyPI. This will provide a flexible solution. For the same reason, I didn’t recommend to use Anaconda.

CUDA v9.0 requires GCC 6, while default GCC version in Ubuntu 17.10 is GCC 7.2. So we have to install GCC 6 and create symlinks as below:

sudo apt install gcc-6 g++-6
sudo ln -s /usr/bin/gcc-6 /usr/local/cuda/bin/gcc
sudo ln -s /usr/bin/g++-6 /usr/local/cuda/bin/g++

Now gcc command is running as gcc-6, check it with:

gcc -v

Then, we stop x-server, download CUDA 9 and install it:

sudo service lightdm stop
wget https://developer.nvidia.com/compute/cuda/9.0/Prod/local_installers/cuda_9.0.176_384.81_linux-run
mv cuda_9.0.176_384.81_linux-run cuda_9.0.176_384.81_linux.run
chmod +x cuda_9.0.176_384.81_linux.run
sudo ./cuda_9.0.176_384.81_linux.run --override --dkms -s

While compiling, it will ask several questions, answer as below:

You are attempting to install on an unsupported configuration. Do you wish to continue?
y
Install NVIDIA Accelerated Graphics Driver for Linux-x86_64 384.81?
n
Install the CUDA 9.0 Toolkit?
y
Enter Toolkit Location
[default location]
Do you want to install a symbolic link at /usr/local/cuda?
y
Install the CUDA 9.0 Samples?
y
Enter CUDA Samples Location
[default location]

If nothing special happens, the process will end succefully.

As NVIDIA’s docs, we may need to add these paths into ~/.bash_aliases:

$ export PATH=/usr/local/cuda-9.0/bin${PATH:+:${PATH}}

$ export LD_LIBRARY_PATH=/usr/local/cuda-9.0/lib64${LD_LIBRARY_PATH:+:${LD_LIBRARY_PATH}}

Lastly, reboot the system.

6. cuDNN v7.0.5 for CUDA 9.0

CUDA 9.0 only plays with its appropriate cuDNN version, you can download it here after joining NVIDIA Developer Program.

Choose the correct item from list as below:

Download it then run these commands:

tar -xzvf cudnn-9.0-linux-x64-v7.tgz
sudo cp cuda/include/cudnn.h /usr/local/cuda/include
sudo cp cuda/lib64/libcudnn* /usr/local/cuda/lib64
sudo chmod a+r /usr/local/cuda/include/cudnn.h
/usr/local/cuda/lib64/libcudnn*

Basically it is done.

Now we talk a little about the workspace.

7. Setup project environment

Depending on the project, the process and the team, you can choose the corresponding way to organize the workspace.

In our project, after finishing the above steps, we give each project member an account to access to the system as regular user.

Note that we have to ensure the paths at the step 5 are available to all users. Simply clone the ~/.bash_aliases.

Persistent data such as datasets, checkpoints, weights, etc can be stored at /storage.

Project member will login using ssh and setup virtual environment by himself, for example:

python3 -m venv computer-vision
source computer-vision/bin/activate
(computer-vision) pip install tensorflow-gpu jupyter
(computer-vision) jupyter notebook --port 7777

With regular user permission, they can do everything related to preprocessing and training, but could not install pip package globally or change system softwares. That will keep the system more stable.

While using GPU, nvidia-smi is powerful command. We can check the real-time stats with:

watch -d -n 1.0 nvidia-smi

Conclution

That’s all. Now we had a good enough environment to get started our deep learning tasks.

The whole script is available here:

In addition, there are some free places to play such as Google Colab and FloydHub. Let’s take a look on them while you considering to invest.

Enjoy studying.

• the notes in a chord
• the chords in a scale

Me too. So I’ve created a minimalist web app that helps me determine the chords based on any given natural scale. With it, once I known which scale the song should be played with, I can choose it on the app’s interface and then the app would display the basic chords that belong to the given scale.

It looks like below:

The algorithm I’used to program and calculate the notes and chords was founded on two principles:

1. How to build the major/minor chords.
2. How to use “circle of fifths” and “circle of fourths” to find the chords those are belong to the specific scale.

Here are some notes I would like to write down for later references after finishing the first version.

Intervals and steps

1, On the piano, including black and white keys, each adjacent key has a distance of a half step between them.

As you can see in the picture below, between D and D# is half step, between D# and E is half step, between E and F is half step … So between D and E is a whole step, between D and F is one and a half step, and so on.

2, If the distance between two notes is 2 steps (4 keys), we have a major third. If that is one and a half step (3 keys), we have a minor third.

Chords

3, A chord is a combination of at least 3 notes, in which the first note is called root note. The chords are named with the name of root note.

4, Major chord = 1 major third + 1 minor third

So, to build a major chord, just start out with root note, count up 2 steps (4 keys), and we have the second note. From second note, count up 1.5 step (3 keys), and we have the third note.

For instance, with the chord C major, we have C as the root note. From any C key on the piano, count up 4 keys, we get E. From E, count up 3 keys, we get G. Thus, the keys that should be pressed are C — E — G.

5, Minor chord = 1 minor third + 1 major third

So, to build a minor chord, just start out with root note, count up 1.5 step (3 keys), and we have the second note. From second note, count up 2 steps (4 keys), and we have the third note.

For instance, with the chord C minor, we also have C as root. From any C key on the piano, count up 3 keys, we get E♭ (or D#). From E♭, count up 4 keys, we get G. Thus, the keys that should be pressed are C — E♭ — G.

Scales

6, A scale is the collection of notes — in an octave — ordered by fundamental frequency or pitch.

The chain of notes in a scale starts from its root note — the first note — which the scale was named after. This note called the “tonic” of the scale.

From the tonic, count up until the last note, we will have a set of nodes which the distance between them follows a particular pattern.

Suppose H (half) represents a half-step and W (whole) represents a whole step, then:

• The major scale is a sequence of notes that follows the W-W-H-W-W-W-H pattern.

For example C major:

• The minor scale is a sequence of notes that follows the W-H-W-W-H-W-W pattern.

For example A minor:

Note that here we just talk about natural scales — in real world, there are many other kinds of scale.

7, About “circle of fifths” and “circle of fourths”

The “circle of fifths” is a model which describe the relationship among the 12 tones of the chromatic scale. Here is the diagram:

With the same picture above, in clockwise sense, we have the circle of fifths, and in the counterclockwise sense, we have the circle of fourths.

Major scale

To find the chords in the major scale, just start from the position of the scale’s tonic, two chords on either side of it are two major chords. Clockwise, the 2nd, 3rd and 4th chords are the minor chords.

For example, to identify the chords of C major, just take C as the first position. The two chords next to C — F and G — are major chords. Clockwise, from tonic, 3 next chords include D, E and A will be the minor chords. Thus, we’ve got at least six chords in C, F, G, Dm, Em and Am to play in C major scale.

Minor scale

To find the chords in the minor scale, we also start from the position of the scale’s tonic, two chords on either side of it are two minor chords. In the counterclockwise, the 2nd, 3rd and 4th chords are the major chords.

For example, to identify the chords of A minor, just take A as the first position. The two chords next to A — D and E — are minor chords. Counterclockwise, the next 3 chords includes G, C and F will be the major chords. Thus, we can play C major scale with Dm, Am, Em, C, F and G.

That’s it. We just need some simple principles, and we can easily build the basic chords. And then, by referring to the “circle of fifths”, we can find all natural chords from any scale. There is a profound relationship between music and math. This is a great starting point for more in-depth studies later.

I hope that the app and/or the theory behind it would be useful for you.

I would not bore you with a long list of features that Zato provides. You can find them somewhere at Zato homepage. In this article, I just want to introduce a demo, a very simple example, to show how we can quickly get started with Zato. But at first, a little overview regarding Zato architecture may be necessary for understanding next section.

Zato architecture

Zato was designed with high performance and scalability in mind. Once we start a Zato ESB instance, we get — not a single server — but a cluster that includes several servers, HAProxy, Operational Database (Postgres is recommended), Key/Value store database (Redis as default) and scheduler as you can see in figure 1 below:

This design gives Zato ability to process a near-unlimited number of connections. Even with a basic setup, Zato can handle hundreds of thousands of concurrent requests.

Is that cool?

Now we would start our ESB. So quickly, just few minutes.

Demo scenario

In this demo, we setup a Zato cluster as ESB core, then we run 2 Node.js processes to simulate external services. One for JSON Document service and other for XML Document service.

Then we try to send a XML document to JSON Document service — through ESB, of course — to see if JSON Document service receives this new item as JSON document.

Let’s start

We’ve prepared a GitHub repository for you. Please ensure that you have git, docker, docker-compose already installed. We also use the ports 8183, 8185, 8186, and 11223.

When everything is ready, please open your favorite command line tool, then:

git clone https://github.com/greenglobal/zato-demo.git
cd zato-demo
docker-compose up

The process looks like in this clip:

At the first time, it may take few minutes to download the images from Docker Hub. Be patience. The next times you will not need to wait.

If nothing wrong, we should get:

• Zato dashboard located at http://localhost:8183
• JSON Document service: http://localhost:8185/documents
• XML Document service: http://localhost:8186/documents

Admin dashboard

Zato provides web-based GUI, CLI and API that allow to use it, control it by any convenient way for you. In this article, we just take action on the ESB via its web-based GUI — that we called “Zato dashboard”.

Open your favorite web browser, then access http://localhost:8183 and login with username “admin” and password:

2cdd3856-ced5-43b8-b3c1-7e8a5cdb0c37

This password is being generated automatically every time we build the image and could be extracted from docker container by running the following command:

docker exec cluster1 cat /opt/zato/web_admin_password

External services

As we’ve mentioned above, there are JSON Document service and XML Document service run at 2 ports 8185 and 8186. They are 2 separate Node.js processes.

The main mission of an ESB is mix the different services together, allow them to communicate with each other without any modification from them self. These services may be different in protocol, data format and data structure. In our example, JSON Document service uses JSON format and opens a RESTFul API (It was built with json-server). While XML Document service uses XML format (It is just a static XML file now, we have plan to make a SOAP service instead).

Basically, XML Document service and JSON Document service could not talk together because they don’t speak the same language. But, Zato ESB stands there, as middle-man, will help them. These 2 services have to connect to Zato ESB, pass the data to ESB, then ESB will do its regular tasks to translate, mediate, transform and then, forward to the receiver what it expects.

Declare outgoing connections

In order to get it works for us, let’s back to Admin dashboard. From the menu, go to Connections -> Outgoing -> Plain HTTP, then create 2 objects JSON_Docs and XML_Docs as in the following clip:

At this step, we are pointing the links between ESB service with its external connection — destination — so that ESB can start pushing requests towards it once the equivalent service involves.

Note that, we’re using docker container name in the URL paths “http://docsv:8185/documents” and “http://docsv:8186/documents” because that is the best way to connect 2 or multi docker containers in the same network together. “docsv” is docker containers’ name as we defined in docker-compose.yml file. In real world, we might use domain or public IP address instead.

Register Document service

The term “service” here may make us confused a little bit. Let’s simple look it as an agent that is responsible for transforming the documents.

In our example, there is a small Python script located at /service2/document_service.py in which we transform XML data to JSON data and post to JSON Document service.

Back to Admin dashboard, go to Services -> List services, click “Upload a service package” button and browse to the above script’s location. Watch the following clip for detail:

Here Zato provides a great feature: hot-deployment. After we upload a service, it will be synced to all servers/clusters and become available to use immediately.

Expose Document service over HTTP

Now we need to expose our Document service so that it can be involved from outside. Let’s call it “Send XML Document”.

Note that, we’ve declared URL Path as /documents, that means the applications/services from outsite can call to ESB’s Document service via absolute path in the format of protocol://your-esb-domain.com/documents. In our example, the full path is http://localhost:11223/documents, with 11223 is cluster’s port.

When a HTTP request was sent to Zato cluster, HAProxy will capture and transfer it to the appropriate server. Zato ESB installed within selected server, in its tour, will call the equivalent service based on declared URL Path. This service does its task on data and then decides to save into somewhere or deliver to the specific destinations.

In our demo, we just send a XML document to ESB’s Document service. If it works as well, it should execute what we written in document_service.py: convert XML data format to JSON data format and then post to JSON Document service. Now, let’s try.

Check how our ESB works

Use your favorite tool to send a post request to ESB’s Document service at http://localhost:11223/documents with the content below:

<request>
  <id>11</id>
  <subject>Hello Zato</subject>
  <body>I'm a tester and I expect this document will be inserted into list of JSON documents</body>
  <by>Kenneth Stokes</by>
  <time>612154834</time>
</request>

Check the result by reloading http://localhost:8185/documents to see if new item has been added to the end of the list.

Watch the following clip for more detail:

That’s it. The program works for me as well. Hope that it works for you too. If it doesn’t, feel free to create issue or leave comment here.

Now is the time to look in other capabilities: enable security, switch to another protocol, process in queue, apply pub/sub model, etc. I’m not a specialist in ESB and SOA, this is the first time I really work for an ESB, but with Zato, I had a pretty good start.

Let’s give Zato a try. Some days it may become your close friend.

(This article is written from a developer’s point of view. I have no benefit relationship with Zato team and Zato brand.)

1. The soldiers can gather resources and construct buildings as farmers.
2. Unlimited population, I can make the big battles with thousands of soldiers.
3. It’s open source.
4. It’s cross-platform so I can play it on Linux.
5. It’s 3D with very smooth experience.

If you have never played 0 A.D., this is the introduction on Play0ad:

0 A.D. (pronounced “zero ey-dee”) is a free real-time strategy (RTS) game of ancient warfare. Lead a civilization set in the imaginary year of 0 A.D., develop a thriving city, raise a mighty army and contend with rivals for hegemony of the world. History is yours for the taking!

I often play the month-long battles, each day about 15 or 20 minutes:

Would you like to try it? Please follow the instructions here:

http://play0ad.com/download/

Are you using Slack? Do you want to get your own Slack for your team or your company? Rocket Chat may be what you need.

I’ve just heard about this package today. It’s an online chat tool based on Meteor, open source, full features, multi devices, and quite easy to setup.

In order to install Rocket Chat, you can use Ubuntu server. Your server must have nginx, node.js and MongoDB.

If everything is already, we install tmux and meteor first:

sudo apt-get install tmux
sudo npm install -g meteor

tmux would be used for keeing Meteor app alive even when you close terminal.

Now, clone Rocket Chat repository into rocket-chat directory:

git clone https://github.com/RocketChat/Rocket.Chat.git rocket-chat
cd rocket-chat
meteor

The last command would download the needed npm and Meteor packages then start server. Wait until the process done, press “Ctrl+C” to stop it. We still need to configure host and database connection.

Here I try to set public domain for Rocket Chat application at http://g8.techpush.net/ and use local MongoDB:

export ROOT_URL=http://g8.techpush.net/
export MONGO_URL=mongodb://127.0.0.1:27017/rocketchat

Now, open tmux session and run “meteor”:

tmux
meteor

If nothing wrong, you have got it runs at the port 3000 — as default. Press “Ctrl+B” and then “D” to leave tmux session.

To access app from the internet, you can use the following nginx config:

server {
    listen 80;
    server_name g8.techpush.net;
    charset utf-8;

    location / {
        proxy_read_timeout 300;
        proxy_pass http://127.0.0.1:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection ‘upgrade’;
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

Save config file and restart nginx:

sudo service nginx restart

That’s it. You can start using Rocket Chat now:

Rocket Chat can do more than that. Please take a look on its feature list and give it a try.

Note: If your server did not have nginx, node.js or MongoDB yet, it may take a little time more to install them:

# install nginx
sudo add-apt-repository ppa:nginx/stable
sudo apt-get update
sudo apt-get install nginx

# install node.js v5.3.0
wget https://nodejs.org/dist/v5.3.0/node-v5.3.0.tar.gz
tar -zxvf node-v5.3.0.tar.gz
cd node-v5.3.0
./configure
make
sudo make install

# install MongoDB v3.2.0
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv EA312927
echo "deb http://repo.mongodb.org/apt/ubuntu trusty/mongodb-org/3.2 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.2.list

sudo apt-get update
sudo apt-get install -y mongodb-org=3.2.0 mongodb-org-server=3.2.0 mongodb-org-shell=3.2.0 mongodb-org-mongos=3.2.0 mongodb-org-tools=3.2.0

In the time of Node.js and PhantomJS, taking the webpage screenshot has became easier than ever. The first thing we need to do is install PhantomJS:

git clone git://github.com/ariya/phantomjs.git
cd phantomjs
git checkout 1.9
./build.sh

The above command lines get the source code from GitHub and build PhantomJS 1.9 from this source. If you want to use another version, please check release notes here:

http://phantomjs.org/download.html

Every released version of PhantomJS has a “release name” after the name of a flower. PhantomJS 1.9 is “Sakura”. PhantomJS 1.8 is “Blue Winter Rose”… Sakura marks the end of the 1.x series as what Ariya Hidayat has explained on the forum of team.

Capture screen just is one of PhantomJS’ features. The main target of this library is simulate web browser’s behaviors. With a given URL, PhantomJS will try to handle it as a web browser: load resources, parse DOM, compile CSS/Javascript, render layout… and then, generate the web page interface as the result we would see on any web browser. Thus, PhantomJS is usually used in testing, monitoring, etc.

In order to capture a webpage’s screen, PhantomJS loads its HTML, CSS, Javascript and fonts, handle them as what a web browser does. Finally, PhantomJS uses HTML5 Canvas API to take a shot.

Compiling PhantomJS may take a few time. While waiting, we install a Node.js module named url-to-screenshot. This module provides a simple and very useful APIs that allows developers easy to deal with PhantomJS.

npm install url-to-screenshot

OK. We will come back here later.

To check if PhantomJS has been installed successfully or not, type the following command:

phantomjs -v

If the system says that phantomjs command is not available, you might run the following commands to download PhantomJS 1.9.7 and make some needed symlinks:

cd /usr/local/share
sudo wget https://bitbucket.org/ariya/phantomjs/downloads/phantomjs-1.9.7-linux-x86_64.tar.bz2
sudo tar xjf phantomjs-1.9.7-linux-x86_64.tar.bz2
sudo ln -s /usr/local/share/phantomjs-1.9.7-linux-x86_64/bin/phantomjs /usr/local/share/phantomjs
sudo ln -s /usr/local/share/phantomjs-1.9.7-linux-x86_64/bin/phantomjs /usr/local/bin/phantomjs
sudo ln -s /usr/local/share/phantomjs-1.9.7-linux-x86_64/bin/phantomjs /usr/bin/phantomjs

Check it again. If everything is OK, url-to-screenshot module is also ready to use. Here is a simple example to show how we can apply PhantomJS and url-to-screenshot:

var Screenshot = require(‘url-to-screenshot’);

function take(url, callback){
   Screenshot(url)
      .width(1366)
      .height(768)
      .capture(function(err, imageData){
           if(!err && !!imageData){
               return callback(imageData);
           }
           return callback(false);
      });
}

The function “take” requires 2 parameters:

- url of web page to take screenshot for
- callback function to handle returned data

This callback function has only one parameter. If PhantomJS could not generate the webpage UI, a value false will be passed to callback. Conversely, the image data of screenshot will be returned and you can do anything with it, for example write to local file:

var fs = require(‘fs’);
take(‘http://techpush.net/', function(imgData){
   if(!imgData){
      console.log(‘Could not take screenshot for this url’);
      return false;
   }
   var file = __dirname+’/screenshots/test.png’;
   fs.writeFileSync(file, imgData);
});

For more info about url-to-screenshot, please visit its repository here:

https://github.com/juliangruber/url-to-screenshot

However, you can choose another modules. Some of them even supports more options such as browser type, screen size, image quality, etc.

The screenshots made by PhantomJS are very because it supports Unicode perfectly. Based on my experience, the accuracy can reach 95%. The problem often arises only when the web page using the rare fonts.

PhantomJS is used on FOMO while creating thumbnails for the articles. When we detect an article that does not have image for creating thumbnail, we will use the screenshot of that article’s URL, as the following figure:

FOMO Screenshot : http://i.imgur.com/NBHa9l7.png

Here are some screenshots to show the ability of PhantomJS, created for FOMO system.

URL : http://goo.gl/NvxTRd
Screenshot : http://i.imgur.com/1iFe4z4.png

URL : http://goo.gl/LC2wml
Screenshot : http://i.imgur.com/4PlYrgJ.png

URL : http://goo.gl/zF6O4j
Screenshot : http://i.imgur.com/XcrrYku.png

There are more than one way to do that, such as systemd, forever, nodemon, node-supervisor and PM2. Forever was the best choice in the past but now it has become outdated. So I recommend to use PM2 here.

PM2 should be globally installed as below:

sudo npm install -g pm2

Since now, we have the command pm2 that can be called from anywhere.

This blog is Ghost platform that I run on an EC2 instance. When the instance reboots by some reason, I’d like to Ghost can be restarted automatically. Here’s what I do:

cd /var/www/ghost
pm2 start index.js —name “ghost”
pm2 dump
sudo pm2 startup ubuntu

At the second line, —name “ghost” means that we name process “ghost” to distint it from other processes and can refer to it in other commands.

PM2 can generate and configure a startup script to keep itself and the processes it manages alive at every server restart. At last 2 lines, PM2 dump the current process into startup script. The command dump will save process information into a JSON file located at /home/USER/.pm2/dump.pm2 — it will be loaded while server start.

You can replace “ubuntu” there by other OS name as you are using, such as amazon, centos, etc.

After running the last command, it may return:

[PM2] Generating system init script in /etc/init.d/pm2-init.sh
[PM2] Making script booting at startup…
[PM2] -ubuntu- Using the command su -c “chmod +x /etc/init.d/pm2-init.sh && update-rc.d pm2-init.sh defaults”
 Adding system startup for /etc/init.d/pm2-init.sh …
 /etc/rc0.d/K20pm2-init.sh -> ../init.d/pm2-init.sh
 /etc/rc1.d/K20pm2-init.sh -> ../init.d/pm2-init.sh
 /etc/rc6.d/K20pm2-init.sh -> ../init.d/pm2-init.sh
 /etc/rc2.d/S20pm2-init.sh -> ../init.d/pm2-init.sh
 /etc/rc3.d/S20pm2-init.sh -> ../init.d/pm2-init.sh
 /etc/rc4.d/S20pm2-init.sh -> ../init.d/pm2-init.sh
 /etc/rc5.d/S20pm2-init.sh -> ../init.d/pm2-init.sh

[PM2] Done.

Sometimes, PM2 may return a guideline looks like this:

[PM2] You have to run this command as root
[PM2] Execute the following command :
[PM2] sudo env PATH=$PATH:/usr/local/bin pm2 startup ubuntu -u ubuntu

Just copy & paste it to run:

sudo env PATH=$PATH:/usr/local/bin pm2 startup ubuntu -u ubuntu

That’s all.

PM2 also provides a set of useful methods to help developers manage and monitor the Node.js processes such as monit, logs, status, etc. Please refer the homepage and try them by yourself today:

http://promotion.pm2.io/

When you use git clone to get a repository, it always downloads all histories those were stored within .git folder. That means if you’ve been uploading a file 100MB in the past, and then you’ve removed it yesterday, and then now you’d like to clone it again, you still have to download that file, 100MB, because it’s a part of repo’s history.

So, sometimes you might want to clean up them all. Here is the way to do.

git checkout —orphan temp
git add *
git commit -a
git branch -D master
git branch -m master
git push -f origin master

What does that means? Theorically, we just create a new orphan branch named “temp”, add the whole data into it, remove the master branch and then set the temp branch as master. Finally, we push them to server with a force flag. That’s all.

Now we are staying on the master branch, a new master branch. We can make this branch track a remote “master” branch by using one of 2 following commands:

git branch —set-upstream-to=origin/master

or:

git branch -u origin/master

In the world of git, an orphan branch is a completely new branch where the first commit made on will have not any reference, so that it will be the root of a new history totally.