Application Generation Comes of Age

Taking full advantage of the built-in infrastructure services of the Microsoft .NET Framework - without taking months to learn new languages, APIs and protocols - is one of the most pressing challenges faced by enterprise application developers today.

Editorial Note

This article is in the Product Showcase section for our sponsors at CodeProject. These reviews are intended to provide you with information on products and services that we consider useful and of value to developers.

To most application users, web applications look better than traditional desktop applications, and they’re also perceived as much easier to use. Web applications afford the opportunity to reach out to both internal and external users like never before, and many organizations are enhancing web applications to integrate customers and suppliers, in addition to internal users.

At the same time, building web applications put you, the developer, in a completely different scenario. Web-based applications add additional development burdens of security, stateless transaction management, page-based navigation, as well as a variety of user interface features, that you wouldn’t normally worry about in traditional desktop client-server applications. Even though platforms like the Microsoft .NET Framework deliver the basic OS-level services for these applications, you still must write SQL statements, create hundreds of web pages, and code the business logic.

Smart IT departments are efficiently conquering many of these critical issues, and focusing resources on creating intellectual property that's truly unique to their businesses. They are using a new breed of software tools called application generators to eliminate hand-coding of the infrastructure programming.

Application generation takes a giant leap forward, offering a broader, more comprehensive solution. Application generators such as Iron Speed Designer create a significant portion of your entire application for you, frequently as much as 80%-90% of the application.

Accelerating the development cycle without sacrificing performance, features and interoperability, are key benefits provided by application generation.

This white paper describes how one application generator, Iron Speed Designer, works. It uses an Iterative Drag and Drop development style most professional application developers find comfortable.

Imagine creating 80% to 90% of your application just by dragging components onto web pages in a visual editor. All of the components – tables, panels, and controls – are magically hooked up with each other and the underlying databases, and all the associated code is generated for you. That’s exactly what Iron Speed Designer does, illustrating the power of drag and drop application generation.

Iron Speed Designer’s approach to application generation is very straightforward:

“Drag and drop” application generation recognizes that only a small percentage of the code in any application is the “secret sauce” – the truly unique elements of business logic that differentiate one application from another. The vast majority of most web applications consists of fairly standard components – tables, panels, and controls – that lend themselves to being automatically generated and connected by an application generator. Only the unique application logic remains to be written by hand.

A brief example illustrates this point. Suppose you need to build an order entry system that allows sales people to create, edit and retrieve sales orders. This application might have an input form for adding and editing orders and a table page for displaying orders for any given customer. Using drag and drop application generation, the developer drags tables (data grids), fields and other components onto web pages and then selects the appropriate mapping between the underlying database and web page components. When ready, the developer lets the application generator produce the underlying application source code and SQL, including code for all of the web pages, controls, and database connectivity infrastructure.

Applications like these lend themselves well to application generation because they use typical database connectivity and application infrastructure. Data is either being entered into a web form and inserted into the database or data is beinig retrieved from the database and displayed on a web page. These data operations are ideal for a templatized approach to application development, enabling an application generator to create the application and its infrastructure based on code templates – standardized and well-accepted ways to perform certain common operations.

Why is this drag and drop method so important and useful for modern .NET application development?

This is how developers work. Most application development projects start with a handful of HTML page mock-ups – or white board sketches – and a database schema. Iron Speed Designer uses your web page designs and database schema as inputs and generates a large volume of custom infrastructure code, including all the transaction processing code and SQL, in a fraction of the time of hand-coding.

Application users are familiar with the web and with sophisticated forms and navigation features. Most developers dread building features such as paginated reports, hierarchical navigation, filtering, and full text search, because the amount of time required is not proportional to the challenge or interest they create. They look simple to implement and application users expect them, but there’s usually quite a lot of coding involved. Iron Speed Designer automatically includes these sorts of features, freeing you to focus on more interesting application logic work.

Connecting individual pages to the database is mind-numbing work. Each page in a web application can contain five or ten separate SQL queries, each of which has to be written, debugged, and vetted for performance. However, by using application generation tools, you don't have to worry about manually programming web pages, controls, or SQL. The repetitive nature of data insertion, retrieval and display operations permit their use as repeatable templates, or code patterns, in an application generator.

Implementing transaction-based web applications can be difficult because of the stateless nature of the web. Because web applications are stateless, they can require complex database management to implement complicated transactions, especially those spanning multiple web pages. While a client-side browser can display pages, it can't be used to implement database transaction logic. As a result, the server-side application must coordinate and manage every aspect of these database transactions.

The next chapter shows how Iron Speed Designer builds each of these layers.

