In the Computer world, Data is stored as a sequence of bits. Bits are basically either 0 or 1. Any data inside a computer is expressed in terms of bits. For example, the decimal number 13 will be expressed as 00001101 in bits inside the computer. Bits are any kind of two-valued things, usually described as zeros and ones. Inside the computer, they take forms such as a high or low electrical charge, a strong or weak signal, or a shiny or dull spot on the surface of a CD. Any piece of discrete information can be reduced to a sequence of zeros and ones and thus represented in bits.

Imagine a sea of bits—an ocean of them. A typical modern computer has more than 30 billion bits in its volatile data storage. Nonvolatile storage tends to have yet a few orders of magnitude more.

There are different types of values called Numbers, String, Boolean, etc. Let’s see one by one in detail.

• Numbers:

Values of number type are just numerical values. Javascript uses 64 bits to store a single number value. With 64 binary digits, we can represent 2 ^ 64 different numbers which are 18 quintillions, and it is so huge. Number values include negative numbers as well, so one bit is used to represent the sign of the number. In order to represent nonwhole numbers as well, some of the bits are used to store the decimal point.

A sample arithmetic operation in Javascript looks like this 10 + 5 * 2

The symbols +, * are called operators. When operators appear without parenthesis just like the expression on the top, the arithmetic operation is performed on the basis of the order of precedence.

There are three special values in Javascript which are numbers but don’t behave like one. They are Infinity, -Infinity, NaN.

• Arithmetic:

The main thing to do with numbers is arithmetic. Arithmetic operations such as addition or multiplication take two number values and produce a new number from them. Here is what they look like in JavaScript: 100 + 4 * 11

The + and * symbols are called operators. The first stands for addition and the second stand for multiplication. Putting an operator between two values will apply it to those values and produce a new value.

• Strings:

The next basic data type is the string. Strings are used to represent text. They are written by enclosing their content in quotes.

• 'Down on the sea'
• "Lie on the ocean"
• 'Float on the ocean'

You can use single quotes, double quotes, or backticks to mark strings, as long as the quotes at the start and the end of the string match.

• Unary operators:

Not all operators are symbols. Some are written as words. One example is the typeof operator, which produces a string value naming the type of the value you give it.

• console.log(typeof 4.5)
• // → number
• console.log(typeof "x")
• // → string

We will use console.log in example code to indicate that we want to see the result of evaluating something. More about that in the next chapter. The other operators have shown all operated on two values, but typeof takes only one. Operators that use two values are called binary operators, while those that take one are called unary operators. The minus operator can be used both as a binary operator and as a unary operator.

• console.log(- (10 - 2))
• // → -8

• Boolean values:

It is often useful to have a value that distinguishes between only two possibilities, like “yes” and “no” or “on” and “off”. For this purpose, JavaScript has a Boolean type, which has just two values, true and false, which are written as those words. Comparison Here is one way to produce Boolean values:

• console.log(3 > 2)
• // → true
• console.log(3 < 2)
• // → false

The > and < signs are the traditional symbols for “is greater than” and “is less than”, respectively. They are binary operators. Applying them results in a Boolean value that indicates whether they hold true in this case. Strings can be compared in the same way.

• console.log("Aardvark" < "Zoroaster")
• // → true

• Empty values:

There are two special values, written null and undefined, that are used to denote the absence of a meaningful value. They are themselves values, but they carry no information. Many operations in the language that don’t produce a meaningful value (you’ll see some later) yield undefined simply because they have to yield some value.

• Automatic type conversion:

In the Introduction, I mentioned that JavaScript goes out of its way to accept almost any program you give it, even programs that do odd things. This is nicely demonstrated by the following expressions:

• console.log(8 * null)
• // → 0
• console.log("5" - 1)
• // → 4
• console.log("5" + 1)
• // → 51
• console.log("five" * 2)
• // → NaN
• console.log(false == 0)
• // → true

Summary:

We looked at four types of JavaScript values in this chapter: numbers, strings,Booleans, and undefined values. Such values are created by typing in their name (true, null) or value (13 , "abc"). You can combine and transform values with operators. We saw binary operators for arithmetic (+, -, *, /, and %), string concatenation (+), comparison (==, !=, ===, !==, <, >, <=, >=), and logic (&&, ||), as well as several unary operators (- to negate a number, ! to negate logically, and typeof to find a value’s type) and a ternary operator (?:) to pick one of two values based on a third value.

