DEV Community: Pranam K

Best Books for Algorithms and Data Structures in Programming

Pranam K — Sat, 09 Jul 2022 15:05:37 +0000

Best Books for Algorithms and Data Structures in programming:

1) Cracking The Coding Interview: 189 Programming Questions and Solutions - 6th Edition - Gayle Laakmann McDowell

2) Algorithms in A Nutshell: : A Practical Guide, Second Edition - George Heineman, Gary Pollice, Stanley Selkow

3) Thomas H. Cormen - Algorithms Unlocked (The MIT Press)

4) Adnan Aziz and Amit Prakash - Algorithms For Interviews: A Problem Solving Approach

5) Narasimha Karumanchi - Data Structures And Algorithms Made Easy: Data Structures And Algorithmic Puzzles

6) Introduction To Algorithms 3rd Edition - Thomas H Cormen, Charles E Leiserson, Ronald L Rivest, Clifford Stein

7) Dynamic Programming for Coding Interviews - Meenakshi and Kamal Rawat

8) Data Structures and Algorithms. Aho, Ullman & Hopcroft

9) Algorithms by Robert Sedgewick & Kevin Wayne

10) Algorithm Design by Kleinberg & Tardos

11) The Design and Analysis of Algorithms - Anany Levitin

12) The Programming Pearls (2nd Edition) by Jon Bentley

13) The Algorithm Design Manual by Steve S. Skiena

14) Beautiful Code: Leading Programmers Explain How They Think (Theory in Practice (O'Reilly))

15) Elements of Programming Interviews: The Insiders' Guide 2nd Edition by Adnan Aziz, Tsung-Hsien Lee, Amit Prakash

How to START, RESTART, STOP and DELETE multiple Azure VM's?

Pranam K — Fri, 01 Jul 2022 06:32:18 +0000

When we have Virtual Machines in Azure (opens new window), we have to stop, start and restart them. We can easily do this for one VM, in the overview blade of the VM in the Azure portal.

But how do we stop or restart multiple VMs at once?

We can do it in the Azure portal!

In this article, we will use the Azure portal to perform basic VM management tasks on multiple Azure VMs.

Prerequisites:

An Azure subscription (If you don't have an Azure subscription, create a free account (opens new window)before you begin)
Two or more existing Azure Virtual Machines (opens new window).

Use the Azure portal to control Azure VMs

We will use the Azure portal to stop, restart and delete multiple VMs at the same time in this article.

Go to the Azure portal (opens new window)

Click on the menu in the top-left and select "Virtual machines". This shows you all your Azure Virtual Machine's.
In the menu, you can see buttons for Start, Restart and Stop. If you don't see those buttons, you can reach them by opening the menu from the ... button.

(Options menu in the Virtual machines blade)

Select two Virtual Machines
Click the Restart button
Confirm the restart operation. This will restart the selected VMs, which can take a few minutes.

(Restart multiple Virtual Machines)

Select two VMs
Open the menu and click on Delete. This opens the Delete Resources blade.
Type "yes" to confirm the deletion and click Delete.

(Delete multiple Virtual Machines)

Conclusion:

We can use the Virtual Machine's blade in the Azure portal to Start, Stop, Restart and Delete multiple Azure Virtual Machine's (opens new window) at the same time.

How Azure Works?

Pranam K — Fri, 01 Jul 2022 06:11:07 +0000

Azure is Microsoft's public cloud platform. Azure offers a large collection of services, which includes platform as a service (PaaS), infrastructure as a service (IaaS), and managed database service capabilities. However, what exactly is Azure, and how does it work?

Azure, like other cloud platforms, relies on a technology known as virtualization. Most computer hardware can be emulated in software. Computer hardware is simply a set of instructions, which are permanently, or semi-permanently, encoded in silicon. Emulation layers are used to map software instructions to hardware instructions. Emulation layers allow virtualized hardware to execute in software like the actual hardware itself.

Essentially, the cloud is a set of physical servers in one or more datacenters. The datacenters execute virtualized hardware for customers. So how does the cloud create, start, stop, and delete millions of instances of virtualized hardware for millions of customers simultaneously?

To understand the servers, let's look at the architecture of hardware in the datacenter. Inside each datacenter, there's a collection of servers sitting in server racks. Each server rack contains many server blades, and a network switch. These provide network connectivity and a power distribution unit (PDU), which creates power. Racks are sometimes grouped together in larger units known as clusters.

The server racks, or clusters, are chosen to run virtualized hardware instances for the user. However, some servers run cloud management software, known as a fabric controller. The fabric controller is a distributed application with many responsibilities. It allocates services, monitors the health of the server and the services running on it, and heals servers when they fail.

Each instance of the fabric controller is connected to another set of servers running cloud orchestration software, typically known as the front end. The front end hosts the web services, RESTful APIs, and internal Azure databases, which are used for all functions in the cloud.

For example, the front end hosts the services that handle customer requests. The requests allocate Azure resources and services such as virtual machines, and Azure Cosmos DB. First, the front end validates and verifies if the user is authorized to allocate the requested resources. If so, the front end checks a database to locate a server rack with sufficient capacity, which instructs the fabric controller to allocate the resource.

Azure is a huge collection of servers and networking hardware, which runs a complex set of distributed applications. These applications orchestrate the configuration and operation of virtualized hardware and software on those servers. The orchestration of these servers is what makes Azure so powerful. With Azure, users don't have to maintain and upgrade their hardware as Azure does this behind the scenes.

Angular 14 is here!

Pranam K — Fri, 03 Jun 2022 05:12:06 +0000

Angular v14 is released today! Angular Team has completed 2 major requests for comments (RFC):

Angular v14 is released today! Angular Team has completed 2 major requests for comments (RFC):

Strictly Typed Reactive Forms RFC closed #1 GitHub issue.
Standalone APIs RFC introduced a simpler way to author Angular apps.

Angular team renamed the default branch in their repositories in the Angular organization to main.

Main Feature's:

✅ Standalone components

✅ Page Title resolver

✅ Route providers

✅ Environment initializer

✅ Typed Reactive Forms

✅ CLI Autocomplete

1) Standalone components:

Angular standalone components aim to streamline the authoring of Angular applications by reducing the need for NgModules. In v14, standalone components are in developer preview. They are ready to be used in your applications for exploration and development, but are not a stable API and will potentially change outside our typical model of backwards compatibility.

With standalone components, directives and pipes, the standalone: true flag allows you to add imports directly in your @Component() without an @NgModule().

Explore a new Stackblitz demo app to learn more about how to build an Angular app using standalone components.

In developer preview, we want to utilize open source to ensure standalone is fully prepared to be released as a stable API. Add your first standalone component with ng generate component --standalone, then head to GitHub repository to provide feedback as you begin to explore.

In the coming months, we will continue to build out schematics (such as ng new --standalone), as well as documenting the use cases and learning journey for this new, streamlined mental model. Please keep in mind that in developer preview, changes may occur as we continue to implement our designs.

2) Typed Angular Forms

