Problems and pitfalls in software development

Stable requirements are the holy grail of software development. Anybody who ever tried to develop an application knows that there is no such thing as stable requirements. The customer's additional demands and changes in the already existing functionality are frequent, annoying and unfortunately unavoidable. These demands and changes in later stages of development can considerably delay the project, increase the development costs, and easily turn a simple project into a very complicated reality. It would be a comfortable privilege to have a tool which enables the developer to elegantly and efficiently resolve every last-minute customer's request.

Programming represents the largest part of software development and can sometimes take up even 80% of the total time spent on a project. Unfortunately there is also the influence of the human factor which cannot be ignored in this stage. Often, the source code contains bugs caused by programmers which must be corrected. Programming is tightly connected with debugging. And debugging is a cumbersome, tiring and time-consuming process.

Every application development is limited in time. If too much time is spent on programming and debugging, less time is then available for focusing on the content of the application. And consequently the final solution will lack in quality. All this emphasises the need for a tool that would completely eliminate or at least reduce to the minimum the influence of the human factor from the process of programming. In order to achieve that, an automatic code generation tool is needed. Such a tool will generate the source code for the developer on basis of his demands, needs and wishes. An automatically generated code will thus eliminate the influence of the human factor, enhance reliability and speed up the development process. And finally, it will reduce the costs and enhance customer satisfaction.

Existing software development tools offer developers a number of ways to create an application. The technologies behind these tools are very complex and require specific in-depth knowledge to use them and see the whole picture. Mostly involved in the projects, developers have little time to keep pace with the current state-of-the-art technologies, which means that the developer is not competitive any more.

Also the communication gap between field experts and programmers is an eternal problem. Field experts have good knowledge about field content, they are aware of all the problems and pitfalls but usually they lack programming skills. On the other hand programmers have excellent understanding of software but know very little about how to solve content issues.

A simple and easy-to-use tool for application development without any programming skills and in-depth knowledge of technologies would make it possible for a non-programmer such as field expert, to develop any application completely on his own. With the inclusion of field experts in the development process, the development team becomes larger and the communication gap smaller; the latest technology becomes understandable and usable even by a non-programmer.

What is the MX-Developer

MX-Developer is an excellent tool for building powerful and visually stunning applications. It is extremely fast, reliable and requires no programming skills. The latest technology built in MX-Developer advanced features shortens the development cycle, simplify testing procedures, eliminates debugging, and lowers the costs.

The backbone of MX-Developer are its intelligent designers. These smart graphical components or tools enable the developer to design different parts of an application completely without coding. With their use the applications are configured simply by pointing and clicking. The application code is generated automatically on basis of intelligent designers configuration. As a result the code is consistent, robust, repeatable, and bug free. And what's more, MX-Developer also contains a rich set of built-in graphic controls tailored to fit the designers perfectly.

Data layer

Data access layer is the foundation of every application. MX-Developer's intelligent designer called MxAdapter is used to create data access layer of any complexity. It provides simpler access to different data sources and data manipulation within the data source without having to deal with the complexities inherent in this access. In simpler words the MxAdapter hides the complexity of the underlying data source from the developer. Another important feature of the MxAdapter is a uniform configuration of different data sources, which is achieved with abstraction of data sources supported in it. MxAdapter supports:

• SQL 2005
• Oracle 9i and higher
• Web services
• OPC

The behaviour of the MxAdapter is standardized. This allows joining data from different data sources such as SQL or Web services together, which provides the end-user with a better overview of the data, improves analytics, and simplifies business decisions.

Image 1: MX-Frame Data Adapter Designer

Data source browsers integrated in the MxAdapter enable the developer to easily browse through data source objects such as tables, views, stored procedures, functions and methods. The MxAdapter also makes automatic mapping between MxAdapter 's objects and objects in data source possible. This feature is generally known as Object-Relational Mapping or ORM. Beside relational data sources such as Microsoft SQL or Oracle the MxAdapter also supports non-relational data sources such as Web services or OPC.

The basic CRUD statements (SELECT, INSERT, UPDATE, DELETE) for data manipulation are available by default in the MxAdapter . But the MxAdapter also allows adding any number of extended statements, readable or writable.

The statements manipulate with data through objects called data schemes. A wide variety of data scheme properties in the MxAdapter enables the developer to fine-tune the behaviour of each element or field within a data scheme and satisfy even the most complex demands.

Linking different data objects by relation such as Master-Detail is a common demand when developing a business solution. But the implementation of such functionality in an application means a lot of coding. With the MxAdapter, the establishment of Master-Detail relation between different data objects has never been easier.

