What Is Windows Azure

Microsoft Azure, previously known as Windows Azure, is Microsoft’s public cloud computing platform. It provides a range of cloud services, including those for compute, analytics, storage, and networking. Users can top choice from these services to develop and scale new applications, or run existing applications, in the public cloud.

The Windows Azure platform is deliberated as platform as a service, which is an authoritative component of a cloud computing platform. It consists of various on-demand services hosted in Microsoft’s data centres and is commoditized through three product brands.

The services and apps developed using the Azure platform run on the Windows Azure operating system, which provides a runtime environment for Web applications along with a wide set of services that facilitate the building, hosting, and management of applications without requiring maintenance to expensive onsite resources.

Windows Azure is designed to support both Microsoft and non-Microsoft platforms. The three main components that constitute Windows Azure are:

  • Compute layer
  • Storage layer
  • Fabric layer

Compute Layer: These services provide virtual machines, containers, batch processing, and remote application access.

Storage Layer: This category includes Database as a service offering for SQL and NoSQL, as-well-as unstructured and cached cloud storage.

Fabric Layer: It is a Platform as a Service (PaaS) offering designed to enable the development, deployment, and management of extremely scalable and customizable applications for the Microsoft Azure cloud platform.

The complete list of Azure services is constantly subject to change. The users should view the Microsoft Azure website for recent updates.

Some organizations use Azure for data backup and disaster recovery. In addition to that, some organizations use Azure as a substitute to their own data centre. Rather than capitalizing in local servers and storage, these organizations choose to run some, or all, of their industry applications in Azure.

Windows Azure also includes an automated service management feature that enables the upgrading of applications without affecting their performance. Windows Azure is aimed to support a number of platforms and programming languages. Some of the languages supported are extensible mark-up language (XML), representational state transfer (REST), Ruby, Eclipse, Python, and PHP.

As with other public cloud providers, Azure mainly uses a pay-as-you-go pricing model that charges based on usage. However, a single application may use multiple Azure services, so users should do analysis and manage usage to reduce costs.


What is DC/OS?

DC/OS (the datacenter operating system) is an open-source, distributed operating system based on the Apache Mesos distributed systems kernel. DC/OS manages multiple machines in the cloud or on-premises from a single interface; deploys containers, distributed services, and legacy applications into those machines; and provides networking, service discovery and resource management to keep the services running and communicating with each other.



How to remove old docker containers?

There is a new feature in Docker 1.13.x called Docker container prune: This will do what you want and will work on all platforms the same way.

There is also a Docker system prune, which will clean up containers, images, volumes, and networks all in one command.

Here is an example on how to clean up old containers that are weeks old:
$ docker ps –filter “status=exited” | grep ‘weeks ago’ | awk ‘{print $1}’ | xargs –no-run-if-empty docker rm


What is a git squash merge? How to use it?


This will take all the commits from the bugfix branch, squash them into 1 commit and then merge it with your master branch. … git checkout master git mergefeature1 feature2 feature3 etc. The last merge is an “octopus merge” because it’s merging a lot of branches at once

You can follow the below commands to use Squash:

git checkout master
git merge –squash bugfix
git commit
This will take all the commits from the bugfix branch, squash them into 1 commit and then merge it with your master branch.


How do you clone an object?