Translating an end-users' vision into a functional and intelligent web application requires three main steps, each of them non-trivial.

Design and create the hundreds of web pages required to access and run your application, including input forms, reports, and data displays;

Build the application's basic functionality, augmented with sophisticated features ranging from filtering and sorting, to search and pagination;

Connect the pages and their components to the database, implementing the underlying SQL and transaction management code.

Fortunately, Iron Speed Designer can help with each of these steps. In fact, the process begins with your vision, turning your HTML pages into sophisticated, custom ASPX pages with the underlying code and SQL.

Iron Speed Designer is an application generator for building full-featured Microsoft .NET web applications in just a couple of hours, shaving months off the development cycle. Iron Speed Designer is different from other rapid development tools because it works just as most developers do, from the application’s user interface inward to the underlying data model. Plus, the tool generates complex user interface pages, and all the SQL and supporting code, without you having to design or code the pages, or know SQL.

Using Iron Speed Designer, a custom, working application—not just a prototype or individual components—is generated in just a few hours. Modifications and enhancements to the user interface and application layer are preserved each time your application is regenerated.

Typically, only a handful of high-level pages are actually mocked up by a web designer, and the developer must create the rest of the pages by hand based on these designs. Or, maybe the developer is left to his own imagination when it comes to application design. While designing the application's look-and-feel is not trivial to begin with, repeating it over and over for each of the hundreds of pages required to run your web application is a significant chore.

Iron Speed Designer saves you this struggle by automatically creating a suite of pages for each database table or database view in your application. These pages reflect the basic operations performed with any database table: Create record, Retrieve record, Update record and Delete record –sometimes referred to as C/R/U/D pages.

Iron speed Designer goes beyond these basics, though, by creating these pages, using only the schema information provided by your database:

Show Table – a paginated, interactive report view of a table or query’s data.

The generated pages include corresponding application layer code, database transaction management code, and the underlying SQL queries and stored procedures. All of the generated pages are automatically linked together with a menu navigation structure, providing an out-of-the-box application with no additional coding required.

How physically attractive are these automatically created web pages? Iron Speed Designer uses a template-driven approach to generate web pages. Over 25 different design themes are included with the product, providing a variety of layouts, color schemes, and other important visual attributes. In short, generated applications look great without any customization. More importantly, these design themes can be customized, allowing developers to either modify one of the design themes to their liking or create one of their own.

Design themes are comprised of an extensible set of HTML panels – snippets of HTML that can be as simple as one tag or as complex as an entire page. Panels contain the code generation tags that instruct Iron Speed Designer to generate data-bound controls at specific locations in the web pages. (More on this shortly.) Panels can also contain VB Script, Java, DHTML, or any other presentation layer code that is desired in the final application. Panels can utilize a common style sheet, ensuring look and feel consistency between panels, or the panels may be completely unrelated.

Because developers can add their own panels to a design theme, the application generator is extensible, allowing developers to replicate visual elements of their own design from application to application.

Iron Speed Designer uses a set of intermediate web pages called layout pages to define your application's web-based user interface and underlying functionality. Iron Speed Designer translates these layout pages into a working n-tier application with well-partitioned service layers.

Layout pages are just HTML pages containing simple XML-based code generation tags that instruct Iron Speed Designer which components to generate in the final application – everything from a data grid table to filters to data-driven menus. Code generation instructions correspond to HTML and source code templates that are automatically included and customized to the specific application when Iron Speed Designer generates application.

You insert code generation tags at each place in your HTML layout pages where you want a page control to appear using several methods:

The Application Wizard that automatically generates template-based pages for you.

Once your code generation tags are placed in your layout pages, a set of wizards and properties dialogs gather the information required to connect the resulting controls to the underlying databases and to set other application parameters. You specify which database tables, fields, and views to use for each component. Thus, most of the traditional coding process is reduced to a straightforward configuration exercise.

When generating the application, Iron Speed Designer reads the code generation tags in the layout pages and generates corresponding .NET data-bound controls, server-side code-behind logic and transaction management code – ASPX, C# or Visual Basic and SQL – that is the bulk of the application. Thus, you do not have to write any code to create sophisticated user interface-based applications with Iron Speed Designer. (Code generation tags have no run-time effect on your application because they are not present in the generated application.)

Most IT departments have an SQL “ombudsman” who is an expert SQL DBA and checks the SQL code written by all the other developers. Iron Speed Designer simplifies the developer's and the ombudsman's tasks by automatically generating every SQL query, and the wrapper code around it, for each web-based component that accesses the database.

