Digital Twin- next level of digital transformation

A digital twin can be defined, fundamentally, as an evolving digital profile of the historical and current behavior of a physical object or process that helps optimize business performance.

Throughout the product development life cycle, right from the design phase to the deployment phase, organizations can have a complete digital foot print of their products. These ‘connected digital things’ generate data in real time, and this helps businesses in better analyze and predict the problems in advance or give early warnings, prevent downtime, develop new opportunities and even plan better products for the future at lower costs by using simulations.


All these will have a greater impact on delivering a better customer experience in business as well.




Digital Twins which incorporates Big Data, Artificial Intelligence (AI), Machine Learning (ML) and Internet of Things are key in Industry 4.0 and are predominantly used in the Industrial Internet of Things, engineering, and manufacturing business space. The widespread reach and usage of the Internet of Things have made the Digital Twins more cost-effective and accessible for the business world.

3 key areas

  • Improvement in the manufacturing process.
  • Provide efficient predictive maintenance of existing products.
  • Developing new products based on real world usage of existing system.

How does a digital twin work?

  • Digital Twins, the virtual counterparts of the physical assets are created as digitized duplicates of machines/ equipment or physical sites using sensors.
  • These digital assets can be created even before an asset is built physically.
  • To create a digital twin of any physical asset, the engineers collect and synthesize data from various sources including physical data, manufacturing data, operational data and insights from analytics software. All this information along with AI algorithms is integrated into a physics-based virtual model and by applying Analytics into these models we get the relevant insights regarding the physical asset.
  • The consistent flow of data helps in getting the best possible analysis and insights regarding the asset which helps in optimizing the business outcome. Thus the digital twin will act as a live model of the physical equipment.

Digital Twin cloud platform



Siemens and Bentley Systems announce Plant Sight digital twin cloud services


Applications of Digital Twins

  • Manufacturing
  • Automobile
  • Retail
  • Healthcare
  • Smart Cities
  • Industrial IoT

save millions of dollars in maintenance costs and reduce product defects and shorten time to market.

Problems and benifits

Digital twins and IoT

digital twin enables a device-as-a-service.

Microsoft Azure IoT does have the concept of a ‘device twin’ that is part of their device management solution.

Amazon refers to a ‘device shadow’ as their version of a digital twin.

digital twin on IBM Watson IoT.

Digital twin vs. predictive twin

November 2017 article for Network World, contributor Deepak Puri outlined an example of an Oracle digital-twin tool that provides users with two options – a digital twin and a predictive twin.

The digital twin “can include a description of the devices, a 3D rendering and details on all the sensors in the device. It continuously generates sensor readings that simulate real life options.”

The predictive twin “models the future state and behavior of the device,”

Digital twins in the industry 4.0

Digital Twins is at the core of this new industrial revolution bringing an unlimited possibilities

It changes the traditional approach of ‘the first build and then tweak’ in the industrial world and brings in a more virtual system based design process that brings in the much more efficient role out of any equipment or system by understanding its unique features, performance, and potential issues if any.


specialized expertise in machine learning, artificial intelligence, predictive analytics and other data-science capabilities.

Features of C# 7.0






C# 7.0 Features

Last article we have looked the features of C# 6.0, so in this article we will see the features of C# 7.0

C# 7.0 March 2017 .NET Framework 4.6.2 Visual Studio 2017

out Keyword

The out parameter can be used to return the value in the same variable and as a parameter of the method, if any changes made to that parameter it will reflect the changes to that out variable.

In earlier version


In C# 7.0

Here no need to declare it separately, specify directly in the argument itself.



C# tuples as richer anonymous types, it’s a set of elements.


You can access name and age by referencing Item1 and Item2.

In C# 7.0

Here we can directly get the name and age instead of Item1 and Item2



Discards are equivalent to unassigned variables, that variable may not even be allocated storage

They don’t have names, instead, they are represented as a _ (underscore.)







Pattern Matching

It’s not new to C#, in the earlier version itself introduced but in the coming version its added some more features in the implementation.

  • Pattern matching has the ability to extract the data from the expression.
  • Pattern matching can be used with any data type including custom whereas if/else can only be used with primitive types.

In C# 7.0, introduced 2 more features like “Is expression” and “Switch case statement”

With “Is” pattern


Pattern with Switch…case statement

Now Switch…case statement also works with expression as well.


Ref local and returns

Ref Locals

Before C# 7.0 it was not possible to declare the return type with the ref modifier. While this feature was available using IL code, the feature was not reflected with C#. This changes with C# 7.0. However, before looking into this, let’s get into another new C# 7.0 feature: ref locals. Local variables can be declared with the ref modifier. Here, the variable x1 references variable x, and thus changing x1 changes x as well





