TechDays 2009 Sessions Announced, and Other News

via Canadian Developer Connection by Joey deVilla on 7/30/09

Developer Sessions at TechDays

The sessions for TechDays 2009, Microsoft's cross-Canada conference taking place in seven cities this fall, have been posted on the TechDays site. You can go there to see the full set of sessions, or you can check the table below to look at the sessions for the tracks related to software development.

I'm the lead for the Developing for the Microsoft-Based Platform track and John Bristowe is lead for the Developer Fundamentals and Best Practices track. John and I picked the best developer-focused sessions from this year's TechEd conference and put them into our tracks. We've also chosen speakers for each session in each of TechDays' seven cities, going for local developers wherever possible. TechDays features international conference material and local speakers, right near where you live. We're not just expanding your knowledge, we're stretching your dollar, too!

And now, the developer sessions…

Track: Developing for the Microsoft-Based Platform	Track: Developer Fundamentals and Best Practices
Learning key skills to develop rich client and web-based applications on the Microsoft-based platform is what this track is all about. In this track you will learn how to develop rich, interactive and interoperable applications for both the client and the web using our newest tools and frameworks. You'll learn how to build software that helps to give your users the best experience possible, whether it's a program running on Windows 7, a website built on ASP.NET MVC or a Silverlight-based rich internet application. You'll also learn how to build services that can deliver data to almost any platform and internet-enabled device. And finally, you'll learn how to build these software and services in ways that are modular and maintainable.	This track is all about taking your skills up a notch while at the same time ensuring effective and efficient interaction with all members of the development team from IT architect, to developer, to tester. You will learn about the importance of Application Lifecycle Management (ALM) and how to leverage the Visual Studio development platform to streamline your efforts. You will learn some best practices from industry professionals while building upon your technical foundation.
Day One: Front End - User Interface and Experience	Day One: Core Fundamentals and Best Practices
Day 1, Session 1: What's New in Silverlight 3 Rich internet applications just got richer! Silverlight 3 is packed with new features and improvements that your users will notice, from pixel shaders to perspective 3D to animation enhancements to bitmap APIs to HD video. We think you'll also be impressed by the features for developers, such as the updated style model, data binding improvements, better resource handling, and a tuned-up Web services stack. In this session, we'll explore new features of Silverlight 3 as we build a Silverlight-based application using Expression Blend 3 and Visual Studio.	Day 1, Session 1: Tips and Tricks for Visual Studio This session enhances your experience with Visual Studio. Keyboard shortcuts, macros, layouts, fonts, tools, and external utilities are all very powerful and underused features of Visual Studio. This session makes you more productive in Visual Studio. Bring your pen and pad because you'll definitely want to take notes!
Day 1, Session 2: Expression Blend for Developers Not a designer? Overwhelmed by Expression Blend? Not a problem! We'll show you how to use Expression Blend to create advanced and polished user interfaces for business applications, consumer applications, multimedia projects, games or anything in between. We'll cover features of Expression Blend from a developer's perspective and show how it works in tandem with Visual Studio throughout the development process. You'll learn how to create professional-looking user interfaces and visual elements – even if you don't think of yourself as an interface designer.	Day 1, Session 2: Test Driven Development Techniques In recent empirical study from Microsoft Research, four case studies were conducted and the results indicated that by using Test-Driven Development (TDD) the pre-release bugs decreased by 40-90% relative to similar projects that did not use TDD. Subjectively, the teams experienced a 15-35% increase in initial development time after adopting TDD. In this session learn some of the key techniques for effectively using TDD to drive the creation of better software, reduce the defect density in projects, and help improve overall productivity
Day 1, Session 3: Building Modular Applications Using Silverlight and WPF How do you build extensible and maintainable line-of-business applications in Silverlight and Windows Presentation Foundation (WPF)? How do you design and code to handle real-world complexity? Composite Application Guidance (a.k.a. "PRISM") offers guidance, libraries and examples – in small, free-standing, digestible chunks – that you can use to build applications with rich user interfaces that are also easier to maintain and extend. You'll learn how to compose complex UIs from simpler views, integrate loosely coupled components with "EventAggregator" and "Commands", develop independent modules that can be loaded dynamically, and share code between Silverlight and WPF clients.	Day 1, Session 3: Patterns for the Rest of Us Patterns. Patterns. Patterns. You hear them everywhere. We're told to use them and call them by names, as if the pattern is a colleague of ours. Hey, did you see Observable Pattern in the demo this morning? If you feel left out in conversations where Pattern buzzwords are thrown around, this session is for you. This session introduces Patterns with imagery, code, terms, and fun and games to help you better understand and remember pattern usage.
Day 1, Session 4: Optimizing Your Apps for the Windows 7 User Experience This session will show you the Windows 7 APIs that will let your applications – and your users – get the full Windows 7 experience. Learn about new extensibility methods to surface your application's key tasks. Discover how enhancements to the taskbar, Start Menu, thumbnails, desktop elements, the Scenic Ribbon, Federated Search and Internet Explorer 8 provide new ways for you to delight your users and help make them more productive. If you want to give your users the best Windows 7 experience, this session is for you!	Day 1, Session 4: A Strategic Comparison of Data Access Technologies from Microsoft Thanks to recent innovations from Microsoft including LINQ, the Entity Framework and ADO.NET Data Services, choosing a technology for data access architecture has become a subject for debate. Among other things, developers must balance productivity, elegance, and performance. Some common questions include: Are data readers and data sets still useful? How should I choose between LINQ and Entity Framework models? Should I design custom entities or use types that follow the database schema? Should I use ADO.NET Data Services to expose my data model or control access via Windows Communication Foundation (WCF) business services? This session looks at data access architecture for each of these technologies, illustrates common practices when employing each, discusses pros and cons, and helps you better understand how to choose the right technology for your scenario.
Day Two - Back End: Programming Frameworks and Principles	Day Two - Team System Fundamentals and Best Practices
Day 2, Session 1: Introducing ASP.NET MVC You've probably heard the buzz about Model-View-Controller (MVC) web frameworks. They're all the rage because they combine speed, simplicity, control...and fun. ASP.NET MVC is Microsoft's MVC web framework, and in this session, we'll talk about the MVC pattern, explain the ideas behind ASP.NET MVC and walk through the process of building an application using this new web framework. We'll also cover several techniques to get the most out of ASP.NET MVC and deliver web applications quickly and with style.	Day 2, Session 1: Practical Web Testing This session is about looking at the past, present, and future of Web testing. We begin by looking at how Web testing was accomplished before the arrival of Microsoft Visual Studio Team System. Next, you will learn about the Web and load testing tools available in Visual Studio Team System 2005/2008.
Day 2, Session 2: SOLIDify Your Microsoft ASP.NET MVC Applications Object-oriented programming makes it easier to manage complexity, but only if you do it right. The five SOLID principles of class design (one for each letter) help ensure that you're writing applications that are flexible, comprehensible and maintainable, and we'll explain and explore them in this session. We'll start with a brittle ASP.NET MVC application that's badly in need of refactoring and fix it by applying the SOLID principles. This session is a good follow-up for Introducing ASP.NET MVC, but it's also good for developers of ASP.NET MVC looking to improve their code – or even if you're not planning to use ASP.NET MVC. The SOLID principles apply to programming in any object-oriented language or framework.	Day 2, Session 2: Better Software Change and Configuration Management Using TFS A critical factor in getting the most out of Team Foundation Server is understanding the version control and build systems. In this session, learn how use Team Build and Team Foundation Server Version Control to effectively manage concurrent development branches. Learn about how set up your repository structure and how to define builds. Learn about different branching techniques like branch by feature and branch for release. Learn how builds help you find what has changed in branches and how to manage releases, service packs, and hot fixes. Attend this session to see how the API can help create better release documentation and get you out the door sooner.
Day 2, Session 3: Building RESTful Services with WCF REST (REpresentational State Transfer) is an architectural style for building services, and it's the architectural style of the web. It's been popular outside the world of Microsoft development for a long time, but it's quickly becoming the de facto standard inside as well. Windows Communication Foundation (WCF) makes it simple to build RESTful web services, which are easy to use, simple and flexible. In this session, we'll cover the basics of REST and the show you how to build REST-based, interoperable web services that can be accessed not just by Microsoft-based web and desktop applications, but anything that can communicate via HTTP from an Ajax client to a feed readers to mobile device to applications written using other languages and frameworks such as PHP, Python/Django or Ruby/Rails.	Day 2, Session 3: Metrics That Matter: Using Team System for Process Improvement Process improvement without adequate metrics is shooting in the dark -- you might hit your target, but it's impossible to aim and difficult to determine how close you were to hitting your goal. In this session we look at how Microsoft Visual Studio Team System collects data, and how we can modify our process to collect the right data. Then we talk about several candidate metrics (top ten key metrics) that many real-world organizations have used to achieve real improvements and help get an excellent return on investment in Team Foundation Server implementation. We frame the discussion and demos around using a process improvement effort (either formal or informal) to help your Team System implementation get you the ROI you deserve!
Day 2, Session 4: Developing and Consuming Services for SharePoint The world gets more service-oriented every day, and with that comes the demand to integrate all kinds of services, including those from SharePoint. This session introduces SharePoint as a developer platform and provides an overview of how you can build and deploy custom services with it. The focus will be on developing ASP.NET and Windows Communication Foundation services for SharePoint as well as building a Silverlight client to consume them.	Day 2, Session 4: Database Change Management with Team System If you develop database enabled applications on top of SQL Server, you owe it to yourself to considering doing it better with Visual Studio Team System. In this session, you'll learn about changes to how the product works under the covers and what that means to you. Then, you'll learn how to use the product to design, build, and deploy your databases to development, test, and production environments -- all with purpose and method instead of the more traditional madness that can be found in many shops in the wild

