Home | IT Managers | Developers | Services | Products | Customers | About

Build Enterprise Applications Quickly and Easily

The PDSA .NET Productivity Framework provides the most complete enterprise architecture on the market! PDSA, Inc. is well known for quality applications and robust, scalable, and flexible architectures. Now you can purchase the same Framework that our own developers use to build enterprise applications for our customers. This Framework helps you build ASP.NET applications or Desktop (Windows Forms) applications in a fraction of the time it would take you build everything from scratch.

Any application being written today has to deal with the same 6 needs:

1. Data Access
2. Session Management
3. Menus
4. Exception Handling
5. Application Settings
6. Security

Frequently these parts of the application are coded at the whim of individual developer styles and techniques. That makes them difficult to re-use by other applications, other developers, and ensures difficulty in troubleshooting errors.

The PDSA .NET Productivity Framework builds these 6 components automatically in a standard wrapper that can be easily changed or called by other applications. By doing this you will:

• Save hundreds of hours of coding
• Eliminate errors in 30% of the application
• reduce development costs of each project by $80,000 to $120,000

When you consider what it takes to develop this kind of infrastructure, you start to see how easy it is to justify the cost of the PDSA .NET Productivity Framework on your first project. The best news is that you can use the Framework for project after project. The Framework helps you keep your bids competitive, and it helps you increase your profits by decreasing your costs.

Framework Success Story

"I am continually amazed at how much time this framework saves me. Once I learned how it works and how to setup all the options in the DACGen, I am able to reap tremendous development time savings from these two products."
Alex Lancaster, Sr. Software Developer, Nations Holding Group

1 — Eliminate errors in data access/input

An experienced programmer can write add, edit, delete and selection screens in an average of 383 lines of code taking approximately 7.2 hours to complete. And we mean an experienced, senior .NET kind of person, and that's for fully working, tested, debugged code. In any language that uses .NET, (Visual Basic, C#), the programmer would need a good working knowledge of connections, commands, data adapters, HTML, ASP.NET controls, data concurrency, SQL, and data grids.

This hand written code will have some serious disadvantages: It may not be standards based (give this to 10 developers and you will get 10 different versions). It's difficult to reuse for the next application. And if it needs to be updated, someone will have to search through all these lines of code to find those locations to update, which results in code that has significantly high error rates. Plus this code will be harder to maintain over the life of the application, as new team members replace the original coding team.

You end up with all the data access code for add, edit, delete, and select; a screen to display all those customers and all the input fields for all the columns in the database. PDSA .NET Productivity Framework has done a lot of the grunt work like aligning fields and building basic screens. It eliminates most bugs, it is reusable and testing time goes to almost zero.

When using the PDSA .NET Productivity Framework the fastest time to complete this is 4 minutes 58 seconds. Typical new users could do this in less than 10 minutes.

PDSA Framework Creating Add/Edit/Delete Pages (16.4 mb)

2 — Eliminate errors in session management

Simple mistakes in the web session management code can lead to frustrating errors that are difficult to find.

Storing "state" means the application knows who you are when you are logged in. This is called a session, and it is typically done with a cookie handed back in forth between the browser and the server.

Let's say you have written your code like this:

Session("username") = txtUser.text

Now a couple months later you write another page and you want to use the same session variable again, but you can't remember what you called the session variable or you misspell the variable "username" as shown in the following code:

Session("usermame") = txtUser.text

You now have a bug. A bug that could take hours to figure out until you discover a careless (but common) spelling mistake.

In the PDSA .NET Productivity Framework, when you want to refer to the session variable, you use Microsoft IntelliSense to pop up a list of all your session variables. This pop up menu gives you the complete list of your session variables. You choose the one you would like. No misspelling, no remembering what the names of your session variables were.

UserSession.UserName = txtUser.text

Additionally, PDSA .NET Productivity Framework will automatically convert the variable to the correct data type (integer, string, long, decimal, object). This avoids remembering how to convert the data each time you wish to use it.

All these PDSA .NET Productivity Framework features virtually eliminate errors in the session management process, one of the most common places for bugs to occur, and one of the most difficult to troubleshoot.

PDSA Framework Session State Management (7.7 mb)

Framework Success Story

"If you're looking to have world class applications built very quickly then I very much doubt you will find a better product or a company to provide the incisive technical mentoring than PDSA. The alternative is to write this framework stuff yourself....that's if you've got a spare 1000 hours or so."
-RB RB, LTD., London England

3 — Eliminate errors in menu development

