Upcoming courses:

  • Aarhus, Denmark, March 5 - 9, 2012
  • New York City, USA, March 26 - 30, 2012
Read more on our website

About me

Brian Holmgård Kristensen

Hi, I'm Brian. I'm a Danish guy primarily working with ASP.NET e-commerce solutions using Microsoft Commerce Server.

I'm co-founder and core-member of Aarhus .NET Usergroup (ANUG), which is a offline community for .NET developers in Denmark.

You can visit my View Brian Holmgård Kristensen's profile on LinkedIn or follow me on Twitter @brianh_dk. Also please feel free to contact me via e-mail Send me an e-mail.


On this page

Entity Framework Introduction
Microsoft Visual C# Under the Covers: An In-depth Look at C# 3.0
Building Great Web Experience with Silverlight 1.x
Small delay on blog posts from TechEd
IronPython and Dynamic Languages on .NET
Building Complete Web Application Using ASP.NET 3.5 & Visual Studio 2008 Part 2
The .NET Language Integrated Query Framework
Building Complete Web Application using ASP.NET 3.5 & Visual Studio 2005 Part 1
Eating your own software, Keynote from TechEd Developers 2007
Getting ready for this years TechEd Keynote speaking
Arrived at TechEd Developers 2007, Barcelona



The opinions expressed herein are my own personal opinions and do not represent my employer's view in any way.

RSS 2.0

Send mail to the author(s) E-mail

Total Posts: 36
This Year: 0
This Month: 0
This Week: 0
Comments: 10

Sign In

Follow me on Twitter @brianh_dk
 Friday, 09 November 2007

I must admit; I was pretty tired at this point, being very focused on getting most out of the sessions. I write notes from each session I attend and when I get back home to my hotel I polish them up so they can be published on my blog. It is causing me a lot of work and it is a bit slow process but it is useful for me, and hopefully others as well. Even though as mentioned I was a bit beaten up at this last session for Tuesday on TechEd for Developers it really had my attention because it was a topic of huge interest. I am really looking for a proper way of modeling my data access layer in a proper encapsulated way supporting my nTier architecture with the benefits of having an OR mapper in place.

The Entity Framework Introduction session was given by a guy called Carl Perry, who is Senior Program Manager Lead at Microsoft, and Carl was here to talk about Data Access methodologies on specific ADO.NET. Data Access as we know it in ADO.NET 2.0 allows a provider based model for abstracting low level access/interaction with the actual store e.g. SQL Server or Oracle.

With Entity Framework they want to raise the level of abstraction. Raise the abstraction from readers, commands and connections for making it easier to build a data driven application as you work closer to your domain model. Entity Framework lets you to only worry about how your domain is expressed. It introduces a Conceptual Schema which is the model we actually program against which has rich support for inheritance and relations. There is also a model to represent the actual data store given by e.g. the schema of tables, views, stored procedures etc. in the actual database called the Store Model. To map between these models Entity Framework introduces a third model in between known as the Mapping Model.

Entity Framework supports many-to-many relationships - it just removes the link table and creates a many-to-many relation on the related objects.

There are two approaches to access data with Entity Framework: 1) Use LINQ, which will properly give you much higher productivity, and 2) use the newly introduced query language called Entity SQL (eSQL) that is a part of the Entity Framework. Entity SQL looks very SQL like, and has the ability to invoke any server function that the provider has mapped. You query against the Conceptual Model in a string-based manner making e.g. joining tables very implicit.

Carl showed us some demos on using the Entity Framework using both approaches as mentioned above.

The Entity Framework is properly going to be shipped on first half of 2008. All database vendors are already developing managed providers on it. The current version of Entity Framework is on Beta 2 with a Beta 3 just around the corners.

I think it was a good session on introducing the Entity Framework and Carl certainly had a lot of knowledge on that area. I’m going to be attending a specific LINQ To Entities session tomorrow, hopefully to get even more insight on the Entity Framework and how it can be used as an OR mapper to support a data driven application. Looking forward for tomorrow sessions after hopefully a good long nights sleep :-)

Posted on Friday, 09 November 2007 08:31:08 (Romance Standard Time, UTC+01:00)
# | Comments [0]

I really had my doubts on whether I should attend this session, because a colleague of mine, Søren, already had done a presentation about the new language features in C# 3.0, and also I attended a session yesterday by Luca Bolognese on “The .NET Language Integrated Query Framework” where he covered many of the new features as well. However there was a really good reason for me being there; 1) that the session took place in the Auditorium where also my previous session on Silverlight went on, meaning I did not have to move at all, and 2) that I have a lot of interest in C# 3.0 and attending a session with only focusing on that simply could not be a bad thing for me.

