What is an application framework?

Application Frameworks are collections of libraries (or code) prevalent in many large IT shops. Frameworks can be expensive to develop properly but the cost is more than offset by the advantages they provide. Some of these advantages include things like code quality, promoting code reuse, standardization of tasks and alleviate overhead that can be common across multiple applications.

Open Source Examples

You could spend days on Google and Bing researching the vast number of available options. We'll save you some time though...The two most prevelant examples in the .Net world are Spring.NET (http://www.springframework.net/) and CSLA.NET (http://www.lhotka.net/Default.aspx). Both of these examples are truly fantastic, robust, open-source frameworks that are geared towards large enterprises. So why build our own?

The Rationale for Building Our Own

Our experience with frameworks is mixed at best. The advantages frameworks provide certainly outweigh the cost but even with the examples given above, complexity quickly becomes an issue. Because these frameworks are geared toward large enterprises and attempt to be all things to all people they are inheritantly complex. Don't get me wrong though, complexity in and of itself is not necessarily evil. In the situation where you are implementing an enterpise framework for a large organization complexity is a fact of life. We find that in the case of most clients the complexity these frameworks introduces an element of risk that is not necessary.

After evaluating the available options and weighing the pros and cons we decided that instead of trying to fit the proverbial square peg into a round hole, we would use our experience and expertise to develop an application framework that is more suited to a small or medium-sized business.

The Enterprise Framework

We chose the name Enterprise Framework because although the framework is geared towards small and medium sized businesses the framework is robust enough to accommodate growth and has the ability to easily scale to support an enterprise application. In fact, the major difference between our framework and other commercially available frameworks is simply scope. The scope of our framework is limited to provide features and functions that are most commonly used in our client projects (such as Data Access, Security, Logging, Error Handling, Email, etc). By taking removing the requirement that our framework accommodate 'everyone' we were able to remove alot of complexity associated with application frameworks.

Our framework currently consists of the following modules:

• EnterpriseFramework - The base module that provides common functions such as Data Access, Security, Logging, Configuration, etc)
• EnterpriseFramework.BusinessObjects - Specific to each client and is generated from the client database (Code Generation - Object-relational Mapping)
• EnterpriseFramework.Services - Provides supports for Web Services (ASMX, WCF)
• EnterpriseFramework.Web - Provides basically functionality for web application such as Security, Caching, URL Rewriting, Visitor Tracking, Localization, Globalization, etc.
• EnterpriseFramework.Web.Controls - An advanced add-on for the web module that provides controls and utilities based on the Telerik Ajax Web controls
• EnterpriseFramework.Windows - A mirror of the web module but geared toward providing similiar services to a windows application.

One of the things we frequently see when a client-project uses masterpages is the following type-cast:

MasterPageType myMasterPage = Page.Master as MasterPageType;

To avoid this type-cast you can simply add the following directive to your page:

<%@ MasterType VirtualPath="~/Site.master" %>

Adding this directive to your page will make the Master property strongly-typed (Page.Master remains loosely-typed) to your masterpage eliminating the need to do the aforementioned type-cast.

While there are many different ways to implement web services the two predominate architectural styles are REST (REpresentational State Transfer) and SOAP (Simple Object Access Protocol). Each style has is own pro's and con's and it is necessary to objectively balance the appropriateness of each when selecting the implementation of your next service. So what's the difference at a high level between the two?

SOAP (WS-*) services are geared toward the enterprise and are inheritently more complex. For each SOAP service you define a contract using the Web Service Definition Language (WSDL). This contract specifies precisely the XML request and response messages needed to interact with the service. The SOAP (WS-*) standards address things like reliability, transactions and message-based security which are important when dealing with any value added transactions. Obviously there is a cost for this functionality in terms of overhead and complexity.

If a SOAP service is consider the 'yin', then the REST service would definitely be the 'yang'. Simple to implement with no contract to define a REST service can be broken down to four actions:

- GET - Gets the Resource
- POST - creates the Resource
- PUT - Updates the Resource
- DELETE - Deletes the Resource

This simplicity means quicker development time, lower overhead although you sacrifice features. For services that are dealing with non-critical data REST services are definitely the way to go.

So which will you choose? We say let the REST versus SOAP debate rage on.Luckily for you, you don't have to be caught in the middle. The Microsoft Windows Communications Foundation (WCF) framework provides you with the flexibility to easily change the method your service uses to communicate and even allows you to service both REST and SOAP requests with the same service.

Central Florida Software Group Blog Introduction.

A link to my SSIS Business Rules Article:

http://geekswithblogs.net/ReelDeepDotNet/archive/2008/03/07/ssis-business-rules-engine.aspx

I should note that both of these reviews are from the perspective of an seasoned and experienced technologist. Your mileage may vary based on the knowledge your background and personal experiences...

Pro WPF in C# 2008: Windows Presentation Foundation with .NET 3.5 Second Edition - Matthew MacDonald

This book is a fairly easy, albiet long read. Coming from a web development background this book provides a solid introduction to to all things WPF. A few of my comments:

- Excellent introduction to the underlying foundation of WPF
- Excellent coverage of Xaml
- Good sections on documents, printing, add-ins and custom elements
- In my experience in the corporate development world I have never seen a business app with either animation or 3-d imaging (yeah...I know its used somewhere), which is why I struggled to understand the long, long, long winded sections on animation and 3D topics

Between this book and the MeasureUp practice exams I was able to passed the WPF certification exam, with no prior WPF experience. (And for those that are wondering...the book is a significantly better exam prep than the MeasureUp practice questions were.)

Microsoft Windows Communication Foundation Step by Step - John Sharp

This book was a very quick read (took less than 2 days to read through) and does little more that introduce WCF. The exercises are contrived and provide little real-world value. The highlights of the book are really the chapters on security. If your looking for something more granualar than an introductory overview I would search out a different book.

‘Sexy’ Extensibility Design and Patterns

“Programming to the interface” is important when addressing extensibility.

Provider Pattern – If you are familiar with asp.net then you have been beat over the head with this pattern enough that I won’t spent much time on it. If your not familiar with asp.net, I’ll give you 50,000ft view…… it allows for abstraction of data and behavior by using an interface that the client is aware of and an external class library that contains the actual implementation of whatever you are trying to do.

Plug-Ins – This is pretty straight-forward. Plug-ins are implemented in a way similar to modules below. The real difference is that you have to explicitly iterate through a list either from a configuration file or a pre-defined directory.

Modules – This was the most interesting pattern and basically defines multiple parts of extensibility in one class. Related patterns are Chain of Responsibility, Loosely Coupled Events and Interception Filter. This methodology is event-driven and in an extremely flexible manner allows modules to hook into the events. The modules are identified to the client or web app through a configuration file and are loaded using reflection.

Man I am so behind on getting my notes and thoughts typed up...I've been to over ten sessions and I only have two typed up. I should be able to catch up this evening. Tuesday was rather uneventful as I hit a string of so-so sessions. Without further ado here is my notes for the session on Spatial Support in SQL Server 2008.....

Spatial Support in SQL Server 2008

- Spatial support is vector based and includes planar (Geometry) and geodetic (Geography)

- SQL Server was expanded to allow large UDTs

o In 2005, UDTs were limited to 5K

o In 2008, UDTs are limited only by LOB size (around 2 gigs)

- Geometry

o Adheres to OGC/ISO standards

o Can store points, lines, polygons and collections of the previously mentioned

o Methods include relationship (intersects, disjoint), construction (intersection, union) and metrics (distance, area)

o Sample:

DECLARE @g GEOMETRY

SET @g = GEOMETRY:PARSE(‘POINT(5.5 8.8)’)

- Geography

o Ellipsoidal data-type

o Does not adhere to OGC/ISO standards

o Same methods as Geometry class

- Spatial Indexes: Uses multi-level grids to map multi-dimensional data into a 2-dimension index