At the click of a button, PDSA .NET Productivity Framework provides you a data-driven Menu Engine. Now you can create menus that are tied to permissions held in the PDSA .NET Productivity Framework security engine (more on our security management later). The Menu Engine allows you to add your own menus on-the-fly at runtime, and edit or eliminate any of the automatically created menus.

The Menu engine saves the typical customer up to 28 hours per project.

Is this really an advantage over hand coding the menus? Yes. Say your manager looks at the menus you have just created. "Hey, I don't want everyone to see that, just the administrators." Now you need to write code, recompile it into a DLL, and install the DLL on the application server.

With the PDSA .NET Productivity Framework, you use data driven menus that are tied to a user's login. That means each specific item in each menu, or entire menus, can be turned on or off based on the user.

Imagine if you are hard coding who can see what on each menu:

if(User.IsInRole("Admin"))
  mnuMaint.Visible=false;

Think about all the possible permutations if you had 50 variations of look and feel for each group! And what if you add a new group? Any time there's a change in permissions or a new group of users — A NEW MENU ITEM! You would have to find every place that menu, permission, or group occurs and change that code.

4 — Eliminate errors in exception handling

An exception is an error that occurs in the application. Rarely is exception handling written correctly. This means a nasty error won't go to the programming team who can fix it — instead it goes to the poor end user. Or worse, the customer! And the information they will get is nothing less than horrifying to a non-technical user. The end user receiving a typical .NET error has the responsibility to figure out whom to send this cryptic error message to (if they send it at all). Even good developers rarely code anything proactive to handle the inevitable errors in code. They might clarify the error message, but it still goes to the end user, RARELY to the development/support team that can do anything about it. PDSA .NET Productivity Framework has an automatic exception management process that:

• Emails the error message to the right people
• Stores the error message in a database with timestamp (and includes useful analysis information like which page threw the exception, which server, the date and time, and the user who caused the error)
• Stores the error message in a flat file somewhere (because the database itself might be the problem)
• Writes to the event log
• And provides you the tools to look at the exception information

Analysis of exceptions is vastly improved with the PDSA .NET Productivity Framework. You can begin your analysis sooner, and you can support the end user proactively (imagine calling the end user and letting them know you are on the case as they are staring at the error message). By capturing all of the errors you can identify how many times this error has occurred. And you can track these exceptions to the specific Class and Method.