This session was by Luke Hoban, Program Manager at Microsoft responsible for the C# compiler. Luke started out by telling about their design themes on this C# 3.0 version, which goes as:

1. Improve C# 2.0 – obvious as many might think.

2. Language Integrated Query (LINQ) - making querying a first class concept in the language. LINQ is really the driving force behind many of the new language features that we'll see as LINQ required making a lot of new capabilities in the language.

3. Being 100% backwards compatible which is always the case.

The rest of the session by Luke was pretty much purely demo-driven to show us the use of the new language features, covering:

Auto-Implemented Properties

The option to introduce a property with an implicit backend data variable. This is very useful for most properties in your classes as they usually always just simple properties without any logic.

Object Initializers

The option to set values on public properties of an object directly in its constructor.

Collection Initializers

Just as with Object Initializers this feature allows to add items to a collection object directly in its constructor.

Local variable type inference

This allows for any local variable inside the code, to just leave out the name of the object type and use the var keyword instead. This is syntactical very convenience and it is completely strong-typed as the compiler already knows which type you operate on given the right side of the assignment expression.

Note that you can't use var as return type or as parameter type. In level of public interface explicit specifying the types is the only way to go.

Query Expressions

The most important thing to understand about Query Expressions is that they are just like any other syntax in C#. It is not some sort of Domain Specific Language, it is just like e.g. a for-loop or a while-loop - a part of the C# language.

Two major reasons why Query Expressions are valuable: 1) they can be used not just over objects but all sorts of data; relational, XML, anything that implements the LINQ Query Provider and 2) it is easy to use as it is a very declarative way of writing queries.

Anonymous Types

The ability to create new shapes that suits the exact needs in your specific logic. Very useful for intermediate results.

The class will be auto generated by the compiler, making sure the type will have the right signature.

Also you can't return it – which means they are for most purposes constrained to a method body.

Lambda Expressions

A way to do anonymous methods but in a more efficient and declarative way. A Lambda Expression is indicated by the => (goes to) keyword. A Lambda Expression starts with a list of all parameters sent to the function.

Extension Methods

The ability to kind of virtually add new methods to existing objects that normally are out of your reach, e.g. sealed classes. It is important to note that this does not in any way break encapsulation. It is purely syntactic sugar. The compiler will go ahead and call the static method on the concrete extension class when it sees an Extension Method.

Expression trees

This is telling the compiler to capture Lambda Expressions not as delegates but as an actual Expression Tree which is a rich object model containing body and parameters exposing the Lambda Expressions thereby allowing the consumer to decide how to process this information, e.g. creating dynamic SQL as with LINQ To SQL.

Partial Methods

Allows you to write code that calls a method that may or not be defined and must be declared within a partial class. A common scenario for partial methods is lightweight event handling and in e.g. LINQ To SQL often used for doing validation in a custom partial class for the generated class.

Implicitly-Typed Arrays

This is a simple but helpful feature allowing you to declare a new array but leave out the name of the type. The compiler then does the type inference for you.

Example: var myArrayOfIntegers = new[] { 1, 2, 3, 4 };

It really was a great session by Luke Hoban and I am glad I attended even though I had my doubts. I feel very lucky having attended only good sessions so far!

Posted on Friday, 09 November 2007 08:25:16 (Romance Standard Time, UTC+01:00)
# | Comments [0]

The speaker of this session, Jesse Liberty actually joined Microsoft because of Silverlight. His work at Microsoft is not about convincing anyone to use Silverlight, his job is more to help developers on how to learn Silverlight and make the best use out of it. There is a tremendous interest in the whole Silverlight technology as he goes, so obviously Microsoft invests in customers wanting to use Silverlight for implementing their applications. Jesse went on a stated his agenda for this session; that we should not expect to see or be impressed by fancy demos of Silverlight in action. That his goal by demo-driven presentation is to show us how easy it is to use the declarative language XAML to build real applications with the .NET Framework and Visual Studio.

Jesse started his demo by creating a new Silverlight project in Visual Studio 2008. What he was about to demo was building a Silverlight application from scratch including a new custom Silverlight control in it. The essence of the demo was to build an application on the Conway´s Game of Life. I don’t want to go into much detail about what Conways Life is, but basically it has something to do with some cells living in a matrix-like world of total 800 cells, where each cell from generation to generation comes to live or dies depending on the state of the cells neighbors.