Free TechNet Plus Subscription for TechDays Attendees

Your admission to TechDays gets you more than just two days' worth of conference and networking. We're also putting together a package of goodies that you can use long after we've turned out the lights at the last TechDays venue.

One such goodie is a full year's subscription to TechNet Plus, the Microsoft IT pro resource that gives you, among other things, full, non-time-limited versions of operating systems, servers and Office System software for evaluation (non-production) use. It also gives you access to pre-release versions, a full technical infromation library, two free tech support calls, and more, It's a US$349 value that you get for free if you attend TechDays.

More Than Just a Conference

In addition to coming to a city near you to hold TechDays, we're planning activities for each city in our tour – things like user group events, academic events, Coffee and Code and more! Watch this blog for announcements for your city.

We also have some surprises in store, and we'll announce them…soon.

Register at the Early Bird Price

You could pay the full price of CDN$599 if you really wanted to. We think that you'd rather save a whole $300 and pay just CDN$299. The early bird price for any of the TechDays cities is available only until 6 weeks before that city's conference, and the Vancouver and Toronto conferences are happening in September. Procrastinate at your peril – register now!

Info Alt.NET Montréal – 29 Juillet 2009

http://ymlp.com/z7lvKj

Type-safe INotifyPropertyChanged and derived classes

Some of you who read my previous blog post notice that this technique doesn't allow to raise “PropertyChanged” event from a derived class. This is because you can only call method of “PropertyChangedEventHandler” from the class where it is defined. Anywhere else you can only assign (+=) and unassign (-=) event handler.

