Angular Modules

Angular libraries are NgModules, such as FormsModule, HttpClientModule, and RouterModule. Many third-party libraries are available as NgModules such as Material Design, Ionic, and AngularFire2.

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.

• declarations: The components, directives, and pipes that belong to this NgModule.
• exports: The subset of declarations that should be visible and usable in the component templates of other NgModules.
• imports: Other modules whose exported classes are needed by component templates declared in this NgModule.
• providers: Creators of services that this NgModule contributes to the global collection of services; they become accessible in all parts of the app. (You can also specify providers at the component level, which is often preferred.)
• Entry Components: An entry component is any component that Angular loads imperatively, (which means you’re not referencing it in the template), by type. You specify an entry component by bootstrapping it in an NgModule, or including it in a routing definition.

Read More

Hoisting in JavaScript

Due to it's somewhat awkward behavior, concepts in JavaScript is little tricky to understand. Hoisting is one of them. Hoisting can be divided in to two. Variable hoisting and function hoisting. We'll first look at variable hoisting.

Variable hoisting

If you execute below line you'll get a ReferenceError.


This is because definition for value1 is not exist. Now consider below.


Even though value1 is defined after line1, still it'll say value1 is undefined. But won't show the value. This is because JavaScript interpreter goes through the file and "hoist" the variable definitions on top of the function. But value assignment happens later.

you must have expected var1 to print 1 since it was defined in the outer scope. But due to function hoisting and functional level scoping it will print undefined. But since var2 doesn't exist in current scope, it will get value 2 and print it. This is the reason it's recommended to declare all variables on top of a function.

Function hoisting

Unlike variables, functions doesn't just hold the function name, it holds the actual function definition.


something to remember is that function hoisting happens only for function defintions. Not function expressions.

Here the variable func2 will be defined but not the function definition. (TypeError). JavaScript only has function level scoping.

function declarations and variable declarations are always moved('hoisted') invisibly to the top of their containing scope by the interpreter. Function parameters and language defined names.

Resources

http://www.adequatelygood.com/JavaScript-Scoping-and-Hoisting.html

Read More

Introduction to Azure Search

Azure search is simply a cloud service which gives developers an API for rich search experience. It executes queries over a user-defined index.

Azue search supports,

• Search data from multiple content types and platforms
• AI powered indexing to extract text from image files or key phrases from raw text
• Create search experience with filters, synonyms, auto-complete and text analysis for "did you mean" auto correct search terms
• Geo-search for find near me.

Functionality is exposed over a REST API or .NET SDK.  

Azure search comes with following features

• Full text search and text analysis
• Cognitive search (in preview)
• Data integration
• Linguistic analysis
• Geo-search
• User experience features
• Relevance
• Monitoring and reporting
• Tools and prototyping and inspection
• Infrastructure

Steps to use

• Provision service
• Create index
• Load Data
• Search

Indexer

Indexer is a crawler that extracts searchable data and metadata from a external Azure data source and populate index based on field-to-field mapping between indexer and data source.

Connecting Azure Search with Azure SQL Database
https://docs.microsoft.com/en-us/azure/search/search-howto-connecting-azure-sql-database-to-azure-search-using-indexers

Read More

Authentication and Authorization in ASP.NET Core

Common vulnerabilities in software

• Cross-site scripting attacks
• SQL Injection
• Cross-Site request forgery
• Open redirect attacks

Authenticiation

ASP.NET Core Identity is a membership system that adds login functionality to ASP.NET Core apps. External login providers are also supported. (Read the article) Identity is enabled by calling UseAuthentication() which adds authentication middleware to the request pipeline. (In ASP.NET Core 1.x this was UseIdentity() - See Migration Guide)

When signing out, SignOutAsync clears the user's claims stored in a cookie. You can also add custom user data to Identity. 

Read More

Software Architecture Design - Considerations

Image Credits  : Colour Box

Architecture of anything defines how well the thing is designed and how long it's going to last. Be it a a building, a car or anything the same rule applies. It is the same when it comes to a software architecture as well.

If the architecture of a software is designed well, it should be able to accommodate any or many of the requirements be it functional or non-functional, the stakeholders requests. Therefore when designing a good architecture, one should be very careful when laying the foundation.

Keep in mind the following non-functional requirements when you're designing the initial architecture of your application.

Scalability

High Scalability has many practical case studies. It is important to keep in mind how much scalable your application is going to be in coming milestones. Size of codebase also matters

• Scale up (Increase power of hardware)
• Scale out  (Increase no. of hardware)

Scalability of Django. This video demonstrate how Instagram scales.

Instagram has a caching(memcache) mechanism between database and the client. Whenever user is served it keeps it in the cache as well as update primary and secondary storage.

Read What is scalability for more information

Performance

This is a key fact when the application grows larger. This might not matter initially but it should be kept in mind as the application grows. Some considerations for performance are,

• Perceived performance (Fluent Conf 2017 - Video)  : Measure of How Quick a User Thinks Your Site Is. 
• If you look at some websites it first loads the content placeholders which is mainly html and then only loads the actual data which takes time
• Applicable for mobile apps as well. First loads the placeholder before loading data from server
• Bundle & minification : Reduces the size of files that needs to be downloaded
• Caching & content delivery networks
• Optimizing image usage

