Build WEB 2.0 Application Without Hand-Coding

Posted by: Alan S Fisher , on 12/22/2008, in Category Product Articles
Views: 63541
Abstract: Iron Speed Designer builds database, forms, and reporting applications for .NET – without hand-coding. The tool enables you to quickly create visually stunning, feature-rich Web 2.0 applications that are easy-to-customize and ready-to-deploy. In this article, we will explore the key features of the Iron Speed Designer tool.
Use Application Generation To Expedite Web Application Development
This article comes under the Product Articles section and provides useful information on some cool .NET Products.
Iron Speed Designer builds database, forms, and reporting applications for .NET – without hand-coding. Quickly create visually stunning, feature-rich Web 2.0 applications that are easy-to-customize and ready-to-deploy. Iron Speed Designer accelerates development by eliminating routine infrastructure programming, freeing you to focus on our business logic.
Increasingly, developers, CTOs, IT business analysts are turning to a new, breakthrough approach for rapidly developing robust web applications: Application Generation.
Iron Speed Designer can be downloaded from here: IronSpeed Free Edition
Build Stunning Web 2.0 Applications Quickly
Developing Web 2.0 applications provides an opportunity to bring desktop functionality to the web by building highly-creative, user-friendly applications like these:
To most application users, Web 2.0 applications look better than traditional desktop applications, and they’re also perceived as much easier to use. Web 2.0 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 paradigm. Web 2.0 applications add additional development burdens of security, stateless transaction management, page-based navigation, as well as a variety of user interface features, which 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 your application’s 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 combines point-and-shoot application generation with Web 2.0 functionality, speeding development and reducing costs.
Why Application Generation?
Why is application generation so important and useful for modern application development?
Ø Speed application development and deployment. Application generation saves weeks and months of development time by generating the routine infrastructure code, freeing you to focus on your business logic. Most application development projects start with a handful of page mock-ups – or white board sketches – and a database schema. Iron Speed Designer uses your database schema as input and generates your application’s infrastructure, including the transaction management code and SQL queries, in a fraction of the time of hand-coding.
Ø Reduce development costs. Creating applications in a fraction of the time means you can develop and deploy applications faster and more efficiently with less cost in human resources. Your clients will be amazed at how quickly you can build proof-of-concept systems, gather feedback, and deploy applications.
Ø Maximize your IT department productivity. 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. Application users expect them, but there’s usually quite a lot of coding involved. Iron Speed Designer frees your team to focus on the higher-level development aspects that support your specific business needs.
Ø Reduce 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.
What are Web 2.0 Applications?
There is no precise definition of a Web 2.0 application. For our purposes, we’ll describe them as applications that bring desktop application functionality to web applications for the purpose of providing rich transaction-centric user interfaces.
Corporate applications have moved to the Web, and with them the need for rich application interfaces, especially for data entry, workflow and reporting. The Web has evolved well beyond information display and order entry / shopping cart applications into the preferred environment for deploying complex corporate applications. Web 2.0 applications provide desktop-style interaction in a stateless Web environment, a challenging task at best.
How are these rich user interfaces implemented? Largely by using a set of new technologies such as Ajax (Asynchronous Java and XML) and ASPX for user interface development, and web services and ADO.NET for data source access.
What are some specific characteristics of Web 2.0 applications?
•        Rich components are a hallmark, frequently ‘mashed up’ from a variety of sources to create a rich, comprehensive application. These components may be hosted on a variety of servers and sites, effecting a truly distributed application.
•        Individual web page controls interact intensively with server-side code. Interactive search, calendar and scheduling controls, and increment and decrement buttons, all interact with server-side code in real-time to provide users with dynamically updated information.
•        They don’t postback, or at least appear to postback. Postbacks refresh the page causing annoying flicker. Web 2.0 applications use Ajax and other techniquest to provide a ‘smooth panel update’ of the affected screen areas.
From a corporate application perspective, Web 2.0 applications provide rich interaction as Web 2.0 applications displace desktop applications for data entry and workflow use.
Web 2.0 Application Types
Most Web 2.0 applications are database-driven, meaning they are used for data input, data display and data manipulation. Most bespoke applications fall into these basic types:
Ø Data entry and management – applications that collect data from users and allow that data to be edited.
Ø Reporting and tracking – applications that report and summarize data.
Ø Workflow and scheduling – applications that implement basic step-wise business processes.
Ø Business process automation – applications that implement advanced business process, often orchestrating data flow between multiple systems.
If these application types sound like client server applications from the 1980’s and 1990’s, you’re right. Modern Web 2.0 applications are those you would have built using a combination of desktop applications for rich user interaction coupled with a back-end server for centralized data storage and processing.
Fortunately these Web 2.0 application types are ideally suited to an application generation approach.
The Iron Speed Designer Approach
Imagine creating 80% to 90% of your application just by pointing a wizard at the database(s) underlying your application-to-be? All of the Web pages and 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 application generation.
Iron Speed Designer’s approach to application generation is very straightforward:
1.       Start with your application-specific data model – an existing database or other data asset.
2.       Automatically create a set of fully functional application web pages for common database operations, such as adding, editing and viewing data.
3.       Automatically create a set of fully functional application web pages for reporting and workflow.
4.       Generate everything needed for a functional n-tier application – all the web pages, source code and SQL queries – and deliver a working, bug-free application.
5.       Automatically generate “pure” source code in native .NET languages, such as C# and Visual Basic, without any proprietary run-time servers or libraries.
6.       Generate built-in application security.
7.       Generate complete and well organized source code that's easy to modify and extend. Allow handmade code customizations to the generated application, automatically preserving them during subsequent application regenerations.
Web 2.0 Application Generation
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 consist 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 an application generator, the developer selects various database tables and views and the appropriate mapping between the underlying database and web page components. When ready, the developer lets the application generator produce the underlying application web pages, source code and SQL, including code for all of the web pages, controls, and database connectivity infrastructure.
Database-driven applications like these lend themselves to application generation because they use typical database connectivity and application infrastructure. They all need data entry pages for the selected database tables and views, reporting pages to view and analyze the data in the application, application security, and other application infrastructure.
Data is either being entered into a web form and inserted into the database or data is being 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 page and code templates using standardized and well-accepted ways to perform certain common operations.
Generating a Web 2.0 Application
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 data entry forms and reports;
Ø Build the application's basic Web 2.0 functionality — sophisticated features ranging from filtering and sorting, to search and pagination;
Ø Connect web 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. Iron Speed Designer generates full-featured Web 2.0 applications for .NET in minutes, shaving months off the development cycle. Iron Speed Designer is different from other rapid development tools because it generates complex user interfaces 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 quickly generated. The generated application’s architecture preserves your modifications and enhancements each time your application is regenerated.
Generating an N-Tier Architecture
Most Web 2.0 applications are built on an N-tier architecture comprised of:
Ø Web pages — the ASPX web pages comprising an application.
Ø Presentation Layer — the web-based user interface including database-connected forms, tables, and reports.
Ø Application or Business Layer — C# or Visual Basic .NET application functionality.
Ø Data Access Layer — SQL and transaction management code.
Ø Stored procedures — database server-resident SQL.
Implementing transaction-based Web 2.0 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 such as multi-page data input wizards. 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 sections show how Iron Speed Designer generates each of these layers.
Create Hundreds of Application Web Pages
While designing an application's look-and-feel is not trivial, repeating it over and over for each of the hundreds of pages in your web application is a significant chore. Iron Speed Designer eliminates 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.
Ø Add Record – a page for inputting data for an individual table or multiple tables.
Ø Edit Record – a page for editing data in an individual record or query
Ø Show Record – a page for viewing data from one or more tables and queries.
Ø Show Table – a paginated, interactive report view of a table or query’s data.
Ø Edit Table – an editable data grid useful for editing a quantity of records.
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.
Web 2.0: Beyond C/R/U/D Pages
Iron speed Designer goes beyond basic C/R/U/D pages, however, by creating a variety of Web 2.0 pages and features you would normally expect to find only in custom desktop applications, such as:
Ø Master-detail pages – pages for displaying, adding, and editing information from subsidiary “detail” tables referencing a “master” parent table, typically through foreign key relationships.
Ø Workflow pages – pages for displaying and processing workflow sequences that automate business processes.
Ø Reporting – pages that summarize data, including PDF and Microsoft Word reports that can be printed and emailed.
Ø Data integration – features that export data in a variety of formats for further analysis by application users.
Web 2.0 features extend beyond page types to the components in those pages. These components might include rich text editors, tree controls, multi-level menus and tabbed panels for data input and display. Complex navigation especially defines Web 2.0 applications with features such as multi-step wizards for data collection and workflow processes governed by application user interaction.
Advanced application features like integrated security, reporting, multi-lingual support, and data integration are also hallmarks of Web 2.0 applications.
Connecting Web Pages to the Database
When generating the application, Iron Speed Designer reads the page and code generation 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. Iron Speed Designer automatically generates every SQL query and the wrapper code around it for each web-based component that accesses the database. Thus, you do not have to write any code to create sophisticated user interface-based applications with Iron Speed Designer.
Ensuring Application Scalability
Even for experienced developers, application 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 offload 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.
Generating SQL Queries and Transaction Management
There are likely dozens or even hundreds of pages in your application, each needing 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.
It's important to consider these application generation issues:
Ø Transaction management
Ø Location of the SQL statements
Ø SQL Efficiency
Ø Concurrency handling
Ø Cursor management
Transaction Management
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, a typical web-based order check out process, such as a shopping cart, collects different aspects of the order in a series of pages, such as the customer’s name and address, credit card information, and shipping instructions.
The difficulty is that there are few options for storing information collected on those pages other than in the database, in the .NET cache or in browser cookies. Unfortunately, storing a user’s transaction information in browser cookies poses security and bandwidth issues. So, for most applications, storing transaction information in the database is the best option. This makes it important to understand what constitutes a transaction and when it is committed to the database.
Iron Speed Designer generates applications with a “page-based” transaction model. This means that all of the changes made to any underlying database table on the current web page are submitted when the user clicks “OK” (or takes a similar action on the page). I.e., upon clicking “OK” (or similar action), all changes made on the page are committed to the database as part of a single transaction. Specifically, Iron Speed Designer applications use the transaction classes in ADO.NET to perform commits and rollbacks.
Iron Speed Designer uses stored procedures to update the database when appropriate. If there are multiple related records being added or updated as part of a single transaction (e.g., Orders with multiple Order Items), then each record is updated individually requiring multiple round-trips to the database. The record insertions, updates, and deletions themselves are performed within database stored procedures, but the application logic calling these stored procedures is resident in the generated code.
In a multi-part transaction, the entire transaction is concluded with a single COMMIT statement at the end of the transaction. I.e., while these many-to-many updates do require multiple trips to the database, they are committed to the database by a single COMMIT at the end of the transaction.
SQL Location: In-line or Stored Procedures
Most DBA's prefer placing SQL in stored procedures because it centralizes 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.
Preserve Your DBA’s Sanity
Most IT departments have a database specialist who either writes all the SQL statements or helps individual developers write them. This approach ensures that all the SQL statements are written accurately and optimized.
Using application generation tools like Iron Speed Designer to generate your application’s SQL frees your DBA to focus on database management. Iron Speed Designer generates all the SQL needed for your application and places them in stored procedures so the DBA can find them as needed.
Application generation removes the dependence your application developers have on DBAs and relieves your DBA from this often daunting task.
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 (Microsoft’s SQL Server language).
SQL Efficiency
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 approaches 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.
Concurrency Handling
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.
Cursor Management
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.
Generating Application Security
Most applications serve a variety of constituents – customers, customer service, marketing, sales, and management, to name a few. It’s increasingly common in contemporary web applications to permit much broader access to applications and their underlying data than was common with client server applications, which had more restricted user bases. With broader use comes an increased need to partition data according to the user type – and sometimes down to the individual user as well.
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.
Iron Speed Designer generates applications with built-in features, such as:
Ø Role-based access control
Ø URL parameter encryption
Ø Automatic sign-out
Ø Data transmission encryption
Generating Role-Based Application Security
Broadly speaking, Iron Speed Designer generates three types of role-based security:
1.       Simple sign-in authentication. Application users must sign into the application. Only users with user names and passwords can sign in, giving you control over who can access your application.
2.       Single-role authentication. Application users must have a designated role in order to access a particular web page. Individual web pages are configured so that only those users with the designated role can access the page.
3.       Multiple-role authentication. Individual web pages are configured to accept users who have one of several designated roles.
Simple sign-in authentication distinguishes between users who are signed in and those are not. Users who are not signed in are called anonymous users. Because of the flexibility in Iron Speed Designer’s role-based security model, you can grant access to individual pages to either signed in or anonymous users, or to both signed in and anonymous users.  This is very useful when you want your application to present one view of your data to a signed in user and a different view, perhaps more limited, to users that haven’t signed in or don’t have an account (anonymous users).
In more sophisticated role-based security systems, users can be assigned multiple roles, effectively giving them broader access than would be granted by a single role. A simple example is that every customer service representative may not be authorized to access customer credit card data. In this example, the customer service supervisor has one role as a "rep" with access to customer account information, and a second role as "manager" with authorization to issue refunds or credits. Ideally, those roles are accessible simultaneously without requiring the user to log in under a second role.
With role-based security, you can:
Ø Define user names and passwords.
Ø Create and assign multiple user roles for your users.
Ø Configure each web page for access by designated user roles.
Ø Generate your application’s entire role-based security infrastructure.
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.
URL Parameter Encryption
Parameters passed from page to page via URL’s can be encrypted so that hackers cannot decode record IDs, enabling them to access records via the URL they shouldn’t access. 
When enabled in Iron Speed Designer, the URLs for Show Record and Edit Record pages are encrypted using the Session ID as the encryption key. In some cases, the URLs for Add Record pages are also encrypted, such as when copying a record.
Customizing Generated Applications
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 for customization, most generated production applications have some amount of hand-coding.
The application generation process must produce code that is readable, easy-to-understand and easy-to-modify; otherwise the time benefits achieved by application generation are for naught. There are perhaps two principal concerns in using an application generator:
•        Understanding how to customize the generated application. An application generator generates code in a certain code model. Customizing that generated code relies on your ability to understand that code model.
•        Preserving each time the application is regenerated. The great thing about application generators is their ability to quickly regenerate an application using different data sources and developer preferences. That regeneration process must preserve any code customizations you’ve made so you don’t lose any work.
Both of these concerns are addressed in the following sections.
Design Themes Provide Look-and-Feel Customization
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 several important components:
•        A style sheet (.CSS cascading style sheet) defining the basic stylistic aspects of a design theme, such as the fonts, colors, and table styles.
•        A set of pages and panels containing HTML and code generation tags that encapsulate useful functionality, such as a set of record fields or a table display.
•        Images for buttons, thumbnails, and other purely graphic elements used in the design theme.
Nearly all look-and-feel aspects can be controlled by changing the appropriate CSS class, making it easy for non-developers and graphic designers, to modify the stylistic elements of the generated application.
Web Page Customization
It’s fairly common to modify the layout of controls on generated application pages to achieve a tighter or more logical layout than can be guessed by the application generator. The ASPX web pages generated by Iron Speed Designer are CSS 2.0 and XHTML 1.0 compliant, so modifying them is a straightforward process of opening the appropriate file in your favorite web page editor, such as Dreamweaver, Microsoft Visual Studio, Microsoft Front Page or in Iron Speed Designer itself.
Customizing and Extending Generated Code
Using your favorite programming language including C# and Visual Basic, you can extend your generated application to:
Ø Add custom application logic
Ø Add additional user interface code
Ø Integrate with external systems
The class hierarchies generated by Iron Speed Designer derive from the base classes in the .NET Framework. 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 classes that implement page management, user interface controls, database access, and data validation.
This object inheritance code model allows you to intercept Windows messages going to a form or control by sub-classing the appropriate class and method, among other benefits. Using your favorite code editor, such as Microsoft Visual Studio or the code editor in Iron Speed Designer itself, simply subclass the appropriate page, control or database class and add your code customization.
You can override any of the functions or methods in the generated classes or the .NET Framework classes, or write your own methods in combination with the existing base class methods. Then, regenerate the application to reflect your changes.
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.
Regenerating Without Losing Code Customizations
One of the biggest challenges of application generation is code orphaning. Code orphaning occurs when your application cannot be modified or extended without severing the application generator’s ability to regenerate that application without losing your code customizations. Application generation encourages iterative development practices, but that’s impossible if customizing your application removes your ability to regenerate it.
Iron Speed Designer allows your application to be regenerated repeatedly without requiring you to re-integrate your external code extensions. This is accomplished using the object inheritance model so that the inherited classes you create for your code customizations are never overwritten when the application is regenerated.
The class hierarchy means your code customizations have access to the full functionality of the generated application, all the way down to the .NET framework. Only the generated classes – the automatically generated portions of your application – are ever regenerated; your inherited classes and methods are never regenerated, preserving your code customizations.
As long as your modifications are segregated in the sub-classed methods and not in the code, your application can be regenerated repeatedly without re-integrating your code extensions. 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.
Extending the Application Generator
Template-Based Page and Code Generation
Iron Speed Designer’s Application Wizard generates the basic application using a set of page templates and code templates. The page templates contain the underlying HTML / ASPX for each page plus the conditional code generation logic that directs Iron Speed Designer to generate specific application and page features based on developer preferences and inputs. The code templates contain the C# or Visual Basic .NET code plus the conditional code generation logic that directs Iron Speed Designer to generate specific application features based on developer inputs.
As with the more basic page types and features, advanced page types and Web 2.0 features are implemented as a set of page and code generation templates that Iron Speed Designer uses to generate the application.
Because page and code generation is template-based, application developers can change the page content and underlying code that is generated for each application to include specialized features that might be commonly used within an organization. These custom features might include custom or third-party user interface controls, specialized security or access control, and custom data source access logic.
Adding New Page Types
Page generation templates are snippets of HTML that can be as simple as one tag or as complex as an entire page. They contain the code generation instructions to generate data-bound controls at specific locations in the web pages. Because developers can modify these page generation templates, they can add their own pages and panels to Iron Speed Designer.
While adding new page types is beyond the scope of this white paper, suffice it to say this provides an extremely powerful capability to sophisticated developers.
Download Iron Speed Designer Free Edition
Building web applications is complicated and time-consuming. The ROI (Return On Investment) 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.
Iron Speed Designer can be downloaded from here: IronSpeed Free Edition
Mr. Fisher was a General Partner at Outlook Ventures, Inc., a venture capital company prior to co-founding Iron Speed, Inc. He co-founded Onsale, Inc. (now part of Amazon) and was its Chief Technology Officer from July 1994 to December 1999. He also co-founded and was President of Software Partners, Inc, a developer and publisher of software products from August 1988 to July 1994. From April 1984 to August 1988, Mr. Fisher served as Technical Marketing Manager and Product Development Manager for Teknowledge, Inc., a developer of artificial intelligence software products. From June 1981 to April 1984, he served as a member of the technical staff for AT&T Bell Laboratories.