output: local variable x after the change: 2

Ref Returns

The ref keyword can also be used with the return type. This allows code as shown in the following code snippet. Here, an array of type int is declared and initialized. In the next line, a local ref variable is declared that references the first element of the array. This variable is then returned in the last statement of the method






Local Functions

Local functions enable you to define a function within the scope of another method to help in promoting encapsulation and bring local variables into scope.











More expression-bodied members

Expression-bodied methods was introduced with C# 6.0, that simplify the syntactic expression for methods in C#. We have seen this for Methods and Properties in the previous version of C#. C# 7.0 extend this features for several new members including constructor, destructor, property assessors etc.

In earlier version







In C# 7.0







Throw expression

C# 7.0 introduces throw expressions. We can add exception throwing to expression-bodied members, null-coalescing expressions and conditional expressions. This blog post introduces throw expressions, demonstrates how to use them and also provides a peek behind a compiled throw expression.

Throw expression

Generalized async return type

Running a Task from async methods can introduce performance bottlenecks in certain paths.

Ever since C# 5.0 when the async/await pattern was introduced, the only supported return types were Task<TResult>, Task, and void

Generalized asyn return

If the directory is empty, the known space is 0 and there is no need for an asynchronous thread to calculate the size.  However, since Task<long> is the return, it still needs to be instantiated.

By using ValueTask<….> we don’t want to instantiate the Task<long>, it can return Task or Task<long> and so on.

New_Generalized asyn return

Numeric literal syntax improvements

The digit separator “_” can be used inside number literals now. The purpose of a digit separator is to improve readability, nothing more

public const int One = 0b0001;

public const int Two = 0b0010;

public const int Four = 0b0100;

public const int Eight = 0b1000;

public const int Sixteen = 0b0001_0000;

Note: 0b -> indicates as binary



I hope this article will help much to understand the features of C# 7.0, in the next article we will see the features of C# 7.1 and 7.2

Features of C# 7.1 and 7.2


C# 7.1 Features

In the previous article we have looked in to the features of C# 7.0,  in this article we will see the some of the features  introduced in C# 7.1 and 7.2

C# 7.1 August 2017 .NET Framework 4.6.2 Visual Studio 2017 version 15.3

Default literal expressions

When we declare the local function or variable or methods until C#7.0 we need to instantiate that in the code, but the newer version of C# not necessary to create a default type of that value.

In C# 7.0

Old_Default literals

In C# 7.1

Here we don’t want to specify the type of the function or variable, by default its taking.





Tuple Name inferred

The names of tuple elements can be inferred from tuple initialization in many cases.

In C# 7.0







In C# 7.1

Here we don’t want to give the name, its taking from the variable name itself.


Async and Await in Main method

The purpose of it is for situations where your main method calls one or more async methods directly. Prior to C# 7.1, you had to introduce a degree of ceremony to that main method.








In C# 7.1









Pattern Matching with Generics

We have already got enough information about Pattern matching in C# 6.0 itself, now in C# 7.0 added some additional feature like “Pattern Matching with Generics”, in the previous version there is a design flow in the pattern matching with switch case statement.


Here the compiler indicates an error, because we cannot match the pattern with generics, so in order to avoid the problem in the next version introduced the feature.












C# 7.2 Features

Private Protected

This is the new access modifier in C#, previously we had private, public, protected and so on, this feature is enable the possibility to access the private member from the parent class and that too within the same assembly.


Non-trailing named arguments

In C# 4.0 a new type of argument is introduced known as a named parameter. Using this feature, we can specify the value of a parameter by parameter name regardless of its ordering in the method.

Non-trailing named arguments








Here we can give the parameter in any order with the specified named parameter.

Leading underscores in numeric literals

The implementation of support for digit separators in C# 7.0 didn’t allow them _ to be the first character of the literal value. Hex and binary numeric literals may now begin with an _.

Reference semantics with value type

out: option to set the value

ref: Should set the value before passing it.

in: This method does not modify the value of the argument used as this parameter.

The “in” keyword specifies that you are passing the parameter by reference and the called method does not modify the value passed to it.



I hope this article will help much to understand the features of C# 7.1 and 7.2.


C# 6.0 Features Overview

C# 6.0 Features.

C# is a general-purpose programming language, it’s an elegant and type-safe object-oriented language that enables developers to build a variety of robust, secure applications in .NET framework.

C# 6.0 July 2015 .NET Framework 4.6 Visual Studio 2015

Read-Only Properties

Properties are an extension of data field in C#, data fields are not directly accessible from outside class, we must use the GET, SET methods to access it.






In general, read only properties allows the properties to set only inside the scope, outside classes can only read.