One way to work around this is to add a method in your base model class that will forward the call to “PropertyChangedEventHandler”.

Here is a modified copy of the class from my previous post:

public class Model : INotifyPropertyChanged
{
    private string _data;

    public string Data
    {
        get { return _data; }
        set
        {
            if (_data == value)
                return;

            _data = value;

            // Type safe raise from base method
            RaisePropertyChanged(() => Data);
        }
    }

    protected void RaisePropertyChanged(Expression<Func<object>> expression)
    {
        PropertyChanged.Raise(expression);   
    }

    #region Implementation of INotifyPropertyChanged

    public event PropertyChangedEventHandler PropertyChanged = null;

    #endregion
}

Now you can define a derived class and use the same method to raise a PropertyChanged event.

public class DerivedModel : Model
{
    private string _moreData;

    public string MoreData
    {
        get { return _moreData; }
        set
        {
            if (_moreData == value)
                return;

            _moreData = value;
            RaisePropertyChanged(() => MoreData);
        }
    }
}

Now with very little effort you can build a type-safe and bindable data model.

It is also useful to be able to raise many property at once. For example if have calculated properties that depends on others like in this sample class:

public class User : INotifyPropertyChanged
{
    private string _lastName;

    public string LastName
    {
        get { return _lastName; }
        set
        {
            if (_lastName == value)
                return;

            _lastName = value;
            RaisePropertyChanged(()=>LastName, ()=>FullName);
        }
    }

