Expression Blend 4

I’m not sure where I missed it, but Expression Blend 4 is now out. I recently went back to create a SketchFlow project to model some stories I’m working on for a proof of concept application and found that Expression Blend 3 does *not* integrate with Visual Studio 2010. I posted a #fail message on Twitter and low and behold @mfcollins3 and @unnir were nice enough to point out that Blend 4 was not only out but *did* work with Visual Studio 2010.

Thanks for the info. I’m downloading and installing Blend 4 as I write this and will hopefully be back to sketching and designing again very soon.

del.icio.us Tags: expressionblend,sketchflow,vs2010

Lessons Learned from a Failed Vendor Engagement

We just terminated a POC engagement with a software vendor (to remain unnamed to protect the innocent :)) because of their inability to deliver a workable solution for our needs. From the beginning, the relationship between the two companies was somewhat iffy. I thought I’d share with everyone some insight into what we experienced as well as see if there were some key takeaways that might prove to be useful for the future.

The Problem

Our company does a tremendous amount of custom application development in support of our primary line of business. One area that we have identified that has room for improvement is the monitoring of the runtime health of our applications. We were seeking an enterprise scale solution that would allow us to instrument and monitor our applications and to be preemptive in identifying problems in production environments before they become outages affecting our end users.

The Process

Beginning with a failed LiveMeeting where the vendor completely missed the mark on what we were looking for, we finally got a high-level demo of the “product” that they felt would serve our needs. A number of hour-long telephone conversations were held and lengthy email discussions and questionnaires were completed all in a fact-finding and discovery mission to ensure that the vendor thoroughly understood our problem, our environment including network and hardware infrastructure, application architecture, etc. The conclusion of this was an agreement by the vendor to be on-site to assist with standing up a POC test environment with their components monitoring our applications. Our goal was to spend 2 days installing and configuring the system, wrapping up with a lunchtime demo of the installed environment, and a plan to spend the remainder of a week exercising our applications in that context to understand how the solution would help us. We never got there.

The Failure

Arriving as scheduled on Monday morning, the reps from the vendor arrived and began the process of installation and configuration. After a couple of hours, it became clear that there was confusion on their part about our environment. It forced me to walk through additional whiteboard discussions of what the environment was and how things were organized (reiterating many points that were made through the countless phone calls preceding the POC). To be clear, our environment is not complicated and when compared to many larger enterprises must be considered quite simple actually. So for a vendor that is positioned to address enterprises that are significantly larger, this already presented some concerns for us. Then came the confusion about which of their products we wanted to demo. Again, the details for all of that had been previously discussed, but confusion and lack of clarity reigned when trying to nail down which of their products would really solve the problems we had.

As the second day was winding down we found that they had completely forgotten an entire tier of our architecture and didn’t understand how it played into the big picture. It left us with a 1/2 complete install and they were scheduled to fly out. The best they could offer was to demo what they had and promise to call back in and via a remote session try to configure the last pieces – at the end of the week with teams of people left twiddling their thumbs unable to test what we planned.

The demo was the most frustrating of all. It was fragmented, bouncing between screens and products to try to get the “big picture” of system health. When trying to drill into specific areas, we would get “well this is how it should have worked – you get the idea” rather than really nailing the working example. Under the gun and with time running out before their flights, they packed up and headed out.

Lessons Learned

Some key takeaways for me in the aftermath of this process are enumerated below (in no particular order)

1. If you supply a product, it is a MUST that you understand your own product. If you can’t install, configure, or use the product to its fullest don’t bother showing up.
2. You MUST listen to your customer. Remember the old adage “The customer is always right.” Take the time to thoroughly understand the needs.
3. Do your homework before committing not only your time and money into something, but more importantly the time and money of your customer.
4. Don’t be afraid to say, “I don’t know the answer to that. I’ll get back to you.” Honesty is always the best policy.
5. Be honest when you know your product has gaps or is imperfect. Knowing the limitations helps make a more informed decision.
6. Technology is not a silver bullet; it will not solve all of your problems. It can help you make better informed decisions, but still needs a personal touch to make it work. Having competent people that understand not only your product but your customers and their environments is a MUST.
7. As a consumer, especially when dealing with products that are this large and complex, get recommendations BEFORE engaging the vendor in a POC

Some of these thoughts are pretty common sense and at least the last one would have saved us the headache and cost of this endeavor had I done that. I hope that others benefit from this experience and the feedback.

