Business Users know business and their needs; Analysts interpret them in a way that programmers can then go write code. This white paper discusses how a prototyping system can help an analyst deliver a complete working prototype, relevant collateral and even the software code to programmers. This will then enable programmers to fine tune the code to satisfy new requirements. More importantly, all stakeholders have a starting point.
You have to start somewhere when thinking of building a system. This could be a PowerPoint to convey a vision, a Word document that describes details, or Visio diagrams to convey the screens so end users can relate a little better. There are of course other tools for the specific tasks, including modeling language to build a model, but in general these tools are passive.
The passive nature requires end users or stakeholders to visualize and extrapolate from the PowerPoint or Visio on how the actual system will behave. Not everyone is good at this visualization – similar to how not everyone can visualize a space based on Architect’s engineering drawings.
Just as an Architect may build a 3-D model of the space to help building owners visualize better, programmers can whip together some key aspects of the system to incrementally help the stakeholders see how things will work. These are great communication tools, but many times fall short of providing the stakeholders a wholistic view.
In this paper we discuss the capabilities that Turanto provides and the general class of applications that it is very well suited for prototyping.
Turanto, a browser based tool, enables prototyping through domain model specification with prediction around visual interface, database design, and integration needs.
Once the basics of the problem are available in a model, Turanto then overlays the common enterprise requirements on that, to create a complete working application prototype.
Agile Software Engineering processes can then be leveraged to keep incrementally updating this prototype, until a sufficiently complete picture evolves to take on a WaterFall development model. The organization retains its choice of development methodology – Turanto simply enables stakeholders to see a working application sooner, so they can provide more complete feedback.
While this is not as measurable as cost savings, an improved engagement of stakeholders is a significant benefit of quicker and smarter prototyping. It makes the project real and feasible, and, turns around the naysayers.
The stakeholders generally have many high priority tasks chipping away on their time, and, the longer a task takes, the more conflicts of time the task has to compete with. However, as visible results are shared and system seems to be coming to life through rapid prototyping, these conflicts resolve themselves as stakeholders begin to find more time.
The net result is better requirements, and, better acceptance.
While there are cost advantages to using Turanto methodology, this benefit is of equal if not more importance.
A detailed prototype that can almost pass as a production system can have two effects – (i) Everyone comes onboard because they can see the result, or, (ii) it is perceived that the system won’t solve the problem for which a solution was sought.
If either answer can be reached sooner, in a matter of weeks, rather than later, it results in significant time and cost savings – regardless of the specific other cost savings discussed below.
Once a project is approved and is beyond prototyping stage, Turanto further saves cost by providing ready to go documentation collateral and working source code to tweak.
Eliminating Writer's Block
Starting from a blank sheet of canvas is sometimes difficult. Turanto eliminates this writer’s block in many areas –
(i) By providing complete documentation in editable format, it significantly reduces the documentation time, while, improving its quality. (ii) By providing complete starter source code, it enables programmers to focus on the change, instead of organization of the same.
In both cases, there is a natural writer’s block that can cause people to spend more time on getting started. By leveraging the output from Turanto, this is eliminated.
Improved Standard Compliance
Every organization strives to improve its deliverables through processes and standards. However, as new people join and workarounds are required, these documented standards are sometimes take a back seat.
Turanto builds it prototypes with these standards – User Interface, Coding practices, Documentation Templates, Deployment Processes, Security compliance, etc. – already applied. Thus, the organization’s standards are truly followed, even during compressed schedule.
Better Resources Sharing
It is just the nature of software that it still remains more of an art than engineering. Thus, a project’s deliverable is heavily influenced by the resources applied to it. Frequently though, to respond to business constraints, the resources have to be moved across projects.
These new-to-project resources generally take a little longer to acclimatize to the project setup and code. Frequently, they may need to re-adjust code to their preferences, resulting in hidden delays.
However, if all resources are used to the established style of architecture, code, and documentation, as created by Turanto, it is much easier to move resources. Everyone is now familiar with the internal database table naming convention, to the session management setup, to the different sections in a documentation guide.
Reducing Project Backlog
Every IT organization is faced with limited resources to a rapidly evolving list of project requests from the business users.
Portfolio management processes help prioritize these, but can do little to reduce the de-prioritized list.
This results in dissatisfied end users. The dissatisfaction can be somewhat reduced by applying Turanto to those requests and determining if the prototype itself can be considered acceptable without undertaking significant development effort.
Enabling Business users to build
When a central IT organization is unable to prioritize a business user request for a system, that business unit still has to find a workaround to keep its processes humming. They may then build a skunkworks system, or, hobble along with patchwork processes with Excel, Access, or other tools they have access to.
In either case, these things end up taking a life of their own and one visible failure or security lapse finds an executive edict that has IT organization owning those awkwardly put together systems.
Thus, it is in the best interest of IT groups, to provide Turanto to all organizations so that at least when the code or system has to be productized, it is already built using all the standard practices dictated by them. Thus, the effort required to bring that edge system under a central umbrella is so much less.
Better Requirement Elicitation
It is human nature to critique and be silent to open ended requests for requirements. It is just plain difficult to visualize everything and provide requirements.
With Turanto based prototype, people begin criticizing sooner and unknowingly contribute significantly to the system improvement. The formative stage is when the criticism and participation is really required. By having a system people can play with, the Turanto prototyping methodology results in a much better requirements elicitation.
Throw Away Applications
There are many scenarios, typically event driven or temporal, that need a custom application built quickly. These applications have a very limited lifespan and can be typically dead soon after the event or time span passes.
An example might be a data collection and tracking for a specific customer case at a lawyer’s office, where the generic legal case management system is not adequate.
Since the cost to build data driven application is so low, it eliminates the major components of a business case analysis – thus keeping focus on true business need and benefit.
Customized Rapid Prototyping
Turanto already provides significant rapid prototyping capabilities – that take a concept all the way to an almost complete software system.
However, the patterns included are generic software engineering patterns.
A large organization can customize these patterns to include internal integration patterns, security practices, and built-in objects (such as “Patient” for HealthCare, or “Inventory” for a manufacturing outfit), so that the prototypes built already include the custom integration. Turanto already has such integration capability and thus, the custom application is more specific to the end user environment.
Better Quality at Lower Cost
Resources with institutional knowledge are generally short of time. Add to that technical expertise and the resource is generally in higher demand – and higher cost.
Turanto enables those resources to deliver a lot more, thus reducing the incremental cost of a task. Further, since a junior person can now deliver almost equally good code, pairing of senior and junior resources begins making more sense.
The end result is to have better quality deliverable, despite a junior resource driving Turanto – as long as someone senior guides him/her through the analysis of the end user needs.
Six Sigma for Software Engineering
In general terms, Six Sigma has done wonders in controlling variances for delivering mechanical components with really small tolerance. However, similar approaches have not yielded results in the world of Software and it largely still remains an art. The results are heavily dependent on the personnel applied to the job.
Alternative standards focus on document what build and build what you document. Even that leaves a fair amount of ambiguity to be resolved by the builder’s discretion.
Turanto reduces that by creating a large part of the system and documentation, according to agreed standards. Thus, the delivered code
between two systems is practically guaranteed to have the same architecture, same behavior, and same defects. The only change is the domain specific terms between the two.
Thus Turanto brings us closer to repeatable software than pure programming path would.
Technology Upgrade Tardemill
Focusing on the latest technology is essential to remain competitive. The cost of such focus is generally high – both in terms of staying engaged and in learning enough to apply the same. To have a larger team maintain this across projects and programs is even harder. Keeping standards in compliance with this evolving technology is harder still.
Turanto leverages the central organization’s technology research by enabling the application templates to be updated with the latest research. This, in turn, enables the different project and program personnel to transparently use that capability.
Since it is easier to modify code than to program to a new technology from scratch, the personnel on different projects slowly begin picking up the new technology through the code provided by Turanto.
The Turanto Methodology
Building working prototypes involves a series of daily meetings – at least for a week. Typically, these meetings should be handled by two people –
(i) In the first half of the meeting, an Analyst keeps the discussion going while the modeler / programmer / analyst keeps feeding that discussion in the form of a model into Turanto. (ii) In the second half of the meeting, the
Analyst demonstrates the solution that was built with Turanto and ensures that the feedback was heard correctly.
The participants can then play with the system and resume the discussion with feedback the next day. This agile approach keeps people involved and engaged.
If the modeling task is deemed difficult, Turanto also allows pointing to an existing database or to an Excel sheet. It then deciphers the model from there and builds all the artifacts discussed below.
Artifacts created by Turanto
Turanto automatically creates a large number of software project artifacts that can be leveraged for a more complete SDLC (Software Development Life Cycle) or left untouched during the prototyping phase.
Turanto interprets the requirements from the model and creates the following:
The applications created by Turanto are typically data driven and need custom database built. The database tables, views, and stored procedure follow standard naming conventions. The database is very specific to an application, and is completely de-normalized. By default it is a SQL Server 2012 database, but can be easily tuned to an alternate version or vendor.
The picture below is from SQL Server Management Studio for an Asset Management Application built to manage Assets of different type that are owned by different employees.
The database includes referential integrity and automatically creates the necessary indices for performance.
For the purposes of prototype, this database structure is less relevant – however, its importance increases when reports have to be added to the prototype, or, when it has to be installed into an existing database server.
Complete Source Code
The source code – User Interface pages, Web Services, Data Access Layer, and all relevant classes (written in C#) – is another important artifact that is produced as part of the prototyping effort.
This artifact is of less importance during the prototyping phase, but, knowing what it is provides impetus that the prototyping effort may not be completely throwaway. Further, it is of paramount importance in eliminating the dependence on Turanto or any associated library. This artifact makes the code as though it was home grown, and hence makes the effort invested in functional requirements discovery that much more valuable.
The detailed capabilities of this source code are discussed in the next section, but in general:
- The code is architected as per Microsoft recommendations for their .NET MVC (Model View Controller) framework.
- It follows .NET 4.5 guidelines, and uses Entity libraries version 6.
- It uses Twitter User Interface libraries for Responsive Layout
- The source code is available as a Visual Studio 2013 solution.
- Sample Class
A Working Web Solution
Turanto platform automatically deploys the newly created solution onto private data center or cloud servers. It configures the URL and completes the configuration as required.
The deployment can be linked to 3rd party login solutions (say Facebook or Google), or, can leverage Active Directory or Windows Domain login within an enterprise.
The deployment can start out in the cloud during the prototyping phase, and then moved into local data center during the go-live phase.
The solution works with all browsers – IE 9 & 10 for Government environments, and Chrome and Firefox in open Internet environments
The deployment of web solution includes the web services required for other applications to integrate with it. However, for security purposes these services are turned off by default.
If a customer user interface application is needed for example, the deployed web services can return the relevant data in JSON format, while the focus of prototyping can be on making sure all the relevant fields and relationships are there and working
A Working Mobile Solution
The mobile solution is generally available on a mobile browser. However, it is architected with Apache Cordova, thus easily transferred into a native Android application or a native iOS application. There is a Turanto application Runner available on Google Play that can be used as well.
The default prototype mobile solution integrates with native smart phone capabilities such as camera and GPS, but more importantly, connects to the same data and applies the same validity rules as the web application
External Application Integration
The prototyped application can consume external application services as well through WSDL (Web Services Definition Language) or HTTP based REST (Representational State
Transfer) API. These externally managed entities can become first class citizens in the prototype, so they can be augmented with more data.
An example might be that Patient information is already in a production and a new system to track their cafeteria orders has to be created without duplicating the patient information. Such a solution can be prototyped through Turanto.
Turanto can build workflows that are leveraged to track states of objects maintained in the prototype. The workflow, even though designed in Turanto, is ultimately the same workflow that Microsoft SharePoint and other Microsoft solutions
Application and Code Capabilities
The Turanto application contains significant capabilities that are summarized below. These capabilities are based on real life scenarios and are predictively added to the model specified in Turanto.
Responsive User Interface
The prototyped applications contain working screens based on the Twitter framework and are responsive to the screen size, and automatically adjust the layout.
Role Based Screens
While the code can of course be modified for each role, a specialized starter screen can be specified via HTML 5. The code automatically protects that page for the role. Alternatively, it hides the fields and buttons that a role is not supposed to see, or, actions it cannot perform.
Dependent Drop Down
It is common in applications to have hierarchical data such as Country -> State -> City. The selection of the first item automatically restricts the items down in hierarchy.Such hierarchy can be incrementally included in the prototype in spirals. Thus initial versions can be built without such hierarchy and then it can be added in.
Entities and Properties
When a problem is described in plain English, the nouns in that description are referred to as Entities (ex, the application tracks the organization’s assets. The assets can be of several types and will have an employee as owner.) The adjectives that define those nouns more are referred to as properties. Alternatively, think of every separate type of item that you will track in Excel sheet as Entity, and every column that gives more information about that as Property.
The prototyped application supports many different types and automatically builds the user interface, API, search classes, and database associated with those properties.
An image property will automatically invoke the camera on a mobile phone, or, provide an upload image button on the web application.
An auto field will automatically provide a monotonically increasing number (e.g. an application number), so that the field remains unique.
A GPS property will extract location information (latitude and longitude) when used from a mobile app and leverage a browser’s location information from desktop browsers. In addition, it will automatically provide proximity search, thus enabling an expected production quality feature without needing to program it in.
A date property automatically pops up a calendar dialog for choosing dates and provides date range searches. Business Rules to ensure an end date cannot precede a start date can also be added in.
A timestamp is so common that it is built-in and provides the prototype with automatic stamping of who performed the action and when.
Not all types and their capabilities are addressed in this white paper.
In addition, as a new Entity is defined, it is available as a built-in type, complete with all capabilities. (In a customized world, such as in Legal world, you could have a pre-defined Entity CASE instead of having to recreate this type each time.)
Relationship between Entities
The prototype system can have several different kinds of relationships between each major item, allowing it to simulate, rather implement, the most common types of relationships.
A many-to-many relationship, such as the one between a document and its category (A document can be in many categories and a category can contain many documents), is automatically manifested in user interface as well as in the database (bridge tables).
A one-to-many relationship defaults to a tab based interface from one perspective and changes to a drop down when looked at from the other entity’s perspective. These defaults can be modified to other display elements as well.
Self-relationships are interesting and can be labelled differently to allow multiple such relationships.
These entities, properties, and relationships combine together to form the basic bulk of the entire application. The other capabilities discussed are then incrementally added into the code.
Built In Validation Rules
A property can be mandatory. A relation can be flagged as required before saving. An integer can be required to be between two values. There are many such common validation rules that can be defined in the prototype without resorting to programming.
The user interface elements (such as displaying a red “*” next to a property is automatic) Web Service access automatically enforces this as well to prevent incorrect data from going into database. Violations of validation rules automatically trigger error messages and do not allow saving of data
Role Based Rules
In some cases the validation rules apply to certain roles only. (Such as a manager may be allowed to pick a value from drop down, but a regular employee cannot.)
Similarly, some may not even see an edit button, or, a particular value (e.g. Salary) on the screen, but others (e.g. HR Manager) can.
Configurable Business Rules
Not all rules can be predicted and defined up front. Once the prototype is ready, it is typical for end users to request special conditions and actions. (If a value falls between this and that, send an email.)
These situations can be configured through a configurable rules engine.
More complicated rules can further be handled in code through additional partial classes, although that does require programmer’s intervention.
Security in the prototype is available for configuration at several levels and should typically be addressed after the basic functionality is deemed acceptable and well understood by all stakeholders.
Users can be added transparently and incrementally into the prototype when people login via a third party (such as google or Facebook), or, in the context of an enterprise, using their Windows Domain account.
These users can automatically be placed into a default role, or, can be assigned to different roles.
Note that an ability to leverage built-in user management exists as well.
Roles & Permissions Management
Different roles can be defined in the prototype, and each role configured differently for permissions on the different entities
The roles can further be configured with field level security – that is a given role can see certain fields and may not be allowed to see or edit others. This provides a far more granular security than available.
Such declarative configuration allows the business users and analysts to change their requirements often (which is anyway the norm instead of the exception), without the typically associated cost of code changes.
Once the system stabilizes, the documents discussed in the earlier section can be downloaded and it automatically contains the latest configuration
Multi Tenant Security
Once effort is spent in creating an application, it hopefully has different organizations that could leverage it, but the data for an organization or end customer will need to be hidden from others. An example might be a patient tracking application that a central state agency may wish to provide to its hospitals, but when a particular hospital employee logs in, he should be able to see only patients in that hospital.
SalesForce™ is a commonly used multi-tenant application that provides such capabilities for customer relationship management.
Self Service Capability
Even if a role has an ability to modify data, there are many situations where the value of the data determines if the particular user in the role should be allowed to modify it or not. For example, a person in the role Employee may be allowed to edit Expense Report, but only if that Expense Report is his or hers.
Such self-service is another commonly required capability that is automatically available via configuration should the business users require it.
Scale and Performance
The application prototype is built to allow millions of records, hundreds of concurrent
accesses, session management that supports horizontal scaling through hardware, and many tweaks to allow the prototype to be tried in real world situations. The page performance is further optimized to be constant so that the pages almost display in constant time regardless of the data. The images are converted to thumbnails when appropriate to reduce the network bandwidth needed as well.
Excel – Import and Export
Since most organizations use Microsoft Excel™ to view and combine their data, the prototype provides the feature to export any data set into Excel.
Further, it contains additional capability to upload data from Excel. Different columns in Excel sheet can be mapped into different fields on the screen and thousands of Excel records can be uploaded with the click of a button. This is very important in the context of a prototype, and allows for quicker data population.
Search – Simple and Faceted
Search is a given and important capability. Any item in the system can be searched either from the home page or from the item listing.
In the context of a simple search, any visible property is searched for those values. Faceted search provides the ability to combine multiple fields, ranges, and values to yield search results that almost mimic a SQL query.
The search screen is further optimized to enable the parameter selection be quicker. The ranges and values are automatically computed based on the property types that are being searched.
A dashboard capability is also available in the prototype, although more to initiate discussion on the different KPI (key performance indicators) that the stakeholders would like to see.
The graphs and charts and associated data in the dashboard can be customized through code. Alternative approaches are discussed in the reports integration section.
The system provides ability to integrate either Crystal Reports or SQL Server Reporting Services. While this does require programmer intervention for completeness, the system does make it simple enough to drop reports into a certain directory and the system then automatically runs the reports.
The reporting menu is also built based on the reports in the directory. Thus, no pre-planning on reports is required – as end users determine the reports, and these reports are dropped in the directory, the screens adjust themselves.
Every change in the prototype data is tracked for who made it, when it was made, what was the old value, and the new value it was changed to.
Thus, any inadvertent change can be traced back. All changes made by an employee can be traced. Thus, prototype effectiveness and training issues can be discovered as well.
In addition to changes, the auditing subsystem also adds capability for view auditing. In the context of legal case management system, this may allow auditing to see who is viewing witness statement or who has viewed the case files
Types of Prototypes
Turanto is good for a large number of application types, however there are some types of applications it is not the right tool for. The capability exclusions include anything that requires algorithmic computation, although, it can be leveraged for other aspects of the application. Turanto is exceptional at building Management Systems (e.g. Asset Management System) or Tracking System (e.g. Tracking Registrations for a conference). Turanto is additionally leveraged in migrating from MS Access or Excel based systems to web and mobile applications
Sample Prototypes Built
– See Something Say Something: A mobile application that lets public works departments receive comments, pictures and locations of potholes, graffiti, trash accumulation etc. This allows public works department to be better connected to end users.
– Suspicious Activity Reporting: A mobile application, with GPS and camera integration, lets people report observed suspicious activity anonymously, including pictures, people, and location. Each activity report can then be managed like a lead and followed to closure. There is also report of "Near Me" so Government officers can quickly know what activities have been reported in the past.
– Milestone-Based Project Payments: A web-based application that tracks projects across the agency and payments to contractors for the milestones achieved on a project. This is not a General Ledger Accounting system, but a tracking system for contract milestones and fund payments across those milestones. A reporting and analytic system allows for comparison across budgeted and actual payments.
– Grants Management System: A web-based, publicly accessible system for NGO (Non-Government Organizations) to apply for grants for public and social work. Government establishes the needs and different NGOs apply online. Ability to upload documents, applications, profiles, metrics, and a workflow form the basis of the system. The milestone-based payments capability improves performance tracking of the granted projects. A reporting and analytic system allows for comparison across grants.
Internal Agency Policy and Compliance Management
– Policy and Procedures Management: Government personnel are subject to more policies and official procedures than at a normal private sector organization. Furthermore, these policy and procedures can change often enough and are frequently not tracked for employee acknowledgement. This web-based system enables an employee to look at the pending policies he needs to acknowledge and learn about. The senior managers are thus assured that all personnel know of the new changes and hence are accountable. An additional module lets an employee take a test pertaining to the new policy/procedure communicated to him.
– Compliance Tracking: Typically when a new policy is made there is a large list of items that have to be tracked before it can be declared that the entire agency is in compliance with that policy. This system lets each employee report in non-compliance items so that a comprehensive view of the problem is visible over time and then an owner and budget for each area can be established. Once all items are reported as compliant, the agency can be declared as compliant. Paperless Application Tracking and Management
– Paperless Application System: Whether it is an application for a license from the Government, or an application for a tender, this class of system can track everything associated with an application and application process. A self-service applicant can come in with his Facebook or Google account, login, and apply online. The applicant can upload the necessary documents and provide all of the required information online. Government officials can then manage the applications and execute the approval process. The candidate can login and see only his application status. The security subsystem controls the different roles by Government officials and what they can do with the application. The entire process is paperless and can be managed over a mobile application.
– Paperless Request Management System: Whether it is a re quest to track a building permit, or a request for a death certificate from Government, citizens can now apply for that online or through their mobile device, and track that request. Government officials can now access the metrics on work performed or the average number of days to close a request. It reduces the time taken to do the work, and yet, increases the amount of work done.
Government HealthCare Solution
– Hospital Operations System: Any Government hospital has a lot of business processes and policies and procedures beyond just tracking patients’ health records. Ordering and managing inventory, tracking operating room usage, facility maintenance, tracking injuries or incidents in the hospital caused by human or other errors, and a myriad of other issues that can be managed better if they are tracked better. Further, it provides hospital administration notifications and access to critical data over a mobile device, so the hospital can be managed better.
– Case Management Solutions: Typical Social Services agencies in Government have to track cases, witness statements, visit reports, follow ups, and the like – regardless of whether the cases involve distributing Government welfare to eligible families or helping children relocate from abusive families. These case management solutions have to be customized for the specific kinds of cases being managed, so the entire process can be made more efficient and paperless – while being more accessible over mobile devices.
Turanto is a unique prototyping system that creates a complete working prototype for many kinds of applications.
It generates a large number of artifacts and capabilities and provides the complete code for both web and mobile applications. A large number of configurable features further help end users discover and settle on requirements.
Thus, Turanto prototyping system enables an organization to reduce risk in new system development and helps engage the end users quicker, while enabling the developers to deliver a more complete system quicker.