What is Docker?

Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications. By taking advantage of Docker’s methodologies for shipping, testing, and deploying code quickly, you can significantly reduce the delay between writing code and running it in production.

What can you use Docker for?

Fast, consistent delivery of your applications

Docker streamlines the development lifecycle by allowing developers to work in standardized environments using local containers which provide your applications and services. Containers are great for continuous integration and continuous delivery (CI/CD) workflows.

Responsive deployment and scaling

Docker’s container-based platform allows for highly portable workloads. Docker containers can run on a developer’s local laptop, on physical or virtual machines in a data center, on cloud providers, or in a mixture of environments.

Docker’s portability and lightweight nature also make it easy to dynamically manage workloads, scaling up or tearing down applications and services as business needs dictate, in near real time.

Running more workloads on the same hardware

Docker is lightweight and fast. It provides a viable, cost-effective alternative to hypervisor-based virtual machines, so you can use more of your compute capacity to achieve your business goals. Docker is perfect for high density environments and for small and medium deployments where you need to do more with fewer resources.

Docker architecture

Docker uses a client-server architecture. The Docker client talks to the Docker daemon, which does the heavy lifting of building, running, and distributing your Docker containers. The Docker client and daemon can run on the same system, or you can connect a Docker client to a remote Docker daemon. The Docker client and daemon communicate using a REST API, over UNIX sockets or a network interface. Another Docker client is Docker Compose, that lets you work with applications consisting of a set of containers.

1. Docker Client: This is how you interact with your containers. Call it the user interface for Docker.
2. Docker Objects: These are your main components of Docker: your containers and images. We mentioned already that containers are the placeholders for your software, and can be read and written to. Container images are read-only, and used to create new containers.
3. Docker Daemon: A background process responsible for receiving commands and passing them to the containers via command line.
4. Docker Registry: Commonly known as Docker Hub, this is where your container images are stored and retrieved.

Docker and security

Docker brings security to applications running in a shared environment, but containers by themselves are not an alternative to taking proper security measures.

Dan Walsh, a computer security leader best known for his work on SELinux, gives his perspective on the importance of making sure Docker container are secure. He also provides a detailed breakdown of security features currently within Docker, and how they function.

Docker objects

When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.

Images

An image is a read-only template with instructions for creating a Docker container. Often, an image is based on another image, with some additional customization. For example, you may build an image which is based on the ubuntu image, but installs the Apache web server and your application, as well as the configuration details needed to make your application run.

You might create your own images or you might only use those created by others and published in a registry. To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it. Each instruction in a Dockerfile creates a layer in the image. When you change the Dockerfile and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.

Containers

A container is a runnable instance of an image. You can create, start, stop, move, or delete a container using the Docker API or CLI. You can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state.

By default, a container is relatively well isolated from other containers and its host machine. You can control how isolated a container’s network, storage, or other underlying subsystems are from other containers or from the host machine.

A container is defined by its image as well as any configuration options you provide to it when you create or start it. When a container is removed, any changes to its state that are not stored in persistent storage disappear.

• Example: docker run” command

The following command runs an ubuntu container, attaches interactively to your local command-line session, and runs /bin/bash.

$ docker run -i -t ubuntu /bin/bash

When you run this command, the following happens (assuming you are using the default registry configuration):

1. If you do not have the ubuntu image locally, Docker pulls it from your configured registry, as though you had run “docker pull ubuntu” manually.
2. Docker creates a new container, as though you had run a “docker container create” command manually.
3. Docker allocates a read-write filesystem to the container, as its final layer. This allows a running container to create or modify files and directories in its local filesystem.
4. Docker creates a network interface to connect the container to the default network, since you did not specify any networking options. This includes assigning an IP address to the container. By default, containers can connect to external networks using the host machine’s network connection.
5. Docker starts the container and executes /bin/bash. Because the container is running interactively and attached to your terminal (due to the -i and -t flags), you can provide input using your keyboard while the output is logged to your terminal.
6. When you type exit to terminate the /bin/bash command, the container stops but is not removed. You can start it again or remove it.

Docker vs. Virtual Machine

Depicted below is a diagrammatic representation of how an application looks when deployed on Docker and virtual machines

Differences between VMs vs Docker:

Advantages of Docker

