Pierre-Emmanuel Dautreppe

Hello,

For this day, I exclusively followed the Developper and Solution Architect track, but switched between the sessions related to Client & Web, Tools & Languages and Servers and Services. It was globally a very good day, very interesting. So let's face the impossible challenge to summarize 8h of trainings in a few words.

Keynote (by Hans Verbeeck, Gil Cleeren, Peter Himschoot, Katrien de Graeve and Gregory Renard)

I really liked the keynote. Hans Werbeeck orchestrated it and the idea was to took a single application and to quickly show how we could pass it from Silverlight to WPF, to publish it in the cloud or to extend it to Surface.

• Hans started by showing the evolution of applications :
  • Monolithic applications
  • Client / Server applications
  • Multi-Tier applications (using COM components)
  • Multi-Tier applications (using Web Services)
  • Distributed applications and SOA
• Gil Cleeren started the demo by building the Silverlight application, using a wrapper around Virtual Eearth to use it directly
• Peter Himshoot continued in WPF
  • Has used a web browser control in his application to use Virtual Earth
  • Has shown quicly the ValueConverters in WPF
  • He used  the WPF toolkit and the Office's Ribbon Control
  • Note that the demo he has done is already available on his blog here 
• Note that there is a "Composite Client Application Guidance" available for building applications targeting both WPF and Silverlight
• Note also that Silverlight 3 shall be announced in the MIX
• Katrien de Graeve then showed the Touch Experience in Windows 7
• The Touch support is not available currently in WPF but shall be supported in the next version
• Gregory Renard shows after Windows Surface that can support up to 50 points of pressure
  • Note by the way that Gregory just published a whitebook about Microsoft Azure. Find it here
• He also showed a Mesh application, hosted in the cloud
• Finally Hans Verbeeck concluded while explaining the hosting of solutions in the Microsoft DataCenters using Windows Azure.

Session 1 : The future of C#: a first look at C# 4.0 (by Bart De Smet)

I really like the sessions of Bart de Smet and how he explains. This session just follow the same rule !

• He explains the trends of C# going towards declarative, dynamic and conccurent.
• The trend towards "declarative language" offer the possibility for the compiler (or the CLR) to optimize the behvaior like parallelizing the execution
• C# 4.0 will include
  • Dynamically typed objects
  • Optional and Named parameters
  • Improved COM interop
  • Generic co-variance and contra-variance
• Some information about the dynamically typed objects
  • The DLR (Dynamic Language Runtime)
    • is the equivalent of the CLR but for the dynamic part
    • already available now : used for IronPython and IronRuby
  • The "dynamic lookup price" (ie looking dynamically which member we should call and on which object) will be paid only once as there will be some "call site caching"
  • Currently the dynamic call today are done thru reflection but there is no unification. For instance in Silverlight, we'll call a method in this way:
    • ScriptObject calc = GetCalculator();
    • calc.Invoke("Add", 10, 20);
    • In "classic reflection", we would call the Invoke method only with two parameters as we would have had a reference to the "add" method before
  • The framework will epxose a new class DynamicObject, which is an abstract class that allows us to control what gonna be done when we call a method on a dynamic instance. He shows us how we could store all the values of properties in a dictionary instead of using "standard private variables"
• Some information about the optional and named parameters
  • Nothing really surprising here as it is exactly the same behavior as in VB.NET : same syntax, same limitations
  • Extra information : using this type of parameters involves the same constraints as we have with const variables. Indeed, all the missing values will be set at compile time in all the calls. Consequence ? Impossible to change the defaut value without recompiling all the clients.
  • Bart concluded these explanations saying that this syntax shall be used for consumption only
• Some information about the improved COM interop
  • First the notion of optional and named parameters will greatly simplify the call to COM interop (Excel and Word API for instance) that require many arguments
  • All calls will now return dynamic objects and so we can avoid casting the result
  • As a result, the mysterious property "value2" of Excel API can be let aside to use simply "value"
  • We can also edit the properties of the reference we are using to select "Embed Type Declaration". As a consequence, the declaration of the types we are using (and only those ones) will be included in our own DLL
• Some information about the co-variance and the contra-variance
  • When creating generic classes we will be able to specify in or out when declaring the generic type. For instance MyClass<in X> {}
  • The in keyword will define contra-variance and the out one will be used to define co-variance