Among other things in his demo, he showed us how to implement a timer in XAML and make use of this timer for creating a loop control structure. Also and by far more interesting he demoed a new feature of Silverlight 1.x where they have implemented the capability of Silverlight to reference standard HTML that is produced in the page where the Silverlight control is hosted. This makes it possible to reference any HTML elements e.g. changing its display or capturing its events using API’s inside the System.Windows.Browser namespace. The .NET code looked exactly like the DOM most of us are already familiar with from JavaScript:


What Jesse really wanted to illustrate was the only really difficult thing on Silverlight is on how to go around declarative programming. When you are passed that barrier you find yourself back in the well known world of .NET programming and just thinking about implementing the logic using standard .NET. This happens very quickly with Silverlight.

I haven’t done any work in Silverlight at all so coming to this session was really good for me as I got some feeling on how Silverlight fits in – technically speaking that is. I have of course seen a lot of Silverlight demos out there – but for me it is really more interesting to see how it is done. Great session by Jesse Liberty – it was cool to see when his little tiny application came to play. Thumbs up!


Posted on Friday, 09 November 2007 08:13:50 (Romance Standard Time, UTC+01:00)
# | Comments [0]
 Wednesday, 07 November 2007

I'm really having trouble following up on all my notes making blog posts out of them. The battery on my laptop is not holding up very well, so I have to write notes in hand at some of the sessions, and finish them up when I get back to my hotel at late evenings. I do have notes though from every session I have attended, so please just be patient as I will do posts from each and every one of them :-)

I'm having a really great time down here and the time is moving really quickly!

I hope to learn lots more as there still is a lot of sessions left for me to attend.

So right now I'm going down to the Auditorium to a session that is going to change my life! Really, it is! Well, at least that is what it says in its description. I'm going down there to learn about asynchronous programming models in ASP.NET. Really exciting stuff.

I'll be back!

IMG_1405 IMG_1406

Posted on Wednesday, 07 November 2007 08:41:03 (Romance Standard Time, UTC+01:00)
# | Comments [0]

Now here was a session where I had absolutely no glue of what to expect. I have pretty much no experience working with dynamic languages other than writing some pretty simple JavaScript code from time to time. But sometimes it can be very good to anticipate in something without having any initial knowledge of what to expect because this usually wideness your perspective on the input you receive (I hope you know what I mean).

The goal of this session was to give us as the audience an understanding on how to use IronPython within our development. Makesh Prakriya, who is working on the IronPython team at Microsoft, gave us an introduction of what defines a dynamic language and where IronPython is resided in the system of .NET. The IronPython dynamic language is built on top of the Dynamic Language Runtime (DLR) which again is running on top of the well known Common Language Runtime (CLR).

Makesh mentioned four factors that makes IronPython interesting:

1. It is a true Python implementation.

2. It has seamless integration with .NET as it is built on of DLR.

3. It is open source released on a Microsoft Public License and also available on CodePlex.

4. It is the fastest implementation of Python out there being at least 70-80% faster than other implementations.

He told us a true story from Microsoft they had an expert (I did not catch his name) initially developing the 0.1 version using .NET to implement it to prove that .NET performance sucks, however they actually discovered that this was not the case, having even this initial version performing better than all the other implementations.

After enough talking about IronPython Martin Maly, another guy from Microsoft, did a level 400 demo to show how it all works under covers. Pretty advanced stuff but also very interesting to hear about, and I think I understood at least most of it :-)

Moving on we had Makish back to demo some IronPython stuff. He basically wrote all his code directly in a Console (see screenshot below) and with only very few lines of code he was able to create an application that allowed him to enable drawing on the form and having this being recognized as text and having this text being spoken by a Speech Recognizer. It was pretty cool to see how making handwriting to speech could easily be implemented using IronPython. This gave pretty good feeling of how easy it is with IronPython to load up any COM object, glue it together with something else and sort of poke around with it and execute its methods in a “quick environment” compared to having the environment of Visual Studio.


The support of IronPython within Visual Studio is possible, but needs to be done through the Visual Studio SDK. This goes for both Visual Studio 2005 and Visual Studio 2008.