• Multiple OS support (Debian, Fedora, Windows, RHEL).
• Run applications anywhere without any concern on the tooling and dependencies.
• Security (build with security regulations).
• Support for CI/CD and ideal platform for microservices development.
• Support in multiple cloud providers (ECS).
• Support in multiple container orchestration.

React.js is an open-source JavaScript library that is used for building user interfaces specifically for single-page applications.

React allows developers to create large web applications that can change data, without reloading the page.

The main purpose of React is to be fast, scalable, and simple.

Based On Component

Build encapsulated components that manage their own state, then compose them to make complex UIs.

Since component logic is written in JavaScript instead of templates, you can easily pass rich data through your app and keep state out of the DOM.

If you’ve learned it, you can write it anywhere.

We don’t make assumptions about the rest of your technology stack, so you can develop new features in React without rewriting existing code.

React can also render on the server using Node and power mobile apps using React Native.

A Simple Component

React components implement a render() method that takes input data and returns what to display.

This example uses an XML-like syntax called JSX. Input data that is passed into the component can be accessed by render() via this.props

JSX is optional and not required to use React.

Try the Babel REPL to see the raw JavaScript code produced by the JSX compilation step.

Output:

A Stateful Component

In addition to taking input data (accessed via this.props), a component can maintain internal state data (accessed via this.state).

When a component’s state data changes, the rendered markup will be updated by re-invoking render().

Output:

An Application

Using props and state, we can put together a small Todo application.

This example uses state to track the current list of items as well as the text that the user has entered.

Although event handlers appear to be rendered inline, they will be collected and implemented using event delegation.

Output:

A Component Using External Plugins

React allows you to interface with other libraries and frameworks.

This example uses remarkable, an external Markdown library, to convert the <textarea>’s value in real time.

Output:

Koa.js is an open source Node.js web framework that was designed by the team behind express.

The framework strives to be a smaller, more expressive, and more stable foundation for web applications and APIs, according to their official website.

Koa makes use of asynchronous functions to help eliminate the need for callbacks and significantly improves error handling.

Koa does not bundle middlewares within its core.

It offers a refined set of methods for speeding up the process of making servers and makes it more exciting.

Features of Koa.js

Koa.js has its own unique features that make it more expressive and developer-friendly, much like all other frameworks. Here are a few highlights of features in koa;-

1. Koa.js is modern and future-proof — Unlike other Node.js frameworks, Koa.js is built using ES6, which simplifies the creation of complex applications by providing a bunch of new classes and modules. This helps developers in creating maintainable applications.
2. Koa.js makes use of ES6 generators to make synchronous programming easier and the flow of controls more fluid. These generators can also be used to manage the execution of code on the same stack as functions.
3. In comparison to other Node.js applications, Koa.js has a small footprint. This helps developers write thinner middlewares.
4. Koa.js has a built-in catchall for errors that help prevent website crashes.
5. Koa.js uses a context object which is an encapsulation of request and response objects.

Who uses Koa.js?

For their websites and web APIs, many organizations use the Koa.js framework. The following is a list of five well-known organizations that use the Koa.js framework;-

1. Paralect
2. Pubu
3. Bulb
4. GAPO
5. Clovis

Creating a server using Koa.js framework

Let’s get practical and see how to use this new framework to create a simple server.

Create a new directory for your application first, then use the terminal to navigate to that directory of your app and run:

(To create a Node.js package.)

Run to install Koa.js

After that, use your code editor to navigate to the index file in your app’s directory and write the code below to build the server.

Importing the koa module and calling its listen method is all that is needed to build the server. Run node ‘name of your index file’ on the terminal to launch the server.

Creating routes using Koa.js

Koa.js, unlike its predecessor Express, does not have routing as a default feature. Instead, it uses a middleware library Known as Koa Router. So, in order to implement routes in our api, we must first install the Koa router library running the snippet below.

Then, in your index file, import the Koa router module and add your desired routes. A code example of route formation using Koa.js is given below.

Start the server again and test the route by sending a request from the browser.

Handling Responses in Koa.js

Koa response objects are embedded in its context object, as previously mentioned. This implies that the response object is accessed via the context object. To illustrate how to handle responses, let’s use a route definition like the one above.

Handling errors in Koa.js

Add an error middleware early in your index file to manage errors in Koa. Only errors identified after the middleware can be caught, so it must be defined early.

Let’s put this to the test by modifying the home route method throw an error when the route is called.

Now run the server again and call the endpoint using a browser.

Pros & Cons about Koa