• Finally Bart De Smet concluded by giving a quick insight of C# 5.0:
  • The C# compiler has been totally rewritten in C#, and is now open
  • We can see it now as "Compiler as a Service"
  • A new class has been created CSharpEvaluator that will allow compiling some dynamically generated code. This compiled code can then be very easliy use as "normal code" in our program, in a delegate for instance

Session 2 : Silverlight 2 CoreCLR : Bringing the power of .NET to the net (by Andrew Pardoe)

• Andrew Pardoe explained his work of creating the CoreCLR : a subset of the CLR that can be embedded in Silverlight
• What has been removed ? Among all we can note :
  • All code related to COM interop
  • All non generic collections
• Some other information ?
  • Silverlight 3 will include 3D support and GPU acceleration
  • One AppDomain will be created (and only one) per any .xap file
  • JIT compiler now focus on startup time
  • He finally showed us the IsolatedFileStorage use, that can be seen as a "super cookie" class

Session 3 : Code Contracts, Pex, CHESS, 3 tools for 1 talk (by Jonathan "Peli" de Halleux)

Another great session! Peli showed us three tools coming from the Microsoft Research laboratory.

• Code Contracts
  • Will be part of .NET 4.0. Can be currently downloaded from the devlab website
  • A new namespace is now available : System.Diagnostics.Contracts
  • Allow to define Pre and Post Conditions to our methods like
    • Contract.Requires(target != null)
    • Contract.Ensures(Contract.Result<string>() != null)
    • Contract.Ensures(Contract.OldValues(this.Count) == this.Count - 1)
  • A new property page will be added in the project allowing to
    • activate a new static code analysis to ensure the contracts are respected
    • activate a runtime check
  • We can add contracts on an interface
    • On an interface, we can add the attribute [ContractClass(xxx)] to define the class that will hold the contracts of our interface
    • On the class that will hold the contracts we need to add [ContractClassFor(xxx)]
    • We can also add a method tagged with [ContractInvariantMethod] : this will get executed after each call and it must success
  • It can generate a separated DLL that will contain only the contracts (can be considered as a documentation DLL)
• Pex
  • This tool will generate a suite of test cases to check a specific method
  • Will analyse the IL code of the method to see all the branches and thus exploring all the branches
  • It can create complex objects based on a given factory. If a factory is not present, it will suggest the one to create
• CHESS
  • This tool seem to be great to be able to reproduce a blocking scenario in a multithreaded application
  • To do so, it will "simply" change the schedule of the different threads in action to arrive to the blocking scneario
  • To be used on a test, we must add the attribute [HostType("Chess")]

Session 4 : Lean Principles, Agile Techniques, and Team System (by Joel Semeniuk)

I really like the session given by agile practitionners as they are automatically more dynamic than the average.

Joel dealt in this session with the sevent principles of Lean Software Development and the associated myths:  

• Myth 1 : Early Specs reduce Waste
  • Principle 1 : Eliminate Waste
• Myth 2 : Tester Job is to find defect
  • Principle 2 : Build Quality In
• Myth 3 : Prediction creates Predictability
  • Principle 3 : Create Knowledge
• Myth 4 : Planning is comitment
  • Principle 4 : Defer Commitment
• Myth 5 : Haste makes Waste
  • Principle 5 : Deliver Fast
• Myth 6 : There is one best way
  • Principle 6 : Respect People
• Myth 7 : Optimize by decomposition
  • Principle 7 : Optimize the Whole 

Some other key information that was shared during the session :

• What is waste ? Partially done work, defects, relearning, hand off, ...
• We must be bias against adding new features : Why do we need this ? How is this helping the client job ?
• Case of Team System : We should edit our process templates (via the TFS power tools) to be able to change the work items and add the notions of "Triage" to all items
• The TFS power tools allow to add more policies to the same folder
• Always assign a piece of work to a team (and not to a single person)
• A system never need 100% flexibility
• Defer the decisions until you have most of the infos

To learn more about Lean Sofware Development, just go to the web site of Mary and Tom Poppendieck

Session 5 : .NET Services: Infrastructure building blocks in the cloud (by Christian Weyer)

It was an interesting session but as I have followed many session about this subject, including one given bu Juval Löwy, I won't give much details here. I will just say that :

• .NET Services is the new name of "Biztalk Services"
• Sql Services will allow to access a real Sql Server in the cloud
• .NET Service bus will also target Ruby, PHP and JAVA, either via Microsoft or 3rd party vendors