Hakaya Studio


Create Your Own Modeling Tools With CML PDF Print E-mail
Written by Hakaya Studio Web Admin   
Friday, 13 August 2010 16:09


intellegence    

The use of automation in manufacturing (e.g., Automobile industry) has introduced great benefits to the different industries. In comparison, the software industry is still in the dark ages. We undoubtedly produce software by backward techniques. The industry continues to hand-stitch applications distributed over multiple platforms housed by multiple businesses located around the planet. Most developers build every application as though it is the first of its kind anywhere. As a result, approximately 70 percent of software projects started fail to deliver what originally was intended without going over budget, missing the deadline, or sacrificing quality. The Hakaya Studio is intended to facilitate the move to software industrialization by providing the necessary tools needed to build the factories that produce the software “product lines”.

The use of automation in manufacturing (e.g., Automobile industry) has introduced great benefits to the different industries. In comparison, the software industry is still in the dark ages. We undoubtedly produce software by backward techniques. The industry continues to hand-stitch applications distributed over multiple platforms housed by multiple businesses located around the planet. Most developers build every application as though it is the first of its kind anywhere. As a result, approximately 70 percent of software projects started fail to deliver what originally was intended without going over budget, missing the deadline, or sacrificing quality. The Hakaya Studio is intended to facilitate the move to software industrialization by providing the necessary tools needed to build the factories that produce the software “product lines”.

The Hakaya Studio is a productivity tool for software development. It utilizes the software factories technology and domain modeling techniques to enable users to build quality applications faster and cheaper. The tool enables users to automate the generation of high quality code from visual models. It supports different programming technologies such as .NET, Java and open source and different platforms such as desktop, web and PDA.

 

The Hakaya Studio ships with the following modules:

 

  • Visual designer for domain modeling
  • Hakaya builder engine
  • Hakaya runner engine
  • Code Generation Templates (CDT) Editor
  • Studio IDE

 

Before going into the details of the Hakaya Studio, consider the basic steps involved in the mass production of some product:

 

  • The process starts by designing the product.
  • Designs identify the basic components necessary to assemble the product.
  • Reusable modular components are then introduced into designs to enable mass production. These components along with their relations and interactions define the manufacturing processes
  • Engineering firms utilize the identified manufacturing process to design and build the factory
  • The factory machinery then assembles the product from the reusable components which are governed by specific behaviors and interactions. Variants of the product can be easily introduced through simple reconfiguration process.

 

The Studio operates in a way similar to modern industrial manufacturing processes where finished products are assembled from reusable components. Drawing on this comparison, developing code in the studio goes through the following steps:

 

  1. Identify the artifacts (concepts) and relations for the domain under consideration.
  2. Model these artifacts and relations using the Hakaya Visual Designer module. The constructed model defines the Concept Modeling Language (CML) for the domain.
  3. Develop the Code Generation Templates to define the behaviors and interactions of the artifacts and relations. The templates along with the artifacts and relations constitute a domain model and represent the blueprint for building the software factory.
  4. Convert the domain model (blueprint) into a software factory utilizing the Hakaya Builder Engine. This software factory or code generator represents a configurable tool that allows users to build applications via visual models that utilize the pre-defined domain-specific artifacts and relations.
  5. Utilize the Hakaya runner engine as an environment to run the software factory and start building applications. The development of such applications will only involve putting together visual models and no or minimum code modifications. The runner engine then generates the actual application from these visual models.
  6. Using the same software factory, create variants of the same application or different applications.
  7. Repeat the above steps for different domains. If the different domains could be defined by the same domain model then a single software factory should be sufficient.

 

Figure 1 describes the above steps from the Studio components perspective and how they map to standard manufacturing processes. Colors imply similar processes. Note also that the software factory component on the Studio side (grey) is an output of the Builder Engine and is not part of the actual Studio. This means that users could build any factories they desire.

 

cmlcomparison

Figure 1: Developing applications using the Hakaya Studio

 

 

 

As an example, let us consider the development of an ERP application with specific focus on the HR component:

  1. A user starts by defining the important artifacts/concepts and relations for an HR application. Important artifacts and relationships for such an application:
    1. Employee
    2. Band/level
    3. Salary Range
    4. Market Competitiveness
    5. Organization
    6. The Band artifact has a 1-to-1 lookup relationship with the employee artifact
    7. Cost center
    8. The Cost center artifact has a 1-to-1 lookup relationship with employee
  2. The user models the above artifacts and relationships using the Hakaya Visual designer.
  3. The user defines the interactions between the artifacts and/or the relationships via code generation templates. For example, to find the salary range for an employee we need to know the employee band and then map that to a salary range.
  4. The Hakaya builder engine integrates the code generation templates with the artifacts and relations defined in the Visual designer. It then produces the Software factory or code generator for the HR application.
  5. The user runs the software factory via the Hakaya runner engine.
  6. The factory provides the user with the capability to build HR applications via visual models that incorporate the concepts and relations defined in step one and governed by rules established in the code generation templates.
  7. At any time, the user could return to the factory environment and reconfigure his HR model to add enhancements, change the application, or build a whole new application. Note that one domain model could produce a multitude of applications depending on how it was designed.

 

Using the Hakaya Studio means producing software in a predictable and repeatable manner which, in turn, produces many benefits:

 

  • Reduced time to market
  • Improved quality
  • Reduced dependency on the human factor and the human skills
  • Enhanced productivity
  • Increased ROI

 

Furthermore, when integrated with other products the studio introduces additional benefits that give the edge against competition,

 

  • It differentiates these products from competition
  • It introduces new business opportunities that could bring in additional revenues

 

With the Hakaya Studio, programming becomes much more efficient. The key to success is the proper modeling of the domain. The resulting Software Factories become well-tested code generators that could be configured to efficiently create many variants of a single product from visual models. That is capitalizing on the commonality and effectively managing the variation in the product line.

To further increase productivity, the Hakaya Studio ships with pre-packaged factories that allow developers to start building business and databases applications instantly. BizForge is one such factory. Designed by the Hakaya team, BizForge generates 100% of application forms, database schemas, stored procedures, layers, security and reports. The Studio has been utilized in building several applications and it proved that it could generate 70%-100% of the code depending on how well the original domain was modeled.