Document handling is also a sensitive task. Let's take the common example of multiple users per one document: errors or misuses are practically inevitable and their origin impossible to determine. The solution is in change tracking, or audit trail. With the MxAdapter, audit trail can be enabled on every field with just one click.

Preventing users from unauthorised changing of sensitive data or starting of actions is another challenging task which requires the time-consuming implementation of authorizations or electronic signatures. The MxAdapter is designed to support this functionality and adding electronic signature to an action becomes a matter of seconds.

Application logic is represented by expressions, i.e. combinations of values, variables, operators and functions. Usually, implementing and evaluating application logic requires time and programming skills. With the MxAdapter's easy-to-use Expression Designer, the developer can define any type of expression without writing a line of source code, while the Expression Engine evaluates this expression according to defined rules and returns a computed value.

Business layer

Business logic is the heart of every application but its implementation requires the majority of time available for application development. Fast and simple implementation would save time and lower the costs. And fast and simple implementation is possible with MX-Developer's MxDiagram, an intelligent designer for creating complex business logic:

• Its graphic environment enables the developer to design a logical sequence of events or workflow in the application, in State Diagram fashion. Business logic design is very simple and intuitive with the MxDiagram. For example business logic can be divided into several workflows. Each workflow or sequence of events can be further divided into a series of steps linked with connectors. These steps represent different functionalities or actions in an application. The direction of transition between two steps is defined with connector which can contain a condition for successful transition from one to the next step. To easily manage these conditions the Expression Designer is also integrated into MxDiagram.

• MxDiagram offers a rich set of predefined steps which cover a wide range of functionalities.

• Variables are another powerful feature of MX-Workflow. The developer can add any number of variables which can be used during workflow execution (for example to temporarily store or transform some data).
  

• Workflows are executed by the MxDiagram execution engine according to their design, context, and operation mode. MxDiagram execution engine ensures robust, repeatable, and reliable workflow execution in different contexts:
  • Periodically
  ,
  • Interactively or
  • Event-based.

• Workflow has three operation modes:

  • Normal - default operation
  • Fault - error operation
  • Cancel - cancel operation

• By default execution engine runs every workflow in the normal mode of operation. In case of an error (e.g. the condition was not fulfilled), the execution engine switches the operation mode to fault and execute the error handling routine. With the cancel mode, workflow execution is stopped externally (e.g. by user).

Visual stunning front ends

Advanced controls

To create powerful and visually stunning user interfaces MX-Developer offers a wide variety of advanced graphic controls. Built-in controls such as charts, pivot grids, advanced grids, etc. will astonish every customer. But adding such functionality demands quite an amount of work.
With MX-Developer, implementing becomes easier than ever. The developer does not need to write a single line of source code to implement these easy-to-use controls, but just drag the control on the user interface and set the data source. Complete personalization of the control's look and feel and behaviour is enabled through an extensive set of properties.

Pivot Grid with interactive charting support

Reports

Reports are an inseparable part of almost every application. With the MxReport designer the developer can easily create any type of report and combine data from different data sources such as SQL or Web services in the same report.

Wizards

Sometimes the user of an application has to perform a complex or rarely used task, which consists of a series of steps that must be executed in a specific order. This complexity of the task and the limited knowledge of the end-user can result in mistakes. To prevent that and to lead the user safely through the whole procedure, MX-Developer offers another powerful tool - the MxWizard designer. The wizard is a user interface which offers the user a sequence of dialog boxes and leads him through a series of steps to perform tasks in a specific sequence.

State management

MX-Developer includes another designer, i.e. State Management which covers two different functionalities. First, State Management allows to save the state of one or more controls such as label, text box, combo box, grid, etc. in a user interface. Next time when the user opens this user interface all previously used control values will be loaded.
The second important functionality of State management is an event-driven change of appearance and behaviour of the user interface control. In this case, data events such as data loading, data updating, etc. can be used as triggers which change the appearance or behaviour of the control.

Navigation

To find the desired functionality quickly, clear and simple-to-use application's navigation (menu) is important. MxNavigation designer enables the developer to create visually impressive menus. It contains runtime preview which allows the developer to immediately see an eventual change in menu appearance, without recompiling the entire application.

MX-Client Navigation Sample

Extensibility

And if all functionalities described above are not enough, MX-Frame architecture allows adding custom source code at any level of the application. Thus, the developer still has the possibility to influence the source code.
Another important aspect of extensibility is the openness of the MX-Frame object model. This open architecture allows the developer to easily extend basic functionalities of MX-Frame by adding new MX-Frame components such as a new data source (e.g. MySQL).