The code generated for the presentation, application, and database layers is itself template-based, just like the previously described HTML panels. Thus, application developers can change the code that is regularly generated for each application to include specialized features that might be commonly used within an organization.

It’s virtually impossible to generate applications that require no code customizations – extensions made by hand to the generated application to add custom application logic, integrate with third-party components, and interface with external systems. While many administrative and data management applications can escape the need to write any code by hand, most production applications have some amount of hand-coding.

The application generation process must generate code that is readable, easy-to-understand and easy-to-modify; otherwise the time benefits achieved by application generation are for naught. Perhaps the principal concern in using an application generator is understanding how you extend and customize the generated application so that your enhancements are preserved each time the application is regenerated.

One of the biggest challenges of application generation is that of orphaned code. Orphaned code is code that, once generated, cannot be modified or extended without severing the application generator’s ability to regenerate that code without losing one’s code customizations. In today's high-pressure IT department, there is no place for code that can't be leveraged for both current projects and future applications.

Iron Speed Designer allows your application to be regenerated repeatedly without requiring you to re-integrate your external code extensions. This is accomplished using a class hierarchy in the generated application, which has set of safe class files expressly for code integration that are not affected by application regeneration. While there are several layers of safe classes at various points in the generated application, safe classes are typically at the top of the inheritance hierarchy, so they inherit from all of the generated code underneath them. This means your code customizations have access to the full functionality of the generated application, all the way down to the .NET framework.

Iron Speed Designer generates the underlying safe classes for your application only once, typically the very first time each page is generated. Once the individual safe class for a page has been created, it is never overwritten, thus making it safe to add your own code to and modify these safe classes. Only the generated class files – the automatically generated portions of your application – are ever regenerated; the safe class files are never regenerated, preserving your code customizations.

In most applications written for the Microsoft .NET Framework, the functionality and logic in the Application Layer are derived from a set of C# or Visual Basic .NET (or other .NET common language runtime language) classes for page management, database access, and data validation. These classes provide advanced user interface controls and server management.

The class hierarchies generated by Iron Speed Designer derive from the base classes in the .NET Framework. Sub-classing allows you to intercept Windows messages going to a form or control, among other benefits. As long as your modifications are physically segregated in safe class files, your application can be regenerated repeatedly without re-integrating your code extensions.

Using Iron Speed Designer, simply subclass the appropriate page, control or database object in the appropriate safe class file and add your code extension. You can override any of the functions or methods in the generated base classes, or write your own methods in combination with the existing base class methods. Then, regenerate the application to reflect your changes. Your code extensions are not overwritten when the application is regenerated, allowing you a high degree of flexibility in making code extensions to the application.

Iron Speed Designer generates native .NET code, including ASPX pages, ASCX controls, SQL statements, C# and Visual Basic code. Developers enjoy unrestricted access to 100% of the generated code and any modifications to the application are automatically preserved when the application is regenerated. There are no run-time license fees or special server software requirements for applications built with Iron Speed Designer.

Even for experienced developers, scalability is hard to implement. Since all of the business logic in web applications is concentrated server-side in the application layer, scalability becomes a big issue for web applications. Functionality isn't distributed to the client-side as it is with client-server applications, so you can't rely on the application user's machine to off load computationally intensive tasks. Hence, improperly designed applications can cause performance bottlenecks in the middle-tier. Iron Speed Designer builds applications with a three-tier architecture that scales easily, including optimized SQL, and advanced transaction, cache, and session management techniques.

There are likely dozens of different pages in your application that each need SQL queries to implement functionality, plus wrapper code to glue it all together. Those pages include input forms, reports, and all sorts of pages where data is displayed in a variety of formats. Writing the SQL queries is often the most challenging task for web application developers, usually requiring the help of a DBA or SQL specialist.

SQL statements are hard to write even if you are an expert. However, writing efficient SQL queries can have a genuine effect on the performance and scalability of your application. This is especially true in the state-less environment of the web, where maintaining transaction state between pages is difficult.

Iron Speed Designer approachs SQL generation from an efficiency perspective. For example, it places queries for multi-table joins in a single query to reduce round trips to the database. For optimal performance, it takes into account fields that are indexed. It even gives you the choice of placing your SQL directly in the application layer or in stored procedures.

Technology that generates SQL statements must be tied specifically to your database schema. Generic queries (queries composed on-the-fly that do not use parameterized field values) can slow down application performance since they often require several round trips to the database to complete. Specific queries that include the names of field values save trips because they use the actual field names from your database. This is how you would write the statements by hand.

