Architecture Perspective: Solutioning Informational models

Usecase: A new product 

Approach: Top to Down 

Source of Information: Market Research, Raw information

Perspective of Architecture Analysis: Informational

Let's assume we have captured raw information for a given problem, through the Market research.

At the most primitive level, categorize them into information categories providing relations and mappings to other information categories, shown below.

At this stage, we could come up with possible information models like

Static Models: Information schema doesn't change frequently

Dynamic Models: Information schema keeps changing frequently. Think of self-learning systems using

                              ML and AI.

Volumetric models: Operating of volume chunks of information for example to render graphical data in 

                                 3D formats

Metadata models: Operating on information that needs to be presented to your query audience whether

                              in the form of exploration (search), analytics or reports. For example Tag Clouds,

                              used to depict keyword metadata for exploration search, or the visualize free-form text.

Depending on the kind of model, specific solutioning could be done.

For example, we have a static model, with the evolution perspective that could cause changes in architecture, hence solutioning information view and flow for the following usecase. 

Example Enhancement to an existing QnA system

Eg: QNA system consisting of a single question with unknown number of options, and possibility of more than one correct answers supporting descriptive answers. A common algorithm that renders this data dynamically in graphical format

Initial Possible schema of information

Question | Option 1 | Option 2 | ...? | Answer 1,2,... ?  | UI markup | Settings <*to*>?! === PROBLEM

Let's think of solutions here.

Type: Static Model

Perspective: Evolution

Principle Applied: Open-Close Design Principle, open for extension

Solutioning:

CASE: Part of the system enhancement introduces frequently changing information

Proposed / Existing Storage Model: RDBMS SQL

Technology Vendors: MS SQL Server, Oracle, DB2, mySql

ANS 1 : Pivoting. Create pivot structures such that the dynamic schema which was to be represented as columns, now is represented as rows.

Pivot as a solution

Question | Option | Is Answer | UI markup | Settings

Q1           | Op1     | No            | </>             | {setting:value,...}

Q1           | Op2     | No            | </>             | {setting:value,...}

Q1           | Op3     | Yes           | </>             | {setting:value,...}

ANS 2:  Extension Tables, based on the principle of inheritance /composition / aggregation translating to Primary Key - Foreign key relationships, that would create two or more structures in the model depending on if the extension calls for One-to-One, One-to-Many, Many-to-Many relationship

ANS3: Keeping the schema constant, and the RDBMS approach, suggest extension in algorithm that processes the QNA data.

ANS 3.1: Modifying data added in the schema, without change in existing schema, using json / xml data as row data. Suggested "extension" through extension code contracts not refactoring in existing processing algorithm.

Question | Answer

Q1           | options: [{option:'Op1', 

                        IsAnswer:'No', 

                       UIMarkup: '</>',

                       settings: {setting1:'value', setting2:'value2',...}

                     }]

ANS 3.2: Modifying data added in the schema, without change in existing schema, using links to json/xml templates / data. This solution works well for content management systems.

QuestionBank | Answer

QB1                | link://jsondoc

~~~ jsondoc on Server