In C# 6.0, it is not necessary to specify the private set, by default it’s a read-only property when we don’t have a SETTER





Auto-Property Initializer

An auto-property initializer allows you to set the value of the property at the same time you declare it in a class, in the earlier version we need to set the property value in the constructor.

In earlier version of C#








In C# 6.0

Auto-Property Initializers



Expression bodied function member

Expression-bodied function members allow properties, methods, operators and other function members to have bodies as lambda like expressions instead of statement blocks. Thus, reducing lines of codes and clear view of the expressions.

In earlier version of C#, the function will be like.





In C# 6.0


So, we can directly write the body as an expression here.

Using static

The using static enhancement; enables you to import the static methods of single class. Previously, the using statement imported all types in a namespace.

In earlier version





C# 6.0





Null-conditional operators

It’s a new feature in C# 6.0 which will bring more productivity for the developers by reducing the number of lines.

In earlier version




In C# 6.0




String interpolation

This feature inserts values into a string with simple syntax. It is similar to string.Format, but variables may be accessed directly (not through index arguments).

In earlier version





In C# 6.0






Exception filters

If you want to use Exception Filter, you have to declare it in the same line where you declared the catch block, just like this: catch (Exception ex) if (FilterIsTrue). Here, if the parenthesized expression after the “if” returns true, the associated catch block will execute. Otherwise, it will move forward.









nameof Expressions

Evaluates to the name of a symbol

In earlier version






In C# 6.0






Await in catch and finally blocks

In earlier version of C# itself we can use try, catch and finally blocks together but was not able to use the Async and await in catch and finally blocks, so the next version of C# 6.0 introduces the features to use the await in catch {} and finally {} blocks without any complicated structure.

The await operator is applied to a task in an asynchronous method suspend the execution of the method until awaited task completes, the asynchronous method in which await is used much be modified by the Async keyword.








Index initializers

Initializing dictionaries and other objects with indexers is less elegant. We are adding a new syntax to object initializers allowing you to set values to keys through any indexer that the new object has

In earlier version







In C# 6.0









I hope this article would help to understand the features of C# 6.0, in the next article we will see the features of C# 7.0

From Functional to Reactive Programming

GIDS’17 Conference

As an attendee, I’m very much happy and I have gained some knowledge from GIDS 2017, and I would like to share the insights which I gained out of this conference.

I wish to share about the session “From Functional to Reactive Programming” given by Dr. Venkat Subramaniam, he is an excellent speaker, the session was very interesting and more interactive, the way he explained the concepts was really awesome.

From Functional to Reactive Programming:

What is Reactive Programming?


Reactive Programming is an asynchronous programming paradigm oriented around data streams and the propagation of change. This means that it should be possible to express static or dynamic data streams with ease in the programming languages used, and that the underlying execution model will automatically propagate the changes through the data flow.

Mostly as a software developer, we are writing code for quick solutions. But that code is not responsive and feasible even though it gives solution for that problem. In Reactive programming, it simplifies the codes and gives feasible and highly responsible solutions.

Imperative to Functional Style:


Imperative, every programmer knows this style and most of the institutions teach this style, programmers gain significant experience with its style. But using functional style, we can avoid writing lot of code inside the function for simple calculations.

In this example, we are finding the first even number which is greater than 3 and doubling it. This is imperative style that too very complex. The same example in functional style,

Its clear, concise and readable code, and lets you focus on solving the problem rather than the required procedure.

Function composition:

composition-of-functions (1)

Function compositions means create a simple and reusable functions that we can combine to compose new function. In the about example we created small functions like isGreaterThan3() for finding number that is greater than three, isEven() for finding whether the number is even or not and doubleIt() for doubling the number. Then finally we have combined these functions to get the result.

Lazy Evaluations:

lazy (1)

Lazy evaluation is the program will not evaluate the expression until just-in -time when its value is needed. If the value is not needed during the execution of the program, the evaluation of the expression will be skipped.

In the above example the program will not evaluate the expression until we calling the findFirst() function. This function only triggering the program to filter isGreaterThan3() function, isEven() function and doubleIt() function.

Benefits of lazy evaluation:

The ability to define control flow

The ability to define potentially infinite data structures

Increase performance by avoiding needless calculations

Functional Reactive Programming:

Reactive programming also called functional reactive programming because it applies functions like lambdas and closures in a reactive manner asynchronous sequence of data. Reactive programming paradigm stays responsive in the face of failure, more responsive and responds in timely manner. An example of the reactive systems is Google Spreadsheet. The library Rx-Java used for reactive + functional programming in java 8.

Thanks to Dr.Venkat Subramaniam,  is an award-winning author, founder of Agile Developer, Inc., and an adjunct faculty at the University of Houston.

GIDS 2017