Most DBA's prefer keeping SQL in stored procedures because it keeps all the queries in one place where they can be conveniently accessed and reviewed. Moreover, storing SQL in stored procedures can improve efficiency by pre-parsing the queries and reducing round trips to the database. Iron Speed Designer, for example, gives you the option of placing generated SQL statements in stored procedures instead of in line, in the application code itself.

Most developers use stored procedures to enhance run-time performance and minimize the number of round trips between the application program and the database. Getting information into and out of stored procedures must be done through a technology that interfaces with the database, such as ADO.NET.

There are, of course, good reasons to place SQL queries directly in the database as well (e.g.: legacy applications and DBA preference). Because Iron Speed Designer generates all the SQL statements, developers don't have to learn proprietary stored procedure languages, such as PL/SQL (Oracle's stored procedure language) or Transact-SQL (Microsofts SQL Server’s language).

In web-based applications, it's particularly difficult to maintain state from one page to another because of the stateless nature of the web. This makes it important to understand what constitutes a transaction and when it should be committed to the database. For example, it is often difficult to construct transactions that gather data across multiple pages, such as a shopping cart, because there are few options for storing information collected on those pages other than in the database, in the .NET cache, or in browser cookies.

Iron Speed Designer frees you from the burden of implementing these schemes.

In any multi-user environment, concurrency becomes an issue when two users update the same record in the database, one after the other. The way your application handles concurrency affects the ability of your application to handle simultaneous transactions against the same records.

In some applications, the second user to update a record will overwrite the changes made by the first. In others, the application will warn the second user that the record they are viewing has just been updated. In still others, the second user's view is automatically updated when the first user updates the record.

In traditional application development, the developer has to hand-code concurrency handling into the application layer. This can be tricky code to write, and it has to be written for each transaction in your application. Unfortunately doing it right doesn't earn you any special recognition whereas mistakes can have you hunting bugs for days. Iron Speed Designer creates this concurrency management code for you, saving hours of hand-coding headaches. It generates optimistic concurrency handling code for each of your transactions so users cannot unintentionally overwrite each other's changes.

A database cursor is the resulting set of records returned by an SQL query. The cursor allows you to request each record in sequence so that the query results may be displayed in a data grid, report or otherwise operated upon. For example, as an application user moves from page to page in an on-screen report, the subsequent page's data is retrieved from the cursor and displayed. It's also commonplace for applications to iterate over the result set, performing some calculation or other update to each of the records in the result set.

Data recency. One issue that emerges with cursors is the freshness of the data in the result set. As long as the cursor is in use, it contains the set of records retrieved when the query was originally performed. However, this data may grow stale over time, especially if the query result is being displayed in a screen that an application user is reviewing over a period of time – minutes or hours. In applications where the underlying data changes frequently, it may be desirable to rerun the SQL query as the application user moves from page to page in their report. This ensures that each displayed page has the most current data. While this also places an extra load on the database because it must rerun the query more frequently, all modern relational databases have very good data cache management that significantly reduces the cost of frequently rerunning queries.

Data management. A second issue to consider is whether the entire result set is pulled from the database into the application layer, a well-known problem with .NET data grids. When a result set contains only a few hundred records, moving all of the data into the application program requires minimal bandwidth and memory to store and manipulate the result set in the application. However, when the result set has hundreds of thousands or millions of records, it becomes nearly impossible to efficiently move all of that data into the application program. Very few application programs are structured to manipulate that quantity of data in memory without additional file management logic, which defeats the purpose of using the underlying database which provides exactly these facilities. So, in applications where the result sets can be large, it's best to retrieve only a manageable subset of the result set from a cursor – such as one page of data – operate on that data, and then request the next subset.

Applications generated by Iron Speed Designer use database cursors to retrieve data from the database. The cursor is used to retrieve the number of records being displayed on the database table view web pages. Only one page of data is retrieved from the database and displayed at a time, minimizing the data transmission load and the application's memory storage requirements. Query results are not stored in a temporary database table view. They are retrieved directly from the database and displayed to the user.

Although most corporations take security precautions at the network level, the majority of application security must be built into the application code itself. Further, as much as we all wish it, the hackers and thieves will not disappear, especially when our networks connect to the public Internet and interface with outside customer and supplier systems. The bottom line is that a large part of your application security is in the program code itself. You can increase your application's security by taking advantage of the powerful benefits of application generation.

Applications generated with Iron Speed Designer utilize the highest level of security features offered in the .NET Framework and include built in security. Additionally, you can easily add features such as Windows authentication and active directory single sign-on. And, applications generated by Iron Speed Designer work well with existing network firewalls.