    private string _firstName;

    public string FirstName
    {
        get { return _firstName; }
        set
        {
            if (_firstName == value)
                return;

            _firstName = value;
            RaisePropertyChanged(() => FirstName, () => FullName);
        }
    }

    public string FullName
    {
        get { return String.Format("{0} {1}", _firstName, _lastName); }
    }

    public void RaisePropertyChanged(params Expression<Func<object>>[] expression)
    {
        PropertyChanged.Raise(expression);
    }

    #region Implementation of INotifyPropertyChanged

    public event PropertyChangedEventHandler PropertyChanged = null;

    #endregion
}

Because a change to either “FirstName” or “LastName” should trigger a change to “FullName” you have to raise both changes from both properties. Of course you can call “RaisePropertyChanged” many times but with a simple overload you can do this. All you have to do is add this to your extensions class.

public static void Raise(this PropertyChangedEventHandler handler, params Expression<Func<object>>[] proppertyExpressions)
{
    foreach (var expression in proppertyExpressions)
        Raise(handler, expression);
}

Aside from beeing type safe, this method will give you intellisense support while you type your “RaiePropertyChanged” calls. You still have to type the right property though.

How to use INotifyPropertyChanged, the type-safe way (no magic string)

Implementation of the INotifyPropertyChanged interface is quite simple. There is only one event to implement. Take for example the following simple model class:

public class Model : INotifyPropertyChanged
{
    private string _data;

    public string Data
    {
        get { return _data; }
        set
        {
            if (_data == value)
                return;

            _data = value;

            // Type un-safe PropertyChanged raise 
            PropertyChanged(this, new PropertyChangedEventArgs("Data"));
        }
    }

    #region Implementation of INotifyPropertyChanged

    public event PropertyChangedEventHandler PropertyChanged = null;

    #endregion
}

This is a pretty standard way to implement a bindable property. The problem here is the “Data” string to specify which property changed. If someone change the name of the property without changing the content of the string, the code will compile fine but won’t work. In a big application with may properties it can be hard to detect and find the problem.

The best solution is to rely on the compiler to warn us. But because the property name is a string it can’t. So let’s change that line with a type-safe one.

public class Model : INotifyPropertyChanged
{
    private string _data;

    public string Data
    {
        get { return _data; }
        set
        {
            if (_data == value)
                return;

            _data = value;

            // Type safe PropertyChanged raise
            PropertyChanged.Raise(() => Data);
        }
    }

    #region Implementation of INotifyPropertyChanged

    public event PropertyChangedEventHandler PropertyChanged = null;

    #endregion
}

What is the trick? Raise is an extension method that takes a lambda expression to specify the name of the property in a type safe way. The Raise method resolve this expression to extract the name of the property and pass it to the PropertyChanged event.

public static class PropertyChangedExtensions
{
    public static void Raise(this PropertyChangedEventHandler handler, Expression<Func<object>> propertyExpression)
    {
        if (handler != null)
        {
            // Retreive lambda body
            var body = propertyExpression.Body as MemberExpression;
            if (body == null)
                throw new ArgumentException("'propertyExpression' should be a member expression");

            // Extract the right part (after "=>")
            var vmExpression = body.Expression as ConstantExpression;
            if (vmExpression == null)
                throw new ArgumentException("'propertyExpression' body should be a constant expression");

            // Create a reference to the calling object to pass it as the sender
            LambdaExpression vmlambda = Expression.Lambda(vmExpression);
            Delegate vmFunc = vmlambda.Compile();
            object vm = vmFunc.DynamicInvoke();

            // Extract the name of the property to raise a change on
            string propertyName = body.Member.Name;
            var e = new PropertyChangedEventArgs(propertyName);
            handler(vm, e);
        }
    }
}

All you have to do is to put this extension method in your code and the jib is done. Of course at the end a string will be used to raise the PropertyChanged event but because you don’t have to type it, you don’t have to maintain it.

How to use INotifyPropertyChanged, the type-safe way (no magic string)