This article has been editorially reviewed by Suprotim Agarwal.

Absolutely Awesome Book on C# and .NET

C# and .NET have been around for a very long time, but their constant growth means there’s always more to learn.

We at DotNetCurry are very excited to announce The Absolutely Awesome Book on C# and .NET. This is a 500 pages concise technical eBook available in PDF, ePub (iPad), and Mobi (Kindle).

Organized around concepts, this Book aims to provide a concise, yet solid foundation in C# and .NET, covering C# 6.0, C# 7.0 and .NET Core, with chapters on the latest .NET Core 3.0, .NET Standard and C# 8.0 (final release) too. Use these concepts to deepen your existing knowledge of C# and .NET, to have a solid grasp of the latest in C# and .NET OR to crack your next .NET Interview.

Click here to Explore the Table of Contents or Download Sample Chapters!

What Others Are Reading!
Was this article worth reading? Share it with fellow developers too. Thanks!
Share on LinkedIn
Share on Google+

Author bio not available

Page copy protected against web site content infringement 	by Copyscape

Feedback - Leave us some adulation, criticism and everything in between!
Comment posted by Frank on Monday, December 22, 2008 11:52 AM
Everyone who reads this article needs to be aware of Ironspeed's short comings as well.  While it will let you build apps in minutes, the quality of the code it generates has issues.  There are a lot of areas where the generate process favors duplication of code instead of proper abstraction.  It also provides poor support for customizations outside of its model.  As long as you stay inside of the sandbox that ironspeed provides it does exactly what it claims but if you venture outside of the safety zone it is an uphill battle all the way.  And as a final gotcha, migration support from one release of Ironspeed to another is almost non existent, their recommendation is to scrape your old code base and generate a new code base using the latest designer.  This works fine unless you have made customizations, at which point your only option is to re-implement them in the newly generated code base.  For anyone who tries Ironspeed, please be aware of these pitfalls and use the tool sparingly.  Never ever use the generated code as a reference for learning, the techniques it uses are considered bad programming partice.
Comment posted by David Stodola on Wednesday, December 24, 2008 11:57 AM
I checked out the tool.Seems good enough for a quick prototype application. I will though keep your suggestions in mind.
Comment posted by Nadeem Q on Wednesday, December 24, 2008 12:07 PM
How does the free ASP.NET Dynamic Data Framework compare against these tools? When do I use what?
Comment posted by Miles Gibson on Monday, December 29, 2008 10:47 AM
I couldn't disagree more.  Iron Speed provides a terrific object model to work from.  When the application is generated, Iron Speed provides a "safe" area to put your custom code into, and a "Generated Area", that the generated code goes into.  Everyone has their own coding style and preferences, which are not going to be the same.  The generated quite is quite well written, and offers a rich learning experience on how to use the ISD object model, which by the way allows you to read and write record(s) using far fewer lines of code.  The idea of code generation is so that we don't have to do the heavy lifting ourselves.