Makish continued with another demo where he talked about game development. With XNA you can write games in .NET targeting the Xbox 360 console. However since the Xbox uses the Compact Framework and because it does not support the ability to emit dynamically created MSIL into an assembly for execution, games written in IronPython are not supported on the Xbox 360. However you can run these games on the desktop. This problem will be addressed in the future.

The last demo from Makish was having a little robot on the stage and through the Microsoft Robotics Studio framework using IronPython as the language he made this robot drive around in front of the audience on the stage. He had a Windows Forms application with some steering buttons and communication was using Bluetooth technology. See below for a picture of the robot. It actually stopped just in front of where I was sitting.


Last on the scene was Michael Foord, who demoed a real world product that has been implemented in IronPython; Resolver. Resolver basically is a very powerful and dynamic spreadsheet application which gives users the capability to write IronPython functions directly in the spreadsheet. Please refer to this blogpost for more information on Resolver.

Resolver consists of 30.000 lines of IronPython code, and has 100.000 lines of testing code.

Unfortunately there were no more time at this point – actually they went 30 minutes over time, but who cares as long as the content was exciting. I’m definitely intrigued by IronPython and I’m looking forward getting my hands dirty with some IronPython code in the future.

IMG_1414 IMG_1413

Posted on Wednesday, 07 November 2007 08:27:44 (Romance Standard Time, UTC+01:00)
# | Comments [0]

Just as yesterdays part one of his session Omar Khan, Group Program Manager on Visual Studio, had almost the entire room packed with people attending part two. And I was there as well.

Omar started out by quickly summing up the things we covered in part one of his session including the new features in the designer surface of Visual Studio 2008; extensively support for editing CSS and with much more control over designer build code and also how to use LINQ To SQL in ASP.NET.

He then went on telling about the new data controls introduced with ASP.NET 3.5. The <asp:ListView> control is new, which is very usefull if you want full control on how the markup will be generated in the page. It gives the same flexibility and power of the <asp:Repeater> control, but with a lot more capabilities including better integration to the design surface of Visual Studio 2008 with support of rendering how the output will look like. Something that the <asp:Repeater> control did not support. The new <asp:ListView> control is also fully template and has support of the various select/insert/update visual rendering modes. Omar demoed this new control by taking some static content from a sample web-page from a previous demo and converted it being populated dynamically from a <asp:LinqDataSource> control which allows to connect to any LINQ To SQL class defined in the solution. The markup rendered from the <asp:ListView> was just as clean as he promised – not even the ID of the <asp:ListView> was outputted to the browser, which was something I particularly found very nice.

With the new <asp:DataPager> control it is possible to put paging on top of any ASP.NET data control. Omar did a quick demo on this by adding the paging to the <asp:ListView> previous mentioned. This is also a really nice and handy control giving you the maximum flexibility on how you want paging to work and how you want it to look by having full control over how it is rendered.

We moved with the next thing which was the Ajax capabilities of ASP.NET 3.5. Support for Ajax has now been integrated in ASP.NET 3.5 where before in the previous version this was an add-on. Visual Studio 2008 has a new feature where it automatically recognizes Ajax Extenders for the various controls so when you for instance drop a <asp:TextBox> control in your page, Visual Studio can figure out which Extenders that can be used for that. They have also changed the way how Extender controls gets visually rendered in the designer by actually not having them being rendered as separate controls but instead as something “on top” of the actual control they extend.

Omar carried on by demoing features of the extensively increased support of developing JavaScript code inside Visual Studio 2008. The JavaScript Intellisense have been tremendously improved (yes I use big words – maybe I just get pretty easily impressed :-)) supporting the dynamic nature of the language with automatically inferring the types, and supporting accessing JavaScript functions from external files. Visual Studio 2008 also supports build time syntax checking of JavaScript and allows debugging your JavaScript code in improved and easy manner compared to how this was supported in previous versions of Visual Studio.

Next from Omar was on how to document your JavaScript libraries and how this gets reflected in the Intellisense allowing having the same documentation capabilities as you are familiar with e.g. the ///<summary>This function converts…</summary> or ///<param name=”name”>Defines the name of…</name>

After that he showed us how simple it is to add a reference to a Web Service in the <asp:ScriptManager> control and how to script against this web-service using the ASP.NET Ajax framework with off course the Intellisense to fully support this. Pretty powerful stuff.

At this point time almost running out so Omar had to quickly go through IIS 7.0 and some of the new features in this upcoming web-server. IIS 7.0 provides much better administration and management of sites and configuration, better support of diagnostics and improved support for Web Farm scenarios. IIS 7.0 has a much more friendly experience around configuration of the web-sites and the web-server providing a nice UI for this. I actually completed a Hands-On lab on the IIS 7.0 and I will properly do a post about this sometime soon.