Implementation of the INotifyPropertyChanged interface is quite simple. There is only one event to implement. Take for example the following simple model class:

public class Model : INotifyPropertyChanged
{
    private string _data;

    public string Data
    {
        get { return _data; }
        set
        {
            if (_data == value)
                return;

            _data = value;

            // Type un-safe PropertyChanged raise 
            PropertyChanged(this, new PropertyChangedEventArgs("Data"));
        }
    }

    #region Implementation of INotifyPropertyChanged

    public event PropertyChangedEventHandler PropertyChanged = null;

    #endregion
}

This is a pretty standard way to implement a bindable property. The problem here is the “Data” string to specify which property changed. If someone change the name of the property without changing the content of the string, the code will compile fine but won’t work. In a big application with may properties it can be hard to detect and find the problem.

The best solution is to rely on the compiler to warn us. But because the property name is a string it can’t. So let’s change that line with a type-safe one.

public class Model : INotifyPropertyChanged
{
    private string _data;

    public string Data
    {
        get { return _data; }
        set
        {
            if (_data == value)
                return;

            _data = value;

            // Type safe PropertyChanged raise
            PropertyChanged.Raise(() => Data);
        }
    }

    #region Implementation of INotifyPropertyChanged

    public event PropertyChangedEventHandler PropertyChanged = null;

    #endregion
}

What is the trick? Raise is an extension method that takes a lambda expression to specify the name of the property in a type safe way. The Raise method resolve this expression to extract the name of the property and pass it to the PropertyChanged event.

public static class PropertyChangedExtensions
{
    public static void Raise(this PropertyChangedEventHandler handler, Expression<Func<object>> propertyExpression)
    {
        if (handler != null)
        {
            // Retreive lambda body
            var body = propertyExpression.Body as MemberExpression;
            if (body == null)
                throw new ArgumentException("'propertyExpression' should be a member expression");

            // Extract the right part (after "=>")
            var vmExpression = body.Expression as ConstantExpression;
            if (vmExpression == null)
                throw new ArgumentException("'propertyExpression' body should be a constant expression");

            // Create a reference to the calling object to pass it as the sender
            LambdaExpression vmlambda = Expression.Lambda(vmExpression);
            Delegate vmFunc = vmlambda.Compile();
            object vm = vmFunc.DynamicInvoke();

            // Extract the name of the property to raise a change on
            string propertyName = body.Member.Name;
            var e = new PropertyChangedEventArgs(propertyName);
            handler(vm, e);
        }
    }
}

All you have to do is to put this extension method in your code and the jib is done. Of course at the end a string will be used to raise the PropertyChanged event but because you don’t have to type it, you don’t have to maintain it.

Silverlight MVP Creates PRISM Videos and Interviews!

Silverlight MVP Creates PRISM Videos and Interviews!

via The Microsoft MVP Award Program Blog by Jas Dhaliwal on 7/20/09

PRISM is a collection of tools for building maintainable and scalable Silverlight applications. It was created by the Microsoft's Patterns and Practices team, and is a collection of libraries, code, documentation and samples.

Silverlight MVP Erik Mork has created a great suite of resources that can help the community to get started with the technology. Check out the list of video, blog posts and podcasts below for further information!

5 minute introduction to PRISM - 10 Things to Know About Silverlight PRISM. This post covers the essential things that web developer should know about PRISM.

Hyper-Videos - These are screencasts in a rich Silverlight Player. They include code that can be copied and pasted while watching the video. In addition, there is video navigation and deep linking support.

Intro to Silverlight PRISM - Silverlight PRISM Video Testing/Module Catalog/Unity - Modularity in PRISM Video

Regions (including Region Scope, Region Adapter and Region Context) - PRISM Regions Video Commanding (including creating new commands) - Commanding in PRISM Video Eventing - Eventing in PRISM Video

Podcast Interviews - These interviews were recorded with the Patterns and Practices team.

· What is PRISM - What is PRISM Interview

· How Modularity Works in PRISM - PRISM Modularity Interview

· When to use PRISM - When to use PRISM Interview

· How Regions Work in Prism - Regions in PRISM Interview

· View or Presenter First? - View or ViewModel First Interview

· How Commanding Works in PRISM- Commanding in PRISM Interview