API stands for Application Programming Interface and allows your application to interact with an external service using a simple set of commands. APIs are another way companies can serve their tools and services.

Main types of Web APIs:-

1. Open APIs

   Also known as Public API, there are no restrictions to access these types of APIs because they are publicly available.

2. Partner APIs

   A developer needs specific rights or licenses in order to access this type of API because they are not available to the public.

3. Internal APIs

   Also known as Private APIs, only internal systems expose this type of API. These are usually designed for internal use within a company. The company uses this type of API among the different internal teams to be able to improve its products and services.

4. Composite APIs

   This type of API combines different data and service APIs. It is a sequence of tasks that run synchronously as a result of the execution, and not at the request of a task. Its main uses are to speed up the process of execution and improve the performance of the listeners in the web interfaces.

Apart from the main web APIs, there are also web service APIs:

1. SOAP
2. XML-RPC
3. JSON-RPC
4. REST

A web service is a system or software that uses an address, i.e., URL on the World Wide Web, to provide access to its services.

The following are the most common types of web service APIs:

1. SOAP (Simple Object Access Protocol):

   This is a protocol that uses XML as a format to transfer data. Its main function is to define the structure of the messages and methods of communication. It also uses WSDL, or Web Services Definition Language, in a machine-readable document to publish a definition of its interface.

2. XML-RPC:

   This is a protocol that uses a specific XML format to transfer data compared to SOAP that uses a proprietary XML format. It is also older than SOAP. XML-RPC uses minimum bandwidth and is much simpler than SOAP.

3. JSON-RPC:

   This protocol is similar to XML-RPC but instead of using XML format to transfer data it uses JSON.

4. REST (Representational State Transfer):

   REST is not a protocol like the other web services, instead, it is a set of architectural principles. The REST service needs to have certain characteristics, including simple interfaces, which are resources identified easily within the request and manipulation of resources using the interface.

The Importance of APIs:-

The importance of APIs from a technical standpoint, they allow the capabilities of one computer program to be used by another. They are a means by which two different programs are able to communicate. APIs enable companies to grow their businesses more quickly than ever before, and represent an answer for the organizations that are currently spending more than $590 billion per year integrating disparate systems. Like the Web, which opened up the Internet’s potential, APIs are driving a new wave of innovation centered on sharing services. Organizations in all industries are looking to learn more about APIs and their potential to transform business processes.

Most Popular API Integrations:-

Out of all 10,000+ APIs on RapidAPI’s API marketplace, these are the APIs that over 1,000,000 developers use the most. For each API, click the link to explore the API documentation, or click “Learn More” to read more details about the API.

1. Skyscanner Flight Search
2. Open Weather Map
3. API-FOOTBALL
4. The Cocktail DB
5. REST Countries v1
6. Yahoo Finance
7. Love Calculator
8. URL Shortener Service
9. NasaAPI
10. Numbers
11. musiXmatch
12. SYSTRAN – Translation and NLP
13. Chuck Norris
14. Hearthstone
15. Currency Exchange

Before we start looking at the specific use cases, here’s a quick note about commit messages. Having a good guideline for creating commits and sticking to it makes working with Git and collaborating with others a lot easier.

Good commit messages serve at least three important purposes:

• To speed up the reviewing process.

• To help us write a good release note.

• To help the future maintainers of Erlang/OTP (it could be you!), say five years into the future, to find out why a particular change was made to the code or why a specific feature was added.

DO's

• Write the summary line and description of what you have done in the imperative mood, that is as if you were commanding someone. Start the line with "Fix", "Add", "Change" instead of "Fixed", "Added", "Changed".
• Always leave the second line blank.
• Line break the commit message (to make the commit message readable without having to scroll horizontally in gitk).

DON'Ts

• Don't end the summary line with a period - it's a title and titles don't end with a period.

Tips

• If it seems difficult to summarize what your commit does, it may be because it includes several logical changes or bug fixes, and are better split up into several commits using git add -p.

Explanation of a few Git Messages are as follows:-