Even though Omar did not talk about how to structure your code properly with LINQ, I really think it he pulled of two very good sessions on how to build web-applications using the new Visual Studio 2008 and ASP.NET 3.5.

IMG_1412 IMG_1411

Posted on Wednesday, 07 November 2007 08:15:39 (Romance Standard Time, UTC+01:00)
# | Comments [0]

This session by Luca Bolognese, LINQ Lead Program Manager from Microsoft was absolutely great! Luca set the atmosphere even before the session began by playing some “Santana - Maria Maria” music from his portable music player out on the main speakers. Maybe it was in favor of the girls sitting on the front row, it might have been, however it was a nice prestart on the session and made Luca look pretty confident.

Data != Objects

He started out by telling the story of how wonderful a life we as developers have, until we reach a certain point in our code where we start to write code to access data from somewhere. Up until that point we get nice compile time errors when writing bad syntax or accessing non-existent properties, methods or whatever. But when we start writing our data access code we no more get our lovely compile time errors for instance when writing a SQL query. He compared this to driving your Ferrari 300 km/hour down the road feeling all great with wind blowing in your hair and all that, and suddenly you crash into a wall! Pretty excessive analogy though a funny one. He followed up stating that he wants to change this experience. He wants to introduce as many compile time errors as possible because this is much better than getting the errors at runtime. He went on saying something like LINQ will change the way you write code and stated out that even though this sounded exactly like a marketing slogan, it was really a true statement.

LINQ is a First Class Citizen in .NET

Luca Bolognese continued showing an architectural overview of LINQ where he provided introduction to the common LINQ To <Something> providers, including LINQ To Objects, LINQ to DataSets, LINQ To SQL, LINQ To Entities and LINQ To XML. And on top of these providers where the actual CLR compliant languages such as C# 3.0 and VB.NET 9 that both have LINQ implemented directly in their syntaxes. He told us that LINQ To SQL is the provider to use if you want the fastest possible way of getting access to data via SQL Server – and by fastest he did not mean performance-wise, but by doing less work as possible. LINQ To Entities is more suitable for enterprise solutions having a complex mapping framework and also offering a far more abstract way of looking at the data store. I will be attending specific sessions on LINQ To Entities later on, so more on this topic as I come to it.

Luca fired up his Visual Studio 2008 in order to demo features of LINQ. His mission was to initially have some C# 2.0 complaint code querying Customer data from an in-memory collection, and then convert this code into C# 3.0 utilizing new language features and LINQ. Luca used his own prewritten code-snippets to generate most of the code in his demo, which I think was very good, thereby adding more time to the actual content rather than use time on writing all the code on the fly. Step by step Luca converted this C# 2.0-ish code to C# 3.0, each time with a new language feature, covering topics like Auto-Implemented Properties, Object and Collection Initializers, Local Variable Type Inference, Anonymous Types and Lambda Expressions. I won’t go into details about these topics, as I will be attending a session tomorrow that should cover all this, but it was really convincing and as he demoed along you could really see the benefit on having these new language features making your code much more readable.

After converting the code to C# 3.0, Luca changed the data source of the Customers from an in-memory collection to be loaded from a SQL Server database using LINQ To SQL. He explained the difference between how the compiler sees queries being an instance of IEnumerable<T>, as it is with LINQ To Objects, to see queries being an instance of IQueryable<T>. When the query is an instance of IEnumerable<T> the compiler will do all the operations supported by LINQ in memory, e.g. the ordering and/or grouping of the collection. But when the compiler sees an query that is an instance of IQueryable<T> then the compiles creates an expression tree that is passed along to whatever Query Processor that is implemented in the concrete LINQ Provider, e.g. the Query Processor in LINQ To SQL which is responsible of generating the T-SQL code.

Luca moved on with his presentation showing us some example of LINQ To XML and showed us how to combine accessing data from the database and generating XML out of that, which very convincing showed the concept of getting data from wherever and place it in whatever using LINQ.

Last Luca also showed a new feature of VB.NET 9 of having fully support of XML directly inside the language which was really impressing and seemed to be a very powerful feature of VB.NET 9.

It was really nice to attend a session where the speaker adds lots of humor to the content and also seems extremely enthusiastic about his work. The best session so far.