var obj = {a: 1 ,b: 2}
var objclone = Object.assign({},obj);
Now the value of objclone is {a: 1 ,b: 2} but points to a different object than obj.
Note the potential pitfall, though: Object.clone() will just do a shallow copy, not a deep copy. This means that nested objects aren’t copied. They still refer to the same nested objects as the original:
let obj = {
a: 1,
b: 2,
c: {
age: 30

var objclone = Object.assign({},obj);
console.log(‘objclone: ‘, objclone);

console.log(‘After Change – obj: ‘, obj); // 45 – This also changes
console.log(‘After Change – objclone: ‘, objclone); // 45


How do you add an element at the begining of an array? How do you add one at the end?

var myArray = [‘a’, ‘b’, ‘c’, ‘d’];
console.log(myArray); // [“start”, “a”, “b”, “c”, “d”, “end”]
With ES6, one can use the spread operator:

myArray = [‘start’, …myArray];
myArray = […myArray, ‘end’];
Or, in short:

myArray = [‘start’, …myArray, ‘end’];


What’s New in TypeScript 2.6

New in TypeScript 2.6

Microsoft’s TypeScript language is an added superset of JavaScript, designed to handle the needs of challenging programs worked on by there teams.

Microsoft’s TypeScript language is an added superset of JavaScript, designed to handle the needs of challenging programs worked on by there teams.


TypeScript 2.7 is due in January 2018 and will feature improved type inference for object literals. The major reason for this upgrade to support both the JSX fragment syntax and properties named with const- declared symbols. An increased builder compiler API is also planned.

At some point perhaps beyond TypeScript 2.7, the language is slated to support project references and provision of specific types of variadic functions.


TypeScript 2.6 is presented as a strict mode flag, which is identified as strictFunctionTypes. In strict mode, any function type that does not originate from a method has its parameters compared as contravariant. TypeScript usually compared as a parameter in a “bivariant” manner, allowing for benefits such as a simpler model for working with arrays. TypeScript 2.6 offers an increasing strictness on all function types except methods.


Traditionally, we have avoided error suppression within TypeScript because in most cases the users asked for it could be solved through more accurate declaration files, or using a type assertion to any.

For the prior one, the benefits are obvious: the developer wants to start moving over to TypeScript, but he/she has to run into a pattern that is particularly difficult to model. The developer might spend time trying to understand it, but maybe he/she would rather get rid of it later on anyway, so to just avoid errors because the code will still run fine.

The latter situation is a bit less clear. The impetus here was that within some large companies, dependencies across projects are updated in tandem, including TypeScript itself and @types declaration files from Definitely Typed. If any change is done the developer gets a type-checking error, someone has to fix that to elude the breaking build. But now a question arises: Who can do this?

The TypeScript 2.6 is bringing // @ts-ignore comments to TypeScript files. These comments suppress any errors that occur on the next line. For instance, in the following code, TypeScript would ordinarily report an error about the console.log statement being unreachable. In TypeScript 2.6, the // @ts-ignore comment flattens the error entirely.

if (false) {

// @ts-ignore: Unreachable code error




There are several minor changes that may impact the codebase.

Write only references are now considered unused under — noUnusedLocals and –noUnusedParameters.

In ambient contexts such as declaration files, and declare module blocks, expressions are now rejected in defaultexports.

Uninhabitable types resulting from intersections will simplify to never when placed in a union.

Various changes have been made to DOM declarations in lib.d.ts.


What’s New in Angular 5

Angular 5

Angular is an all-encompassing JavaScript framework that is recurrently used by the developers all over the world for building web, desktop, and mobile applications. In this article, we will be covering the new features in Angular 5 and several other changes.

The update from AngularJS to Angular 2 was a very big step forward, but it was also ill-famed for not being backward compatible. In contrast, Angular 4 brought new features despite the fact being backward compatible. And now, six months later, the latest major release is available.

The upgrade to Angular 5 is a new increased version. Many of the changes are done in this version are invisible.

The major focus of Angular 5 is to make Angular faster.


Angular 5 now formally supports TypeScript version 2.4. Previous versions of Angular have supported TypeScript 2.3 without errors since release 4.3, including the Strict-Null-Check option.

Below are the some of the key features from the latest TypeScript:

String-based enums are a new feature introduced in TypeScript 2.4. This means that the members of an enum can now be expressed with a string instead of a number. Let’s see an example below.

enum Colors {Red = “RED”, Green = “GREEN”, Blue = “BLUE”,}

Note that in this look, string enums cannot be mapped backward like their number-based relatives. Therefore, a query like Colors [“RED”] is not possible to catch the string “Red”.

Also, the latest version of TypeScript advances type checking with regards to generics.

On the other hand, type checking is becoming stricter and the return types of generic functions can now also be inferred. For instance, the subsequent call leads to an error:

let foo: Promise = new Promise(resolve => {
// Error

Another development is the so-called Weak-Type-Detection. Types are weak if they only own optional parameters which can now be detected. Here is an example of this kind of type:
export interface Options {
showSideNav?: boolean;
description?: string;


Even for advanced web applications, updates in the framework are not enough, the build tooling has to be extended.

This is exactly what happens with Angular-CLI in other areas. The static analysis of the AOT mode is partly done in the normal build. Thus, many errors are noticed earlier at build time and not at runtime.
The AOT mode has also been fast-tracked in order to support incremental builds and significantly reduce built time.

For faster builds, a build tool from Google called Bazel can be integrated. However, it is still in a very initial stage of development at the moment. In the future, the Google Closure Compiler can also be used more rigorously to achieve more optimized build results.


To improve performance, the developer can now specify when validators should be executed in forms.

Every time a FormControl value is changed, the validation will be performed accordingly – potentially with every major element. In the case of more difficult validations, this can lead to an unusual worse performance.

With the new updateOn option, Angular 5 also allows the developer to specify more exactly when this validation should be performed. The developer can select change, which requires the previous behaviour, submit or blur options.


For forms that are defined through a template, the updateOn parameter presented with Angular 5 can also be stated. This is done at ngModelOptions, as shown in the below example:

<input type=”email” ngModel [ngModelOptions]=”{updateOn: ‘submit’}”>

Here the setting is inherited from the element interleaving in the DOM. In the following example, the setting is made directly in the element of the form:

<form [ngFormOptions]=”{updateOn: ‘submit’}”>

<input name=”email” ngModel type=”email”>

<input name=”password” ngModel type=”email”>


A subordinate element can overwrite the default value just as reactive forms.

<form [ngFormOptions]=”{updateOn: ‘submit’}”>

<input name=”email” ngModel type=”email” [ngModelOptions]=”{updateOn: ‘blur’}”>

<input name=”password” ngModel type=”email”>



The Angular Router has been stretched with additional events. Now, for example, the developer can create progress displays that will display when a route is changed. The corresponding events are ActivationStart and ActivationEnd or ChildActivationStart and ChildActivationEnd.


// Event = RouteEvent | RouterEvent

.filter(e => e instanceof RouteEvent)

.subscribe(e => {

if (e instanceof ActivationStart) {


} else if (e instanceof ActivationEnd) {





Angular 5 came with new features and major enhancements. It is smaller and faster. We are very happy with what

the Angular team achieved with this release.

Have you switched to Angular 5 yet? What are your opinions? Did you notice any major enhancements? Try and let us know your opinion on the new upgrade of Angular.


New AWS ECS Kubernetes Release

New AWS ECS Kubernetes Release

There are a lot of AWS customers who run Kubernetes on AWS. In fact, according to the publishes, 63% of Kubernetes workloads run on AWS. While AWS is a popular place to run Kubernetes, there is still a lot of manual configuration that customers need to manage their Kubernetes clusters. The user has to install and operate the Kubernetes master and configure a cluster of Kubernetes workers. In order to achieve high availability in Kubernetes clusters, the user has to run at least three Kubernetes masters across different AZs. Each master needs to be configured, consistently share information, load balance, and fail-over to the other masters if one experiences a failure. Then once the user has all set up, the user still has to deal with upgrades and patches of the masters and workers software. Explore this article and know more about AWS ECS Kubernetes release.


Amazon Elastic Container Service for Kubernetes (Amazon EKS) is a completely managed service that makes it easy for the user to use Kubernetes on AWS without having to be a proficient in managing Kubernetes clusters. There are few points that developers will really like about this service. Firstly, Amazon EKS runs the upstream version of the open-source Kubernetes software, so the user can use all the standing plugins and tooling from the Kubernetes community. The users can easily migrate their Kubernetes applications to Amazon EKS with zero code changes. Secondly, Amazon EKS spontaneously runs K8s with three masters across three AZs to protect against a single point of failure. This multi-AZ architecture provides resiliency against the loss of an AWS Availability Zone.

Thirdly, Amazon EKS also automatically detects and replaces unhealthy masters, and it provides automatic version upgrades and patching for the masters. The Amazon EKS joins with Amazon features like Elastic Load Balancing for load distribution, IAM for authentication, Amazon VPC for isolation, and AWS Cloud Trail for logging.


Amazon EKS integrates IAM authentication with Kubernetes RBAC in association with Heptio. The user can assign RBAC roles to every individual IAM entity allowing the user to control the access authorizations to their Kubernetes masters. This allows the users to easily manage their Kubernetes clusters using Kubernetes tools such as Kubectl.

The user can also use a private link if he/she wants to access their Kubernetes masters directly from their Amazon virtual private cloud. This process lets the users access their Kubernetes masters and Amazon EKS straight from their own Amazon VPC without using public IP address.

Lastly, an open source CNI plugin that anyone can use with their Kubernetes clusters on AWS. This allows the user to natively use Amazon VPC networking with their Kubernetes pods. With Amazon EKS, introducing a Kubernetes cluster is as easy as a few clicks in the AWS Management Console. Amazon EKS handles the rest, the improvements, fixing, and high availability.