Building web applications is complicated and time-consuming. The ROI from using Iron Speed Designer versus hand coding means more efficient utilization of key personnel, reduced development and testing time, and more rapid deployment of robust applications.

Let us show you how Iron Speed Designer can accelerate your web application development efforts overall, and jump-start your Microsoft .NET application development.

Application Layer - native .NET program code: Easily extensible class hierarchy built on the .NET Framework base classes, as well as enterprise-class features such as role-based user access control.

Database Layer - all your SQL and transaction management:All the SQL queries for data display and reporting as well as record insertion, modification and deletion. Advanced features include multi-table joins and a page-based transaction model.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

Share

About the Author

Iron Speed makes software development tools for database application developers who need to build powerful, enterprise-class, Web applications in less time, and with fewer resources. The company?s flagship product, Iron Speed Designer, quickly creates about 80% of an application?s infrastructure programming, allowing developers to focus on the remaining 20% of the application logic that is unique. Iron Speed recognizes that developing Web applications is more complicated than traditional application development, and so provides software development tools for IT departments looking to take advantage of the flexibility and extensibility of Web-based applications.

Comments and Discussions

Right after the installation was getting stuck and crashing on the splash screen, had to try 5 times to generate the actication code, and in the end the code I received in the email doesnt work and doesnt even give an indication what's wrong... great first impression for a 2k+ product... NOT!!!

I believe this approach to development is the future. Unfortunately, I agree that this software is way over priced, and directed at the Corporate level.

I hate to steal the wind out of your sail, but there is a free tool out there called MyGenerations. (http://www.mygenerationsoftware.com). This is for .NET 1.1 development and they also have a 2.0 version called Entity Spaces (http://www.entityspaces.net). The 2.0 version you have to pay for but the maximum you will be charged is $400.00 for one year of support and updates.

What's nice about this code generator is that it can handle most popular DBMS products. The software is template based, anyone can build their own templates, and there is a large community developing templates to apply all sorts of patterns.

Wow! This is a tough crowd. I stopped here to have a look at this app and to get a feel for what some of the reviewers thought. Not impressed at all. Oh, I’m not talking about the application, I’m referring to most (not all) of the comments. After more than 30 years as CEO of a fairly successful software house, I know two things for certain: Set your price to whatever you feel is right; the market will tell you if you need to re-think. And, a lot of the things that seem not to work quite often resolve themselves with a little training/learning. A little T&L eliminates a lot of PEBCAK, which I am sure you all know well as “Problem Exists Between Chair And Keyboard”.

To the gentleman who speaks on behalf of that really big, big, big client: I remind you that it is not possible to lose what one does not already possess. And finally, to you Mr. Lopes: When referring to my country, please have the respect to spell its name correctly. I am an American; that’s with a big ‘A’.

Now, I will remove myself to the website of the owner of this application and continue my evaluation. I remind you all (and myself) of the words of Abraham Lincoln who said, “Better to remain silent and be thought a fool than to speak out and remove all doubt.

I used it against our current app db with 60 tables.
Point Ironspeed at the db and presto chango... magic

Builds, compiles, adds all the store procs, and you up and running in 30 mins. (After a little tweaking of the configuration of course)

Sure the first page is slow to start up.... but that is only the first time you hit the page.

After that first page cached everything is pretty quick.

If you an experienced dev there might not be much of reason except for a tonne of automation of mundane tasks and very quick development.
(ohhh the dreaded CRUD sp's...bleh...)

But if your in the Application development and customization gig then you sell your Application (that you built using a ironspeed friendly design) to the client and then package up Ironspeed with your app and sell it to them (or get them to buy it) as a customizable software solution.

But if you don't need the the fancy UI that Ironspeed provides then there is always codesmith and .nettiers.

Considering the potential and facilities .NET 2.0 offers, and how easy is to setup apps to work with different and various Databases at the same time, I think your product should have seriously considered supporting not only SqlServer.

The company I work for is one of the biggest in Latinamerica, and was very interested in your product, but we work with a Sybase database as well as with SqlServer. You lost a big big big client over here.

I tried using your application on a simple table and it not only took 2 minutes to run, it then came up with a compile error.
I then tried using your knowledge base of solutions and guess what, just like microsoft, there was no solution.

1) It looks like some tv-shop product name that will change our life cause it saves 10sec time in kitchen
2) What is the speed of iron?
3) It just looks like you made your name with your product, i.e., you dragged 2 strong labels without connection to your workspace, it sounded good and let's ship it.
4) Doesnt sound professional
5) Sounds too much american, like those stupid products names for dumb people. Something-o'matic and similar.