IMG_1402 IMG_1401

Posted on Wednesday, 07 November 2007 08:14:10 (Romance Standard Time, UTC+01:00)
# | Comments [1]
 Tuesday, 06 November 2007

I attended this session to get an overview on some of the new features in Visual Studio 2008 and hopefully learn some tips and tricks from that. And I did :-)

The speaker of this session was Omar Khan, Group Program Manager of Visual Studio, who did a convincing and stable speech on his part one of two presentations of "Building Complete Web Application using ASP.NET 3.5 & Visual Studio 2008".

Omar started out by showing the new Multi-targeting feature of Visual Studio 2008, allowing the development of any .NET 2.0, 3.0 or 3.5 application in Visual Studio 2008. It is possible to specify which .NET Framework version the application targets which automatically gets reflected in the IDE by switching features on/off. An example of this is that the available list of controls in the toolbox gets extended when targeting an ASP.NET 3.5 web application rather than an ASP.NET 2.0 version. It is a pretty useful feature that makes it a no-breeze to continuously develop our .NET 2.0 solutions in .NET 2.0 but then use the newest IDE available and leverage from its new features and benefits. And all this without having to upgrade the complete solution to the newest version of the .NET Framework as we had to when Visual Studio 2005 was shipped. Omar actually showed us how an ASP.NET 2.0 application was easily upgraded to ASP.NET 3.5, where Visual Studio goes and updates the web.config and adds some new assembly references including LINQ. Sadly I did not manage to found out whether it is possible to upgrade applications from .NET 1.x.

Moving on Omar showed us some more new features of Visual Studio 2008 with focusing on the HTML Designer. This has been improved and it uses the same WYSIWYG designer engine as in Expression Web, meaning that you don't have to worry about pasting any HTML delivered by your designer working in Expression Web causing Visual Studio to change the markup of this and vice versa. They have also done some work on improving the performance between View Switching, and they have now included support for nested MasterPages. In Visual Studio 2005 having nested MasterPages is not completely useful as the IDE do not support to render this, so now having this in Visual Studio 2008 is really exciting. With Visual Studio 2008 they have introduced a common feature called Split View, that is splitting the view between the markup that you write and the design that it produces. A feature seen for ages in many other products but until now not supported by Visual Studio. I should have asked Omar whether it is possible to dock the design-view on another physical screen having the full benefit of two monitors - but I didn't  - so I just need to check it out for myself (I don't think you can actually).

Another thing that Omar used a lot of time talking about was the new enhanced support of Cascading Style Sheets (CSS) in Visual Studio 2008. They have really put a lot of effort in providing a confident and fine grain control over the markup. From what I saw from his presentation, it really looks as they have succeeded in that. I have always been avoiding using the designer view because this typically meant that Visual Studio went ahead and created all kinds of inline CSS on my elements, which lead me to do all the work on that. I don't see however how this supports ASP.NET Themes, as they can be changed and applied runtime for your web-site, leading the IDE without any knowledge of the actually applied style - but I think that goes for all scenarios where the runtime can change the behavior that the designer in Visual Studio has no clue about. I need to dig a little more into this to fully understand it, but I really welcome the enhanced support of CSS in Visual Studio 2008.

The final topic on this part 1 of the session was how to work with data. Omar went, not surprisingly, into the world of LINQ, showing a demo of LINQ To SQL as an ORM provider for his Web Application. He generated the DataContext class by dragging tables from the NorthWind database to his web-site project - unfortunately all his LINQ code was placed in a inline code block of his ASP.NET WebForm leaving me a bit disappointed as the topic for the session was to build a "complete web application" having to think that we would see at least semi-structured code and not this kind of spaghettish-code. Luckily enough Omar pointed that out himself saying that he would refactor this in the part two of the session implementing an actual data access layer. With that said I could again relax and enjoy the show!

Omar showed some features of LINQ, including aggregating, Lambda Expressions, server-side paging and the use of partial classes to implement validation logic to the generated LINQ classes.

I'm looking forward to part two of his session where Omar hopefully, as promised, will structure his code in a more architectural right way and to learn more about new controls introduced in ASP.NET 3.5.

Below are some photos from the session with Omar Khan:


Posted on Tuesday, 06 November 2007 08:15:39 (Romance Standard Time, UTC+01:00)
# | Comments [0]

This was actually not the headline from the keynote by S. Somasegar, the Microsoft Corporate Vice President of the Developer Division, who was the keynote-speaker at this years TechEd Developers 2007 conference in Barcelona. The headline however is from a funny part of the keynote where S. Somasegar plays a video from Microsoft on how they build Visual Studio 2008.

With a totally packed Auditorium of expectant developers S. Somasegar started out his keynote speech by telling a true story of an experience he had here in Barcelona after arriving. It took place in a restaurant called “Moo Restaurant” where he had had the absolute best dinner experience in a longer time. He told us that it was a combination of two things; 1) that the chef did a fantastic job cooking the dinner, and 2) that the ambience and the way the food was served, really met his expectations and then some. In software perspective he did the analogy that being a fantastic developer is not enough when failing to have an understanding of the differentiated user experiences and requirements that users have. Otherwise the software won’t survive in the longer run.