[ {question: 'Q1',

     options: [{option:'Op1', 

                       IsAnswer:'No', 

                       UIMarkup: '</>',

                       settings: {setting1:'value', setting2:'value2',...}

                     }],

              {question: 'Q2',

                 options: [{option:'Op1', 

                       IsAnswer:'No', 

                       UIMarkup: '</>',

                       settings: {setting1:'value', setting2:'value2',...}

                     }],

                  ...

]

 

CASE: Change Storage Model Type, convert to self-learning system

Type: Dynamic Model, Volumetric Model, Metadata Model

Storage Model: No-SQL DB

Technology Vendors: MongoDB, Cosmos DB, ElasticDBs, Bigdata

ANS : Extending existing structures to incorporate Json / xml data

[ {question: 'Q1',

     options: [{option:'Op1', 

                       IsAnswer:'No', 

                       UIMarkup: '</>',

                       settings: {setting1:'value', setting2:'value2',...}

                     }]

]

          

OR

 

<Question title='Q1'>

   <Options>

         <Option title='op1'>

            <IsAnswer>No</IsAnswer>

            <UIMarkup>&lt;lasjdf&gt;<UIMarkup>

            <Settings>

                  <Setting title='setting1'>value</Setting>

                  <Setting title='setting2'>value</Setting>

             <Settings>

         </Option>

   </Options>

</Question>

CASE: This is a system for a small set of users supporting upto 100 question banks

Technology Vendors: Access, CSVs, Flat File DBs, Xml Dbs, Excel Dbs, Json file dbs

Integrating systems with each other - Some standard solutions

 Here, we shall take an example of integrating a large framework with smaller frameworks.

This case can be applicable for a lot of enterprise applications today.

Eg: The .Net Framework, CRM Applications like MIS, Zoho CRM or even OLA, Netflix

Here, we will take the usecase of 2 systems

1. The Core System / Framework: This can be a product that supports integration with other products offering some standard features of its own
• Eg: Common Infrastructure Layer of  the .Net Framework is the core Layer with supports multiple versions of .Net framework and other device frameworks
2. A sub-system: An independant product which needs to be integrated with the core framework.
• Eg: Integrating Node js with the .Net Framework.
•       Integrating a new Language like Python with .Net Framework

C# Basic Boiler plating code for absolute beginners

 The following syntaxes are helpful in boiler-plate coding of any application. Here, we shall focus on the C# language. Please note, we are speaking of the common syntaxes that are used in every application. This is not a cheatsheet of all possible C# syntaxes.

We have seen in the post: Coding Best Practices - Part 1 article, about writing boiler-plate code.

Boiler-plate code is just creating the structure of an application, without a logic.

In .Net, everything is an object, hence the basic operating paradigm happens to be OOPs.

C# is a modern language created for .Net and also operates on OOPs.

In any application developed using the OOPs paradigm, following entities become very important

• Namespaces: Logical grouping of code entities such as class, interface, enum, delegate, events
• Class: A blueprint of a real-world object
• Properties: Special variables with getters, setters. The main purpose is to share information with other classes, assemblies (executable version of a project)
• Methods: Functions that contain logic.
• Interface: A code contract, that is agreed upon by classes as required
• Relationships:
• Inheritance: Parent-Child Relations. In C#, we use ":" to indicate an inheritance / contract implementation
• Eg: class Circle : Shape{...}
• Here Shape is a normal class
• Eg: class Circle: Shape, IPaintContract{...}
• Here, IPaintContract is an interface
• Association: Here one class contains a property, parameter of another class

• class Circle

  {

     //Property of type Compass. Here Compass is a class

     public Compass DrawingTool {get; set;}

  }

   

  Class Compass{ ... }

Lets take an example of an application such as Employee Management System

• It would contain
• Classes like Person, Employee, Project, Department etc.
• Namespaces for grouping a category of classes
• Relationships
• Contracts like IEmployeeContract

Here are the syntaxes for

• Namespace: Syntax: namespace <namespace_name>{ ... }

• namespace EMP

  {

  }

• Class: Syntax: <access-specifier> class <class_name>{ ... }

• Here, <access-specifier> can be one out of

• public
• Shareable and accessible in a given assembly and across different assemblies
• private
• Not shareable / accessible outside the class scope
• protected
• Shareable / accessible only to classes related through inheritance
• internal
• Shareable and accessible only within the assembly where it is created.

• public class Person {

                     

   }

   

  public class Employee {

                     

   }

   

• Interface

• interface IEmpContract

  {

  }

   

• Relationship. In this case, the relationship of inheritance

• Class Employee : Person, IEmpContract{

  ...

  }

Polymorphism In OOPs Paradigm

 Polymorphism can be visualized as a person who wears multiple disguises, at different times.

Technically, it means that a method / property behaves differently, at different times. These times could be captured at compile time / runtime

Polymorphism forms one of the most important pillars of OOPs paradigm. At an enterprise level, this principle is used on a day-in-and-out basis. There are 40 design patterns at the minimum that use the concept of polymorphism. The most common and obvious pattern is the "Factory" design pattern, which can be found even in the simplest and most complex enterprise projects.

In an interview, polymorphism questions come up in the first 5 questions.

There are two types of Polymorphism namely

1. Compile-Time Polymorphism
1. Overloading is the technique used to implement Compile-time polymorphism
2. Run-Time Polymorphism
1. Overriding is the technique used to implement Run-time polymorphism
2. In overriding, the base class gives the permission to the derived classes to allow change in the implementation logic.
1. This permission is given using special keywords
1. virtual
2. abstract
3. interface

You can visualize Polymorphism in the following manner

OVERLOADING

• Think of a person named "Kunal". Technically, "Kunal" is an object of the  "Person" class, right?!
• A person can work. Hence, technically, "work" is a method inside the person class.
• Now a person can work on a single task, sometimes the person may work on multiple tasks. Technically, it means we can have two flavours of "work" viz.
• bool work(string task)
• bool work(string[] tasks)
• Both these methods are essentially having the same name and return type. The only change is the change in the parameter types and count. Also these methods are in the same class.
• Hence, in this case we can say that Work() is an overloaded method.

OVERRIDING

• Let's say the same Person "Kunal" is also an Employee.
• Technically, it means there is an IS-A relationship between Employee and Person, both of which are classes.
• For overriding, it is important that the classes involved are in an inheritance relationship.
• In this case, the Person object "Kunal", when started working in a company also became an object of "Employee" class, right?!
• The Person also works, and the Employee also works. This is a common behaviour between the two classes. But the way (implementation) work is done at office is different from the non-office environment. Both work on tasks, but the way they work and deliver is different.
• Technically, the logic is different for work() in Person, and different for works() in Employee
• work() is a method that returns bool. This declaration will remain the same whether the work is done at home or office, only the logic will differ.
• Hence, we are "overriding" only the implementation for work(), when we instantiate "Kunal" as person Vs when we instantiate "Kunal" as an Employee.
• In overriding, the method signature remains the same in both the base, derived classes. Only the logic is different.
• There are three ways of implementing overriding
• "virtual" keyword in base class --- "override" keyword in derived class
• "abstract" keyword  in base class --- "override" keyword in derived class
• Interfaces  also known as Code Contracts

SUMMARY WITH SYNTAX

1. Compile Time Polymorphism: Done by "overloading"

   Same class, same function name & return type, multiple flavours of method by changing parameters

class Person{

public void Works(){}

public void Works(string pTask){}

    }

2. Runtime Polymorphism: Done by "overriding"

   Pre-requisite: Inheritance relation between classes

a. Using virtual

Mark a method as "virtual" in base class

Use "override" keyword to change the logic in derived class

** A method marked as virtual can have default implementation logic

Eg: class Shape{

public virtual PrintDetails(){

...default logic

}

}

    class Circle : Shape{

public override PrintDetails(){

... different logic

}

}

        b. Using abstract

   Pre-requisite: Inheritance relation between classes

** Abstract means Incomplete

** A method / property can be marked as abstract

** If a method / property is marked as abstract, the class MUST be marked as abstract

** An abstract class can NEVER be instantiated

** Hence, use base = new derived() formula

i. Mark a method / property as abstract in base class.

ii. Mark the base class as abstract

iii. In derived class use "override" keyword

Eg: abstract class Shape{

public abstract void Draw();

}

    class Circle : Shape{

public override void Draw(){

...logic

}

}

Best Practices while writing code - Set 1

 Enterprise Best Practices to be used while working on labs. The first set of best practices are as follows.

If you are a student or a learner upgrading to a technology and are creating quick applications, then these first set of enterprise best practices are applicable to you.

1. Working in n-tier architecture
    - Separated the core logic from the presentation layer
    - Keep the entry point of Presentation Layer LEAN
    - Modularize the logic into separate files, classes or a BL project

2. Boiler Plating code
    - While creating a project, always create the skeleton
      then fill in the logic in the right places

   - Example: 

          # Create the projects in the respective layers

          # Inside each project, create the classes with inheritance or association relations, with empty  

             properties and methods without logic

          # Compile your project. Compilation should succeed

          # Now, for the given set of requirements for a module, only add the logic in the relevant classes

             and methods

3. Exception Handling
    - The lower level tiers like DAL, BL should throw exceptions
      when such a case is encountered

           throw new Exception("exception message");

    - The higher level tiers like PL, must include the try--catch     
       block to catch any kind of exceptions which were thrown from     
       the lower tiers
        try{
            //suspecting code that could create issues
           }
        catch(Exception ex){
            //Print exception
            }

    - For exception handling, usually a custom strategy can be adopted, where third-party tools can be

       used to log the exceptions for further analysis, such as using log files or database. At the coding

       level, all exceptions should be thrown from the lower layers upwards towards the Presentation 

       Layer. At intermediate levels, specific exceptions can be added to error log files or database, while 

      at the Presentation Layer, a friendly message indicating something has gone wrong could be given 

      with a link to contact support.

The Modern Monolithic N-Tier distributed deployment Architecture used Today

 

The N-TIER Architecture and its Deployment Perspective for Web Apps

 

 

The N-Tier architecture above is used in most enterprise applications even today. The presentation Layer of an application has different forms of presentation such as presenting the product UI as a desktop App, as Mobile App and as a Web App at the same time. All these three presentation forms of the product are deployed on different servers but are in sync with the same Business Logic Layer and replications of the Database (Data Storage in above diagram)

This introduces a neutral layer known as the Services layer which become the common point of communication between the different presentation layers and the common server-side business logic.

The Presentation layer is also become complex owing to the usage of different client-side technologies that are built on architecture patterns such as MVC, MVP, MVVP, Prototype etc.

Hence the presentation layer gets further divided into n-tiers, namely the

1.       Html / UI Layer: Has dedicated UI developers who work on HTML based Languages (Polymer, JSX, React) & CSS Based Languages (LESS, SASS)

2.       Presentation Business Logic Layer: Has dedicated Front-end developers who work on Object Oriented Javascript based technologies

3.       Presentation Services Layer: Has dedicated Front-end developers who write client service classes to consume server side services-layer

When the N-Tier architecture is analysed from the deployment perspective, then it results in deployment architectures such as

1. Monolithic

2. Microservices

3. Micro-Kernel

and so on.

Let's stick to transforming the above n-tier architecture into a hybrid or enhanced monolith deployment.

Here, it looks similar to a distributed architecture of deployment, but the reason one can say its enhanced monolith is because, even with additional releases the total number of servers used in the deployment stay constant.

The current age monolithic architecture, is hybrid, considering the Presentation Layer becoming polyglotic, meaning the presentation layer uses more than one technology stacks, frameworks, languages.

A lot of times, our product has multiple UI interfaces like Web UI, Mobile App (Android, iOS, TvOS), Desktop App. All these UI apps could be synchronized to the same database data, the same business logic.

When the presentation layer becomes polyglotic, the deployment cannot be done on a single server always. Eg: The mobile App requires to be deployed to the respective vendor's cloud store, while the desktop app should be deployed on individual customer workstations, while the web app could be deployed on the enterprise's  own servers. 

Irrespective of the above, all of the data is synced with the same business logic and database. In this case, a pure monolithic architecture cannot be used as a pattern for deployment.

Converting the above development view of N-Tier Architecture to the Deployment View, of a modified / enhanced monolithic. The total number of servers in this distributed monolith will always be constant, even with additional releases of the product.

For each deployed node (server), today, a secondary node is attached, so that it eases managing failures and deploying the parts of the product. Hence to every node (active or primary) a secondary node is attached.

When a deployment is made, the deployment is done to the secondary node, and then synced with the primary node. The secondary node is made active for a few seconds until the primary node is synced with the latest deployment. After this a smooth switch is made so that the primary node now becomes active.

Hence for every server on which deployment is done, a secondary server is always attached, but is not active. This node is used for seamless switch while deployments are done and when the primary node for some reason fails.

A standard architectural solution for this is High Availability, which helps in the seamless switch after the new deployments are done on the primary and secondary node, such that the end customer / user using your app, is not affected.

Hope this helps you in your quest!

Pearls of Wisdom - Quotes Widget

Dear all, if you wish to embed Pearls of Wisdom widget on your website, you can do so by just attaching this widget code, and the widget will start working immediately. 

Try this on your website and let your users have an enhanced User Experience and a emotional connect with your content. 

For your perusal, considering requests from some of you and specific web admin permissions on each one's website, adding a generic PLUG-AND-PLAY Widget that just needs to be copied and pasted on webpage wherever you wish to use it.

Here's the link and sample on my blog post.

https://inspireinnovativelearning.blogspot.com/2999/06/headlines.html

In case of customized content on User Experience, could get it supported for your specific needs.

Have tried this widget myself on websites of my own, and it does its job well.

P.S: As an example this can work well where you wish to have a connect with customers like cousellors, Wellness Industry, Motivational Speakers, Soft Skill Trainers and their respective blog sites / websites.

#userexperience #wellness #content