Angular v14 closes Angular’s top GitHub issue: implementing strict typing for the Angular Reactive Forms package.

Typed forms ensure that the values inside of form controls, groups, and arrays are type safe across the entire API surface. This enables safer forms, especially for deeply nested complex cases.

This feature is the result of a public request for comments and design review, which was built upon the prior prototyping, work, and testing of Angular community contributors

Update schematics allows for incremental migration to typed forms, so you can gradually add typing to your existing forms with full backwards compatibility. ng update will replace all form classes with untyped versions (for example, FormGroup -> UntypedFormGroup). You can then enable types at your own pace (for example, UntypedFormGroup -> FormGroup).

In order to take advantage of new typing support, try searching for instances of the Untyped forms controls and migrating to the new typed forms API surface where possible.

3) Streamlined best practices

Angular v14 brings built-in features that enable developers to build high quality apps, from routing to your code editor, starting with new change detection guides on angular.io.

4) Streamlined page title accessibility

Another best practice is ensuring that your app’s page titles uniquely communicate the page’s contents. v13.2 streamlines this with the new Route.title property in the Angular Router. Adding a title now requires no additional imports and is strongly typed. We can configure more complex title logic by providing a custom TitleStrategy.

5) Extended developer diagnostics

New extended diagnostics provide an extendable framework that gives you more insight into your templates and how you might be able to improve them. Diagnostics give compile-time warnings with precise, actionable suggestions for your templates, catching bugs before run-time.

The flexible framework this introduces for developers to add diagnostics in the future.

6) Catch the invalid “Banana in a box” error on your two-way data bindings

A common developer syntax error is to flip the brackets and parentheses in two-way binding, writing ([]) instead of [()]. Since () sorta looks like a banana and [] sorta looks like a box, we nicknamed this the “banana in a box” error, since the banana should go in the box.

While this error is technically valid syntax, our CLI can recognize that this is rarely what developers intend. In the v13.2 release we introduced detailed messaging on this mistake and guidance on how to solve this, all within the CLI and your code editor.

7) Catch nullish coalescing on non-nullable values

Extended diagnostics also raise errors for useless nullish coalescing operators (??) in Angular templates. Specifically, this error is raised when the input is not “nullable”, meaning its type does not include null or undefined.

Extended diagnostics show as warnings during ng build, ng serve, and in real-time with the Angular Language Service. The diagnostics are configurable in tsconfig.json, where you can specify if diagnostics should be a warning, error, or suppress.

8) Tree-shakeable error messages

As we continue our Angular Debugging Guides, a community contribution by Ramesh Thiruchelvam adds new runtime error codes. Robust error codes make it easier to reference and find info on how to debug your errors.

This allows the build optimizer to tree-shake error messages (long strings) from production bundles, while retaining error codes.

To debug a production error, go to Angular reference guides and reproducing the error in a development environment, in order to view the full string.

9) More built-in improvements

Angular v14 includes support for the latest TypeScript 4.7 release and now targets ES2020 by default, which allows the CLI to ship smaller code without downleveling.

10) Bind to protected component members

In v14, you can now bind to protected component members directly from your templates.

@Component(
  selector: 'my-component',
  template: '{{ message }}',  // Now compiles!
})
export class MyComponent {
  protected message: string = 'Hello world';
}

This gives you more control over the public API surface of your reusable components.

11) Optional injectors in Embedded Views

v14 adds support for passing in an optional injector when creating an embedded view through ViewContainerRef.createEmbeddedView and TemplateRef.createEmbeddedView. The injector allows for the dependency injection behavior to be customized within the specific template.