PROS

• Generator support from ground up Using generators (a bleeding edge feature, even for Node.js) would clean up your code from the mess caused by all those callbacks; making your code more manageable.
• Development team has a proven track record
• Koa is developed by the team behind a widely used node.js framework (express.js).
• Extremely lightweight
• Koa is very lightweight with just 550 lines of code.
• sync/await keywords are supported and has transcended beyond generator functions
• Generators functions are of course a huge plus, but at the time Koa team has transcended generations functions and shifted towards async/await style programming. It has made the Koa best framework available in the market.

CONS

• Community is relatively small.
• Not compatible with express style middleware.
• Koa uses generators which are not compatible with any other type of Node.js framework middleware.

Conclusion

So from this article, we learned about Koa.js, including what it is, its functionality, how to use it to build servers and it’s pros and cons. We’ve seen its unique syntax and some of its new features in action by building a simple server. Koa.js is a new Node.js framework that has been implemented by a number of well-known organizations around the world. Koa.js is a good choice for any web developer who wants to try out a new framework.

Node.js was written initially by Ryan Dahl in 2009.

It’s created with the aim of creating real-time websites with push capabilities (websockets).

What is Node.js?

• Node.js is an open source server environment
• Node.js is free
• Node.js runs on various platforms (Windows, Linux, Unix, Mac OS X, etc.)
• Node.js uses JavaScript on the server

Node.js = Runtime Environment + JavaScript Library

Why Node.js?

Opening a file on the server and returning the content to the client is a typical activity for a web server. A file request is handled in PHP or ASP as follows:

• Sends the task to the computer’s file system.
• Waits for the file system to open and read it.
• Returns the content to the client.
• Ready to take on the next task.

A file request is handled in Node.js as follows:

• Sends the task to the computer’s file system.
• Ready to take on the next task.
• The server returns the content to the client after the file system has opened and read the file.
• Node.js skips the waiting and instantly goes on to the next request.

Node.js is a memory-efficient single-threaded, non-blocking, asynchronous programming language.

Features of Node.js

The following are some of the main features that make Node.js the software architect’s first choice.

• Asynchronous and Event Driven
• Very Fast
• Single Threaded but Highly Scalable
• No Buffering
• License

Concepts

Where to use Node.js?

The places where Node.js is proving to be an excellent technology partner are as follows.

• I/O bound Applications
• Data Streaming Applications
• Data Intensive Real-time Applications (DIRT)
• JSON APIs based Applications
• Single Page Applications

Where not to use Node.js?

Node.js is not recommended for CPU-intensive applications.

What is a Node.js Loop?

• Node.js files contain tasks that will be executed on certain events
• A typical event is someone trying to access a port on the server
• Node.js files must be initiated on the server before having any effect
• Node.js files have extension “.js”

The Event Loop in Node.js

The Event loop is what allows Node.js to perform non-blocking I/O operations — despite the fact that JavaScript is single-threaded — by offloading operations to the system kernel whenever possible. Since most modern kernels are multi-threaded, they can handle multiple operations executing in the background.

Phases of the Event Loop

The Event Loop consists of the six stages listed below, which are repeated as long as the application’s code needs to be executed:-

1. Timers — Callbacks scheduled by setTimeout() or setInterval() are executed in this phase.
2. I/O Callbacks — I/O callbacks deferred to the next loop iteration are executed here.
3. Waiting / Preparation — Used internally only.
4. I/O Polling — Retrieves new I/O events.
5. setImmediate() callback — It invokes setIntermediate() callbacks.
6. Close events — It handles some close callbacks

When Node.js starts executing your index.js file, or any other application entry point, the Event Loop begins. These six stages combine to form a tick, which is a cycle or loop.

The Event Loop itself executes some stages, but the main tasks for others are passed to the asynchronous C++ APIs

Advantages of using Node.js

• Open Source
• Java Script language
• Node js is fast
• Asynchronous I/O
• Active community support
• Rest API
• Caching Modules
• Less Problems with Concurrency
• Unit Testing
• Streaming Data

Disadvantages of using Node.js

• Not effective with large scale applications
• Inconsistent
• Not suited for CPU-intensive tasks
• Poorly supported to relational databases

Famous Apps Built on Node.js

What is “Version Control System”?

“Version control systems are a category of software tools that helps in records changes to a file or set of files over time so that you can recall specific versions later.”