S. Somasegar also shared some statistics with us; that over the last two years, there have been over one million professional developers using Visual Studio 2005 where 25 percent of these use Team System in development, that there have been over 17 million downloads on the Visual Studio Express product and last that 80 percent of all questions asked on the MSDN forum have been answered.

Offering a free license to a feature-limited Visual Studio IDE, the Express editions, is available to make it easy for anyone to getting started on learning how to develop applications. I really like the idea of having these free feature-limited editions of Visual Studio and SQL Server as this helps getting as many people as possible joining the community. Another effort that his division has done is to increase/strengthen the community by making the MSDN much better. On the forums they have done a lot to improve response time on questions. Also with the Microsoft Valuable Professional (MVP) Program it can really pay off being an active community member. I hope to find myself struggling for that title someday – but as for this moment I have other things to focus on. Upcoming improvements to MSDN is the possibility to share code, which makes it easy for developers to share work with the rest of the world, and also a new MSDN Wiki lets community members add more content to the documentations. These new things will help transition MSDN from a one-way platform to a community-based platform. Really great news from my point of view.

S. Somasegar went on speaking some about the Mission of his division, which he stated being to: Make every software project successful with Microsoft tools & platforms.

He wants to do this by constantly deliver platform technologies and tools that support different developers with different experiences for different projects. LINQ is one of the technologies to accommodate that. LINQ makes it easier for developers to execute data queries without having to know anything about e.g. SQL, XPath and/or XSLT. The developer simply just makes the queries in his own .NET language e.g. C# or VB.NET. A lot of sessions on this years TechEd will be on LINQ with some I will be attending.

S. Somasegar told us that Microsoft Patterns & Practices have just released (or are about to release) some blueprints for Software plus Services solutions (S+S), which should make it very easy to take an application and make it serviceable. The releases will contain ready to use building blocks and plug-ins for Visual Studio. Blueprints are frameworks with source code and will target different scenarios. There will be more blueprints to be published during the next couple of months. It is something that I haven’t heard about until know, but it sounds very cool and something that I will definitely check out.

After that, Tony Goodhew, Product Manager of Visual Studio was brought to the stage for a demo on how to build great applications with Visual Studio 2008. He quickly demonstrated some of the new features in the IDE including the Split View feature between markup and design when creating ASP.NET solutions and the enhanced support for Cascading Style Sheets (CSS). He also showed how Visual Studio 2008 can target different versions of the .NET framework (2.0, 3.0 and 3.5), making it no excuse to not using Visual Studio 2008 on your .NET 2.0 solutions (and why shouldn’t you?). He showed us something that for me was new; extended support for JavaScript in the IDE which included support of debugging with breakpoints – that is pretty cool. Tony also showed us a fictional customer case of having workflows in SharePoint with a typical sequential Vendor Approval Workflow. This workflow included a Vendor Application word-document, with a custom Microsoft Office add-in dialog, which had WPF hosted inside an ElementHost control on this dialog. The ElementHost control supports two-way interop and it is there to host the right technology in the right place which was very well and convincing demoed in this case.

After the demo by Tony Goodhew we moved on to the funny video I was mentioning in the start of this text. S. Somasegar put on the video: “Visual Studio 2008: True Development Story”, which was had a sort of X-Files (or “Operation X” as we have a Danish documentary series called) kind of theme/atmosphere over it. It had this Professor commenting on the state from Microsoft that in the development of their Visual Studio 2008 they have been using their own product to build their own product – the professor compared that to his new book “Eating your own dog-food”, and even moved things a step further introducing the sequel “Eating your own dog-food even before you even have a dog” stating that it was too good to be true that such thing could occur. It was a great video and had Scott Guthrie in it. Scott is one of the Microsoft folks that I pay especially attention to by subscribing his blog-posts. The moral of the video did all go well with the philosophy that S. Somasegar stated in the speech: "Use what we ship, ship what we use".

