Building Blocks

This session was supposed to be another session, but I’m quite happy that they changed it.

I didn’t notice since I thought this seemed like a session I would go to.

The session was held by Roy Osherove who works at Typemock. His talk was not a Typemock commercial by the way. Event though he suggested using Typemock for testing Sharepoint since Typemock allows mocking of sealed classes.

What was good though was that we talked of the subject of how to make TDD and similar techniques avaliable to the non-early adopters. He thought that one should start with first just Unit testing and then when that technique is mastered by the developers, move on to TDD. So that the developers doesn’t have to focus on learning two or more techniques at the same time. Then start with TDD on a subsystem or smaller part of a system that has low risk.

For testing JavaScript he suggested JsUnit, Ive checked it out but havn’t used it my self. I’ve worked with qUnit (the jQuery testing framework) myself, but qUnit seems a bit immature. However I’m going to try qUnit for a while longer before trying jsUnit.

This is the first session that realy hit the roof when it comes to the level of the session. I arrived late to the session (sorry). The session is about reliability on large system. The session was held by Pat Helland. Basiclly Pat presented the idea of ACID 2.0, ACID (Atomicity, Consistency, Isolation, Durability).

I was quite happy with going to this session. Pat presented an interesting way to look at fault-tollerant large-scale systems using definitions of discrete mathematics. This first concrete use of basic mathematical rules Ive seen used in industry, or since I finished my education.

Ill try to summarize the idea. The idea is to have your transacations (units of work if you wish), designed in a way so that order doesn’t matter. That way you can achieve consistency over time as the transactions arrive from failing parts of the system. Ofcourse each transaction should be idempotent and isolated aswell.

I know this is a very short summary and definitly doesn’t give the session nearly enough credit.

Im adding a link to Pat’s blog.

This Session at tech-ed was held by Rob Tiffany, about how to utilize SQLCe with merge replication to achieve a scalable solution with SQL Merge replication to and from devices.

This is the typical session that I wish I’ve been to 3 years ago. We’re using merge replication to devices In our current product (not the new on though). We’ve had moderate success with it, but Rob’s recommendations could definitely improve our synchronization performance.

In general most of the what Rob recommended is about the setup of replication devices, and the performance of the hardware on which they run. There were also some suggestions of organizing the database. Ill try to summarize.

• Organize your data across replication servers based on geographical location, it is easier for an SQL server to handle a subset of the overall data based on location. Location is also natural when it comes to mobile devices.
• Have the replicated databases synchronize their subsets of business hours.
• Make sure that the database reserves most of the data, but leave some memory left. This is to make sure the database works intensively with memory without thrashing the memory access for the operating systems services. Swapping memory to disk for common operating system services can reduce the performance of the server.
• Keep as short a span as possible for the subscription timeout date. The faster a subscription times out the less meta-data is stored.
• Have the hidden system tables run on a different physical disc than the database itself.
• Having row-level tracking increases performance but can increase the amount of conflicts.
• Try to keep join-filter depth as low as possible, and reduce the amount of filters. The database structure sets the limits of how good performance you can achieve with merge-replication.
• Make sure the thread-pool settings equals the numbers of cores of the hardware, this is to avoid thrashing the CPU with alot of thread switching.
• Try to defrag or rebuild the indexes on the replicators often. A good tool to check for indexing hot spots is the performance dashboard
• For the IIS have the .dll file used for merge replication located on a separate physical disc.

All in all, alot of suggestions on how to make your merge replication work better on mobile devices and scale across geographical locations.

Interesting session indeed. This was the first time that I felt a culture difference between he session hosters and the people listening to the session.

The crowd was somewhat hard to active, and I believe that most of the people whom went to the session didnt realy know what to expect.

Here are a few interesting points I brought with me:

• HTC Diamond has multitouch support in the hardware but there is no application that uses it
• There is a Tell Me service that takes a recording and transforms it to text processing the recording on a webservice.
• MyMobiler is a free alternative to PocketController, Im using this now on my development PC to test it out, it can be downloaded at http://www.mtux.com/
• Redfly, a laptop like extender for windows mobile phones. Connect your phone and all of a sudden you have a 7″ display and qwerty keyboard. Aswell as VGA output and USB port extensions.
• FakeCall
• Dashwire, backup service for your windows mobile phone, complete for pictures, movies etc.
• GLMaps 3d virtual earth on a phone with accellorator support to detect which angle your viewing it from.
• Klaxon alarm clock that can be turned off by shaking the phone
• WIFIRouter; software that turns your cellphone into a WiFi accesspoint that allows internet sharing over the 3G connection.

This session was held by Miha Kralj. He described the trends he was seeing when looking at software architectures and systems. This was a realy good session. Im not going to list everything I found interesting in the blog. I recommned everyone to take a look at this session, its not technically oriented but its a very interesting session to listen too.

Miha describes how the software leaders of the future are highly connected young people, with communication and leadership skills that have been tuned through years of online collaboration. That there will be culture differences between these “Digital Natives” and the current descision makers. For example most people who are now starting to enter the Software industry will probably not accept having a standard issue pre configured laptop on which they cannot install what they want.

Miha also presented an interesting theory to what happened to IBM, they had a cash cow. Noone slaughters their cashcow everything is focused on the cashcow. This type of focus makes a company vounerable to competitors whom can take innovative approaches to the same problem, without having the customer paying for the cashcow.

