Mariano Szklanny

Want to see how we work at Prism? Don't miss this great post from Glenn. He describes the team, how we work, what being at the team room feels, and he also shows pictures of the (distributed) team and includes videos that show how we do iteration planning.

The Prism team.
1st picture: Redmond, WA, USA. 2nd picture: Buenos Aires, Argentina. 3rd picture: India

This is a question I made myself many times:

What book would you recommend to a guy that is new to your company?

or even this one:

What book would you recommend to a guy that is new to your company, who has never programmed Object-Oriented and who has never worked with .NET or Java?

Typical answers would be something like Thinking in Java or Introducing Microsoft .NET. And yes, these books would probably be included in my answer. But at Southworks our culture does not stop at technology. Technology is a key part in the company's culture, but technology on its own is not enough. At Southworks, our core is the people.

Damian is a young guy that has just joined the company. In fact, he is the youngest member of the company; when he entered he was only 17 years old. As part of his initial training, we asked him to read the book The 7 Habits of Highly Effective People (together with other technical books).

Why this book? Because at Southworks we pursue most of the things this book promotes. This book is not about technology at all - it is about personal and professional development, and it is in line with Southworks' culture.

Damian has just finished reading the book and did a great post about it. In the last paragraph, he says:

In an utopic society values would be the center stone, and most habits in this book would be followed by all, but it is not the case.

I couldn't agree more. However, Damian, do not be frustrated - at least at Southworks you will find people that place values and these habits in the core of their life. And that, I believe, makes Southworks a special company and a great place to work at.

As Blaine already announced, we have published the Web Client Software Factory documentation on MSDN. After so much work spent on the docs, it is great to see them standing there. I hope it will help users find what they need quickly, and to evaluate the factory's content before downloading it.

Much has been mentioned about the new features the WC-SF February 2008 release includes. However, there is no much detail about what has changed as far as documentation is concerned. Since I was part of the docs team for the factory and the bundles, I thought that sharing some thoughts with the community could be a good idea.

So What is New?

Most of the efforts in the February 2008 release -regarding documentation- were targeted to include the bundles' documentation within the factory's documentation. This was an interesting challenge because the documentation was already large, and bringing in more content implied that it would grow even more, potentially making it harder to digest. Moreover, we wanted to stick to what we have learnt from previous releases and that we verified with the bundles: for most users, small packages of guidance are easier to read and understand than a large set of documents.

The approach we followed this time was somewhat innovative (we didn't do this neither in SC-SF nor in previous releases of WC-SF). On one hand, we decided to bring in the bundles docs as individual guidance sections that could be read integrally and that would provide value by themselves, keeping the reader focused on the specific technical concept she/he wants to learn. This way, for example, if you want to learn about validation you know you will reach all the validation-related topics from within the Validation Guidance section.

You will find these individual guidance sections inside the new Technical Concepts node. The sections basically map one to one with bundles. They are:

• Modularity Guidance
• Validation Guidance
• Search Guidance
• Autocomplete Guidance
• Views Testability Guidance (MVP)

On the other hand, (and here comes the innovative part) we duplicated topics across the documentation. For example, the Model-View-Presenter topic can be found within the Views Testability Guidance section, and within the Patterns for Web Client Applications section. By doing this, we allow users searching for Web development patterns to discover this topic, and we allow users looking for views testability guidance to find it too, without having to jump from one topic to another topic miles away.

To warn you that you are reading a duplicated topic, we included a short note at the beginning of each duplicated topic.

This way if you see a topic twice, you know you are not crazy :)

You might wonder about the other bundles shipped that don't appear in the Technical Concepts section (like the Guidance Automation or the Reference Implementation bundles): those bundles that already had a specific section in the existing documentation were kept where they were.

How did We Do It?

To develop our documents, we used an internal tool that converts Word 2007 documents into HxS (Visual Studio Integrated Help) and CHM files. The Southworks team has been part of the dev team of this tool, and I'm happy to see that it has just become a public tool (see the Southworks's announcement in Spanish). You can get the bits from its Codeplex site: patterns & practices: Documentation Tools.

Feedback Wanted!

Did you find the new docs organization useful? Do you hate it? Do you want to know more about how we design our docs? Please let us know - you can influence on future releases. Feel free to contact team members directly or to post a message in the Codeplex Discussions.

In case you missed it, Mariano Converti has been blogging about the Composite UI Application Block and Smart Client Software Factory in spanish. It's good to hear that because there are very few people blogging in spanish about CAB and a lot of hispanic CAB users, so this is very valuable to the community.

Here is the list of posts that he has published so far (more to come for sure!):

• Introducción a Composite UI Application Block (CAB) I (Intro to CAB)
• Introducción a Composite UI Application Block (CAB) II (Intro to CAB applications initialization) 
• Introducción a Composite UI Application Block (CAB) III - (Intro to Modules)
• Introducción a Composite UI Application Block (CAB) IV - (Intro to MVP pattern)
• Introducción a Composite UI Application Block (CAB) V - UI Extension Sites (Intro to UI Extension sites)