We then had a demo on Visual Studio Extensibility by Dan Fernandez, the Lead Product Manager of Visual Studio, who showed us an Add-On Studio to the famous game World of Warcraft. Basically he had built his own custom IDE using Visual Studio and used it to create an add-on to World of Warcraft with Intellisense support to a custom .NET language that converts to what I think he called the LUA data structure which the game is based on – or at least something very close to that.

The new add-on to the game he demoed was an in-game screen dialog showing some info from the opponent creatures that he was attacking (or something like that – I haven’t played the game), and when he killed his opponents a MP3 file was played. It was pretty funny to see Dan walk around with his wife’s character in the World of Warcraft universe; slaughtering creatures and when doing so, a “Killimanjaro” sound was played when the third opponent was killed (this was actually the logic of the small code sample that he showed us – killing three opponents should result in playing this special MP3 file).

Dan Fernandez also did the final demo when he announced the new Microsoft Popfly. Popfly is an online web-based platform where you can share and publish web-pages with the rest of the world. The development can take place in Visual Web Developer Express and you can find a lot of Silverlight prebuilt templates/gadgets on Popfly to drag to your own page, or share your own. Popfly will make it easier for anyone to create a nice and cool-looking web-site, or at least that was the experience he brought from the presentation. He demoed a World of Warcraft fan web-site, and even so that it was a very quick presentation, Popfly seems to be very promising as they have made it easier for none-developers to create very cool web-sites, with the use of innovative products and technologies such as Visual Studio and Silverlight.

S. Somasegar finished off the keynote by telling us what is coming down the pipe from Microsoft. We got some insights on the future roadmap, which includes Expression Studio 2, Visual Studio 10, Silverlight vNext, .NET Framework 4.0, Windows Server 2008, Internet Information Services 7.0, SQL Server 2008 and BizTalk Server R6 – where some of the mentioned products/platforms are sooner to be released than others. He also gave us some detailed insight on the next version of Visual Studio Team System, codename “Rosario”, where the key themes for the product are; 1) enabling us to built the right thing the right way - being able to have a rich way to prioritize features with deep level integration between Project Server and Team Foundation Server, and 2) having the testing tools being more comprehensive than they are today, including support of test case management, manual testing, stress testing, load testing, code analysis testing etc.

Although he sometimes was a bit hard to understand due to strong dialect it was all in all a very good and informative keynote with cool demos and a funny video, but most important of all it was a nice kickoff to TechEd Developers 2007 which hopefully will contain lots of cool sessions! More on that as I go along. Stay tuned.

(Sorry about the long post - and most likely possible misspelling)

Posted on Tuesday, 06 November 2007 08:09:51 (Romance Standard Time, UTC+01:00)
# | Comments [0]
 Monday, 05 November 2007

I am sitting here practically live from TechEd Barcelona, in a crowded auditorium waiting for S. Somasegar, the Microsoft Corporate Vice President of the Developer Division, to do this years keynote speaking.

While waiting we have two graffiti painters and a DJ pumping some really cool techno music out to entertain us.

I just wanted to share some pictures with you, and then I'm off again.




Posted on Monday, 05 November 2007 13:38:53 (Romance Standard Time, UTC+01:00)
# | Comments [0]

I'm here!! Sitting at the TechEd Developers conference in Barcelona :-)

The traveling however did not go as expected, due to a delayed plane in Kastrup, some confusing bus- and train rides in Barcelona (I wished that Microsoft had been there to pick me up in the Airport) and a hotel receptionist who couldn't find my reservation. But hey, that doesn't matter anymore - I'm here now, have had a good nights sleep, and that is all that counts :-)

I'm sitting this moment on-site at the conference, and I have now decided which sessions that I will be going to attend for today:

WEB303 - Building a Complete Web Application Using ASP.NET "Orcas" and Microsoft Visual Studio 2008 (Part 1 of 2)
by Omar Khan

TLA318 - The .NET Language Integrated Query (LINQ) Framework
by Luca Bolognese

Well I'm off again - I want to check this place out and most likely do some Hands-on Labs on VS.NET 2008 and LINQ before the sessions.

Posted on Monday, 05 November 2007 09:12:42 (Romance Standard Time, UTC+01:00)
# | Comments [0]