This enables cleaner APIs for authoring reusable components and for component primitives in Angular CDK.

viewContainer.createEmbeddedView(templateRef, context, 
      injector: injector,
})

12) NgModel OnPush

NgModel changes are reflected in the UI for OnPush components.

@Component(
      selector: 'my-component',
      template: `
        <child [ngModel]="value"></child>
      `,
      changeDetection: ChangeDetectionStrategy.OnPush
    })

class MyComponent {}

13) Built-in primitives and tooling

CDK and tooling improvements supply the building blocks for a stronger development environment, from CDK menu primitives to CLI auto-completion.

14) New primitives in the Angular CDK

Angular’s Component Dev Kit provides a whole suite of tools for building Angular components. In v14, we’re promoting the CDK Menu and Dialog to stable!

This release includes new CDK primitives that can be used to create more accessible custom components based on the WAI-ARIA menu and menubar design patterns.

15) hasHarness and getHarnessOrNull in Component Test Harnesses

v14 includes new methods for HarnessLoader to check if a harness is present, and to return the harness instance if present. Component Test Harnesses continue to provide a flexible way to write better tests for your components.

const loader = TestbedHarnessEnvironmen
        .loader(fixture);


    const hasButton = await loader
        .hasHarness(MatButtonHarness)


    const buttonHarnessOrNull = await loader
        .getHarnessOrNull(MatButtonHarness);

16) Angular CLI enhancements

Standardized CLI argument parsing means more consistency across the entire Angular CLI, and now every flag uses --lower-skewer-case format. Angular team has removed deprecated camel case arguments support and added support for combined aliases usage.

Run ng --help for cleaner output that explains your options.

17) ng completion

Accidentally typing ng sevre instead of ng serve happens all the time. Typos are one of the most common reasons a command line prompt throws an error. To solve this, v14’s new ng completion introduces real-time type-ahead autocompletion!

To ensure all Angular developers know about this, the CLI will prompt you to opt-in to autocomplete during your first command execution in v14. You can also manually run:

ng completion

and the CLI will automatically set this up for you.

18) ng analytics

The CLI’s analytics command allows you to control analytics settings and print analytics information. More detailed output clearly communicates your analytics configurations, and provides our team with telemetry data to inform our project prioritization. It sincerely helps a lot when you turn it on!

19) ng cache

ng cache provides a way to control and print cache information from the command line. We can enable, disable, or delete from disk, and print statistics and information.

20) Angular DevTools is available offline and in Firefox

The Angular DevTools debugging extension now supports offline use. For Firefox users, find the extension in the Add-ons for Mozilla.

21) Experimental ESM Application Builds

Finally, v14 introduces an experimental esbuild-based build system for ng build, which compiles pure ESM output.

To try this out in your app, update the browser builder in your angular.json:

"builder": "@angular-devkit/build-angular:browser"

"builder": "@angular-devkit/build-angular:browser-esbuild"

Reference:

https://angular.io/guide/roadmap

https://update.angular.io/?v=13.0-14.0

Say No to NgModule in Angular 14!

Pranam K — Sat, 28 May 2022 16:19:57 +0000

NgModules consolidate components, directives, and pipes into cohesive blocks of functionality, each focused on a feature area, application business domain, workflow, or common collection of utilities.

An NgModule is a class marked by the @NgModule decorator. @NgModule takes a metadata object that describes how to compile a component's template and how to create an injector at runtime. It identifies the module's own components, directives, and pipes, making some of them public, through the exports property, so that external components can use them. @NgModule can also add service providers to the application dependency injectors.

Angular 14 is going to introduce an alternative way to write applications — Standalone components, directives, and pipes.

The term “standalone” refers to components, directives, or pipes that can be used independently of NgModule. Although you’ll still need to use the core and external NgModules, you probably won’t need to create new ones.

Let’s create an application without NgModules. First, we need to generate it using the angular-cli:

npx @angular/cli@next new ng14

The next step is to delete app.module.ts and replace the bootstrapModule() function in main.ts with bootstrapApplication():

import { enableProdMode } from '@angular/core';
import { bootstrapApplication } from '@angular/platform-browser';
import { AppComponent } from './app/app.component';
import { environment } from './environments/environment';

if (environment.production) {
  enableProdMode();
}

bootstrapApplication(AppComponent)

The bootstrapApplication() can take a list of providers that should be available to the root component and all its children:

import { importProvidersFrom } from '@angular/core';
import { bootstrapApplication } from '@angular/platform-browser';
import { AppComponent } from './app/app.component';
import { HttpClientModule } from '@angular/common/http'

bootstrapApplication(AppComponent, {
  providers: [importProvidersFrom(HttpClientModule)]
}).catch(err => console.error(err));

The function extracts the providers from the provided module.

Now we need to change the AppComponent to be a standalone component. Let's set the standalone property to true:

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  standalone: true,
  styleUrls: ['./app.component.scss']
})
export class AppComponent {}

Now we can see the AppComponent’s template in our browser. As our component is standalone, we can use the new imports property. The imports property specifies the template dependencies of the component — those directives, components, and pipes it can use.

Standalone components can import other standalone components, directives, pipes, and existing NgModules. For example, we can create a standalone directive, and use it in our component:

npx ng g directive foo --standalone

import { Directive } from '@angular/core';