Good luck!

How Do You Manage Multiple Dev Environments?

I often am required to work on multiple versions of a product, some of which may span different versions of .NET, require different versions of Visual Studio, 3rd party controls, etc. Other times, I need a different version of the O/S for development or testing. What’s the best way to manage all those differences and keep from stepping on one environment or another?

My preferred way of doing this juggle is to use Virtual PC. The beauty with using Virtual PC for this is that I can configured a completely self-contained environment that has everything I need to represent the project I’m working on. I can quickly replicate it for the next project, change what is unique and be up and running with an environment that is customized specifically for my needs without breaking the first one, which allows me to return to it when needed.

One caveat with using Virtual PC for this: you need a pretty well configured machine to run it on especially if you want to load up resource intensive tools like VSNET, Resharper, etc. I highly recommend a minimum of 8GB of RAM – more if you can get it. In some cases, I’ll have more than one virtual spun up at a time and having LOTS of RAM is essential.

Perhaps the other tip I can offer here is to take the time to organize your virtual images based on O/S and tool sets installed. It will help you to duplicate an environment quickly and customize it to your needs.

How Does VSTS Recognize Which Projects Have Test Classes?

I recently ran into an interesting gotcha with VSTS 2010. I added a Library project to my solution that I intended to populate with integration tests. When I created the project, I chose the Class Library template. I then added a class to the project that would represent my test fixture. Expecting VSTS to leverage the [TestClass] attribute that I applied to the class, I went about adding test cases and attributed them with [TestMethod].

