Our organization is fairly new to Agile/SCRUM. We have always struggled to create the master backlog for this project. Along with adapting to a new process, it has been especially challenging for our product owners to consider the 60,000+ customers in which they proxy for.

The project is 16 iterations in (2 week), we are making great progress and are trying to finalize the vision of our first release. Over the past 3 weeks our product owners & scrum masters took over a conference room and flushed out the remaining backlog items for our first delivery. As you can imagine it was a very tedious task, but I for one am extremely excited about the results. No it is not perfect, Yes there will be changes, but its great to visualize what we are trying to do in its entirety.

This last week the teams were brought in to do estimations and tweak stories (combine/split) to complete the backlog. Here are a few photos from the last 15 minutes on Friday as we were finishing up.

Chickens!

Here is our awesome Scrum Master John P in action

Windows are great with sticky cards

We use planning poker (fibonacci seq) for estimations, here is my sweet deck. You also have to take note of the orange with the painted face in the coffee cup. He is our bad mojo orange, so anytime you are getting frustrated there is a big scene and you have to touch the orange to remove your evil thoughts. Though by the end of the week it was kind of getting gross.

And this is what happens when your test engineers are trapped in a room with markers for a long period of time

And of course my favorite card, inspired by “doodle the developer” (Aka Steve J). It works nicely in place of the ‘Infinity’ card.

What am I looking forward to:

* Visual Studio Speed improvements.  Nuff said.  Please keep making it faster.

* SQL Server 2008 features in LINQ 2 SQL. I just did a big demo of SQL Server 2008 T-SQL changes for BSDG, and the one thing I was not able to do was really show off the new features.  How do you use the HierarchyID in LINQ2SQL right now?  With stored procedures.  I’m hoping this release will fix that.

Also, this pretty well determines when SP1 will release: at the same time as SQL Server 2008.  If you listen to .Net Rock show 340, they say that a SQL Server 2008 release is imminent.  Which could mean anything.

* Routing for ASP.Net. We aren’t talking about Routing for ASP.Net MVC Framework, but regular old WebForms.  I love this.

* Cold start performance improvements.  One part of working with .net that kind of sucks is the cold start.   Someone boots up their computer and starts your application, which take forever to load.  Then the next time you load, it boots right up.   According to Scott Guthrie the are seeing up to a 40% performance increase.

What I’m interested in:

Here are some new features I’m interested in, but I don’t expect to jump on right away.

* Dynamic Data. Much has been said about this already.  I will be looking into it.  There is scaffolding support in there, as well as a lot more.  Plus it can be used with multiple ORM solutions.  I believe LLBLGen will have support, and Scott Hanselman said NHibernate support was also being worked on.  I suspect SubSonic in there somewhere as well.

* Entities Framework.  I’m always looking for better ways of getting data from a database.  While this doesn’t seem better than some of my current tools (NHibernate, SubSonic, LINQ2SQL), I’m keeping an eye on this one.  If you read down Scott Guthrie’s blog comments, you will also see that Oracle will be supported with Entities Framework.

* Microsoft AJAX Stuff. I’m using JQuery for more of this right now, but there are some enhancements to the ScriptManager coming.  And JQuery or no JQuery, I still use the ScriptManager.

* Improved Client Distribution. While I mainly blog about Asp.Net, I also work with WinForms.  And in WinForms, .Net Framework distribution is always a hot topic.  Better bootstrappers, improved ClickOnce.  Give me everything you got.  One key feature: they made it smaller.

* More WinForms Controls.  These are actually some of the Visual Basic.Net PowerPack controls.  Thank you.

* WPF Stuff.  I having had the opportunity to really get into WPF yet, but the time will come.

OK, that is all that I’m going to list.  There really is a lot out there for a Service Pack.  But one quick note: this is beta.  And this is one beta I’m not installing yet — but I will as soon as it is released. 

If you are looking for more information, check out these articles:

Scott Guthrie: http://weblogs.asp.net/scottgu/archive/2008/05/12/visual-studio-2008-and-net-framework-3-5-service-pack-1-beta.aspx

Brad Abrams: http://blogs.msdn.com/brada/archive/2008/05/05/visual-studio-2008-and-net-framework-3-5-sp1-beta.aspx

Scott Hanselman: http://www.hanselman.com/blog/VS2008AndNet35SP1BetaShouldYouFearThisRelease.aspx

Tim Sneath: http://blogs.msdn.com/tims/archive/2008/05/12/introducing-the-third-major-release-of-windows-presentation-foundation.aspx

I thought Martin Fowler answered the question very well:

“Anything that causes a state change to my world, my domain model… I capture in an object, you can think of it as a command object, I like to think of it as an event object. That object carries with it all the information about the kind of state change it might be. Then I have some way of processing it against my domain model to actually perform the change, but I still store and persist that event object as part of the record of what I’ve done.” DDDD video, 49:00ish