@Directive({
  selector: '[appFoo]',
  standalone: true
})
export class FooDirective {}

import { CommonModule } from '@angular/common';
import { FooDirective } from './foo.directive';

@Component({
  selector: 'app-root',
  template: `
     <div appFoo *ngIf="bar">Foo</div>
  `,
  standalone: true,
  imports: [FooDirective, CommonModule]
})
export class AppComponent {}

Let us add routing to the application.

const routes: Routes = [{
  path: 'todos',
  component: TodosPageComponent
}]

@Component({
  selector: 'app-root',
  template: `
     <a routerLink="/todos">Todos</a>
     <router-outlet></router-outlet>
  `,
  standalone: true,
  imports: [RouterModule.forRoot(routes)],
  styleUrls: ['./app.component.scss']
})
export class AppComponent {}

This isn’t possible because Angular doesn’t allow us to use ModuleWithProvider in a standalone component. Next, we might try using the new importProvidersFrom function in the component’s providers:

const routes: Routes = [{
  path: 'todos',
  component: TodosPageComponent
}]

@Component({
  selector: 'app-root',
  template: `
     <a routerLink="/todos">Todos</a>
     <router-outlet></router-outlet>
  `,
  standalone: true,
  providers: importProvidersFrom(RouterModule.forRoot(routes)),
  imports: [FooDirective, CommonModule],
  styleUrls: ['./app.component.scss']
})
export class AppComponent {}

Using in-app navigation will work. The router will miss the first navigation. Initialization of the router should be performed in the bootstrap process:

bootstrapApplication(AppComponent, {
  providers: [importProvidersFrom(RouterModule.forRoot(routes))]
}).catch(err => console.error(err));

The TodosPageComponent is eagerly loaded. Let’s change it to load lazily and add a TodoPageComponent:

import { Routes } from '@angular/router';

export const todosRoutes: Routes = [
  {
    path: 'todos',
    title: 'Todos Page',
    children: [
      {
        path: '',
        loadComponent: () =>
          import('./todos-page.component').then((m) => m.TodosPageComponent),
        children: [
          {
            path: ':id',
            loadComponent: () =>
              import('./todo-page/todo-page.component').then(
                (m) => m.TodoPageComponent
              ),
          },
        ],
      },
    ],
  },
];

Instead of using loadChildren and passing a NgModule, we use the loadComponent property and pass a component. We can also declare providers for this Route and its children using the new providers property:

import { Routes } from '@angular/router';

export const todosRoutes: Routes = [
  {
    path: 'todos',
    title: 'Todos Page',
    providers: [
      {
        provide: 'Angular',
        useValue: 'v14',
      },
    ],
    children: [
      {
        path: '',
        loadComponent: () =>
          import('./todos-page.component').then((m) => m.TodosPageComponent),
        children: [
          {
            path: ':id',
            loadComponent: () =>
              import('./todo-page/todo-page.component').then(
                (m) => m.TodoPageComponent
              ),
          },
        ],
      },
    ],
  },
];

We can also pass an array of routes to loadChildren:

export const ROUTES: Route[] = [
  { path: 'child', component: ChildCmp},
]

{
  path: 'parent',
  loadChildren: () => import('./children').then(m => m.ROUTES),
}

Conclusion:

In coming days, Angular team may come up with Angular 14 update and new feature's. Stay tuned!

Create a CI/CD pipeline in Microsoft Azure DevOps for the .NET project

Pranam K — Sun, 15 May 2022 17:49:45 +0000

Pre-requisites:

Microsoft Azure Account: If you do not have an active account, sign-up here: Sign-up
Visual Studio Dev Essentials: If you do not have Visual Studio subscription, check this out: Visual Studio

Let's get started.

What is DevOps Starter?

DevOps Starter makes it easy to get started on Azure using either GitHub actions or Azure DevOps. It helps you launch your favorite app on the Azure service of your choice in just a few quick steps from the Azure portal.

DevOps Starter sets up everything you need for developing, deploying, and monitoring your application. You can use the DevOps Starter dashboard to monitor code commits, builds, and deployments, all from a single view in the Azure portal.

What are the advantages of DevOps Starter?

DevOps starter the following supports 2 CI/CD providers, to automate your deployments:

1) GitHub Actions
2) Azure DevOps

DevOps Starter automates the setup of an entire continuous integration (CI) and continuous delivery (CD) for your application to Azure. You can start with existing code or use one of the provided sample applications. Then you can quickly deploy that application to various Azure services such as Virtual Machines, App Service, Azure Kubernetes Services (AKS), Azure SQL Database, and Azure Service Fabric.

DevOps Starter does all the work for the initial configuration of a DevOps pipeline including everything from setting up the initial Git repository, configuring the CI/CD pipeline, creating an Application Insights resource for monitoring, and providing a single view of the entire solution with the creation of a DevOps Starter dashboard in the Azure portal.

Key benefits of using DevOps Starter:

Quickly deploy your application to Azure.
Automate the setup of a CI/CD workflow or pipeline.
View and understand how to properly set up a CI/CD workflow or pipeline.
Further customize the release pipelines based on your specific scenarios.

What is CI/CD pipeline and what is the purpose of CI/CD pipeline?

A CI/CD pipeline automates your software delivery process. The pipeline builds code, runs tests (CI), and safely deploys a new version of the application (CD). Automated pipelines remove manual errors, provide standardized feedback loops to developers, and enable fast product iterations.