When I went to my Test View, the methods that I’d added didn’t show up :(  The problem was that I expected VSTS to behave similarly to NUnit, which reflects over the classes looking for the [TestFixture] attribute to figure out which classes contain tests. VSTS does not do it that way; rather, you have to modify the .csproj file to include a new element

<ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>

Once I added that element to the project, the Test View happily found my new tests.

Hope this helps you if you run into a similar problem.

del.icio.us Tags: unittest vsts

Free eBook: Programming Windows Phone 7 Series (DRAFT Preview)

While we were at MIX, we were given an opportunity to peek into the upcoming book from Charles Petzold on Windows Phone development. He has released a preview of the book that you can download now.

Check it out here:

http://blogs.msdn.com/microsoft_press/archive/2010/03/15/free-ebook-programming-windows-phone-7-series-draft-preview.aspx

Enjoy!

del.icio.us Tags: windowsmobile,phone,petzold,mix2010

Key Takeaways from MIX 2010

I had an opportunity to attend MIX this year in Las Vegas. I hadn’t been before, so I really didn’t know what to expect. Marketed as a conference for the web doesn’t do it justice – or maybe it’s just because the technologies that Microsoft now brings to the table to satisfy web development is so rich and diverse – but there is a LOT of information there for folks even if they’re not doing web development.

So what were the big takeaways? The message that I came away with was that there were four big areas of focus:

Silverlight

Impressive stuff here. Silverlight 4 really has stepped up to be a 1st Class desktop citizen. It’s ability to run as an out-of-browser application with elevated privileges really bridges the gap between older versions and WPF. I am honestly asking myself if we are seeing Microsoft make WPF irrelevant? While at MIX they demoed Silverlight running on the Windows Phone 7 platform and the Xbox. All with the ability to leverage the Expression Blend designer tool, which is an extremely powerful tool in it’s own right – probably unparalleled for XAML layout.

A big announcement from Microsoft was that they were making the development tools for Windows Phone development FREEEE. You can download them from here.

Cloud Computing

While I didn’t get the opportunity to attend but one session on Windows Azure, it was enough to convince me that it will make a big impact on design decisions for companies that want a fast low cost entry into a secure, reliable, and scalable environment in which to host their apps. This is a very new area, particularly for me, but the advantages are immediately obvious when you look at them – reliable, secure, scalable, open standards-based.

One new service called AppFabric that will really make this shine allows for Azure to integrate with on-premise applications. Imagine being able to run your LOB applications in the Cloud and take advantage of it’s capabilities, but also allow them to reach back into your network for secure data or other internal resources. Very powerful.

Open Data Protocol

While the last thing we want (or need) is another data access acronym to go along with ADO and all of its predecessors, OData (short for Open Data Protocol) is Microsoft’s commitment to data integration and interoperability. Many of the MIX sessions demonstrated consuming data using OData syntax through the browser, through RESTful web services. I expect this will be a game changer when it comes to how we write data services.

During the conference, numerous demos gave the same message – OData will make it possible to mash together data from numerous disparate sources and provide a seamless and compelling user experience. Imagine pulling data from Netflix, the local movie theaters in your area, and your own personal movie database to provide a single application on your phone to search movies. Now imagine doing that using a standards-based syntax that makes it equally easy to consume any/all of those data sources. Now imagine that you want to serve up your data using OData and being able to do it completely from within your web browser! All demoed this week!

IE9

The sessions didn’t have anything to do with the vNext version of Internet Explorer; however, the Day 2 keynote gave us some peeks into what’s in store for IE9. First – it’s FAST. Second – it’s standards based. Third – Did I mention it was fast? It was amazingly fast for developer code. It features a completely redesigned rendering engine that will leverage the power of multi-core CPUs. The demonstration of some of its polygon rendering capabilities and performance were quite compelling.

Its support for HTML5 and video were amazing. The other browsers will finally have something to catch up to. Watching streaming HD video at full frame rates with 50% of the CPU utilization of competitors was impressive – especially since the others were dropping frames like hot rocks.

That said, I’m still leery of the security issues that have plagued IE in the past. Let’s hope they’ve (or will) resolved those.

Summary

Collectively, these technologies come together to provide a rich development, deployment, and support environment. I expect them to go WAY beyond the development of just web applications.

I plan on writing more about each of these as I get the opportunity to explore them and employ them in my projects.

Starting Down the Path of Android Development

Awhile back I decided to begin doing some Windows Mobile development. Overall, it’s been a good experience and the tool support from VS2008 is excellent. The ability to debug your mobile app in a virtual device emulator is extremely helpful to visualize how your app will run on the target device platform.

However, now that I’ve had the chance to begin using the Motorola Droid and seeing their marketplace application, which gives access to scores of free and pay apps, it has convinced me that I need to begin looking at developing for this platform as well. In the short time that I’ve used this new phone, it’s clear that the user experience is far superior to WM6. Not having seen the new Windows Mobile 7 platform more than a couple of screenshots, it does look like it WM7 could be a strong competitor though.

My next posts will be about ramping up and getting started with a basic application for this platform. It should be exciting and hopefully I can help share some of the stumbling blocks that I run across to save you a bit of your own frustration.

del.icio.us Tags: windowsmobile,motorola,android

Where Scrum Falls Short and Software Engineering Has to Pick Up

For any company that adopts Scrum, there will be an initial period where productivity dips a bit while everyone understands the process, but then within a very short time their productivity will spike higher. Ayende Rahien in a recent post gets into a some excellent detail into where Scrum as a “Product” development process falls short when developing software.

The reasons for this are pretty obvious when you look at Scrum side-by-side with what we know to be best practices for software engineering. It isn’t until you understand what each bring to the table that you can see their shortcomings and then blend the two together to create a process that brings the strengths of both together to bear on the problem.

Scrum’s short iterations, frequent feedback, and quick turn-around are clear winners. It shortens the feedback cycle and makes staying focused on the highest priorities for the Product Owner much easier. It also allows for changing direction when requirements change. However, as Ayende points out, there is nothing in this that is software-specific. That’s where software engineering practices like Test Driven Development, Continuous Integration, and Refactoring come into play. These work together to ensure that the “product” is built using best practices that focus on the actual product and the idiosyncrasies of its development.

It is critical that these best practices be interwoven into your software development process – especially an Agile process like Scrum. Because without them, you are missing out on the aspects that emphasize quality. Over time, as quality declines, so too will your velocity. Ayende describes this:

“You hit the Scrum wall when you adopt Scrum and everything goes well, then, after a few Sprints things don’t work any more - to use an English expression, they go pear shaped. You can’t keep your commitments, you can’t release software, your customers get annoyed and angry, it looks like Scrum is broken.”

How many times have you gotten a few sprints into your project, and then had to put on the brakes to introduce a “go back and fix stuff” sprint? For our team, it happened a lot early on before we adopted those best practices. After adopting them, we rarely had to go back to code due to quality issues; rather, we were more likely to have to revisit code due to changes in requirements or additional features being added. Clearly this is much better – we’re now focusing on business drivers and less on technical debt.

Bottom line – don’t forget to roll into your process the details for following the software engineering best practices. Let Scrum manage what it does well – requirements and deliverables. When you include the best of each of these your product will benefit greatly.

del.icio.us Tags: Agile,Scrum,TDD,ContinuousIntegration,Refactor

Exporting Table Definitions from SQL Compact Edition Database Files

While working on a mobile app that uses SQLCE, I was unpleasantly surprised to find that there was no built-in capability for the SQL Server 2008 Management Studio to export table definitions into a script file. So when I found that @ErikEJ on the CodePlex site had written this little plug-in I was quite happy.

Thanks Erik For a very useful little utility :)