I use Iron Speed every day to build enterprise level applications, it should not be discounted as a "Prototype-only" tool.

Iron Speed frees me from writing tedious data and businessy layer code, and therefore gives me more time to work on the UI etc.
Comment posted by Staffan Wiljergårdh on Monday, December 29, 2008 10:54 AM
I have used Ironspeed many years now and it is a perfect application to build complex websites easily and rapidly. Nice way to handle security and design..just works perfect.
If there are some missing features when building the websites there are many users to help you.  
Comment posted by Paul on Monday, December 29, 2008 11:08 AM
As someone who has been using Iron Speed for almost 4 years now, I can say that it has become one of the greatest tools that I use.  The larger the project, the more time and money it saves.  I was able to build my first project in 2005 -- a pretty complicated database app -- without a single code customization.  Subsequently, although it took a little time to master, I was able to leverage my ASP.NET knowledge and figured out how to make almost any kind of code customization.  This means that it is a simple matter to include any third-party objects into an Iron Speed project.  I have even figured out a way to quickly build content management applications for ASP.NET sites -- CMS applications that look as if it took weeks to create -- all in a couple of hours.  Once you get the hang of how it works, you can use it to build almost anything.  I recommend it highly to anyone who wants to shave lots of time off their development schedule.
Comment posted by James Whistler on Monday, December 29, 2008 11:49 AM
I believe that Ironspeed Designer is about as comprehensive an application generator as you're ever likely to find.  

