Tiling a Polygon

One of the most challenging problems I came across working on a .NET PDF Annotator and Editor application was to tile a 2-D polygon and also accurately determine the number of tiles that fill the surface of the polygon.  The tiling part was not as much of a challenge as the counting part. The tiled polygon was to be rendered on a PDF document since the application in question is a PDF Annotating and Editing tool. We looked for anything the third party .NET PDF rendering/manipulation API that was used could provide for the tile rendering but there was nothing unfortunately.

So we set out to use C#'s native GDI+ library to render the tiles for the polygon.  After trying out different approaches to accomplish the rendering of the tiles, we discovered the one that would work best. The idea was simple. Every 2-D shape on the drawing surface has a bounding rectangle that encloses the shape. Starting from the top left bounding point of the rectangle, iteratively render a rectangle (tile with whatever length and width) across the X axis until the right most edge of the rectangle and this iteration needs to happen over the Y-axis (not sure if I explained clearly enough .  So now we have rectangular tiles laid out across the bounding rectangle for the polygon. GDI+ gives us a clip method that allows us to clip the rendering surface to a specific graphics path or region. Using the clip method, clip the drawing surface to be the graphics path for just the Polygon so that only tiles within the polygon's graphics path get rendered on the screen. We could apply other transformations to the rendered tiles like offseting, rotation or a gap between each tile.

Coming up with the most efficient way to count the number of tiles (including partial tiles) was a little trickier than rendering the tiles.  It turned out that the ideal approach was to essentially count each tile as it was drawn and checking whether the tile was partially or fully part of the polygon's graphics path/region. So, there is this method Region.IsVisible that lets you test whether a rectangle is partially or fully contained within a graphics region. During the rendering of each rectangular tile, the method was used to check whether the tile was going to be part of the region associated with the polygon and was counted if it was going to be. Even though, this was the most efficient solution for the problem, we did nt see 100% accuracy sometimes when rotation transformation was applied to the tiles. Still havent found an answer to this anomaly.

Related posts:

1. Eyespot – AJAX App for Video Editing
2. LINQ to My Domain
3. How to REALLY do Page Preview in Java with Embedded HTML Rendering

The C# compiler itself is setup to extract documentation which can then be piped through one of a number of documentation generation apps. My preference is a new(ish) project called SandCastle from Microsoft, which aims to provide much of the featureset that NDoc once did. Unfortunately this application provides no GUI. A fine gentleman named Eric Woodruff stepped in to wrap this application in an easy to use GUI for us aptly named Sandcastle Help File Builder. Through the use of good comments written WHILE we wrote the code, we were able to pop out some documentation for every bit of code we wrote in a matter of minutes. Add to this the nice information we get when using our code via intellisense, and it simply doesn't make sense not to strictly enforce documentation standards on your project.

I often see code written with little or no attention paid to comments. Sometimes the comments are fairly haphazard and appear to follow no standards whatsoever. By following documentation standards, you too can auto generate documentation instead of wasting hours or days going back through and trying to remember what your code does. The following are some of the more important tags available for C# documentation, presented in a roughly organized fashion. You can find a more complete list here.

Method/Type Description:
summary - To describe a type or type member
param name='name' - To describe a parameter of a method
example - To show an example of code usage
returns - To describe the data to be returned from the method

Formatting:
code - Denotes what is contained is code
c - Similar to 'code' but used within comments
para - Usually nested in another tag, allows formatted text

References:
see cref='member' - To specify a link to another type
seealso cref='member' - To specify text that may appear in a "See Also section" (I honestly have no clue what that means)
paramref name='name' - To reference a parameter in comments

There are other tags available, but with these in your arsenal, you should be able to build some nice documentation. Here's an example of what I would consider well commented code:

/// <summary>
/// This is a class description
/// </summary>
public class MyClass
{
  /// <summary>
  /// This method gets something
  /// </summary>
  ///
<param name="number">An integer input</param>
  /// <returns>Returns a <see cref="string"> based on the provided
  /// number
  /// </returns>
  public string GetSomething(int number)
  {
    ...
  }
 

That's not that painful is it?

Related posts:

1. Agile Development, Documentation and Bringing Projects back from the Dead
2. Integrating Design and Agile Development
3. ZK – Documentation & Tools

Design patterns. I think they are the one of the most intriguing areas of object oriented application design and development. There are so many out there that can puzzle you each and every time you try to take a crack at them (I can name a few of them that I still can't figure how they are to be used or implemented).  But a thing that most programmers would agree is if used wisely and appropriately, these design patterns can provide really powerful benefits that can enhance one's programming experience and also the software that is being built. There are several patterns I have used/implemented in my projects that I think are awesome. I ll touch upon how I used some of them and why every Object oriented programmer needs to master them.

Factory Method

This must be one of the most commonly used patterns out there. We indeed have used it the most in our projects. The crux of this pattern is essentially delegating the task of creating objects to a method that basically takes in information about what kind of object is to be created etc.  There were a number of instances in the applications we built where there was a base domain object that had a bunch of derived types. In most of these instances, single method/interface that returned the base domain object type but created instances of the appropriate the derived type was used. The benefit? The object creator is decoupled from the users of the objects and makes the code more reusable and maintainable.

Dependency Injection

I m absolutely in love with this design pattern. It is a very effective design approach in my opinion. What it advocates is lazy/runtime injection of object dependencies or modules instead of hard-wiring them.  There are a number of third party dependency injection frameworks like Spring, Object Builder etc that let you implement dependency injection out of the box. A very simple example of how I used this on a recent project : Consider the application needs to talk to a remote service for what ever reason. We also built out a fake service that mocked the real remote service to enable us to test/run the application when the real one was unavailable or being developed. We needed a way for the application to swap dependencies (basically the real service and the fake one) at run time. Spring .NET's dependency injection enabled me to implement this.

Command Pattern

A really powerful design pattern that helped us a great deal in implementing an undo/redo feature  in one of our desktop application projects. The idea is pretty simple. Every operation that you want to be undone/redone is encapsulated in the form of a command object that contains information about the method or delegate that needs to be invoked for that operation, parameters for that method or delegate, the undo method etc. Every time, any such command is executed, it is pushed to an undo stack. If the command needs to be undone, it is simply popped off the stack and the undo method is invoked. There is a redo stack for handling redo operations.

Other patterns that I have used widely are the Singleton, Facade, MVC, Pure MVC and MVP. These are effective in their own different ways.

Related posts:

1. Using Design Patterns
2. Defining RIA Interaction Patterns on time in Flex Agile Development
3. Style Guide tips and Tricks: Finding patterns

Vu360, the latest Pathfinder product, was launched by our client the Blue Book of Construction earlier last month.

It’s an Internet-tethered desktop application that enables easy viewing, markup and takeoff of PDF and TIFF documents for the architecture, engineering and construction industry. Some of the features include:

• Blueprints for projects seeking bids can be downloaded and annotated from the online plan room.
• Once a contractor is done annotating and marking up a blueprint, the file is easily saved back to the online plan room for viewing by the developer, general contractor or architect.
• While work is underway, the blueprint is saved on a users local computer. The tool does not require a persistent Internet connection to function.
• The tool includes a multitude of notations and graphing unique to the construction industry.
• The tool makes it easy to perform item counts and calculate length, perimeter, area and volume simply by drawing a square, line, cube or irregular, ad-hoc polygon directly on the blueprint.
• Sub-contractors can search BPM Select, Blue Book's repository of contracting supplies and products within the tool. When quoting installation of flooring, for example, a sub-contractor can link to a product sheet for the specific type of wood flooring they propose to use.

So far it’s been getting rave reviews from customers, including this one:

"VU360 is an incredible tool, and it’s sooooo easy to use. I cut back on my “job” estimate by at least 80% actual time. That would have been enough to impress me but, on top of that, I was able to export the figures to Excel."

We like those kinds of reviews. They tell us we’re doing something right when we design and develop software.

Vu360 is free, so if you’d like to download it and play with it, just go to the Blue Book and check it out. We’d love to get your feedback, so let us know what you think of it.

You can also check out the case study in our showcase for more project details and agile development goodness.

Our client, the Blue Book of Building and Construction also has a 40 minute tutorial for Vu360.

Related Services: PDF Application Development, .Net Application Development, Custom Software Development, User Experience Design

Related posts:

1. Launched: Rapid Reporting Employment Chek
2. Down with HTML + Code Markup!
3. The Desktop Application is Dead…Almost

100% coverage and a discuss with a few internal colleagues on the subject. Interesting to know is if I exclude the views from code coverage,  I hit a high of just over 90%.  So, is not testing your UI the end of the world? Not at all, as long as you use good development practices and aim to make your UI as slim as possible, without any business processing, branching or conditional type logic.

I've been very pleased with using the PureMVC framework on my current project, and haven't running into any Ah! Ha! I gotcha scenarios yet and frankly can't envision any as we continue to add new features to this application.  In fact using PureMVC has helped me think more about testability of our code and its single messaging bus has been just what the doctor ordered in terms of eliminating Publishing/Subscribing to events between the various components of the system, namely Mediators, Proxies and Commands.  But with great power comes great responsibility.

One could easily access the Singleton Facade of the PureMVC framework directly from your view and send a system wide message to any component interested in that message. The problem here is testability of the UI event required to trigger that system notification.

For instance in the code snippet below you would have to create an instance of the UpgradeView and simulate a click of the download button in order to test sending this notification.

public parital class UpgradView :Form, IUpgradeView
{
...

private void DownloadButton_Click(object sender, EventArgs e)
{
Facade.SendNotificaiton("DownloadUpgrade");
}
}

A better approach here is to allow your view to publish events that its mediator can subscribe to. This way you could add more logic before/after sending the notification and makes your code more testable.

public parital class UpgradView :Form, IUpgradeView
{
...

public event EventHandler OnDownLoad;

private void DownloadButton_Click(object sender, EventArgs e)
{
if(OnDownload != null)
OnDownload(this, e);
}
}

public class UpgradMediator : Mediator
{

public UpgradeMediator(IUpgradeView view)
{
view.OnDownload += Download;
}

private void Download(object sender, EventArgs e)
{
// Add more logic here,
Facade.SendNotificaiton("DownloadUpgrade");
}
}

[TestFixture]
public class UpgradMediatorTest()
{
...

public void HandleNotification(INotification notification)
{
switch (notification.Name)
{
case Notification.DownloadNewVersion:
Assert.IsNull(notification.Body);
break;
default:
Assert.Fail();
break;
}
}

[Test]
public void DownloadUpgradeTest()
{
upgradeView.BackToRecord();
upgradeView.Expect(x => x.CloseView()).Repeat.Once();
upgradeView.OnDownloadUpgrade += null;

IEventRaiser eventRaiser = LastCall.IgnoreArguments().GetEventRaiser();
upgradeView.Replay();

UpgradeMediator mediator = new UpgradeMediator(upgradeView);
eventRaiser.Raise(this, EventArgs.Empty);

upgradeView.VerifyAllExpectations();
}

}

So its it possible to get 100% coverage or is 100% just some pie in the sky that we aim for. Frankly, 90%+ code coverage aint bad, especially when my views are lean mean fighting machines.  Ok one last thing I'm sure your wondering  is why not 100%  coverage now that the views are excluded. Well, smarty pants, I can't test external third party APIs code that we include, nor do I want to.

Related Services: .Net Application Development,
Custom Software Development

Related posts:

1. WinForms Development Made Simple with PureMVC
2. Code Coverage – Why?
3. Notification Testing with PureMVC and FlexUnit

Last week, Karega Scott made a nice post on how Pure MVC makes development of Windows applications using C# simple. I thought I ll piggyback on this post and share some of my thoughts regarding this popular framework. I think the framework, if understood completely and adopted intelligently, has to offer some really cool benefits like :

• Light-weight messaging mechanism (using Notification/Observer patterns) between different parts of the application without having to create custom events/hooks all over the place.
• Highly Decoupled Components allowing abstraction and seperation of logic.
• The application's testability is enhanced greatly because of the reason stated above.
• A Centralized singleton Facade component that mediates between the different components in the application.
• The use of commands in the framework can help in building complex applications that need to perform several different UI-driven functions.

The framework's limitations (or should I say "perceived weaknesses") are :

• Registering and removing components on the Facade? Could there have been a better way to accomplish this? May be.
• Named references for components were not helpful at all.
• If the framework's notification mechanisms are not used appropriately,  there are chances of infinite message loops leading to debugging hell.

There was considerable ramp up time involved in understanding the framework's capabilities/strengths/weaknesses. I still don't think I have realized the complete potential of Pure MVC  and I hope to explore more of it these coming days.

Related Services: .Net Application Development, Custom Software Development

Related posts:

1. UI Views – Include or Exclude from Code Coverage
2. WinForms Development Made Simple with PureMVC
3. Pure GWT – Converting Scriptaculous to GWT

Our presenters were responsible for handling the user interaction coming from the views by subscribing to events published by the views, and coordinating these actions with changes needs from the models such that these changes are then reflected back in the views themselves.

Although this approached work, it requires a lot of wiring and unwiring of events from the various presenters to views, presenters to model, and presenters to presenters. So the code quickly begins to look like the following:

public class presenter1

{

public event EventHandler<EventArgs> SomethingHappened;

public presenter1()

{

_model = new Model();

_model.StateChanged += OnModelChange;

_model.DocumentSaved += OnModelSaved;

_view = new View();

_view.OnMouseDown += OnMouseDown;

_view.OnMouseUp += OnMouseUp;

_view.OnMouseMove += OnMouseMove;

_view.OnMouseEnter += OnMouseEnter;

}

…

…

As you can see, for every user interaction on the view or model change a particular presenter is interested in, you must subscribe to an event, and if other presenters are interested in particular actions from views they are not responsible for, well, I’m sure you can get the picture. So act II, introduction of PureMVC framework for WinForms.

So exploring the capabilities of PureMVC framework, uncovered a simplification of our code. At its core, it consists of four singleton objects Model, View, Controller and Façade. The Model, View and Controller contain literal string references to Proxies which are data model, Mediators which provide and manage the user interface, and Commands which interact with the Proxies and Mediators or other commands.

But the simplification revolves around the Façade which is responsible to provide messaging throughout the core framework using an Observer notification scheme. So now our code quickly begins to look like the following:

public class presenter1 : Mediator

{

public presenter1()

{

}

public override void ListNotificationOfInterest()

{

return new List<string> { Nofication.ViewMouseClick, Notification.ModelChange,};

}

public override void HandleNofication(INofication notification)

{

switch(nofication.Name)

{

case Notification.ViewMouseClick:

Dosomething();

break;

}

}

…

…

public class presenter2 : Mediator

{

public presenter2()

{

}

public override void ListNotificationOfInterest()

{

return new List<string> { Nofication.ViewMouseClick,};

}

public override void HandleNofication(INofication notification)

{

switch(nofication.Name)

{

case Notification.ViewMouseClick:

DoSomethingFun();

break;

}

}

…

…

public partial class view1 : Page

{

…

…

protected void view_mouseclicked(object sender, MouseEventArgs e)

{

Façade.NotifyObserver(new PureMVC.Pattern.Notification(Notification.Name));

}

…

…

Both presenter1 and presenter2 state they are interested in Notication.MouseClick event, and view1 uses the Façade to notify both presenters that the user has clicked the mouse button. No need to publish and subscribe to any events outside what’s naturally needed in the view.

The only thing I dislike is the name references, but as long as we are using constants you should be fine.

Related Services: .Net Application Development, Custom Software Development

Related posts:

1. UI Views – Include or Exclude from Code Coverage
2. Notification Testing with PureMVC and FlexUnit
3. Making Vaadin, PureMVC and Grails Work Together

Fluent NHibernate is an extension of the widely used and very popular NHibernate framework for Microsoft .NET. It is an open source framework that sits on top of the NHibernate layer and utilises all the core NHibernate methods. This framework provides an alternative to the standard XML based mappings (.hbm xml files) of NHibernate. It lets you define the NHibernate mappings in strongly typed and concise C# code.  For those who are new to NHibernate, here is more information.

 Traditional NHibernate XML mapping

 <?xml version="1.0" encoding="utf-8" ?> 
<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" 
  namespace="QuickStart" assembly="QuickStart"> 
 
  <class name="Cat" table="Cat"> 
    <id name="Id"> 
      <generator class="identity" /> 
    </id> 
 
    <property name="Name"> 
      <column name="Name" length="16" not-null="true" /> 
    </property> 
    <property name="Sex" /> 
    <many-to-one name="Mate" /> 
    <bag name="Kittens"> 
      <key column="mother_id"/> 
        <one-to-many class="Cat"/> 
      </bag> 
  </class> 
</hibernate-mapping> 

Fluent NHibernate equivalent

public class CatMap : ClassMap<Cat>  
{  
  public CatMap()  
  {  
    Id(x => x.Id);  
    Map(x => x.Name)  
      .WithLengthOf(16)  
      .Not.Nullable();  
    Map(x => x.Sex);  
    References(x => x.Mate);  
    HasMany(x => x.Kittens);  
  }  
}

 Why use Fluent NHibernate? Here are some benefits that it offers:

• It favors convention over configuration and overcomes the repetitiveness that is there with NHibernate. For instance, NHibernate requires string properties to be not null and have a default value. You don't have to handle this if you go fluent.
• By getting rid of XML based mappings, it paves way for easy-to-read code that can be refactored and maintained in a simpler way. The mappings sit along with your code so any refactorings/changes to the code will cause the mappings to be affected as well. This helps catch compile errors/bugs with mappings.
• One other obvious benefit is that the XML verbosity of NHibernate can be avoided.

I think this is a good place to start picking up Fluent. You find a nice little project example that talks about mapping a simple database schema and building an application to read data using the fluent mappings.

Related posts:

1. .NET 3.5 Linq to Sql and IBatis.NET
2. Hibernate Gotcha: java.lang.IndexOutOfBoundsException: Remember that ordinal parameters are 1-based!
3. Afraid of LIE (LazyInitializationException)… Don’t Be.

Where the heck is print?

There is a print method that is available on this control which directly prints the current web page without popping up the print dialog. This is fine but what if I want the print dialog to be show up? After some digging into the msdn documentation and googling around, I determined there was a way to do this. The trick is to use the execcommand method on the browser's document object. The syntax goes like this: 

 Browser.Document.ExecCommand("Print", false, 0)

I believe this method basically executes the specified command on the underlying Microsoft active-x/html control. There are number of different commands such as cut, copy, paste, undo, redo etc that are available. One thing to keep in mind is that all the edit commands operate directly on the DOM elements of the HTML document. 

What about Search?

This one did take quite a while to figure out.  The browser control did not offer anything directly for searching the current web page.  If  its the Control-F search (that you normally get to see on the browser) is what you want, there is a simple way to enable that on the browser control.  Set the WebBrowserShortcutsEnabled property to true and you have it. This also enables other shortcut operations like control-C, Control-V, Delete etc.  I came across a number of posts that talked about using interop to get to the underlying active-x control to accomplish functions like search, copy, cut, paste etc. I guess you can avoid all this trouble by making use of this property on the control.

Any other gotchas with this control? Feel free to let me know.

Related posts:

1. Keeping up with Firefox 3: Six more bookmark-manager gotchas
2. Don’t be lazy, download a good browser
3. GWT 2.0: Cool Beans on In Browser Development Mode

RikMigrations
Migrator.NET
Subsonic Migrations
dbDeploy.NET

Here are some useful links I've found to help determine which toy, I mean, tool, I plan to use next.

http://www.infoq.com/news/2009/01/migrations_dotnet
http://flux88.com/blog/net-database-migration-tool-roundup/
http://alekdavis.blogspot.com/2008/07/database-installer-revised.html

Related posts:

1. Visualizing Your Database Schema Entirely in Rails
2. acts_without_database: Leverage ActiveRecord with Non-Database Backed Objects
3. Agile planning tools.. paper or ‘plastic’?

photo credit: Paul L. Nettles

We're starting a software development summer internship in our Chicago office this year. If you're a college junior, senior or recent graduate who want to learn the agile/OO development ropes while developing really cool products and services and earning $20/hr per hour (you should pay for the privilege, right?), give the internship posting a look here.

Related posts:

1. Software Development and Wasted Motion
2. Ruby on Rails Internship
3. Software Development and the Construction Analogy

I m sure many of the .NET programmers who have worked on building .NET windows applications must have had a chance to play around with the MSI/Deployment Project. This is the built-in project that the framework offers to build installers for deploying and installing windows applications. I think this project provides decent capabilities for packaging and installing windows applications but definitely has some limitations.

MSI/Deployment Project

The windows installer that was needed for our current project needed to accomplish some specific tasks like auto download and install of the .NET framework (without going out to the Microsoft site), detection of the windows version, file type association etc. We started out using the MSI/deployment project to build this installer. At a point when most of the plumbing was done, we realized that the project was'nt going to give us all that we needed. Even though the project offered the ability to build custom actions to perform specific tasks like the ones mentioned earlier, the amount of control that it gave us was pretty limited. We decided to look for other alternate solutions and that's when we came across the Nullsoft Scriptable Installer package.

Nullsoft scriptable Installer Package

Nullsoft scriptable installer (NSI) is a pretty straightforward scripting package that lets you build installers for windows applications using scripts driven approach. It is open source of course. I think it definitely is a promising alternative to the .NET deployment project. You essentially build a .nsi script which is like a master installer script that encompasses different sections for install, uninstall etc. This script can include code from other scripts and also macros. Macros are like script snippets that basically get inserted into the main script at compile time. The package comes with a nsi compiler that lets you the compile the nsi scripts and also test the installer. Let me briefly outline the pros and cons of NSI.

I think the pros are:

• It is quite dynamic and offers facilities for different installation tasks like modifying the registry information, versioning and accessing OS level information.
• It allows the user to customize the installer's UI to a great extent and also enables addition of new dialogs in the installer.
• It also offers additional plugins that can be integrated into the installer for performing different tasks that might be necessary
• It even enables debugging using some built in methods.
• There is a nice developer forum on the NSI website that contains useful tips and references for building scripts.
• It is free!!

The drawbacks are not too many. A couple of not so nice things about this installer package are :

• The mechanism to include the files that need to be a part of the installer is not very intuitive. It involves hard coding the different filenames in the script. Ideally, the script should have had the ability to include the complete output of a project or solution. This would prevent errors like files being missed or incorrect files being included in the installer.
• I think the documentation that is available on the NSI website could have been a little more comprehensive. The site has some decent script examples that can get you started. But they are definitely not any close to  a real world installer that you might want to build.

We were able to use NSI successfully to build the installer that we needed after a little bit of a learning curve. Anyone looking for an alternative to the traditional .NET deployment project should definitely check out NSI.

Related posts:

1. Automated Deployments Rock
2. Rails Development on Windows: Native or Virtualize
3. Ruby on Rails with Windows – How I made it work

photo credit: erix!

In my last post, See the Code, Be the Code, I compared agile development to the game of golf. But how does one truly "see the code" as the software grows in size and complexity? On one hand, you could ignore the fact that software is developed over many iterations and try to build a very complex system all at once that does everything under the sun, or you can keep the design simple and focus on the iteration at hand knowing that as our understanding increases we will refactor the code.

Refactoring is the process by which you modify the behavior and appearance of the code to ensure that code is up-to-date with current system requirements or changes in the system environment. It gives the development team an opportunity to continuously improve code quality for long term readability and maintainability. The easier the code is to follow, the less time it will take for current and future development teams to make changes as the system matures. It can also help the development team take advantages of improvements to existing frameworks and other software used to develop the application. These improvements can be realized through better performance and reusability of existing and future code. In short, it helps keep your code from become stale and mildewy.

So we are developing a custom desktop application that utilities a third party PDF library. Our team has developed the core tools for marking up documents using simple shapes - lines, rectangles, circles and polygons, calibration of a document to a specific scale - 1/4 in = 1 ft, and more complex shapes that using the scale to compute the shapes length, area, perimeter, etc. Now we are working on hole 10 of the software development golf course and one of the user stories requires multiple scales per document.

Upon inspection of our code base, we decided that we could meet the user requirement by restructuring the code contained within the ViewPort class. This class was originally designed to allow a single scale for the entire document, and contains methods for setting and updating the scale and basic properties for accessing the scale information for use by markup that requires calibration.  The ViewPort still needs a single, default scale that's used for entire document but should support scales for specific areas/zones of the document.  Below shows the current and proposed refactored ViewPort class and new ScaleZone class.

Now that we have an idea of how we want to refactor the code, we need some unit tests.

Unit Testing is just as important as refactoring because it helps to ensure unchanged code isn't affect by improvements to other parts of the applications,  it helps document how to use new or updated functionality, and confirms the accuracy of our changes. So before we start changing the coding, we create a few  Unit Test. For example AddScaleZone method: we want to test calibrating a blank document and adding a new scale zone. We should save the document and reopen and assert that new scale zone exist with the correct data.

[Test]
public void AddScaleZoneTest()
{
  string fileLocation = FileUtil.GetFileLocation(FileUtil.BlankDocument);
  docModel = new DocumentModel(fileLocation);
 
  CreateDefaultCalibrationViewPort(docModel.Document);
 
  docModel.SaveAs(savedFileLocation);
  docModel.Close();
 
  MeasurementProperty scaleZoneMeasurementProperty = GetScaleZoneMeasurementProperty();
 
  savedDocModel = new DocumentModel(savedFileLocation);
 
  // Create the scale zone and add to viewport
  ScaleZone scaleZone = new ScaleZone(new RectangleInfo(25, 25, 425, 425), 1);
  scaleZone.SetScaleZone(scaleZoneMeasurementProperty, "ScaleZoneUnitTest");
  savedDocModel.AddScaleZone(scaleZone);
 
  int scaleZoneCount = savedDocModel.GetScaleZoneCount();
  savedDocModel.SaveAs(savedFileLocation);
  savedDocModel.Close();
 
  ValidateCalibrationViewPortSaved(savedFileLocation);
  ValidateScaleZoneSaved(savedFileLocation, scaleZoneMeasurementProperty, new RectangleInfo(30, 30, 90, 90), 1, scaleZoneCount, scaleZone);
}

We know the project won't compile until we add the new ScaleZone class and refactor the ViewPort class. Let's also not forget that our existing unit tests can become stale and out-of-date; it's just as important to update the existing ViewPort Unit Tests base on the new requirement.

The point here is that code regardless of purpose needs refreshing. Don't let it mildew! Refactor your code!

Related posts:

1. Cucumber Rocks – But it’s not a replacement for unit tests
2. Ruby Code Audit Checklist
3. Rails Testing Frequently Asked Questions — The Non-Code Version

Related posts:

1. The Blogs Have Moved
2. PureMVC, Spanning the Platform Spectrum?
3. Touch Screen Kiosk in Adobe Air

So we recently had a powwow between all the different parties to talk about MVC and this convergence. With the exception of the insufferable Mac and iPhone developers and their disgustingly mature Cocoa framework, we all agreed it would be nice to have an application level MVC framework for each platform. We also agreed that Swing is a great example of what happens when the vendor doesn't provide such a thing -- spaghetti code that relies on component level MVC and hard wiring at the application level. There are a few MVC frameworks for Swing, such as TikeSwing and Spring Rich Client (soon to be superseded by Spring Desktop), but for every Swing app that has this sort of design, there are hundreds that are just a mess.

Most of us felt that RIA's, including Flash and Flex apps, were suffering from the same framework vacuum. Wouldn't it be nice, we thought, if there was a common framework between all of these platforms, that brought application level MVC to the party? Sasha, our Flex lead, mentioned PureMVC, a "simple" framework that has its origins in ActionScript. It now has ports to Java, GWT, C#, Objective-C, PHP, Python and JavaScript. We'll be evaluating this framework over the next few months to see if it is suitable as a general solution for our RIA's and desktop apps.

If any of our readers have experience with PureMVC or any other cross platform MVC frameworks, feel free to comment.

Related posts:

1. Learning PureMVC the Hard Way (is there any other way?)
2. Using Flex Code Generator (FCG) with Flex & PureMVC
3. Flare on PureMVC in Flex example

• Amazon EC2 is offering Windows on EC2, with the pricing at $0.125 per hour for a small instance running Windows Server (as compared to $0.10 for a Linux instance). You can run SQL Server Express at no extra charge. The SQL Server Standard smallest instance (Stadard Large) rings in at $1.10 per hour, however, which ain't such a good deal.
• Microsoft's Azure Services Platform. It's still in community evaluation mode, but there is one thing that is already clear about it: it's as confusing as all git out. One of the advantages of Amazon's services like S3 and EC2 is that they are simple and can form the building blocks for other applications and services.

If I'm provisioning a web application, I'm pretty comfortable thinking in terms of virtual servers or instances. Not sure how to think about scaling and cost with Azure. I think MS would have done better to start out with a KISS approach to drive adoption. Time will tell if their "it can cure cancer" approach will work out.

Related posts:

1. Microsoft to Jump on Board EC2
2. Rails Development on Windows: Native or Virtualize
3. Agile Business, Microsoft and the Threat of Cloud Computing

This piece of news has brought about great cheer in the Web Developers community. jQuery has been fast gaining reputation in the world of web-development as a light-weight, flexible and easy-to-use Javascript library. Integration of jQuery with Microsoft's development platform should provide web developers with new capabilities and opportunities.

This is very smart move by Microsoft given the fact they have always hesitated to incorporate open-source technologies into their products. It is planning to ship jQuery with the ASP .NET MVC very soon. Integration with Visual Studio is something that is going to happen later. There are plans to enable intellisense support for jQuery in Visual Studio which would be really cool I think.

Some of the high-points of jQuery integration with ASP .NET could be :

• JQuery provides an attractive alternative to conventional Javascript making client-side DOM and HTML manipulation much easier and quicker.
• It could complement ASP .NET Ajax and play with it really well
• The original jQuery libraries are going to be ported into ASP .NET without any change which would enable developers to leverage jQuery's true potential

image-source : www.webmonkey.com

I have posted a few links below that discuss more about what the MS-jQuery marriage means for the web development community and how it can make life easier for developers out there.

http://weblogs.asp.net/scottgu/archive/2008/09/28/jquery-and-microsoft.aspx

http://weblogs.asp.net/bleroy/archive/2008/09/28/jquery-now-officially-part-of-the-net-developer-s-toolbox.aspx

http://jquery.com/blog/2008/09/28/jquery-microsoft-nokia/

Related posts:

1. My IBM developerWorks series, part 2: Tooltips, lightboxes and more jQuery goodness
2. Pitfalls of Using JQuery with ASP.NET Ajax
3. jQuery Form and jQuery UI Tabs: Two great tastes that taste great together

Ruby has been known work to well with Mac OS, Linux and Cygwin traditionally. I came to understand that it doesnt work very well with Windows. There are a number of pitfalls that are associated with Ruby or Rails running on Windows. Here, I going to talk about a couple that I hit when I was trying to get RoR to work on Windows :

• Most of the unit tests in my RoR project were failing throwing some weird database errors. I had done everything right from installing Ruby to installing the various gems needed for the project. After a quite a bit of googling, we learnt we could resolved these issues by making a simple change to the MySQL settings. The "Enable Strict mode" option had to be disabled using the MySQL interface config wizard. I ran the tests after this was done and voila!

• This problem was even more perplexing than the above one. A bunch of unit tests were still failing with a dreadful "Segmentation fault" error (I m sure "ROR on Windows" folks might have seen this before). Some research on this error led to the finding that MySQL versions greater than 5.0.18 might cause this problem. So I downgraded my version of MySQL to 5.0.18 to see if that fixed my problem. No luck as yet! This was followed by trying out a number of other potential fixes like using different versions of libmysql.dll (the MySQL library used in Ruby), making changes to database configuration in the project etc. None of these helped me. After a few days of frustration, I uninstalled the MySQL gem and reinstalled it upon the advice of my colleague. That finally did the trick!

I m still puzzled how these fixes worked but glad they did .

Related posts:

1. Rails Development on Windows: Native or Virtualize
2. A Java Programmer’s transition to Ruby on Rails
3. Testing various roles in ruby on rails

MyClasses.dbml - This looks like any ORM frameworks mapping file. It associates classes with tables, maps fields to object properties, and defines relationships.

 
<table border="0"></table>
 

MyClasses.dbml.layout - This looks to be specific to the layout of the design surface and appears to serve no purpose outside of this design.

MyClasses.designer.cs - This is the beast that I'm looking to replace. It contains the class definitions and attribute based mappings to bring my database schema into my application, and ready it for use by LINQ.

So this leaves me with a couple questions. One, why are attributes used to specify mappings? Can this be done strictly via XML? More importantly two, can I use my own domain model, and if so how do I map it to the database?

My goal would be to design a layered system, separating the underlying data store from the repositories required to push and pull my domain objects from these data stores. This would allow in memory implementations of the data store, and would make unit testing (and developing) a whole lot easier. I will be digging into this in the coming days and will report back soon. Stay tuned!

Related posts:

1. .NET 3.5 Linq to Sql and IBatis.NET
2. Fluently NHibernate
3. ADO.NET Entity Framework

Some benefits of the Entity framework:

• Data storage engine and schema independence: Due to the layer of abstraction between the logical and conceptual schema of your application, you no-longer need to know and hard cord the application to a specific data storage engine or schema.
• More expressive conceptual model: Entity types can inherit from other entity types and allows the creation of more complex types in addition to the standard scalar types support by the database.
• Access to multiple database system: Because the application is free from hard code data storage dependencies, the developer has the ability to access data from multiple storages using a consistent application object model
• LINQ: Language Integrated query support that offers compile time syntax checking for queries against the conceptual model.

The Entity Framework works by allow the developers to hand code or use code generation tools to create the XML metadata for the conceptual entity data model, a storage entity model, and a mapping specification between the two. The XML file created for the conceptual entity data model is then stored in the conceptual schema definition file (.csdl), the storage entity model is stored in the storage schema definition file (.ssdl), and mapping between the two in the mapping specification language file (.msl). These XML file are then loaded into the metadata workspace of the entity framework, and a set of classes are generated to allow the developer to work directly with the conceptual model and indirectly with the logical model.

Figure: ADO.NET Entity Framework Architecture

So with these benefits design and built directly into the the framework and the logical approach used by framework to interact with various data providers, some experts in entity-based applications and software architectures on the .NET platform still feel that the framework has some pretty large deficiencies.

They are concerned that the framework is...

• Inordinate focus on the data aspect of entities leads to degraded entity architectures
• Excess code needed to deal with lack of lazy loading
• Share, canonical model contradicts software best practices
• Lack of persistence ignorance causes business logic to be harder to read, write, and modify, causing development and maintenance costs to increase at an exaggerated rate.
• Excessive merge conflicts with source control in team environments.

Are these claim valid concerns to consider?

Sure, only if the framework is mature with several versions under its belt and its prohibits the productivity, maintainability and scalability of the application.

Isn't the right approach to software development to deliver a subset of the full feature set right the first time than try to deliver everything at once with massive issues that prevent the usability of the tool?

You decide...

Below are some useful references to get you going with Entity Framework.

Achieve Flexible Data Modeling With the Entity Framework
ADO.NET Entity Framework Pre-release documents
Microsoft ADO.NET Entity Framework Overview
ADO.NET Entity Framework Taking Some Heat
Programming Against the ADO.NET Entity Framework
ADO .NET Entity Framework Vote of No Confidence

Related posts:

1. Hibernate Gotcha: java.lang.IndexOutOfBoundsException: Remember that ordinal parameters are 1-based!
2. .NET 3.5 Linq to Sql and IBatis.NET
3. Framework Watch – ThinWire