Why we use Version Control Systems?

As we all know, a software product is created collaboratively by a community of developers who may be based in various locations and each contributes to a particular collection of functionality/features.

As a result, they changed the source code in order to contribute to the product (either by adding or removing).A version control system is a type of software that helps the developer team in efficiently communicating and managing(tracking) all changes made to the source code, as well as details such as who made the change and what it was. A separate branch is created for every contributor who made the changes and the changes aren’t merged into the original source code unless all are analyzed as soon as the changes are green signalled they merged to the main source code. It not only keeps source code organized but also improves productivity by making the development process smooth.

There are many benefits of using a version control system for our projects.

Benefits of Version Control System;-

• Enhances the project development speed by providing efficient collaboration.
• Version control systems allow you to compare files, identify differences, and merge the changes if needed prior to committing any code.
• Versioning is also a great way to keep track of application builds by being able to identify which version is currently in development, QA, and production
• Helps in recovery in case of any disaster or contingent situation.
• Reduce possibilities of errors and conflicts meanwhile project development through traceability to every small change.
• Leverages the productivity, expedite product delivery, and skills of the employees through better communication and assistance.
• Through improved communication and assistance, increases employee productivity, expedites product delivery, and improves employee skills.

Use of Version Control System;-

• A repository: It can be thought of as a database of changes. It includes all of the project’s edits and historical versions (snapshots).
• Copy of Work (sometimes called as checkout):It’s a personal copy of all the project’s files. You can make changes to this copy without impacting other people’s work, and when you’re done, you can commit your changes to a repository.

There are three different Types of Version Control Systems.

1. Local Version Control Systems.
2. Centralized Version Control Systems.
3. Distributed Version Control Systems.

01. Local Version Control Systems

• It is one of the simplest forms and has a database that kept all the changes to files under revision control.
• RCS is one of the most common VCS tools. It keeps patch sets (differences between files) in a special format on disk.
• By adding up all the patches it can then re-create what any file looked like at any point in time.

02. Centralized Version Control Systems

• All changes to the files are tracked in this system by a centralized server.
• The centralized server holds all versioned file information as well as a list of clients who check out data from that central location.

Example: Tortoise SVN

03. Distributed Version Control Systems

• The clients completely clone the repository including its full history.
• If any server dies, any of the client repositories can be copied on to the server which help restore the server.
• Every clone is considered as a full backup of all the data.

Example: Git, Mercurial

Popular Jargons Related To Version Control System:

1. Repository

• Central location where all the files are being kept. Usually a directory with set of files.

2. Trunk

• Also referred to as master branch. This is where the most stable code is being placed which is referred as the production code.

3. Stage

• Mark files for tracking changes.

4. Commit

• Create a snapshot of the changes being made to the files.

5. Branch

• Copy of the master branch taken at a given point. All the feature developments and bug fixes will be done in a branch. Usually it is allowed to have multiple branches at the same time.

6. Checkout

• Mark/unlock file for changing.

7. Merge

• Combining branches together to update the master branch.

8. Merge conflict

• Merge conflicts occur when merging a file which has been changed in two separate branches or places. Changes that interfere other changes.

What is “Git”?

“Git is the most commonly used version control system. Git tracks the changes you make to files, so you have a record of what has been done, and you can revert to specific versions should you ever need to. Git also makes collaboration easier, allowing changes by multiple people to all be merged into one source.”

So regardless of whether you write code that only you will see, or work as part of a team, Git will be useful for you

Advantages:

• Branching capabilities and merging are easy.(as they are cheap)
• Good data integrity.
• Free and open-source.
• Add ons can be written in many languages.
• Good and faster network performance.
• Superior disk utilization.
• Object model is very simple.
• Minimizes push/pull data transfers.

Disadvantages:

• Requires technical excellence.
• Slower on windows.
• It lacks window support and doesn’t track empty folders.
• GIT doesn’t support checking out sub-trees.
• The process of Packing is very expensive completely.
• Do not provide access control mechanisms.
• Doesn’t support binary files.

Git Commands:

• Git init
• Git clone
• Git add
• Git stage
• Git commit
• Git push
• Git pull

Software developers should have a rudimental understanding of what VCS is and which type of VCS suits them. The adoption of a VCS is a must in software development. It helps software developers manage their codes easily because it is common to have a lot of changes involving addition or deletion of features.