Step 1:

Set up a sample ASP.NET project using DevOps Starter project

Sign into the Microsoft Azure portal: https://portal.azure.com/
In the search box, type DevOps and select DevOps Starter. Then click on Create DevOps Starter.

By default, DevOps Starter project setup with GitHub. Click on change settings to change the destination to Azure DevOps and click Done.

Select the .NET sample application and click Next.

The .NET samples include a choice of either the open source ASP.NET framework or the cross-platform .NET Core framework. Select the .NET Core application framework. This is an ASP.NET Core MVC application. Enable Add a database toggle to add the database to the application. When you’re done, choose Next.

Web App on Windows is the default deployment target. We can optionally choose Virtual Machine. Click Next.

Select your Azure DevOps organization and choose a name for your project and Web app. Click Review + Create.

Click on Additional Settings if you would like to edit web app and database parameters.

Click Go to resource.

We can now work on ASP.NET Core app with a CI/CD process that automatically deploys our latest work to our web site. On the right side of the dashboard, select Browse to view our running application.

Step 2:

Let's check and validate CI/CD pipelines configuration for the Azure DevOps project.

Select Build Pipelines from the top of the Azure DevOps project dashboard. This link opens a browser tab and the Azure DevOps build pipeline.

Click on Edit.

This build pipeline performs various tasks such as fetching sources from the Git repository, restoring dependencies, compile the application, run tests and publishing outputs used for deployments.

Go to pipeline name, select History. We can see an audit trail of our recent changes for the build. Azure DevOps keeps track of any changes made to the build definition and allows us to compare versions.
Select Triggers. The Azure DevOps project automatically created a CI trigger and every commit to the repository initiates a new build.

Click Releases under Pipelines section.

Now select the release pipeline. Click Edit.

Under Artifacts, select Drop.

To the right-hand side of the Drop icon, select the Continuous deployment trigger. This release pipeline has an enabled CD trigger, which executes a deployment every time there is a new build artifact available. Disable this trigger, when our deployments require manual execution.

Select Tasks. The tasks are the activities your deployment process performs.

On the right-hand side of the browser, select View releases.

Now click on the release number.

Click Logs. The logs contain information about the deployment process.

Step 3:

Write code. Commit & Push the code changes and execute CI/CD.

Click on Repos to view the created Git repository by Azure DevOps project.

To view the repository, first clone URL by selecting Clone from the top right of the browser.

Go to left-hand side of the browser, navigate to the Application/aspnet-core-dotnet-core/Pages/Index.cshtml file. Select Edit, and make a change.

Make some changes and commit the code.
Go to Pipelines. Notice, build is in progress. The changes are automatically built and deployed via Azure DevOps CI/CD pipelines.

Once the Build and Release are completed in your browser, navigate to the Azure DevOps project dashboard. On the right side of the dashboard, select Browse to view your updated running application.

Conclusion:

In this blog we have learned how we can set up a CI/CD pipeline for the sample .NET project in Microsoft Azure DevOps with step by step guide. Hope it helps someone out there. Thank you.

How to set LinkedIn on Dark Mode?

Pranam K — Fri, 14 Jan 2022 04:16:41 +0000

LinkedIn recently introduced Dark Mode for Mobile as well as Web. They faced a lot of problems and they have rolled back. Again, this time LinkedIn has introduced Dark Mode feature. Those who like this feature, make use of it.

How to set LinkedIn on Dark Mode? 🤔

Click on the Profile Picture -> Settings -> Account preferences -> Display -> Dark mode -> Dark mode

Conclusion:

Dark Mode feature is totally up to user's who like to use.

What really happened with Aaron Swartz?

Pranam K — Mon, 10 Jan 2022 06:06:38 +0000

Introduction:

Many of the programmer's spend their valuable time on the open source community and platforms. Their work needs to be valuated and should give them the credits when it comes to copying/downloading their contents.

Now, let us see what is OSS?

Open Source Software (OSS) is a product or in general, computer software that is released under a license (example: MIT) in which the copyright holder grants users the rights to use, study, change, and distribute the software and its source code to anyone and for any purpose.

What are the Open Source communities?

Open Source is a platform where developer's code and maintain their repositories in a decentralized and collaborative manner. It also contains peer-review system, maintain packages, build, deployment, etc.

Examples: GitHub, GitLab, Git, Bitbucket, Heroku, AWS, Azure DevOps, Stack Overflow, etc.

Story:

Marak is a well-known coder/developer over GitHub. He was good at his work all the time. He maintained a lot of code repo's and worked on lot of projects over GitHub. #oss and #opensource are the 2 big term's until and unless they get valued. Often OSS developer's make the world keep the lights on but aren't compensated for their time :)

Marak created & maintained a repository which is used by Fortune 500 companies. Which has 2,424,317 Weekly Downloads and 2,571 Dependents.

Marak was struggling, asked help. Got nothing in return. In protest, he updated the README.md file with the famous quote "What really happened with Aaron Swartz?" and he removed his code (faker.js) from his repository. In the mean-time, GitHub suspended his account for removing something he owned the rights to.

Now the question comes here is:

1) On what basis GitHub removed his account? He wrote the first line of code and he will write the last line as well. He has the right to maintain his code and repositories. On what terms and condition's GitHub has the right to remove his account from the community?