Even if you write this kind of exception handling manually (and you probably won't!), you will write 12 lines of code to gather up the exception and email, 10 more to send to the database, etc. Yet with PDSA .NET Productivity Framework, you write one line of code to enable Exception Handling. That's it.

You get full diagnostics, a full record of exceptions across the system, and you are alerted within seconds. All of this with one line of code!

Framework Success Story

"The Framework really gives us a terrific head start on constructing a world-class web application by allowing us to implement the basic user interface container first and then filling in each page with what we need. The Framework provides us a standard for how each page should be designed and the menu system lets us easily test as we go."
Jerry Reed CTO, Greater Relations

5 — Eliminate errors in application settings

The problems that occur with typical application settings are almost too numerous to list here. We will settle for the 4 most common, and show you how PDSA .NET Productivity Framework cures them.

PROBLEM 1: Errors in calling a key. A standard practice would be to use the ConfigurationManager.AppSettings("ProfilePage") method to retrieve application settings from a Config file. For example, given the following settings in your config file:

<appsettings>
  <add key="ProfilePage" value="Default.aspx" />
  <add key="SecurityOn" value="true" />
<appSettings>

You would use the following .NET code to retrieve the SecurityOn value:

bln=Convert.ToBoolean(ConfigurationManager.AppSettings("SecurityOn")) 

But when you hard code this, you have to remember the PRECISE name of the key in the Config file. If you don't remember the precise name, or you can't find it, you will not get the data you were expecting. You now have potential bugs that will only show up at runtime.

For example, if you want to use the SecurityOn setting, you will call the key, but if you can not find the key, or you call the wrong spelling of the key, you could get a blank response and think security is off. To make matters worse, you would not get a compile time error, you would get a runtime error when you run the app. And it might take going through 4 or 5 screens before you finally get to this code. Now you have to step through virtually every line of code, which can take quite a long time. Or, you may test and never push the app to the specific circumstance that causes the error. This is a very typical bug in app development, and one that the PDSA .NET Productivity Framework virtually eliminates.

In the PDSA .NET Productivity Framework, we keep all these keys in a class. By doing this we again take advantage of IntelliSense, and every time you want to reference a key, you get a pop up of all the keys. You simply pick the one you want to reference. No misspellings, no confusion, the right key, period.

bln=WebAppConfig.SecurityOn

PROBLEM 2: Config files only store the string data type. That means every time you call the AppSettings method using config files, you need to remember to convert to the correct data type. You will have to hard code this conversion EVERY time you grab the key, and it is another chance to misspell or mistype a line of code. Just like the "key" call above, the app will compile and you won't see the exception until runtime.

In PDSA .NET Productivity Framework, we eliminate this error by creating a class that wraps up all access to your Config files. This class contains a list of properties that you create once, and your application simply refers to the key and all conversions are done for you. Even if it is wrong, you trouble shoot it once and it is fixed EVERYWHERE.

PROBLEM 3: Using the AppSettings property is slow. When you use the AppSettings property to retrieve data from your config files, it reads the config file each time. Using the PDSA .NET Productivity Framework class will speed up this access to your config file settings by 100%. We take advantage of a little used class in the .NET Framework to read all values in your config file at one time. This is much more efficient. This class is also notified if you make any changes to your config file.

PROBLEM 4: The unforeseen change to application settings location. It's becoming more common to have Information Protection people who are responsible for keeping things like the connection strings secure, so hackers or internal people can't get access to sensitive data. 87% of the time security is considered at the end of the development cycle, after the code has been written. And since so few developers have ever had to deal with these new security practices, they write code that doesn't accommodate these requirements.

Say you have just completed 8 months developing code. Suddenly, the Information Protection team says "Hey, you can't put the connection string in the config file, because that's a completely unsecured file. You need to move it to the Registry, where you can lock it down." Now you have to find EVERY instance of calling this key that uses the appSettings property and change the code to now go to the registry. In a typical application you could have anywhere from 100 to 500 references to this type of code. After changing all these references you now have to TEST EACH AND EVERY instance again!

In the PDSA .NET Productivity Framework, you only have to change two places, and this can be done in ten minutes. Not only does this protect against these last minute changes; it protects against future changes such as moving all values from the registry to an XML file in a secure folder.

PDSA Framework Configuration Management (9.1 mb)

6 — Eliminate errors in security

Typically, the development team is focused on the application, and is not thinking about the security architecture.

A common way to address security in .NET would be to write two tables: Users and Roles. You might define all the permissions based on role (ex, admins can do x,y,z) but quickly you will need to expand those roles to things like Admin-HR, Admin-Sales, etc. And each role needs to be hard coded. Even if you cut and paste, you're still writing code. Some developers will use active directory but are you going to put 500 users in your active directory if those users are not a part of your domain? Even if your security system is data driven, you still have to write the code to make all your security work together (menus, controls, pages), and will the code you write be generic enough to re-use in each application?

The PDSA .NET Productivity Framework solves the security problem by providing you with a complete, re-useable, data-driven security engine that includes Users, Roles, and Permissions. You simply create your users, your roles and a list of permissions, and you can hook these up to any object within your application quickly and easily. Or, you may hook directly into the Windows authentication system to grab the user information and use that.

With the PDSA .NET Productivity Framework now you can:

• Secure Menus
• Secure Pages
• Secure Controls
• Track user logins
• Track usage of pages by individual users
• Set and control a myriad of security features that normally would be difficult to program

How does this save time and eliminate errors? Say you needed to change a security attribute like hiding payroll information for a specific user. You'd have to write code accurately, test it, and upload it. In the PDSA .NET Productivity Framework, you can do this in 30 seconds without any coding at all!

PDSA Framework Security (8.5 mb)

The PDSA .NET Productivity Framework Provides Thousands of Lines of Tested Code You Won't Have To Write — Saving You Hundreds Of Hours And Tens of Thousands Of Dollars.

The PDSA .NET Productivity Framework provides thousands of lines of tested, best-practice code you won't have to write. It would take a senior .NET developer (assuming you can find one) over 1500 - 2000 hours to design all the specifications of data management, session management, menu structures, exception handling, application settings and security included in the PDSA .NET Productivity Framework. Then, they would have to test and troubleshoot. That's one man-year, or two people in six months. Microsoft Consulting Services charges $200/hour, meaning this framework would take a year, at a cost of $400,000. Even if you were to find the expertise at $75/hour (and you won't assemble security experts, best practice managers and deeply experienced architects at that price), you would spend at least $150,000!

So at a cost that is a fraction of all the above listed alternatives, the PDSA .NET Productivity Framework solves these typical problems:

• Life Cycle Support: Is this application going to be scalable? Reliable? Secure? Flexible? Maintainable? Are the programmers using personal ‘styles' that will be difficult to support when they're gone? PDSA .NET Productivity Framework standardizes the style and techniques of the most common areas of errors and changes in custom applications.
• New Projectitis: You bring up Visual Studio, you're looking at a single page and nothing else. Where do you start? PDSA .NET Productivity Framework actually builds a complete working application automatically in less than 4 minutes.
• Specialist Syndrome: Often senior developers are specialists in a certain type of application development like database access or security, but rarely are they good at everything. The PDSA .NET Productivity Framework provides best-practice, world-class code and architecture, automatically.
• Vanishing Support: If you outsource, the support leaves with the development team. And if your outsourced developers do write an internal framework, 88% of the time it won't be documented so it can't be replicated in the next app or trained to the new people. The PDSA .NET Productivity Framework is documented in over 1000 pages of architecture and best practices and fully supported by our staff. When new people join your team, they have a system they plug into, lowering ramp up time and costs.

Would you like a more detailed look at how you can justify the cost of the PDSA .NET Productivity Framework? Check out our special report "Justifying the Cost of Purchasing a Framework!"

The PDSA .NET Productivity Framework Builds Your Application Today, Knowing It Will Change Tomorrow.

Applications built with PDSA .NET Productivity Framework easily adapt to changes during the life cycle because of the way Framework creates an application. It uses best-practice adherence to OOP (Object Oriented Programming). This is huge.

For example, presently Microsoft uses ADO.NET for data access. But Microsoft has had 6 data access technologies since 1993. When this changes again, if you have not wrapped up the data access (which Framework does automatically and instantly), it could mean a rewrite of 50% - 90% of the code.

Let's say your boss wants to change the storage location of the configuration settings, and you're using the recommended .NET Framework methods. Guess what? You will have to search up to 90% of the code to find all references to the config settings. This could take hours or days, and you won't find them all the first time. Do you want your customers to find these errors? That's exactly what will happen.

The PDSA .NET Productivity Framework automatically puts these settings in class that will be adaptable to changes in minutes.

I Don't Want To Buy A Framework And Be Left Guessing. How Will You Support Me?

Unlike support on most outsourced projects, we fully support the PDSA .NET Productivity Framework with our 6 Step PDSA Success Policy:

• We use the PDSA .NET Productivity Framework every day in-house for our customers. We're banging on it everyday, finding ways to improve and enhance our product. Since this is the SAME system we use to build our customer applications, it has evolved into a solid, proven technology.
• We offer free, unlimited email support + 5 free phone calls + a dedicated support website.
• Our documentation has 1,071 pages (in the form of 36 .pdf files), includes 5 .avi training videos, 45 sample applications, and 14 utilities.
• 98% of our PDSA .NET Productivity Framework customers also buy the 2-Day Workshop that teaches everything you need to build a successful application.
• You KEEP THE FULL SOURCE CODE of the PDSA .NET Productivity Framework (this is helpful since most developers learn by seeing others' code).
• PDSA has been architecting frameworks for 15 years. We're constantly evolving the PDSA .NET Productivity Framework and responding to our user community

We realize that purchasing a framework is a big step for you. We also know that you are trying to complete your development project in a brutally competitive market with price and time pressures.

Even if you're just thinking about buying a framework right now, the FREE PDSA .NET Productivity Framework Webcast will show how to improve the speed and success of your application development.

P.S. Don't forget — 3 out of 4 custom application projects FAIL! Register for our FREE PDSA .NET Productivity Framework Webcast to ensure your applications finish on time and under budget.

More Information

• Download the User Manual (ZIP 3.7 MB) for the FW Version 3.0 to see what this product can do!
• Download a White Paper (PDF 0.2 MB) on the benefits and what the PDSA Framework can do for you.
• Download the complete list of features (PDF 0.3 MB) we offer in our Framework.
• Download sample documentation (PDF 7.0MB) to get an overview of how easy it is to develop with the PDSA Framework.
• Download our special report Justifying the Cost of Purchasing a Framework (PDF 0.5 MB) to learn how easy it is to justify the cost of a framework on the first project!
• Our AVI tutorials give you a great overview of how our Framework works and how to build an application using the Framework.
• Register for a Webcast that demonstrates how you can use the PDSA Framework to build a custom application in 4 minutes!

Quick Links:

Webcasts | eBooks | Developer Reports | IT Manager Reports | Downloads | Remove from Email List

Contact us today for more information. Toll-Free at (888) 899-7372 or (714) 734-9792. Or email us at info@pdsa.com