In order to adopt a VCS, a software developer must know and perfectly understand which approach should be used as it will affect the whole project and team. It is also important for them to have the knowledge of different approaches of VCS because the various approaches will affect their software development process differently.

SOLID Principles is a coding standard that should provide a simple definition for all developers to properly build software to prevent bad design.

It was promoted by Robert C Martin and it is used throughout the continuum of object-oriented design. It makes the code more extensible, logical, and easier to read when implemented correctly.

How do we recognize rot as a potential code? Possibly, these signs suggest code rot to come:

• Rigidity — small changes causes the entire system to rebuild.
• Fragility — changes to one module causes other unrelated modules to misbehave. Imagine a car system in which changing the radio station affects windows.
• Immobility — a module’s internal components cannot be extracted and reused in new environments.

The SOLID principles of Object Oriented Design include these five principles:

01. Single Responsibility Principle(SRP)

“A class should have only one reason to change, and a class should have only one responsibility.”

Let’s look at this specific class. This class represent a simple book.

In here, we store name, author and text associated with an instance of a Book. Let’s add some methods for querying the text now,

Imagine a scenario where we need to get output of the book details and add a print details methods in to a similar class. Isn’t it violate the principle of having single responsibility? indeed it violate. So what is the most ideal approach to get the output.

We should implement a different class that is concerned uniquely with printing details as demonstrated beneath.

02. Open-Closed Principle(OCP)

“Objects or entities should be open for extension, but closed for modification”

Let’s further explore the idea with an example of a fast code. Assume that you have implement a guitar class as shown below.

It works well and it’s loved by users. But you may think this needs to be updated after a few months to be even more appealing by adding a new pattern. It can cause errors that we didn’t expect if you just apply the new pattern to the same application. So the best method is to use our principle of open-closed and simply extend the guitar class.

We can then be confident that nothing is going to happen to our current class.

03. Liskov Substitution Principle(LSP)

“Every subclass/derived class should be able to substitute their parent/base class”

The most complex of the 5 principles is Liskov substitution. Simply put, if class A is a subtype of class B, then without disrupting our program’s actions, we should be able to substitute B with A.

So that is simply, Derived classes must be substitutable to their base classes.

Above, we define a simple Car interface with a couple of methods that all cars should be able to fulfill — turning on the engine, and accelerating forward.

Now let’s implement our interface for a motorcar and provide some code for the methods:

We are now having electrical vehicles also. We should perceive what will happen while implementing that.

We are inherently altering the behavior of our software by throwing a car without an engine into the mix. This violates the Liskov Substitution principle and is a little more difficult to fix than our previous 2 principles.

One potential solution would be to rework our model into interfaces that take the engine-less condition of our car into account.

04. Interface Segregation Principle(ISP)

“Clients should not be forced to implement methods they do not use”

Let’s begin with an interface that outlines our roles as a bear keeper,

As we know, petting bears is even more risky. We have no option here, according to the code, instead of integrating all three methods in the same implementation.

Let’s fix this by splitting our large interface into 3 separate ones,

We can now introduce strategies that matter to us without any hesitation, thanks to interface segregation.

And then, we should leave the risky stuff to the crazy people,

05. Dependency Inversion Principle(DIP)

“Higher level modules should not depend on lower level modules, but they should depend on abstractions.

Abstractions should not depend on details. Details should depend upon abstraction.”

Let’s understand the Dependency Inversion principle through an example,

It is worth, if we have not keyboard and mouse to work on Windows. To solve this problem, we create a constructor of the class and add the instances of the keyboard and monitor. After adding the instances, the class looks like the following,

Now we can work on the Windows machine with the help of a keyboard and mouse. But we still face the problem. Because we have tightly coupled the three classes together by using the new keyword. It is hard o test the class windows machine.

To make the code loosely coupled, we decouple the Windows98Machine from the keyboard by using the Keyboard interface and this keyword.

In the above code, we have used the dependency injection to add the keyboard dependency in the Windows98Machine class. Therefore, we have decoupled the classes.

Why should we use SOLID principles?

• It reduces the dependencies so that a block of code can be changed without affecting the other code blocks.
• The principles intended to make design easier, understandable.
• By using the principles, the system is maintainable, testable, scalable, and reusable.
• It avoids the bad design of the software.

“Next time when you design software, keeps these five principles in mind. By applying these principles, the code will be much more clear, testable, and expendable.”