The quality of the generated code is high and the separation between safe areas for custom code and generated areas is always distinct ensuring that developed customisations are not overwritten by re-generation, a common flaw of other code-generators.

It may be true that the generated code is not always the most efficient possible but this is more than offset by the robustness Ironspeed Designer offers.  In my experience, well-structure and documented code, whether hand-written or generated, is rarely the most efficient method but this is vastly preferable due to its increased maintainability.

I'm not quite sure what Frank's experience of migration between ISD releases is but mine is that it's always been easier than migrating applications with any other product I've worked with.  The support network, from the ISD forums all the way to their own support line, has never let me down yet.
Comment posted by Piyush J on Monday, December 29, 2008 12:08 PM
Good inputs. Does anyone have answer to Nadeem Q question?
Comment posted by Jason on Monday, December 29, 2008 1:05 PM
We have used Iron Speed for custom software development on several projects of various types and sizes. A large part of the infrastructure that must be created for each new project such as security, navigation, user profiles, etc. are all provided "out of the box" by Iron Speed and gives us great savings in project effort and cost. Moreover,any changes that are made to the framework are made by very experienced "tool smith's" and the quality of the code that is produced is very high.  All generated code is consistent and coded according to standards regardless of the experience level of the developers.
Also, I have been using IS for the past several years and never had a problem with migrating my apps between different ISD releases.On the contrary, I think it goes to the credit of IronSpeed that migration is not only possible,it is also pretty simple.
Comment posted by Jeremy Scrime on Monday, December 29, 2008 1:21 PM
Iron Speed as a product is phenomenal.  Perhaps not a coincidence due to the fact that behind the scenes is one of the best IT Related Companies I've ever had the pleasure of working with over my 15 years as a programmer.  Weekly online webinars offering a Question and Answer period, periodic webinars related to new releases and other training material, a dedicated and very active Forum where questions can be posted and responded to by experts or advanced users all come for free with your purchase of the product.  