He are a couple of great articles from Martin’s site which elaborate on his statement, if you are interested in making the transition from request/response to messaging I recommend giving them both a thorough read. I am currently in the process of making the transition myself and I found them very helpful.

Fowler – Event Sourcing

Fowler – Event Collaboration

Also from the session came a great list of other reading materials, so bone up!

Pattern Oriented Software Architecture Books 1-4

Enterprise Integration Patterns 

Domain Driven Design 

Domain Driven Design Quickly (Free 100 page compressed version in PDF provided by InfoQ)

Power of Events

Distributed Event Based Systems

Event Based Programming

Software Architecture in Practice (weighing ‘ilities’)

SEI – Quality Attributes (PDF)

Thanks to all the attendees including Evan Hoff, Udi Dahan and Greg Young for helping compile the great list of books you see above. (as well as their contributions to the conversation in general)

The Ado.Net Blog

The Forum

Danny Simmons

Colin Meek

Jaroslaw Kowalski

Ju-Yi Kuo’s blog

Alex James

Zlatko Michailov

OakLeaf Systems

Andy Conrad (Astoria)

Pablo Castro  (Astoria)

Julie Lerman (EF, 3.5, Astoria, Silverlight, Blend)

Mike Taulty  (EF, 3.5, Astoria, Silverlight, Blend)

Her owner has spent several days throwing together an InfoPath application for his employer and is quite happy with his work. Butters thinks that he should be ashamed because he is paid to be an “architect” and he has built an application his mother could probably get going in a pinch.

“But, Butters,” his owner exclaimed, “the point is to use the right tool for the job. I am just making a little form that business folks fill out and use to save XML documents. This is exactly what InfoPath is for, and it is so gosh, darned easy.”

“Oh,” replies Butters, “and I suppose there is validation logic and conditional formatting and other event automation going on in the form?”

“Uh, yes. Aren’t you a dog?”

“And I suppose all of those things are written right into the view, which is data bound directly onto the data sources?”

“Well, yeah. Aren’t bulldogs supposed to be one of the dumber breeds?”

“And didn’t you just blog about how easy the new MVC framework from Microsoft will make these things? Do you not promote yourself as one who can spin that code as quickly as clicking your way through the stupid InfoPath designer?”

“Yeah, I know, Butters. I am feeling kind of guilty about this.”

“You should, InfoPath Boy. You have all these great theories about separation of concerns, thin UI, and data abstraction, yet you solve a coding problem with InfoPath? You, sir, are not worthy of your peers.”

“Damn you, Butters. Damn you,” I replied.

Following the MVC talk, Martin Danner will be doing an hour or so on the fresh new features found in Team Foundation Server 2008.

I hope to see you there. Let’s go for a beer after over at Table Rock!

I sent an inquiry to our Code camp online group asking the simple question, “How would you send 400 emails?” The list of answers was hilariously geeky and shows the nature of my friends.

Option 1 – Write Code

You could rip through a CSV and Send via code through Google.

   1: MailMessage email = new MailMessage();

   2: email.From = new MailAddress( "support@foo.com",    "FOO Support");

   3: email.Subject = "Welcome to list";

   4: email.Body = "The Message";

   5: email.To.Add(TextBox1.Text);

   6: SmtpClient server = new SmtpClient("smtp.gmail.com", 587);

   7: server.Credentials = new     NetworkCredential("support@foo.com",     "ThePassword");

   8: server.EnableSsl = true;

   9: server.Send(email); 

Option 2 – Write Code

Send it with a local SMTP client.

   1: using System.Net.Mail;

   2: using System.Text;

   3:  

   4:        //'ute' is my utility object and it has a property 'AdminEmailAccountName':

   5:         MailMessage msg = new MailMessage(ute.AdminEmailAccountName, toUser.Email);

   6:         msg.IsBodyHtml = true;

   7:         msg.Subject = "Message from Code Camp";

   8:        //Use my template with the verbiage for the message

   9:         StringBuilder sb = new StringBuilder(Resources.ContactUser.EmailTemplate);

  10:  

  11:        //Replace the placeholders with actual values:

  12:         sb.Replace("recipientPlaceHolder", toUser.DisplayName);

  13:         sb.Replace("senderPlaceHolder", fromUser.DisplayName);

  14:         sb.Replace("subjectPlaceHolder", ute.CleanCusswords(txtSubject.Text));

  15:         sb.Replace("bodyPlaceHolder", ute.CleanCusswords(txtMessage.Text));

  16:         sb.Replace("UserIDPlaceHolder", fromUser.UserID.ToString());

  17:         msg.Body = sb.ToString();

  18:  

  19:         SmtpClient client = new SmtpClient(ute.SmtpHostName);

  20:         client.Send(msg);

Option 3 – MS Word Mail Merge Feature

What is Mail Merge you ask? It’s one of those 9000 features in MS Word you never heard of and never would have considered finding in a text editor. To be fair, after playing with this feature, it is very cool and is how I will send the email next time.

Check it out, it’s in help. I know, I know, but that’s what I had to do.