Johnny reminded me with this nice post that one year ago, we were working together in Redmond for the Web Client Software Factory project; I can't believe how fast the time goes, thanks Johnny for the remainder! :)

Looking at the collage he assembled a funny unit test came to my mind. Yes, a unit test that appeared in the team room on my 21st birthday:

Isn't it a nice way to say "happy birthday" to a geek? :) (Pocho's my nickname...)

And, of course, this picture that I won't forget:

Matias Woloski, Bill Gates, Eric Rudder (in the back) and me.

Unfortunately, due to the fact that I'm still in college I couldn't travel again (actually I traveled on March for the WC-SF workshop, but it was just a one-week trip). However, other southies of my team had the chance to travel: Julian, Miguel and Juan, which makes me happy. And even though I cannot travel so often, I'm glad because I have been working since then with the amazing p&p team (from Southworks offices at Buenos Aires, Argentina), on the SC-SF v2 and WC-SF v2 projects. Thanks to p&p and Southworks for these great experiences!

More pictures from the trip:

• Strategic Architect Forum @ redmond - Picture with Bill Gates :)
• @ Redmond
• Some pictures from the Web Client Software Factory team

We released a draft version of the hands on labs for Smart Client Software Factory almost a month ago, and we got over 1000 downloads. We will release the final version soon which will include, apart from the current labs, the following ones:

• Adding offline capabilities to your solution through the Disconnected Service Agent Application Block
• Using WPF views

This is a great opportunity for you to influence on the final version of the labs. Please let us know what you think about the draft release, by either leaving your comments in our blogs, contacting us directly or posting in our community site. The following questions might help you:

• Suppose you are starting a project that uses SC-SF. Would you recommend your team members to read the labs?
• Were the procedures clear enough?
• Did you find the background information and content useful?
• What topics need further explanation?

Thanks in advance; your feedback will help us improve the labs.

After a long waiting, the hands on labs for WC-SF June 2007 are out :)

Download

The labs are based on the ones we used for the workshop held in Redmond on March 2007, but they contain a lot more content, background information, and revised procedures. Please let us know what you think about them.

Content

1. Lab 1: Creating and Initial Web Client Solution with a Business Module
2. Lab 2: Creating a Service
3. Lab 3: Adding Views and Unit Testing
4. Lab 4: Databinding with the View-Presenter pattern
5. Lab 5: Creating a Foundational Module
6. Lab 6: Authorization
7. Lab 7: Logging and Exception Handling
8. Lab 8: Using Page Flow

I'm happy to announce that we have published a draft version of the Hands On Labs for Smart Client Software Factory May 2007!

Download

The goal of these Hands on Labs is to provide developers with a step-by-step guidance to help them understand the core components of the factory and learn how to take advantage of them to develop smart client applications.

This set of labs is not just a minor update to the version published for the June 2006 version of the factory: we revised all the content, included additional background information, and demonstrated new features of the factory.

This release includes the following labs:

For the final release we plan to include these labs too (subject to change):

Please feel free to provide feedback in our community site. We are still in development process so you have the chance to influence on the final release.

After we shipped the May 2007 release of the Smart Client Software Factory, I moved to the Web Client Software Factory team to work in the next version (in case you missed it, the second weekly drop is already available). Since then, I've been working on the Hands On Labs for both factories. I cannot give too much details about them yet, but I can give you some hints:

• The WCSF Hands On Labs will be based on the ones that we presented in the workshop held in Redmond on March (which you can download from here). We've been working really hard to improve them taking into account the valuable feedback that we received from the attendees. The main complains I've heard are that the procedures were not detailed enough and that there was a lack of content in some parts (I remember an attendee saying "Please tell me what I just did!" :), thus we are spending a considerable amount of time on adding details and content to help users understand what they are doing, and why.
  
• The SCSF Hands On Labs will be built upon the existing ones. They will be updated to work with the latest release of the factory, and we are planning to cover the new features such as the ability to host WPF smartparts and the offline capabilities provided by the Disconnected Service Agent / Connection Monitor / Endpoint Catalog application blocks.

The second weekly drop of the Web Client Software Factory is out! You can get it from the releases page.

One of the changes that I'm most excited about is the ability to have (a kind of) dependency injection on master pages, user controls and web services apart from regular Web forms. From the releases page:

Now, instead of happening automatically, an object that wishes to be injected must call a single static method:

Microsoft.Practices.CompositeWeb.WebClientApplication.BuildItemWithCurrentContext(this);

This will cause the DI container to walk the given instance, and resolve any dependencies. The disadvantage is that this isn't really dependency injection anymore; the object must know that there is a DI container and invoke it. However, it has the major advantage that getting dependencies resolved now works for, and in exactly the same manner, pages, master pages, controls, and web services. Among other things, this enables building user controls and master pages using the MVP pattern.