The shocking part to me was that many of my forum questions and all of the webinars are hosted by the co-founders who happen to be the Chairman and CEO.  You have direct access to the top, and I can assure you these guys are motivated to make this a great company and product.  They read the forums and often respond to you directly.  I've worked with many others within the company on a first name basis as well and the courtesy and professionalism is certainly an added benefit but at this point I'm sold on this product and would use it no matter if that existed or not.  It's easy to forget the small guys like me who only have 1 or 2 licenses and deal with the big companies with many developers but this company works very differently and everyone works for the betterment of the product and my input is just as valuable to them as the customer of theirs with 50 licenses.  Their dedication and devotion does shine through in a truly great product but I'm sure like everything else the good sometimes goes unnoticed/unspoken until someone fires off an attack that evokes some energy in the community.  

Migration has never been an issue for me.  If you are looking for something that does everything for you and you have absolutely no work then hopefully this product doesn't exist or many of us would be out of decent paying jobs.  Like anything new theres a very manageable learning curve.  Good database design is essential but again this isn't intended for any Joe The Programmer (a re-hash on Joe the Plumber) to fire up, push a button and sell a product for thousands of dollars.  You have to have some programming, database, technical experience or else you shouldn't drive the machine if you don't know how the engine works.

I am so confident in the product but perhaps the real confidence lies in the risk free completely zero cost version the company offers for download to let the product speak for itself.  I can assure you it is not a huge time investment to get the product installed and have a fully functioning web 2.0 application up in running in hours.  When you see that come together, and things work as expected, then at that point make your own determination as to the true value of this product.  I can assure you the time and money you'll save make this one a no brainer.  Frank's statements are highly opinionated as are mine and each of us has our own experience.  It was important to me to make my thoughts on the product heard as I have had quite the opposite experience as Frank.

