source : http://githut.info/
One of the biggest problems with writing software is duplication. As soon as duplication occurs this immediately adds development cost, since every change to the original now has to be done twice.
This adds significant overhead. Unfortunately with the rise in popularity of distributed architectures (e.g. Single Page Applications and microservices) this duplication is becoming more prevalent, it adds cost because it makes applications more complex and difficult to maintain.
For example; let’s take a typical Single Page Application (SPA). You have a client server relationship. On the client (the browser) you need to store a list of security policies against some sort of entity. These security policies are important. They might include things like (can delete, can update). They are important because you don’t want to show a user things it can’t do.
The problem is that you also need to store this information on the server. Because anyone with a tiny bit of technical knowledge can send fake requests to the server if you don’t apply the same policies there.
an example of how physcial separation of boundaries causes duplication of information
This situation; where the browser and the server is storing the same information is a typical duplication problem. It is often caused by using different languages in distributed systems.
In the diagram below I have extended our diagram from above to show that the policies (in red) are now consolidated down to a single place.
by using the same language we can share code which reduces complexity and most importantly allows software designers to remove duplication
It seems like everywhere you turn there is another product or language touting cross platform support. In todays digital transformation programmes cross platform is a big topic because it allows a
write once, deploy everywhere development mindset and this ultimately leads to faster time to market. This in turns makes businesses more competitive.
If you are a non developer then this probably doesn’t mean a lot to you so I will try and explain it in simple terms.
Most languages have functionality that allows them to run more than one instance of themselves.
They ‘place’ instructions onto a big list of things to do. The processor comes along and services these instructions one by one.
This is called ‘multi-threading’. So the programmer can write code that takes advantage of this. This opens up numerous options and they can do cool things; like write web servers which need to process lot’s of concurrent users.
But… this comes at a cost; context switching! All that switching between processes chews up the processors time because it has to keep dumping stuff in and out of memory. This slows it down.
Because this convention is forced on the designers of the system they have to write code that will not lock the processor - this is called a non-blocking architecture.
This makes it more tricky for the programmer. Because they have to write code that deals with events rather than code which is linear.
This has the effect of having significant performance increase on applications that run high load processes and makes it perfect in a web environment.
Native Cross Platform Support: It’s maturing native cross platform support across IOS, Android and even Windows/Mac Desktop is allowing organisations to improve their time to market. They can reduce bottlenecks around skills and support for their applications.