My previous post on Lean Development – challenges talks about the challenges of using the existing platforms for fostering lean development. The post concludes with a description of a concept platform that will foster lean development principles. SMART implements the principles of the concept platform.
SMART is conceptualized as a platform that hosts Business flows. Business flows can co-exist and loosely interact with each other. SMART is not a platform that just provides tools for abstracting technical details such as persistence, transaction etc. , but a functional platform that enables scale out of functionality by allowing easy mash up of available business flows together to form a new application or a new flow. This form of application development allows for incremental coding where flows can be easily added or removed based on customer feedback. This promotes the lean principle of “Amplify learning” by allowing modular flows to be released for feedback from the customer rather than waiting for whole product to be complete.
SMART goes the next step in implementation detail abstraction and completely removes relevant “cross-cutting concerns” and implementation details from the equation and lets the developer focus purely on business logic. SMART uses a innovative variation of AOP, called stereotyping which allows code to be written without any dependency (annotations or function API calls dependent on SMART), yet not sacrificing the advantages of AOP.
Let’s say that we want to write a “feedback component” whose sole functionality is to accept a feedback from a one set of customers and show it to another set of customers. We at SMART, questioned ourselves what is the “necessary code for this” which is related to only business logic. The answer seemed evident, “The Data” and “The UI”. Everything else such as saving to a database, retrieving from the database, translating from a web format to an internal format, security etc in the development is a “cross-cutting concern” very much dependent on implementation.
What if, we can provide a platform that abstracts it to a level where a developer has to just write the data and the UI and all other technical details are provided by the platform. This is what SMART does.
SMART works using a finite state machine architecture. The basic building blocks in SMART are “Data”, “Event” and “transitions” written by developers. These are functionally grouped and deployed together as a “Flow”.
- The “Data” represents the business data that assumes various states and is automatically persisted and available in cache.
- An “Event” occurs on a “Data” which triggers one or more “transitions” to be executed.
- The execution of these transitions follow the ACID properties of a transaction and can be executed in sequence or in parallel.
- An “Event” can arrive into the platform via various channels. The two identified channels in SMART currently are “The external channel” which is via Http(s), “The internal channel” which is via internal queues.
SMART provides out of the box “Events” and “Transitions” such as CRUD events and transitions that act on any data. Thus by just varying data, actions can be kept the same. Multiple developers can write functionally independent transitions and all of them can execute within a single transaction, thus enabling parallel development. This removes unnecessary dependencies and speeds up coding time. The added advantage of architecting SMART in this manner is that it allows us to address each of the concerns identified in the previous post, and help the developer write only “Necessary Code”.
- Duplication of code is reduced
Since none of the developers need to write any code related to persistence or transactions, when deployed into the platform, they assume the appropriate forms by virtue of them being deployed as a “Data”, “Event” or “transition”.
- Web Enabling is out of the box.
Deploying an event specifying the channels via which it can arrive, provides the “Event” with the “web enabling” form or the “queue enabling” form. Without a single piece of code written by the developer, data that arrives in a channel is converted to the “Event” and posted appropriately to the searched “Data”. This reduces the code required to translate data, lookup data and write a controllers.
- Ease of Customization.
Customization is reduced to a matter of adding or removing “transitions” from the path of execution. All code executes asynchronously until specified as a dependent transition on another transition. This allows the developer to think about business execution as a synchronous or asynchronous process as opposed to an technical implementation as a asynchronous or synchronous execution.
- Re-use of functional components.
The SMART platform out of the box provides various reusable functional components such as auditing, business metrics etc. But components written by developers can be reused by other developers thus also reducing time of development. SMART promotes development of a ecosystem where components can be exchanged and progressively improved upon, where the improvement by one developer is automatically available to all other developers.
Application development paradigm shift
SMART thus shifts the application development paradigm from a technical tools container to a container that hosts business flows. Components can be mashed together to form bigger components. With SMART change is fast, code is small and code is focused on “business logic” at hand rather than implementation. SMART is thus a new age platform that aids lean development principles.
Sign up @ SMART PLATFORM for more details. A alpha version will be available soon for trying out.