Happy Programming to all!  Jeremy
Comment posted by San5050 on Monday, December 29, 2008 4:20 PM
I have been working with this tool for over 3 years now, started with their 2.X version. Over the years, I can see huge improvement for each release and the product is very refined at this point. Like somebody has pointed out, there are a lot of repetitive steps in building an application such as security, CRUD screens, etc but this tool generates all that for you in minutes, leaving you time to focus on pages that needs customization. For IT managers who have a huge list of applications to complete and want to have a consistent approach, this is the answer to his prayers. In this case, I only have to review those business screens that have customizations and I am certain all maintenance pages are following one consistent pattern. No code reviews for everything and it is easy when it comes to maintenance. For any changes to the database, I just re-scan and accept. It does have its learning curve, but it's totally manageable for any seasoned developer who is not resistant to learning. This saves me a lot of time and money!
Comment posted by NeilE on Monday, December 29, 2008 6:47 PM
I have used Ironspeed Designer (ISD) for two years and love it.

I have done extensive customizations to the generated code, and migrated that code through several different versions with no problems at all.

The generated code is well structured, easy to understand and well documented.  It even generates technical documentation for every page it generates.

The generated pages are attractive, user friendly and efficient.

And the customer support is second to none.  I've exchanged several technical emails with CEO Alan Fisher as well has had great support from the support forums.