2) When a developer writes the code why can't he get's valued when million's of people download his code and take the credits?

Conclusion:

GitHub is just an open source platform to share and maintain code repositories. However, it is not the only choice for a developer!

Reference:

https://lnkd.in/gtW28Hhg

https://lnkd.in/g2F_zMtk

https://lnkd.in/gRseV7gh

https://lnkd.in/g7rC6e6G

https://lnkd.in/gvshgVkh

https://lnkd.in/gPzDDwr5

https://lnkd.in/gTQHD9DA

List of Algorithms in Computer Programming

Pranam K — Mon, 06 Dec 2021 09:24:57 +0000

Introduction:

In this article, we will see all the available algorithms in computer programming. This will be helpful to develop and build great products and thus will improve efficiency and quality.

Description:

I have listed out all the algorithms at one place. Few of them are most familiar one’s and the rest all of them are not used by us on a regular basis. However, these concepts/data structures/algorithms are really helpful when deciding the complexity of the architecture or problem. If all of us make use of these algorithms at right place, we can build and deliver top-notch products to the market.

Searching:
1) Binary Search
2) Linear Search
3) Depth First Search
4) Breadth First Search
5) Rabin-Karp Algorithm
6) Z Algorithm

Sorting:
1) Insertion Sort
2) Heap Sort
3) Selection Sort
4) Merge Sort
5) Quick Sort
6) Counting Sort
7) Bucket Sort
8) Bubble Sort
9) Radix Sort
10) Shell Sort
11) Comb Sort
12) Pigeonhole Sort
13) Cycle Sort

Graphs:
1) Kruskal’s Algorithm
2) Dijkstra’s Algorithm
3) Bellman Ford Algorithm
4) Floyd Warshall Algorithm
5) Topological Sort Algorithm
6) Flood Fill Algorithm
7) Lee Algorithm
8) Prim’s Algorithm
9) Boruvka’s Algorithm
10) Johnson’s Algorithm
11) Kosaraju’s Algorithm
12) Tarjan’s Algorithm

Arrays:
1) Kadane’s Algorithm
2) Floyd’s Cycle Detection Algorithm
3) Knuth-Morris-Pratt Algorithm (KMP)
4) Quick Select Algorithm
5) Boyer — More Majority Vote Algorithm

Tree:
1) AA Tree
2) Binary Indexed Tree or Fenwick Tree
3) Quadtree
4) Cartesian Tree
5) Fibonacci heap
6) Interval Tree
7) Finger Tree
8) Crit-bit Trees
9) Scapegoat Tree
10) Splay Tree
11) Suffix Tree
12) Counted B-Trees
13) Binary Space Partitioning
14) Van Emde Boas Tree

Others:
1) Huffman Coding Compression Algorithm
2) Euclid’s Algorithm
3) Union Find Algorithm
4) Manacher’s Algorithm
5) Eukerian Path (Hierholzer’s Algorithm)
6) Convex Hull | Set 1 (Jarvis’s Algorithm or Wrapping)
7) Convex Hull | Set 2 (Graham Scan)
8) Convex Hull using Divide and Conquer Algorithm
9) Quickhull Algorithm for Convex Hull
10) Distinct elements in subarray using Mo’s Algorithm
11) Line Sweep Algorithm
12) MO’s Algorithm (Query square root decomposition)
13) Disjoint-set Data Structure
14) Ackermann Function
15) Zobrist Hashing
16) FM-index
17) Circular buffer
18) Hungarian Algorithm / Kuhn–Munkres Algorithm / Munkres Assignment Algorithm
19) Dekker’s Algorithm
20) Winged Edge
21) Burrows–Wheeler Transform
22) Zipper
23) Five Balltree Construction Algorithms
24) Cuckoo Hashing
25) Rope (Data Structure)
26) Binary Decision Diagram
27) Disjoint-set Data Structure
28) Bloom Filter

Conclusion:

In this article, we have seen the list of algorithms available in computer programming. Let us learn and use these algorithms to build great products in our day to day life. If you know any algorithm other than these algorithms, kindly comment here! Let us learn these algorithms one by one! Thank you.

Angular & Ivy Compiler

Pranam K — Sat, 22 May 2021 14:49:36 +0000

Ivy is a complete rewrite of Angular’s rendering engine. In fact, it is the fourth rewrite of the engine and the third since Angular 2. But unlike rewrites two and three, which you might not have even noticed, Ivy promises huge improvements to your application. With Ivy, you can compile components more independently of each other. This improves development times since recompiling an application will only involve compiling the components that changed.

Ivy also has a very big focus on tree-shaking. This is the process in which the Typescript compiler looks at your code and figures out exactly which libraries are needed and then eliminates any unused code. As a result, the distributed code will be much smaller and the loading times of your application will improve.
Ivy has been around in a preview version since Angular 8, but you previously had to manually opt into using the new engine. With Angular 9, Ivy is the standard engine for rendering your content.
With all these massive changes behind the scenes, you might be scared and wonder how much you would need to refactor your code to be compatible with Ivy. It turns out that the Angular team has made backward compatibility a priority and, in most cases, you should not have to change anything in your application other than updating it to the latest Angular version.
Tree Shaking
Tree Shaking is a term that means removing unused code during bundling process. This can be done by using tools like Rollup and Uglify. During the build process, tree shaking tools use static analysis and eliminates the unused and unreferenced code. However, tree shaking tools have limitations when the conditional code exists as static analysis depends on references. For example, an unused code path within “IF” statement cannot be identified by static analyzer and that code still resides in bundle even if it is not used during runtime. Due to the above mentioned limitations, current rendering pipeline is modified to optimize the bundle size.