Mr. S. Sheik Mohamed

Ramarson Technology Developers LLP, Trichy, Tamilnadu, India.

Great Indian Developer Summit (GIDS) 2017 at Bangalore.


GIDS is one of the best developer summit in India, it’s an excellent opportunity to upgrade our knowledge to the current  Market requirements, speakers from all over the world shared  their knowledge and current trends in the IT industry. There are lots of delegates participated in that event, they talks about 10 important technologies to change the developers landscape, which is a highlight in the GIDS 2017. The speaker Mr. Arun Gupta – vice president of developer advocacy at couchbase explains the technologies and concepts very interestingly to the audience. He gave the summery about Containers, Micro services, CI & CD, DevOps, IoT, Server less, Virtual & Augmented reality, AI & Machine learning, Block chain, ChatOps, he explained  the overview of these  technologies and how they lead in the technology world in few years  to the developers concerns and how they change the developers activities and so on.



The interesting thing was about the containerization concepts, because the deployment is really painful when we are building the large scale application and deploy into the customer side. The developers are facing so much of problem while fixing it in the customer side, so the containers will overcome those problems and make a smooth deployment in the customer side. Now a day the containers play a vital role and great feature for the developers to make the life easier. Followed by a lot of speaker explains the trends and technologies about cloud platform from Amazon, Google, etc., they talks about how the cloud is playing the important role in the current industry and 12 factors to cloud success and how Docker image is important and what benefits its bring out from kubernetes in the deployment also interesting in the GIDS.

Now a days IoT is one of the hot topics in the industry, people are moving towards more and more to automate the things to reduce the human efforts. I gained some clear picture about how the systems are connected each other and how they  are talking thru the cloud platform, little things about UPnP protocols in the Internet Of Things, how its evolving in the technologies are very interesting.



Mr. Venkat Subramaniam, founder of agile developer explains the Functional to Reactive programming techniques.  He performed a coding  session about concepts like Functional compositions, Lazy evaluation, immutability, declarative programming vs Imperative programming, it  really grabbed  the attention of developer, and got good understating about why the reactive programming is important to the developers, how its changing their life, how do we become a smart programmers in the software development and so on.

Finally, GIDS 2017 was really very interesting event I attended this month and it brings a lot to know for the software developers to become a smart developer in the world!!!

Golang Http Middleware

Http Middleware

Http Middleware is a shared functionality, using that we can log every request, gzip every response and check a cache before doing some heavy processing. Http Middleware has a single responsibility; we can plug it in our app at the interface level, it doesn’t affect our coding style like another layer in our request handling cycle. It is a pluggable and self-contained code, if we really want middleware we can plug it or if don’t want just remove it.                         wsgi_middlewareUsing middleware in Golang is very simple, we have to use middleware between a ServeMux and application handlers. The Http Middleware function accepts a handler as a parameter and returns a handler so that we can directly register the Middleware function with the ServeMux.

Middleware Chaining

T_AspNetCoreStartup_02In Golang, we can create handler chain by nested middleware functions inside another function. We can share values and also pass errors from one handler to another using middleware chaining.


This is an example of middleware chaining; we are passing the handler to “middlewareOne” as a variable, then transfer the control to the next “middlewareTwo” and then finally “loggingHandler”. This is necessary to know the control flow of middleware handlers, chain with other middleware handlers.

In Golang we can use Http Middleware for some specific handlers, no need to use it for all handlers. There are some third-party packages offers such kind of facilities.

Third-Party Middleware                                  

In Golang, we can use third-party package middleware instead of using our own middleware all the time. Well known third-party packages are Gorilla’s package and Negroni package.


The Gorilla package has collection handler for use with Golang’s net/http package. It mainly offers handler for logging, compressing http request and responses, validating content types.

Negroni provides an idiomatic approach to use Http Middleware in Golang. It supports to use net/http handlers, and also offers a way to handle Http Middleware. Negroni package offers middleware functions for logging handlers and to use the middleware functions some specific routes.


The Http Middleware is one of the advantage in Golang, by using this we can log each http request, gzip all responses and also we can check the cache before doing some heavy processing. The flow control of middleware handler is very useful and effective, also we can use middleware functions for specific routes.


Welcome Message



Dear Ramarson Experts,

I welcome you all for this new beginning. I request all the team members to contribute for the blog and share your valuable thoughts, ideas and experience to the world. Lets encourage intellectual discussion and use this platform to share knowledge.

You can write about Agile software development, our clean coding practices, SCRUM, Domain Driven Design, Mob Programming, DevOps, Continuous Delivery, Talk about the recent technology you have used or

interesting know-hows you would like to share with the world.

Lets keep the sprint of learning together and sharing the knowledge with the world for the betterment of all.