The product has saved me hundreds of developer-hours, and thousands of dollars.  I could not have completed some key projects without it.

It gets better with each version.

Best of all - you can try the free version as long as you like at no risk.
Comment posted by Arnie Liberty on Tuesday, December 30, 2008 3:21 AM
With all these comments, I feel tempted to use this tool(glad that there is a free ver). I will post my observations on this tool soon.
Comment posted by Jim Murphy on Thursday, January 1, 2009 2:57 AM
I've worked with Iron Speed Designer since v1.4.  It sounds to me like the only issues raised are old 'luggage' that no longer applies.  The product has matured nicely over the years and is a very different product than it was years ago.  As seen in this article, there are a ton of parts and pieces to making a web application, from security to pagination and from data display to transaction handling.  Iron Speed Designer really handles the rest of that nicely.  

Here is one example: In a non-Iron Speed Designer application, if there is an error of some sort saving data (for example), the normal process is catch the exception at the most granular level and bubble it all the way up to the top layer where the exception needs to be 'converted' to a javascript alert to display the error in a pretty format to the user.  This involves registering some javascript and setting it in the page load body.  Don't forget to clean the error for quotes, etc. or the javascript will be malformed and not display.  Also there may have been many data actions along the way and all of them need to have the transaction rolled back (hopefully we coded in a transaction).  Also, if we register our javascript error, but continue to do the redirect to the 'done' page, then no one sees the error, so we need to cancel the redirect.  Also, we don't want to show 10 Alerts with varying details - only one.  And for the end user, we only want to display a 'pretty' error, but as a developer we need more detailed errors logged somewhere (table, eventlog, file, etc.) so we can debug production issues.  And if the save works great, don't forget to commit and redirect as normal.  As a developer, you can perceive how much code this all takes.  However, ALL of this is done automatically!  What is more, is if you want to throw your own 'error' (say in a custom business-rule validation routine or whatever), you simply need to throw a standard exception - Iron Speed Designer will detect it, roll back, prevent the redirect, show the except in javascript and on and on.