Tree Shaking is applied to Angular features. If any of the Angular features are not used in your code, you don’t need to pay for that code

Test Results by Google
Here are results of basic Hello World application provided by Google. Current angular generated 36Kb size of bundle wherein Ivy generated 2.7Kb, which is 93% reduction in size.

Google tested the Hello World application on mobile devices that have slower network like 3G. The current application load time is 4.0s whereas Ivy application load time is 2.2s, which is 45% reduction in load time.

Google is still in verification process. Once it is done, Google will make Ivy a default renderer.

To start a new project with Ivy, use the --enable-ivy flag with the ng new command:

npm i -g @angular/cli@latestng update

ng new angular-ivy-app --enable-ivy

To enable/update the existing project to Ivy Compiler:
npm i -g @angular/cli@latestng update

OR in your tsconfig.json file update this:

{
"compilerOptions": {
"module": "esnext",
// ...
},
"angularCompilerOptions": {
"enableIvy": true,
"allowEmptyCodegenFiles": true
}
}

angular.json:

{
"projects": {
"your-project": {
"architect": {
"build": {
"options": {
...
"aot": true,
}
}
}
}
}
}

Advantages of Ivy Compiler:

1) Smaller bundle sizes:
The Ivy compiler has been designed to remove parts of Angular that aren’t being used via tree-shaking and to generate less code for each Angular component.

2) Faster testing:
In Ivy, TestBed doesn’t recompile components between tests unless a component has been manually overridden, which allows it to avoid recompilation between the grand majority of tests. With this change, the framework’s core acceptance tests are about 40% faster. We would expect users to see their own application test speeds to be around 40–50% faster.

TestBed
Configures and initializes environment for unit testing and provides methods for creating components and services in unit test.

Note: TestBed is the primary API for writing unit tests for Angular applications and libraries. Use TestBed in tests. It will be set to either TestBedViewEngine or TestBedRender3 according to the compiler used.

3) Better debugging:
Ivy provides you with more tools to debug your applications. When running an application in Dev Mode with the Ivy runtime, we now offer the new ng object for debugging.

Ivy also improves the stack trace for debugging issues such as the ExpressionChangedAfterItHasBeenCheckedError.

4) Improved CSS class and style binding:
The Ivy compiler and runtime provides improvements for handling styles. Previously, if an application contained competing definitions for a style, those styles would destructively replace each other. With Ivy, the styles are merged in a predictable way.

5) Improved type checking:
The Angular compiler can check more of the types of your application, and it can apply more strict rules. These features will help you and your team catch bugs earlier in the development process.
• fullTemplateTypeCheck — Activating this flag tells the compiler to check everything within your template (ngIf, ngFor, ng-template, etc)
• strictTemplates — Activating this flag will apply the strictest Type System rules for type checking.

6) Improved build errors:
The Ivy compiler makes all of the error messages easier to read. This in turn helps a developer to resolve and fix the bugs at faster rate.

7) Improved build times, enabling AOT on by default:
For the first time ever we are using AOT even for DEV mode builds. This means that ng serve now benefits from the same compile-time checking as production builds, significantly improving the developer experience for Angular.

8) Improved Internationalization:
With Ivy, we’re making this faster by moving the build-time i18n substitutions later in the build process. This change allowed us to make it up to 10 times faster.
Internationalization is the process of designing and preparing your app to be usable in different languages. Localization is the process of translating your internationalized app into specific languages for particular locales.
Angular simplifies the following aspects of internationalization:
• Displaying dates, number, percentages, and currencies in a local format.
• Preparing text in component templates for translation.
• Handling plural forms of words.
• Handling alternative text.

9) Backward Compatibility:
Ivy supports backward compatibility so that your existing applications wouldn't break. Today, thousands of applications are using angular framework. You don’t need to upgrade angular for Ivy.

Example:

A sample Angular 10 project with Ivy Compiler:

Make sure you have the latest version of Angular:

1) git clone https://github.com/PranamBhat/Angular-Ivy-Compiler
2) cd Angular-Ivy-Compiler
3) npm install
4) npm start (or) ng serve

Go to browser: http://localhost:4200

Now see the Bundle Files, Network and Timings:

Conclusion:

As we can see, the bundle file size, network connectivity/loading speed and overall timings are much faster than Angular old versions. With Angular 10 and Ivy Compiler we can run any application effectively by keeping efficiency and quality in mind.

Simplified Azure Storage Client in .NET Core

Pranam K — Fri, 19 Mar 2021 08:00:01 +0000

I have created "Simplified Azure Storage Client in .NET Core". I was originally thinking to just create a RESTful client at first, and then decided to make it more powerful by enabling it to communicate with Azure Storage and Redis Cache.

All tools are wrapped into single class "Restme()" to keep everything simple. The class will automatically identify whether it's used as HTTP Client, Azure Storage Client or Redis Cache Client.