Please let us know what you think of this change on our forum.

Go grab the zip and start playing with it :)

Yes! We finally shipped it! It took us a little more time than what we expected but I'm very excited about the new features and capabilities we are providing to the community. This release provides (from Blaine's announcement post):

• Windows Presentation Foundation interoperability CAB extensions  and View with presenter recipe (don't miss this post from Miguel Saez for more details)
• Offline application blocks and recipes; the application blocks support asynchronous calls to WCF web services.
• Richer ClickOnce Deployment capabilities
• Enhanced guidance packages which includes code generation Visual Basic .NET 2005 (don't miss this post from Juan Arguello for more details)
• Improved installation with a new dependency checker

You can get it from the Microsoft Downloads Center.

One of the things we added at the very end of the project, is a QuickStart that demonstrates how to integrate the Disconnected Service Agent (DSA) and the Connection Monitor (CM) Application Blocks with a Composite UI Application Block application. Although we had to postpone a little bit the release date to include this QuickStart, we strongly believe that it will help you better understand how to consume these blocks from your smart client application.

The Offline Application Blocks demonstrated in the QuickStart

In just a few words (see the Help for detailed information), the Disconnected Service Agent Application Block allows you to invoke web services asynchronously from occasionally connected smart clients. This means that you can, for example, enqueue a request while the application is offline and have it automatically dispatched by the block when connectivity is detected. When the request is dispatched, a callback will be invoked for your application to process the response.

The Connection Monitor Application Block basically monitors connectivity status. As a developer, you can define what set of services you need to reach from your smart client application and the block will notify you whenever changes in the client's computer affect the ability to reach those services.

Overview

The QuickStart basically shows a master-details view. The Shell form displays a list of restaurants in the left and their corresponding menu items in the right. To retrieve the data (restaurants and menu items lists), a WCF service is consumed:

If you launch the QuickStart without having an Internet connection available, the application will enqueue the request that will retrieve the restaurants list, and will display an Offline status indicator.

As soon as you go online, the restaurants list will be loaded and the connectivity status indicator will be updated:

If you click a restaurant, you will see the menu items list loaded in the right. But if the Internet connection was dropped, you will see a message saying that you must be online to retrieve the menu items list:

Now suppose you go online again, but the web service now is failing or has been shut down (you can close the WCF host to test this scenario). The application will handle the error and ask the user to try again later:

Retrieving data from a remote service is an expensive task and might take a while. Therefore the QuickStart displays a progress bar when a call to a the web service is performed:

What can I do next?

Download the factory and start playing with it! :)

If you want to know the internals of the guidance package that will be shipped in SC-SF v2, don't miss this post from Juan Arguello:

Smart Client Guidance development

During the WC-SF workshop and after spending valuable time with customers one of the questions that came up is how do I integrate the WC-SF with my existing Web client application?. Michael has just posted and excellent entry explaining how to enable the guidance package in a non-WC-SF solution.

Here I'm adding some tips that you might want to take into account if you are looking forward to use the WC-SF with existing Web applications:

• To minimize the amount of code re-writing and modification, try to wrap existing business logic in CWAB (Composite Web Application Block) services and store them in business modules. This will not only save you some time, but it will also increase the testability surface of your solution because you will be able to replace the services with mock implementations.
• Encapsulate shared components like security and data access providers in global services (you can place them in foundational modules).
• Don’t try to migrate the whole solution to use the patterns suggested by the factory at once, do baby steps. Start implementing small new areas with the WC-SF approach first, one at a time, and analyze the results. Once you and your team feel comfortable with the factory, start migrating existing items if needed.
• If your application contains areas that mainly perform simple CRUD operations, you might want to move them to one or more business modules and to avoid using the module controller for them. Module controllers follow the Application Controller pattern (see the WC-SF docs for more information), which might not be the best solution in these scenarios because usually there is little or no page flow / business logic in them. In these cases, you could wrap the existing business-specific data access logic in module services and consume them directly from your presenters.
• Customize the guidance package according to your needs. One change you will find useful for existing solutions is to update the view's template to use your own master page instead of the default one that you get when using the Web Client Solution template. You can find the template in WebClientFactoryPackage\Templates\T4\View\View.aspx.t4.

During this week's first couple of days we run the Web Client Software Factory workshop in Redmond, and I had the pleasure of sharing it with the attendees. Personally, I should say that it was a very rich experience and I hope the people that came feel the same way.

Not only we discussed and worked around the factory, but we also received valuable feedback that will help us improve our work and future releases. I just want to thank you all for your participation, and I hope to meet you again :)

Remember that you can still contact us through our blogs and vote for features or participate in the discussion forums in our community site. 

One of the things the Web Client Software Factory provides out-of-the-box is global exception handling. I must admit that this feature is a bit hidden (actually it is not documented), so Michael did a great job posting about it.

See: Undocumented WCSF Feature: Global Exception Handling.