Web Performance: Leveraging the Metrics that Most Affect User Experience (Google I/O '17)

Re-usability

Make sure to design common things in such a way that they can be reusable.

Supportability

What devices is your application going to support in future? Can the architecture be designed in a way that it supports future requirements of new devices?

See - Azure Design Guideline

There are lot of other things which should be considered when designing an architecture. But most importantly,

"make sure to think through cost and the benefit for every decision you make."

Read More

Getting started with ASP.NET Core

ASP.NET Core is a complete redesign of ASP.NET framework. It is open source and cross platform. This can be run on .NET Core or full .NET framework.

Dependency injection in ASP.NET Core
By default ASP.NET Core supports dependency injection.

Read More

Getting Started with Azure CDN

For a better user experience and a faster delivery of content from server to client, both caching and CDN (content delivery network) comes hand in hand. When considering performance it is important to use both of  these techniques for better user experience (See Caching vs CDN - Stackoverflow).

CDN can be used to cache static web content to provide content faster to end users. It caches content in physical nodes across the globe.

Watch this video to understand how to link a storage account with Azure CDN.

Resources
https://azure.microsoft.com/en-us/blog/enabling-cdn-for-azure-websites/
https://docs.microsoft.com/en-us/azure/cdn/cdn-create-new-endpoint

Read More

Catch these things in EF Core

            var b = _context.Tasks.Include(j => j.TaskItems).Include(j => j.Creator);

TaskItems is an ICollection in Task object, hence it'll execute separately in SQL Server. Since Creator is a 1 to 1 mapping, It'll do a inner join with Task.


            var a = _context.Tasks.Include(j => j.TaskItems).ThenInclude(j => j.Status);

First tasks will be queried. Then in another query, TaskItems will be left joined with Workflow status. To map with Tasks, Where query will be appended with Exists, which will map Tasks and TaskItems

Read More

Microservices what is it really

Image Credit : Contentful

Microservices is a architectural pattern where a structure of an application is decomposed as collection of loosely coupled services. These services are responsible for handling separate business capabilities.

Microservices helps software teams to continuously deliver large scale complex application in pieces. (Should you use microservices)

We all can search and find theories of microservices, but practical use cases and practical issues are what most of us will be interested in espeically when such resources are rare. So I thought of organizing this page to list some concerns involved.

Image Credits : Bhagwati Malav (via. Medium)

Problems with Monolithic Architecture

Traditionally monolithic architecture is used for many software's but it generates bigger problems with time.

• Involves a single code base which increases code complexity, learning curve, maintainability, dependencies
• Overloads IDE since there's only single code base
• Difficult continuous integration since all application is a single one
• Scaling is linear. Since there is no modularity all modules comes as a single package. Cannot scale different modules separately based on the requirement (Even if module A gets used 99% and B 1% both will be handled via. same infrastructure) 

For smaller teams most of the time monolithic will be the way to go. Consider microservices if you  have previous experience but not because you want to try it. If your application tends to get bigger , much complex or if you encounter a non-functional business requirement such as one part of the application need higher performance consider using microservices. This is because separate services can scale independently. Note that what can be done in monolithic can be done in microservices as well.

Patterns in Microservices

There are patterns which can be used with Microservices.

API Gateway (source)

There could be requirements from front-end to have an API which would access multiple microservices to retrieve data. Solution here is to create a separate API Gateway which would access required microservices and give what you need. 

API Composer is when you need to query multiple services where services uses Database per service pattern. API Gateway often does API composition as well. 

(Azure API Management,  Amazon API Gateway)

Microservices in Azure - Service Fabric

https://docs.microsoft.com/en-us/azure/service-fabric/service-fabric-overview-microservices

https://azure.microsoft.com/en-us/blog/microservices-an-application-revolution-powered-by-the-cloud/

https://docs.microsoft.com/en-us/azure/service-fabric/

Case studies

https://blogs.msdn.microsoft.com/azureservicefabric/tag/case-study/

Authentication in Microservices

https://stackoverflow.com/questions/29644916/microservice-authentication-strategy

Microservices - Case Studies

Introduction to Microservices - Nginx

Microservices Architecture of Uber (Video)

10 Tips for failing badly at Microservices by David Schmitz - Youtube

http://blog.christianposta.com/microservices/the-hardest-part-about-microservices-data/

Read More

ASP.NET Core Request Pipeline

With ASP.NET to ASP.NET Core lot of things has changed. ASP.NET had a request processing pipeline with lots of events such as BeginRequest, EndRequest etc. With Core the architecture was changed.

This is how ASP.NET Core application is initialized

ASP.NET Core now has the concept of Middlewares. You can have many middlewares as you need and each of them will execute one after the other.

Fundamentals of Middleware

https://docs.microsoft.com/en-us/aspnet/core/fundamentals/middleware/?view=aspnetcore-2.2

You can also write your own custom middleware

https://docs.microsoft.com/en-us/aspnet/core/fundamentals/middleware/write?view=aspnetcore-2.2

Read More