Since they are all about requesting and saving data, it is going to play a major role when it comes to saving time and space.

Code:


//HTTP Restful client (sudo code)  
// Get data  
rest.Get(requestUrl);  
// Save data  
rest.Add(paramKey, paramValue);  
rest.Post(requestUrl, data);  
// Delete data  
rest.Delete(requestUrl);
  
//Azure Storage or Redis ache sudo-code  
// Get data  
rest.Get("/container/filePath");  
rest.Get("/container/jsonData");  
rest.Get("/container/filePath");  
  
// Save data  
rest.Post("/container/filePath", myObject);  
// Delete data  
rest.Delete("/container/filePath");

Example:

1. Use it as a basic RESTful HTTP Client:

//direct string JSON return    
var rest = new Restme(new Uri("http://freegeoip.net"));  
var result1 = rest.Get("/json/github.com");  
  
//automatic Generic cast    
var result2 = rest.Get < MyObject > ("/json/github.com");  
var resultAsync2 = await rest.GetAsync << MyObjecT > ("/json/github.com");  
  
//add parameters (Parameters get automatically converted into query string or post form fields)    
rest.add("q", "github.com");  
var result3 = rest.Get < MyObject > ("/json");  
var resultAsync3 = await rest.GetAsync < MyObjecT > ("/json");  
  
//supports POST, DELETE, PUT etc.    
var rest2 = new Restme(new Uri("http://example.com"));  
rest2.Add("Username", "abc@def.com");  
rest2.Add("Birthday", DateTime.UtcNow);  
rest2.Post < MyObject > ("/someurl");  
  
rest3.PostAsync < MyObject > ("/asyncexample");  
  
  
//supports direct object submission    
var myObject = new MyObject()  
{  
    Username = "abc@def.com",  
        Birthday = DateTime.UtcNow  
};  
var rest3 = new Restme(new Uri("http://example.com"));  
rest3.Add(myObject);  
rest3.Post < ExpectedResultObject > ("/directObjectPost");

2. Use it as an Azure Storage Client:

//get blob stream directly      
var blobStorageConnectionString = "{Your Storage Account Connection String}";  
  
  
var rest = new Restme(blobStorageConnetionString);  
  
  
rest.CreateAzureBlobContainerIfNotExists = true; //do this only if you want to auto create the container        
  
  
//NOTE 1: first segment of the path should always be your container name      
  
  
//NOTE 3: Type T: if it is a type of Stream it will be stored as original Stream as Azure Blob, otherwise it is always saved into JSON format as Azure Blob      
  
  
//NOTE 2: use a type of Stream if you want the original value retrieved from the blob      
  
  
rest.Get < Stream > ("/myContainer/myfilePath");  
  
rest.GetAsync < Stream > ("/myContainer/myfilePath");  
  
  
//NOTE: only blob items saved in JSON format is suppported      
  
  
rest.Get < ObjectType > ("/myContainer/myfileObjectInJSONFileFormat");  
  
rest.GetAsync < ObjectType > ("/myContainer/myfileObjectInJSONFileFormat");

3. Use it as a Redis Cache Client:

var redisConnectionString = "{Your Redis Cache Connection String}";    
var rest = new Restme(redisConnectionString);    
    
//get cache data (support Generic cast)    
var cacheResult = rest.Get("home:testKey");    
var cacheResult2 = rest.Get("home:testKey2");    
var cacheResult3 = rest.Get("home:testKey3");    
    
//set cache data    
rest.Post("home:testKey","value");    
rest.Post("home:testKey2",true);    
    
var myObject = new ObjectType();  //will be serialized into JSON format and stored as string on redis server    
rest.Post("home:testKey3", myObject);

Advantages:

The main goal is to increase productivity and keep code simplicity.
Currently it includes: RESTful HTTP Client, Azure Storage Client, Redis Cache Client.
Simple methods and flexible calls
Uses Newtonsoft JSON and allows custom serilization
Async support
HTTP Client:
- Parameters get automatically converted into query string or post form fields
- Supports GET, POST, PUT, DELETE
- Bearer Authentication and custom headers
Azure Storage Client:
- Simplified call stack
Redis Cache Client
- Simplified call stack (Currently only support Azure Redis Cache, you can modify the source code to support other Redis Servers as well)

Check out the full code here:

PranamBhat / AzureDotNet

Simplified Azure Storage Client in .NET Core

REST Http Client

Simplified Azure Storage Client in .NET Core is a collectino of useful utility tools implemented in .NET Core aiming to increase productivity and keep code simplicity. Currently it includes: RESTful HTTP Client, Azure Storage Client, Redis Cache Client.

All tools are wrapped into single class Restme() to keep everything simple, the class will automatically identify whether it's used as HTTP Client, Azure Storage Client or Redis Cache Client.

Features

Implemented based on the latest .NET Core 1.0 (RC2)
Simple methods and flexible calls
Uses Newtonsoft JSON and allows custom serilization
Async support
HTTP Client
- Parameters get automatically converted into query string or post form fields
- Supports GET, POST, PUT, DELETE
- Bearer Authentication and custom headers
Azure Storage Client:
- Simplified call stack
Redis Cache Client
- Simplified call stack (Currently only support Azure Redis Cache, you can modify the source code to support other Redis Servers)

Nuget Package

    Install

…

View on GitHub