• feat - a new feature
• fix - a bug fix
• docs - changes in documentation
• style - everything related to styling
• refactor - code changes that neither fixes a bug or adds a feature
• test - everything related to testing
• chore - updating build tasks, package manager configs, etc

Git is such a complex tool that I often feel as if I'm barely using 10% of its complete functionality. The various commands range from the absolutely essential (commit, push, pull) to the more exotic to the downright obscure or scary. However, this list compiles 6 commands that you may not know about that have seriously improved the way in which I use git.

• git log -p

  git log is git's way of showing you the history of your codebase, and adding a path to the command will limit the log to the changes in that one file. Finally, the -p flag includes the diff on the file at each commit, so you can see exactly how the file has changed at each point in the history of the code.

$ git log -p README.md

• git checkout

  If you want to see the state of your code at a particular point in history, git makes this trivial. Just run this command with a commit hash as the argument (you can use git log to find the hash you want to revert to).

$ git checkout 08c6fa

• git checkout --

  This is useful in the case when you need to restore a deleted file, or restore a file to a previous state. Here, refers to a commit hash, tag or branch, and is the path of the file relative to the top directory of the project.

$ git checkout 05c5fa -- config/routers.rb

• git stash

  This is an extremely useful command that isn't as well known as it should be. If you have uncommitted changes in your tree that you want to temporarily undo, then this command allows you to stash them for later. This is particularly useful if you want to check the state of your code before your changes, or if you want to merge in someone else code but aren't yet ready to commit your code as it is.

$ echo "This is a temporary" >> README

• git cherry-pick

  This command allows you to apply a single commit to your working tree. For example, if there's a commit in another branch that you want to apply but the branch isn't ready to fully merge, you can use this command to grab that commit and drop it into your current branch.

$ git cherry-pick 9f4afc

• git annotate

  This handy command shows each line of a file next to the information about which commit last changed that line, when it changed, and who changed it.

$ git annotate Readme

In this article, we are going to go over the top Common Git Commands. Some of these you may have used, some may be new to you, and some you might think there’s no way this is going to work. But you'll never know until you try them out!

The Commands are as follows :-

• git init

  This command turns a directory into an empty Git repository. This is the first step in creating a repository. After running git init, adding and committing files/directories is possible.

# change directory to codebase
$ cd /file/path/to/code
# make directory a git repository
$ git init

• git add

  Adds files in the to the staging area for Git. Before a file is available to commit to a repository, the file needs to be added to the Git index (staging area). There are a few different ways to use git add, by adding entire directories, specific files, or all unstaged files.

$ git add <file or directory name>

• git commit

  Record the changes made to the files to a local repository. For easy reference, each commit has a unique ID. It’s best practice to include a message with each commit explaining the changes made in a commit. Adding a commit message helps to find a particular change or understanding the changes.

# Adding a commit with message
$ git commit -m "Commit message in quotes"

• git status

  This command returns the current state of the repository. git status will return the current working branch. If a file is in the staging area, but not committed, it shows with git status. Or, if there are no changes it’ll return nothing to commit, working directory clean.

$ git status

• git config

  With Git, there are many configurations and settings possible. git config is how to assign these settings. Two important settings are user user.name and user.email. These values set what email address and name commits will be from on a local computer. With git config, a --global flag is used to write the settings to all repositories on a computer. Without a --global flag settings will only apply to the current repository that you are currently in.

$ git config <setting> <command>

• git branch

  To determine what branch the local repository is on, add a new branch, or delete a branch.

# Create a new branch
$ git branch <branch_name>
# List all remote or local branches
$ git branch -a
# Delete a branch
$ git branch -d <branch_name>

• git checkout

  To start working in a different branch, use git checkout to switch branches.

# Checkout an existing branch
$ git checkout <branch_name>
# Checkout and create a new branch with that name
$ git checkout -b <new_branch>

• git merge

  Integrate branches together. git merge combines the changes from one branch to another branch. For example, merge the changes made in a staging branch into the stable branch.

# Merge changes into current branch
$ git merge <branch_name>

• git remote

  To connect a local repository with a remote repository. A remote repository can have a name set to avoid having to remember the URL of the repository.

# Add remote repository
$ git remote <command> <remote_name> <remote_URL>
# List named remote repositories
$ git remote -v