Option 4 – Brute Force

Copy and paste 400 comma delimited email addresses into the TO: field of Google mail and hit “send”. When the warning pops up telling you this is taking a long time, just say “I know” and tell it to keep spinning.

I can tell you from experience that this works just fine

Conclusion

I feel like a doof for passing up an opportunity to write code. On the other hand, I had time to blog about this because I didn’t bother writing code.

Go figure.

Most of the examples out there use code in the ASPX view page to build the view, but I am a strongly typed kinda guy and I just can’t live without my user controls for rendering UI. This lead me to find an obtuse little bug in the designer.

I realize this is a trite detail and will likely be fixed in a future release, but I just wanted to drop this out there because it was quite frustrating for me for awhile.

When you create a new ViewPage via the Add > New Item > MVC View Content Page it created the typical ASPX and the code behind *.aspx.cs file. Then when you drop or declare a control on your ASPX page, the control is not declared in the code behind, making it impossible to bind to. We expect the control to be declared in the partial class *.aspx.designer.cs as is typical for a WebForm, but no such file is generated.

That’s ok, you can add your own partial class and Visual Studio sees it as a designer file. Do this before you add controls to your ViewPage and those controls will get auto-declared for you.

In the image below, I have added a partial class for my List page, but not for my Detail page.

The following code is the code I put into the file.

   1: namespace MvcApplication.Views.Product {    

   2:     

   3:     public partial class List {

   4:         

   5:     }

   6: }

After dropping a literal onto my ViewPage and re-opening my designer class code file, this is what I find.

   1: namespace MvcApplication.Views.Product {

   2:     

   3:     

   4:     public partial class List {

   5:         

   6:         /// <summary>

   7:         /// _categoryName control.

   8:         /// </summary>

   9:         /// <remarks>

  10:         /// Auto-generated field.

  11:         /// To modify move field declaration from designer file to code-behind file.

  12:         /// </remarks>

  13:         protected global::System.Web.UI.WebControls.Literal _categoryName;

  14:     }

  15: }

Smooth as butter.

“Standards? Why Bother?” asked Bill.

XForms is a way of expressing data and business logic into an XML instance that you can embed into an XHTML file and run in your favorite browser (sort of). XForms essentially provides a complete MVC programming model complete with events and view binding available within an XML file. Wikipedia describes XForms thusly:

XForms is an XML format for the specification of a data processing model for XML data and user interface(s) for the XML data, such as web forms. XForms was designed to be the next generation of HTML / XHTML forms, but is generic enough that it can also be used in a standalone manner or with presentation languages other than XHTML to describe a user interface and a set of common data manipulation tasks.

Of course, an XML instance cannot do anything by itself, it merely represents potential for action. In order to execute the business logic and view represented in an XForm you need an XForm execution engine. Significant XForms engines fall into 2 camps, each with their own set of vendors and advocates. The different strategies are browser execution and server execution.

Browser Execution Engines

FireFox leads off with native support baked into the browser. This makes a convenient platform for a closed ecosystem like an enterprise document workflow application.

Additionally, plugins are available for IE and other browsers. The leading plugin for IE comes from formsPlayer, although Pico Forms is hot on their trail with a plugin in its 3rd beta.  Pico Forms also has a custom XHTML browser and promotes XForms in the mobile space.

Lastly, two XForms Engine implementations exist (that I know of) in the form of JavaScript libraries.

The first is from the open source project FormFaces and has not seen active development since January of 2007. FormFaces implemetns much of the XForms specifications and as long as your application doesn’t need sliders to do range selections, this is viable option. The second is a forthcoming product from the plugin provider, formsPlayer. In exchanges with the CEO of formsPlayer I learned their implementation is close to done. I actually am hoping to see a demo next week.

These JS libraries provide the most realistic option for getting your XForm application to function on the web as no thick app requirements exist on the client.

In order to get the XForms to do something interesting, it is likely you will need to include some other dynamic content technology into your application. I have had some success in including the Yahoo UI AJAX library and triggering the AJAX controls using the data model event handlers. A model of this implementation is illustrated below.

Click the image for a larger version.

Server Side Engines

The idea here is that XForms are parsed and rendered into HTML on the server and subsequent changes to the embedded data model are managed by round tripping to the server. Sure this works, but it kind of takes all the fun out of it.

IBM is a major player here as well as a company called Orbeon and even Adobe has skin in the game.

Now What?

On November 29th, the W3C working group for XForms promoted XForms 1.1 specification to Release Candidate stage. This is really good news for vendors and developers embracing XForms technology because it represents a commitment to the technology by several leading adopters.

Although this technology is in its infancy, I strongly encourage you to take a look at it the next time you are asked to implement a dynamic forms application within your enterprise. After all, how many times must we reinvent this wheel?

For More Information

Some links I have found very useful in learning more about XForms are below:

• The W3C XForms Working Group
• XForms Tutorial
• XForms Institute

Technorati Tags: XForms,XML