del.icio.us Tags: sqlce,codeplex,programming

Writing Stored Procedures for SQL Server 2008 in C#

This is my first foray into writing stored procedures for SQL Server in managed code. I decided to check it out since I was already doing some other SQL Server work in support of a WPF-based Agile project management application and thought this would be a good opportunity to explore a little and see how it might apply.

Let me be clear, this is a post really to capture my thoughts and experience along the way. I’ll include links and quotes where it seems applicable.

Decision Points

From “Overview of CLR Integration” - http://msdn.microsoft.com/en-us/library/ms131045.aspx

Choosing Between Transact-SQL and Managed Code

When writing stored procedures, triggers, and user-defined functions, one decision you must make is whether to use traditional Transact-SQL, or a .NET Framework language such as Visual Basic .NET or Visual C#. Use Transact-SQL when the code will mostly perform data access with little or no procedural logic. Use managed code for CPU-intensive functions and procedures that feature complex logic, or when you want to make use of the BCL of the .NET Framework.

Choosing Between Execution in the Server and Execution in the Client

Another factor in your decision about whether to use Transact-SQL or managed code is where you would like your code to reside, the server computer or the client computer. Both Transact-SQL and managed code can be run on the server. This places code and data close together, and allows you to take advantage of the processing power of the server. On the other hand, you may wish to avoid placing processor intensive tasks on your database server. Most client computers today are very powerful, and you may wish to take advantage of this processing power by placing as much code as possible on the client. Managed code can run on a client computer, while Transact-SQL cannot.

* Note: I have some reservations about the suggestions made in the last section. While many business-class PCs today have more processing power, and while scenarios may exist where it would be nice to distribute the computational work to the client, it is likely unreasonable to place the burden of processing on the client PC due to the need to transfer the required data to the client. This seems like a corner case, which probably doesn’t happen often.

Advantages

While reading through the various articles, I came across this list of advantages for using managed code instead of Transact-SQL.

• Enhanced programming model
• Enhanced Safety and Security
• User-Defined Types and Aggregates
• Common Development Environment
• Better Performance (for computational sorts of logic; see the point above regarding straight data access)
• Language richness
• Reusability of code
• Extensibility
• Leverage existing skills
• Richer development experience
• Stability and reliability

Step-by-Step

1) Create the database project in your solution. Click the database category and choose the “SQL Server Project”. Give it a name and choose the directory where you want it created.

The wizard will create a .SQL script from which you can test the database objects that you create.

2) I decided to create a subfolder in which I’ll place my new stored procedures

3) After that, right-click the new folder and add a new stored procedure; give it a descriptive name. Use a naming convention that lets you know what the stored procedure does. I prefer to prefix my stored procedures with the name of the module of the app that it applies to; e.g., Products_InsertNewProduct or Products_SelectProductById

4) The stored procedure template will give you a basic outline for a stored procedure. The first thing you’ll notice is that it creates a static method on a partial class. Also, the method is marked up with the Microsoft.SqlServer.Server.SqlProcedure attribute.

5) Modify the signature of the method to include the parameters that you want

6) The implementation of this is pretty much plain vanilla ADO.NET; There are a couple of minor differences to make note of:

a. The connection string for the SqlConnection is based on the current context that the stored procedure is running under:
”context connection = true”

b. When returning data, you use the SqlPipe, which is accessible from the SqlContext

7) Next, compile and deploy the project. Both of these commands are available from the “Build” menu.

That’s about it for now. You can use the Test.Sql script that is generated in the project in order to test your procedures. Going forward, I see lots of potential for code reuse. My next post on managed code for SQL Server will focus on triggers and user defined types.

Have fun!

Related Links

Introduction to SQL Server CLR Integration (ADO.NET)

Overview of CLR Integration

Creating SQL Server Objects in Managed Code

del.icio.us Tags: sqlserver,c#,code,programming