· Loosely Coupled Communications in PRISM - Event Aggregator in PRISM Interview

Blog Posts - Helper resources for PRISM

PRISM Overview Post - 10 Things to Know about Silverlight PRISM (overview of all resources) Downloading and Building Prism - Finding and Building PRISM Post

Learning new technologies, who should pay the price?

Sometimes I’m wondering, what am I doing in computer science? I’m good at it, or I think I am, but there always something new to learn.

Ever since the beginning of my career and may be before that I have to learn new things, new concepts, new technologies, new practice to do my job. I’m not complaining, I love to learn. It keeps me motivated, but who should pay the price.

I rarely did the same kind of project twice. Anyway it would be boring. I’m the kind of guy that like to build new things, to boldly go where no one has gone before (Start Trek). But this time I think I took the biggest leap of my career.

In my current project I use many new and emerging technologies, and beside the fact I’m coding in C# it’s all new to me.

Microsoft CRM 4.0

First our whole project is built on top of Microsoft CRM 4.0, it acts as our repository. We chose CRM because it has most of the data structure we need for our project. Hopefully I’m working with Alexandre Leduc who knows all the bells and whistles of MS CRM.

LINQ to CRM

One of the technology we use to connect our application to CRM is Linq to CRM. This is a fairly new project on codeplex, in fact it’s not final yet. There still many Linq command missing from this framework. But because it uses CRM as an IQueryable<T>, it gives us the performance we need.

ADX Studio CRM Metal

Because entities generated by linq to CRM are somewhat hard to manage (all the names are lower case and some of them have custom prefix), we use CRM Metal to generate our plain domain model. CRM Metal annotate all the classes and properties with attributes that helps to find the underlying linq to CRM types. We use those information as mapping when we load a new object in memory.

RegEx

Because we want to be able to bind our UI to our domain model and it doesn’t implement INotifyPropertyChanged we use a find and replace regular expression to change all auto properties to properties with a backing field and a RaisePropertyChanged. At first we used PostShap to do that but it was way too slow to compile and because our data model is so big it was generating OutOfMemoryException every once in a while.

Windows Presentation Framework (WPF)

Just because its the new trend and a little because we want to be able to style our application, we chose to use WPF for our front end application. This is my first real experience with WPF, so I have everything to learn. I have to rethink the way I build an application layout. Expression Blend is an awesome tool when you finally understand how it works.

Composite Application Block for WPF and Silverlight 2.0 (formerly known as Prism)

I merely had the chance to work with the CAB framework with winform in a previous project, so Prism was almost all new stuff for me. Besides all the CAB concepts of shell, modules, views, services, commands, messages, Prism introduce Unit Application Block. Unity is an Inversion Of Control (IOC) container and a Dependency Injection (DI) framework. The basic concept is, the framework will handle the discovery and/or the creation of instance and will give you that instance on demand when you request it by its interface. This saves a lot of code and removes hard dependencies. When you start a new module (class) you only have to declare interfaces arguments to your constructor and Unity will handle you the appropriate instance. It a little overwhelming at first because you look like you loose control of your code. After a while you get used to it.

Who should pay the price?

As you can imagine, learning all that takes time, and the project still has a budget and a timeframe. It’s hard to throw all those costs to the customer. So, I take most of that on my shoulder hoping that someday I will reuse all this knowledge.

Plenty of Color Resource for Expression

Plenty of Color Resource for Expression

via Canadian UX Blog by qixing on 7/17/09

Thinking about a color palette for your new website or application project? I've been using the site Colourlovers.com to get color inspirations. It's a virtual color library where you can find thousands of color palettes, articles on color design, and follow color trends from magazine and websites.

What's more useful about the site is that you can import the color palettes into Expression Design as swatches or add them into Expression Blend as application resources. Let me show you an example:

Summer is in the air and a mixed berry lemonade sounds good. :) I found the follow color palette on the site.

Once you registered as a site user, you can download the palette and import into Expression Design as a Swatch Library (below left).

Or, you can download the XAML file and copy the content into your Silverlight application's App.xaml file (see below). Make sure to insert the the code into the Application.Resource section of your App.xaml. You can see the result in Blend as the one on the right above. Simply just drag and apply brush onto the objects on canvas.