• git clone

  To create a local working copy of an existing remote repository, use git clone to copy and download the repository to a computer. Cloning is the equivalent of git init when working with a remote repository. Git will create a directory locally with all files and repository history.

$ git clone <remote_URL>

• git pull

  To get the latest version of a repository run git pull. This pulls the changes from the remote repository to the local computer.

$ git pull <branch_name> <remote_URL/remote_name>

• git push

  Sends local commits to the remote repository. git push requires two parameters: the remote repository and the branch that the push is for.

$ git push <remote_URL/remote_name> <branch>
# Push all local branches to remote repository
$ git push —all

• git stash

  To save changes made when they’re not in a state to commit them to a repository. This will store the work and give a clean working directory. For instance, when working on a new feature that’s not complete, but an urgent bug needs attention.

# Store current work with untracked files
$ git stash -u
# Bring stashed work back to the working directory
$ git stash pop

• git log

  To show the chronological commit history for a repository. This helps give context and history for a repository. git log is available immediately on a recently cloned repository to see history.

# Show entire git log
$ git log
# Show git log with date pameters
$ git log --<after/before/since/until>=<date>
# Show git log based on commit author
$ git log --<author>="Author Name"

What is GitHub?

GitHub is an important tool for most developers since it enables them to use the benefits of code hosting to access a project centrally. Users can contribute to a project no matter where they are in the world and save their changes independently of one another. In contrast to other service providers that manage open source software, the project doesn’t concentrate on collecting source codes, but the possibility of using individual repositories (directories that are managed with Git). GitHub users can either use Git or Subversion as a VCS (Version Control System) to manage, maintain, and deploy their software projects.

Reasons for using GitHub alternatives:-

1. Steep learning curve: Many commands with many options, some commands are non-intuitive and need a level of understanding the internals of git, commands and arguments are inconsistent to some degree
2. Binary files are a big no: If your project has non-text files that are updated frequently (images for websites or MS Office documents), then git becomes bloated and slow. (I believe it still does better than most systems)
3. Sometimes there are complications between the client and the employer, for example, when a private server is hosting the generated code.
4. Another reason for needing an alternative to GitHub is when you wish to use another VCS that isn’t supported by GitHub.

There are some good GitHub alternatives, five of which are presented below:-

1. GitLab

   GitLab offers many useful features in its DVCS such as an integrated project wiki and a project website. GitLab’s continuous integration capabilities test and deliver your code automatically, which saves time in the test phase. With GitLab, you get easy access to all the important aspects of your project through a code viewer, pull requests, and practical conflict resolution. The application was mainly written in Ruby.

2. SourceForge

   SourceForge actually existed before GitHub and other open source alternatives and used to be the first choice when it came to open source solutions. The company had some problems with malware in 2015, but has been back on track since January 2016. SourceForge now offers multi-factor authorization, which echoes how conscientious the software is when it comes to security. Other features include issue tracking and a built-in code directory.

3. Cloud Source Repositories

   After Google Code flopped, the service merged with Google Cloud platform’s version control. Using Cloud Source Repositories, which is in the beta phase, other repositories can be connected via GitHub or Bitbucket as required. You can also use Google’s own repositories where your files are saved as part of the complete Google infrastructure so you can be sure your code and applications are secure. The best advantage of Cloud Source Repositories: you can search for code directly through the browser and also track bugs through Cloud Diagnostics, while your code runs in the background.

4. GitKraken

   GitKraken puts a lot of emphasis on saving time which benefits the user while testing the code. The system is known for its sizeable interface, its focus on speed, and its simple Git operation. With a practical undo button, any errors can be revised immediately, which simplifies the workload. The free version is available to companies with fewer than 20 employees and non-profit organizations. The pro version offers additional useful features, such as profile support so that various projects can be separated from each other.

5. Apache Allura

   Allura is an open source software from Apache and is used for managing source code repositories, bug reports, discussions, wiki pages, blogs, and other online content. When it comes to issue tracking in Allura, you can use markdown formatting and file attachments as well as issue tickets with so-called milestones. An advanced search syntax is also available, which you can use to store frequent search queries. However, code verification isn’t possible with this system. The platform was developed with Python.