This session was held by David S. Platt whom wrote a book with the same title.

It was a fun session. David explained that developers cannot design software with the assumption that if the developer thinks it is good software then it is good software. Instead you should design software so that the customer thinks it is good software.

Most developers are forexample male with high education, however customers are often “uneducated” and has a population of 52% female based on the numbers presented by David. Just this difference can be used to point ut the differences between the users and the developers.

David raised a great analogy when it comes to user interfaces.
Assume that 1 click in an interface takes roughly 1 second.
This 1 second can the be directly translated to cost in financial terms.

Consider then that this 1 second is done on 1000 PCs over the world, then the cost is multiplied by 1000, if its done 35 times an hour on 1000 PCs over the world the cost for such a design would be 1 * 35000 * AVG.PricePerSecond /hour.

This gives an execellent measurment to analyse different UI desicions based on a number, and also a good way to have a discussion about UI with financially oriented people.

To be honest, I do not think that this was much of a Deep Dive. It was more like a technical overview of the new features of Virtual Earth 6.2. However I still think it was a good session.

In version 6.2 of Virtual Earth they are releasing what is called “Virtual Earth Web services”. They seem to be just like the Mappoint web services, but with a slightly different interface. The services offer the possibility to receive map images, routing information, search information and geocoding through a SOAP interface. This allows me to make look-ups of addresses in C# code instead of JavaScript code. For me there is potential for improvements of my existing Virtual Earth code.

He also showed a demo where he used the new spatial data types in SQL2008 to show aggregated information based on geographical location. This was indeed an interesting demo, later when I talked to him he mentioned that a few report engine developers were working on ways to develop report- and BI tools for aggregation over geographical areas.

This session covered do’s and don’ts of software Architecture. It described the different roles of Software Architects, and finished off by showing a vision of the future of Software Applications.

I think it was a very good session. He started by describing the role of a software architect,
in an effort to defend against the “Ivory tower” view of software architects. I’m not sure that the audience was the correct target for such a defense talk; however the overview of different types of Architects was interesting.

After describing Architects he described a series of Anti-patterns. I’m not going to list them here but the presentation of Anti-patterns was good. However at times he seemed a bit like a proponent of heavy processes, especially when discussing documentation. Now I’m very anti-documentation, and believe that documentation should be written on demand.

However he does have a point when saying: “If the requirements aren’t documented, how do you know that you’ve met them?”

We might not share the same vision here, but it is true that quite often requirements can get lost during development simply because we rely on a human brain to remember all the requirements.

To finish off he described a vision of the future where the future of application development revolves about Data and the architecture on how to data is transferred, persisted and accessed. He will be talking more on this in his talk “Why software sucks” that I will be attending tomorrow.

A quote I liked from the Session:

“Architecture is simplicity, not intellectual violence.”

Meaning a good architecture is something that can be described in 5 minutes.

I didn’t think I’d be posting a blog post about the TechEd keynote, however I can’t help
myself. So why am I posting about it? Well I saw Visual Studio 2010 for the first time.

So what was presented for Visual Studio 2010?

• Packing Support. Visual studio assists you in creating packages for deploying your applications to different servers with different setups.
• Testing support. Using the packaging support you can easily set up a testing environment on virtual machines or actual testing severs. With different configurations of the system
  under test. While doing manual tests you can record the testing scenario and attach the recording to a bug report item.
• Better support for parallelism. Using parallel Linq and or parallel for loops similar to OpenMP or other academic parallelization research projects where you declaratively can tell the compiler to parallelize execution of for example a for loop.
• Sharepoint development supporting F5 debug deployment. For once I might be interested of developing Sharepoint solutions.
• Annotations are now shown as a popup in the code.
• You can add diagrams to display directly in the code.
• Support for viewing visualizations of code. Dependency graphs showing the structure of the application. Generate sequence diagrams directly from the code, etc.
• Minor refreshments of the history view. Displaying history in a single document with a timeline selection control.
• Refactoring support off the shelf. Resharper like features in VS out of the box.
• Better support for addins. Easier to extend VS by just dropping .dll files to the execution directory
• JQuery packed with VS. Complete with Intellisense

To be honest I’m looking forward to testing VS2010. I especially like the visualization features, since I’m sort of a visualization addict.

Ill be spending 3 days at Tech-Ed Barcelona. These are the sessions I will be attending. Hopefully I will be posting a small post about each session.
Architectures: The Good, the Bad, and the Ugly

Live Platform: Deep Dive on Microsoft Virtual Earth

Why Software Sucks

How IT will change the next 10 years and why you should care

Seeing Microsoft Unified Communications in action!

UI-Testing with UI Automation Framework
Or
Mobile Smack down

Mobilize your Enterprise and Achieve Global Scalability with Windows Mobile and SQL Server Compact
Or
Building Differentiated UI Applications using composite Windows Presentation Foundation

Building on Quicksand

If Threads could Talk – Architecting Threads

Web Scalability via Asynchronous Systems Architecture
Or
P&P Application Architecture Guidance and Futures Panel

IronRuby in Action

Reliability, Availability and Scalability: How you can have your cake and eat it too

Claims-Based Identity: An Overview of ”Geneva”