Color is an important element of graphics design. Here's a nice article talks about the Color Basics: Do's and Don'ts. Check out the article and have fun with color in Expression.

Microsoft Office 2010 Web Apps to be Free; Testing Starts Today [Microsoft]

Microsoft Office 2010 Web Apps to be Free; Testing Starts Today [Microsoft]

via Gizmodo by John Herrman on 7/13/09

After Microsoft's initial announcement, the forthcoming Google-docs-like Office web apps—"Office Web"—kinda fell off the radar. Today, we get confirmation that the online suite will be free, and that Office 2010 will start semi-private testing today.

With free or cheap alternatives from Google, Zoho, Apple and Adobe, Microsoft didn't really have much a choice when it came to pricing the online suite: it'd either be free, or a failure. Thankfully, the apps, which include Word, PowerPoint, Excel and OneNote, will be available to anyone with a Live account, and judging by the (lone) screenshot above, will aim to compete directly, feature-wise, with other companies' offerings—although hopefully with better handling of complex formatting.

This announcement is paired with news that the actual suite, shown in the gallery above, has hit the "Technical Preview" stage, and that it'll be available for testing to tens of thousands of users, albeit by invitation. (Although for the rest of us, it's already been leaked) There aren't a ton of surprises in the announcements, but PowerPoint video editing, new grou-editing tools, and a bevy of small tweaks and feature-adds can be expected. [Microsoft]

Office 2010 Hits Major Milestone and Enters Technical Preview Microsoft showcases new product capabilities and announces Office Web applications will be available to nearly half a billion people at launch.

NEW ORLEANS, La. - July 13, 2009 - Today, at its Worldwide Partner Conference, Microsoft Corp. announced Office 2010, SharePoint Server 2010, Visio 2010 and Project 2010 have reached the technical preview engineering milestone. Starting today, tens of thousands of people will be invited to test Office and Visio as part of the Technical Preview program. "Office 2010 is the premiere productivity solution across PCs, mobile phones and browsers," said Chris Capossela, senior vice president, Microsoft Business Division. "From broadcast and video editing in PowerPoint, new data visualization capabilities in Excel and co-authoring in Word, we are delivering technology to help people work smarter and faster from any location using any device." Office 2010 and related products will deliver innovative capabilities and provide new levels of flexibility and choice that will help people:

• Work anywhere with Office Web applications—the lightweight, Web browser versions of Word, PowerPoint, Excel and OneNote-that provide access to documents from anywhere and preserve the look and feel of a document regardless of device.

• Better Collaborate with co-authoring in Word, PowerPoint and OneNote, and advanced email management and calendaring capabilities in Outlook, including the option to "ignore" unwanted threads.

• Bring ideas to life with video and picture editing, broadcast capability in PowerPoint, easy document preparation through the new Microsoft Office Backstage view, and new Sparklines in Excel to visualize data and spot trends more quickly;

Microsoft also announced that it is streamlining the number of Office editions from eight to five and enhancing each edition with additional applications and features. The company also announced that Office Web applications will be available in three ways: through Windows Live, where more than 400 million consumers will have access to Office Web applications at no cost; on-premises for the more than 90 million Office annuity customers; and via Microsoft Online Services, where customers will be able to purchase a subscription as part of a hosted offering. Partner Opportunities: Microsoft also is preparing partners for the release of Office 2010 and SharePoint Server 2010 through a number of new and refreshed readiness tools and training programs. These include: the Ignite program for SharePoint, Office and Exchange; Business Productivity Infrastructure Optimization (BPIO) University; Masters and Architect Certification for SharePoint; new Partner Business Productivity Online Services features and distributor model; and, Exchange 2010 Readiness Webcast Series and Demo Showcase. More information on these programs can be found at: http://partner.microsoft.com/businessproductivity

Availability: All Microsoft Worldwide Partner Conference attendees will receive invitations to participate in the Technical Preview program. Microsoft Office 2010 and related products will be available in the first half of 2010. More information about Office 2010 can be found at www.microsoft.com/Office2010 .

I’m am an MVP

Finally I’m now a member of the MVP family.

I will have access to things I can talk about but I will be able to advice anybody with better suggestions because of that knowledge.

Feel free to talk to me as I am to talk to you.