I am out at DevConnections this week and so far I have been impressed with the improvements and new features that are coming in the 2008 product line. I will post recaps of the sessions I attended as time allows...

- Data Warehousing in SQL Server 2008 by Christian Kleinerman – this session focused primarily on the new features and performance enhancements that were made in the SQL engine.

ETL Enhancements:

1. The new MERGE statement – this powerful new statement combines DML statements into one to allow for “UPserts” and “Deletes” between a specified source and destination.

MERGE tblDestination t

USING tblSources s

ON t.ID=s.ID

WHEN MATCHED

UPDATE SET t.Name=s.Name

WHEN NOT MATCHED

INSERT VALUES(s.Name)

WHEN NOT MATCHED BY SOURCE THEN

DELETE

2. Logging enhancements were made to allow for minimal logging. This level of logging keeps only what is needed to successfully rollback. According to there test significant performance gains where seen with this change.

3. Insert over DML – you know have the ability to do an insert off a DML statement with the OUTPUT clause.

INSERT INTO tbl

SELECT FROM (

<>

) CHANGES

WHERE Action=’UPDATE’

4. New tabled-valued functions were attended to track and query changed data.

5. The data flow thread allocation was changed from static to dynamic assignment for operators. This improves parallelism performance and adds thread starvation prevention.

6. A new ETL lookup is being added to SSIS. The new lookup has an unrestricted cache size and the ability to persist cache.

7. Data Compression to shrink table sizes and improve query performance is being added. The compression can be configured at the table or index level and they have seen performance gains anywhere between 1.5x and 7x improvements. During this topic they Mr. Kleinerman discussed the tradeoff between memory and CPU usage when using compression. He also briefly covered how compression was implemented (I will go through later).

8. Enhancements were made to the designer to build ‘best practices’ into the tools suite.

Query and Analysis:

1. Partitioned Table Parallelism was improved through dynamic thread allocation.

2. SQL Server 2008 can support multiple bitmap filters to improve star join query processing.

3. GROUPING SETS where added to the sql toolbox

GROUP BY GROUPING SET (date, (state, city))

4. Changes were made to the MDX query processing for subspace computation. Since cubes are sparsely populated changes were made to minimize what is processed during computation.

5. The Reporting Services engine was completely rewritten for 2008. I won’t go into all the changes but there were a ton of them discussed (i.e. Enhanced visualizations, Word Rendering, etc).

Admin

1. Backups can not be run with compression

2. The entire AS backup storage system has been replaced

3. The Resource Governor basically allows workload to be differentiated and per-request limits to be set ( I plan on elaborating on this is a separate post).

I had an opportunity to attend my first Tampa SQL BI Meeting last night and I wanted to share some of my thoughts from the SSIS demo that was given.
The first thing that really caught my attention is complexity of expressions that are used in a conditional split. I started picturing the nightmare scenario of debugging it and figured there has to be a better way. Enter the Script Component. The script component allows you to define multiple outputs and by monkeying (yeah thats a technical term) with the ExclusionGroup property you can filter the input rows. I am probably biased towards this technique (since my background is primarily in software development) and will need to find the time to do some analysis to see if there is a performance difference between the two methods.
The second item that got my thinking during the demo is more of a difference in approach. The case that was being presented had a requirement that before the package did any work a rowcount on the source data had to occur. If the row count returned 0 no further processing occured otherwise the destination was truncated and reloaded. To accomplish this task the presenter used an 'Execute SQL Task' to run the count query and then used to a 'Script Task' to determine if the control flow should proceed.
My thought on accomplishing this 'requirement' is a little more condensed. I would use the 'Execute SQL Task' but instead of a 'Script Task', I would use a 'Precedence Constraint' to modify the flow if necessary. By writing a simple expression to determine if the variable assigned to in the 'Script Task' is greater than zero you could either continue with required work or direct to an error flow.
Thats pretty much all for today...


Tight Lines!!


--Chris