This was JUST ONE example of how the product massively simplifies the development of a web app by plumbing all of that mundane code for you.  And working with the Iron Speed Designer 'framework' is like normal .NET programming (throwing exceptions, creating method overrides and handling events as normal).  So there is really no mystery to how to add custom code - even if the code is extremely custom;

All in all, I love the product and have used this tool on big projects where the budget exceeded $100k even with Designer.  By hand?  A project that size would require a LOT more people on the team, a LOT more calendar to get it done and lot more money.

And if there is concern about the product or the code - try it and look at the code.  
Comment posted by Franck Ballack on Thursday, January 1, 2009 11:22 AM
Does the tool help me generate code using a layered approach? Can I like keep the business and data layer and easily switch the UI (web) with a UI (windows). Is that possible?
Comment posted by Les Cardwell on Tuesday, January 6, 2009 6:51 PM

It does, and with some customization, it can. There are examples up on the ISD forum. That said, it's focus is thin-client (web-client), as are most efforts now and into the future.

The wave of the movement is model driven development, and IronSpeed is striving to capitalize on that effort, or at least move in lock-step with Microsoft's initiatives in that direction.
Comment posted by Franck Ballack on Wednesday, January 7, 2009 7:10 AM
What's an ISD forum? Can you provide links.
Comment posted by Alexandra on Monday, January 19, 2009 12:14 PM
ISD forums stands for Iron Speed Designer forums. Visit their website to find out the forum link.
Comment posted by jeyasanthan on Friday, May 29, 2009 6:23 AM
A reference architecture for workflow management systems
Comment posted by jeyasanthan on Tuesday, August 18, 2009 5:29 AM
Speed application development and deployment. Application generation saves weeks and months of development time by generating the routine infrastructure code, freeing you to focus on your business logic. Most application development projects start with a handful of page mock-ups – or white board sketches – and a database schema. Iron Speed Designer uses your database schema as input and generates your application’s infrastructure, including the transaction management code and SQL queries, in a fraction of the time of hand-coding.
Comment posted by raja on Tuesday, December 15, 2009 5:17 AM
Speed application development and deployment. Application generation saves weeks and months of development time by generating the routine infrastructure code, freeing you to focus on your business logic. Most application development projects start with a handful of page mock-ups – or white board sketches – and a database schema. Iron Speed Designer uses your database schema as input and generates your application’s infrastructure, including the transaction management code and SQL queries, in a fraction of the time of hand-coding.
Comment posted by krishna kant pandey on Friday, January 15, 2010 2:08 AM
given to coding in this search,delete,update using through sql server2000