Cluebat-man to the rescue : Event

Tech-ed Berlin 2009: Afterthoughts

vanDooren — Mon, 16 Nov 2009 20:47:40 GMT

All in all, tech-ed was worth it this year.

If you’re an an IT professional, then visiting tech-ed is a valuable learning experience. Even though most of my job involves off-the-shelf process control software, this software is still running on the Windows platform, and uses Windows and Microsoft technologies to work.

So for the purpose of administering and troubleshooting software on the windows platform, it is important to know how the software works, what it’s capabilities and configuration options are, and how it fits into the larger ‘Microsoft’ eco system.

By attending tech-ed and choosing the appropriate tracks, it is possible to keep a broad perspective. By knowing the important basic aspects of Windows 2008 and SQL server, Active Directory and other related things, I can get a better understanding, which will always come in handy eventually. Sooner or later we’ll run Windows 2008 and Vista, or ‘7’, or SQL server 2008, or something else.

And some things are downright practical already: The capabilities of powershell are astounding, and can definitely make life much easier in cases where now batch files are used that are not always easy to understand, or unable to provide much feedback when run as a scheduled task.

From that perspective, tech-ed was definitely a success.

Technorati Tags: General,Event,Teched

Tech-ed Berlin 2009: Day 5

vanDooren — Sun, 15 Nov 2009 10:01:00 GMT

Check-out was a painless experience. I’d already packed my stuff yesterday so I was at the reception early enough to avoid the rush. The cloakroom in the Messe was organized properly so luggage drop-off was painless as well.

Time for a coffee and a quick e-mail check, and it was time for the first session of the day.

DEV307: Parallel computing for managed developers

This talk is hosted by Steve Teixeira.

It is a repeat of the talk that was held earlier this week. Despite that, the room is filling up nicely. When the session starts, the room is not completely packed, but just well attended.

From interviews with customers in large ISVs and game companies, there is still only a minority of programmers who program in parallel. Usually, the parallellimization (my spell checker claims this is not a real word J) is done by one or 2 programmers at most who do the infrastructure, and the rest of the team just makes their code so that it can hook into that. The number mentioned was that only a handful of percent of programmers program in parallel. This really surprised me, since I have been doing that for over 10 years, as I thought many people did.

One of the big reasons for this disconnect with the parallel world is that up until recently, thinking about parallelism meant that you had to think in term of actual execution flow instead of task based. Threads, locks, and the various patterns made it hard to focus on solving the actual problem at hand, because the concurrency plumbing around a parallel problem was so complex.

To ease the transition to parallel programming, Microsoft is working on a parallel programming toolkit that has all the basic plumbing in place so that programmers can start thinking about task based programming and letting the runtime take care of the gory guts underneath. This way, you, the programmer, are not forced to hammer your solution in a threading paradigm, and implement the guts to support cancellation, exception handling, and other things that can otherwise turn a seemingly simple threaded solution from simple to stupendously convoluted.

Steve is a natural born speaker, and again his presentation was a handful of powerpoint slides, interspersed with lots of demos and code explanations. This presentation was based mainly on the necessity to change the way we think about parallel execution.

CLI309: Sysinternals tutorials

This talk is hosted by Aaron Margosis.

Now that I see him, I recognize him as ‘the other guy’ whose name I forgot during the virtualization - > app compat talk.

His presentation included 3 powerpoint slides, and these were shown during the first 2 minutes. The rest of the presentation was a non-stop demo of some of the sysinternals tools and how they can be used.

I have been using these tools for over 10 years now, and they are THE tools you need during trouble shooting, debugging, or simply if you want to know what goes on under the hood. Despite the fact that I have been using them for so long, I still saw a couple of interesting features that I hadn’t seen before.

This talk went very smoothly, and Aaron is a great speaker. As with Mark Russinovich’s talk, the room was packed full. They had already changed the room assignment so that it was now in one of the biggest rooms of the convention center, but still it was packed.

There is little point in me trying to cover the contents of this presentation here. Just download the latest release of the sysinternals suite and start playing with it.

Lunch

The food aspect of the lunch was as basic as it gets: packed lunch. The turkey sandwich wasn’t bad though.

The company was great though. Steve and I finally managed to meet up and we spent an hour and a half catching up. That was really great, and one of the nice things about going to tech-ed. Not only is the learning experience extremely valuable, but you also get to meet people from all over the world.

Because of this, I missed the last session of the week. As usual, this wasn’t a real drama. The afternoon session(s) on the last day of tech-ed is/are usually less interesting because they factor in that many people are already leaving because of their flight times.

I had thought to attend Mark Russinovich’s talk about ‘The case of the unexplained…’ windows troubleshooting talk, which is would cover the various troubleshooting scenarios he was involved in, and solved with the sysinternals tools. I followed the blog series in which he wrote about those things so I didn’t miss a whole lot.

Day 5 wrap-up

Today was less intense, due to the fact that everybody is leaving today, and the schedule is set to that expectation. The talks were interesting though.

I am writing this from the starbucks at Tegel airport, and I have to admit that I misjudged the size of the mugs here. I chose the middle size because I thought that it was the size I am used to. The only reason I thought that, was the relation between the different sizes that were shown.

Now that I am actually holding it, I can conclude that they don’t use ‘small’, ‘medium’ and ‘large’, but ‘large’, ‘oversized’ and ‘humongous’.

I still have some time to fill before I can check-in for my home flight, so I can get something to eat and finish my reports. I’ve already checked with my colleague and there were no dramas at work so that is good.

I have to say that Tegel airport is a much nicer place to wait than Barcelona airport. There’s a lot of stores here, a starbucks, places to sit… and so far noone is looking me out of the premises because I am not actually buying additional coffee so that is nice.

My flight doesn’t leave for another couple of hours so I can do some development or begin on my tech-ed wrap-up report. It won’t be as extensive as the day posts, but I always like making a summary of the week.

I am already looking forward to home, and being able to hug my kids. Unfortunately, my wife is in the US at the moment, and it will be another week before I see her back.

I had an interesting experience at the security challenge though. I always carry a swiss pocketknife with me. You know the ones: with a file, screwdriver, can openener, a dozen other things, and of course, a blade. A couple of times I thought ‘I must not forget to put it in my checked luggage’. And of course I arrived at the security gate with that knife in my pockets.

I quickly put it in my carry on bag and put everything in those plastic X ray boxes. I was told not to take off my rings, and I triggered the metal detector. I was wanded down by a friendly security guard. For some reason, their detectors were set so sensitive that the wand beeped because of the individual rivets in my jeans, the zipper of my jeans, my rings, and even the roll of peppermints in my pockets.

No kidding, the wand beeped at the foil wrapper of my peppermints. Still, I was allowed to go through but there was no fooling the X ray machine. The lady kindly asked if I had a knife in my bag after which I dutifully handed it over. She looked at it for a minute, tried to open it (she failed), said ‘Hm, ok no problem’ and then gave it back to me with a smile.

She must have decided that I was unlikely to attempt a hijack with a little swiss army knife. It probably helped that it was clearly recognizable as a swiss knife, and that I used it as a keychain with keys attached. I don’t think I’d have gotten the same treatment had it been my spyderco. Interestingly, she made more of a fuss about the fact that my drinking bottle was still half filled with water. So I opened it and started drinking, and after a couple of gulps she told me it was ok.

It was nice to see that the German security guards were both paying attention AND showing common sense.

Tech-ed Berlin 2009: Day 4

vanDooren — Thu, 12 Nov 2009 19:27:00 GMT

Today I will go shopping for presents for my wife and kids. The last session ends at 18:15 and the store I want to go to is open till 21:00. There is a train station right next to the ‘spielmax’, and I feel confident that I will be able to get there in 1 go.

CLI312: Group Policy changes for Windows 7 and 2008R2

This session is hosted by Michael Kleef.

There are 2 reasons for me to attend this session. First of all, this is the only remotely interesting session at this hour of the day, and Group policy is something interesting which I actually use.

Secondly, this session is in the same room as CLI401, which it THE talk by Mark Russinovich. This means I don’t have to travel half a mile to get there in time.

The most important thing I took away from this talk was that in ‘7’, group policy is no longer just a logon action, but a hardened service to apply policy in the background. That sure is nice and would have solved a lot of my problems, if we actually ran something other than XP on my network. Still it is good to know for future reference.

This new service is network aware, so it will try to haul in group policy when it detects a domain controller, and not blindly wait until it is triggered by its default schedule. This is a boon for mobile users, or rather, the admins in charge of the machines of mobile users.

Then there was a word on group policy replication and how FRS (the file replication) sucks really bad. DFRs is supposed to be much , much better and solve a lot of issues. In particular, if FRS breaks (and it does), it doesn’t tell you. DFRs logs things in the windows event log for you.

Preferences were also mentioned, and how they can be used to help you configure computers with much more options, like printers, drive mappings, and other things. These are not real policies though.

Some part of the talk also covered the difference between adm files and admx files (the new file format for policies) and how they make your life easier.

I was impressed by the group policy abilities, though sadly I won’t be able to use them for a while, since we are still running 2003/XP.

CLI401: Windows 7 and 2008R2 kernel changes

This talk is hosted by Mark Russinovich.

This is amazing. I left the previous talk 5 minutes early to go to the bathroom and then returned immediately to make sure I got a good seat. For me, this is the most anticipated talk at tech-ed. The amazing thing is that the previous talk has ended slightly early, and yet the room is filling up already! There is another half hour to go, and most of the front half of the room is already occupied. And this is the largest room of the event!

2 years ago I was talking with a new programmer. You know the type: wearing a suit, having a slick haircut, carrying books about ‘patterns’… We ended up talking about programming, and I mentioned I was a C++ MVP and that I was currently reading Windows System Internals 4^th edition because I really wanted to know how things work under the hood. He said he didn’t care about that level of understanding. He cared about managed languages, patterns, and ‘agile’ programming. No offense to the agile people, but it just fit with the rest of the picture.

At that point we had a bit of a disconnect. I am of the opinion that if you want to be a –real– programmer, then it is your duty to understand what you are doing, and not just doing things to get results.

At this point we are still 5 minutes away from the start of the talk, and the back of the room is getting packed as well. There are still some seats available, but pretty soon they’ll have to start turning people away.

As the talk is beginning, there is one moron in front of me using his cell phone. Personally, I would not presume to think that what I am saying is more interesting than what Mark is saying. And this is where Marks status among the audience shone through, because the guy with the phone was prodded from several sides and told bluntly to shut his yap. He stubbornly kept talking on, and I was glad he quit half a minute later, because there is a good chance that bad things would have happened.

Mark’s talk was very good. He has an easy way of talking to an audience, and he connected immediately. The talk started with an explanation of the various ways in which the memory footprint of Windows 7 and 2008R2 (they’re based off the same kernel version) has been decreased, so that it’s the first OS release ever to use significantly less resources than its predecessor. And not only has the memory footprint been reduced, but there have been other changes that prevent runaway processes to stomp over the working set of other components or applications.

In the realm of power efficiency, Mark talked mostly about core parking, triggered services and timer coalescence. One of the major investments in ‘7’ development was to make sure that the kernel was doing ‘nothing’ as much as possible. J Incidentally, the kernel version for ‘7’ is 6.1, for no better reason than app compatibility and the morons who implement OS version checking the wrong way.

After that he briefly touched on the new virtual service accounts and managed service accounts, which are almost identical to normal service accounts, except that they managed their passwords like computer accounts.

The final part of the talk was about scalability, the number of CPUs Windows can use properly, and what was done to decrease the amount of lock contention in the kernel. It was pretty impressive. The biggest single improvement in scalability was the removal of the Dispatcher lock, which was apparently a very surgical process to do, and quite an achievement.

The talk zoomed past and was very interesting.

Afterwards I managed to ask Mark about his recent Newsid blog post, because I manage a complex software infrastructure in which the machine SID is used by the application, and I wanted to ask him about it. Mark asked if that software also runs on our DCs, and when I said yes, he then told me that it is not using the machine SID to communicate.

After first I was a bit skeptical, but then I remembered that in the past, we had 2 machines in our system which were both active in the software system AND fulfilling a domain controller role. So Mark was probably right. The reason I thougth it did use the SIDs, was that they are displayed, and sometimes referred to in documents or procedures.

Mark’s talk was top notch.

Lunch

Mashed potatos with onion, Brussels sprouts, and pommes gratin with carrot and corn. It was good.

You may notice the absence of meat here. Quite unusual for me, and I haven’t turned vegetarian overnight. The meat was a good looking beef stew, but the description included mushrooms. I can eat regular plain mushrooms just fine. I like them. But if they used forest mushrooms (the weird looking ones) even in small amount, then that would be the end of tech-ed for me.

On the same note, I skipped desert, since all the cakes and muffins had red blotches, and I religiously stay away from red fruit, on the assumption that it may contain strawberry. The chances may be small, but strawberry could indeed cause a religious experience for me, or at least allow me to find out whether there is an afterlife or not.

For the same reason I skipped the sandwiches during the event party on Tuesday. I nearly picked up a cheese sandwich when I noticed they had slices of strawberry in between. I’ll never understand why on earth someone would put strawberry in a cheese sandwich, but it sure kept me on my toes.

DEV313: Architecture discovery and Validation with VS2010

This talk is hosted by Peter Provost.

The talk centered around the new architect tools in VS, and how they can be used by developers and architects to get an overview of large and complex applications, by creating hierarchies of namespaces and assemblies, and perform analysis on those various diagrams.

Related to this was the layering of code and classes, and how it could be used.

He also showed the UML modeling that can be done of existing code, to get a better understanding of what actual code is doing, and whether it is looking good (understandable) or not. The flip side of this was the ability to generate code from UML diagrams. What was also very interesting was being able to define validation diagrams which are checked against the code during compilation. This allows architects to detect violations of the various layer interfaces that were defined. The violations messages would take you to the violations themselves, so that you could easily see what the issue was, and you could fix it there and then.

This is something that is generally only useful for large projects, like for example the last project I did for a satellite test bench. With over 20 projects, a handful of developers and 50000 lines of code, it would have been very useful. Especially since we had to document everything with UML in detailed design documents. This would have saved me many months of work, both in documentation and design.

The first question of course was: does this support unmanaged C++. And the answer was no, it did not… yet.

This is apparently the number 1 asked question. Even people within Microsoft would really like to use this for the unmanaged codebases of the various projects which are unmanaged, and can be classified as ‘complex’, like Windows, Office, …

It will not happen in the VS2010 timeframe, but they are actively working on that feature. Judging by the effort required to make Intellisense run decently (not super, just ok) doing this for unmanaged C++ is a task of herculean proportions.

DEV410: Building high performance parallel software

This session is hosted by Steve Teixeira, who is generally a good guy despite having left the C++ team. The contender for this session slot was SIA313 about how attackers target the Windows stack, and how to protect against that. That seemed interesting too, but this is probably more practically useful to me.

Btw, as much as I would like, I am not going to hang around after his talk, because I will have to RUN (not walk) to hall 7-2C if I want to be in time to have a good seat for Mark Russinovich’s next talk CLI402 about the limits of Windows 7: another talk any self respecting geek just has to see if he or she is here this week.

I told Steve I’d drop by tomorrow morning at his other talk so that we could chat for a bit longer. He was glad he didn’t have to compete with Mark in the same session slot though J

Steve’s talk was basically a rollercoaster ride of demos with only a handful of slides, where he showed off the capabilities of the new concurrency analyzer tool (I forgot the actual name) for analyzing concurrency scenarios. I have to say it was pretty impressive.

After that part of the talk he also showed lock contention scenarios and how you recognize them. Btw, locks do not contend with Chuck Norris. For the rest of us it can be a real pain to deal with. The new analyzer even has runtime deadlock detection, which was sweet to see.

I didn’t write down much of the details, since these were demos and I was paying attention to those. This was a very nice talk and the new concurrency / parallelism features in VS2010 are definitely worth checking out.

CLI402: Pushing the limits of Windows

As I already mentioned, this is another talk by Mark Russinovich. The limits of windows are like the price of clothes in the ‘better’ boutiques: If you have to ask, you can’t afford it. But despite that fact it is really interesting to know the limits and know where they come from.

Steve’s talk ran slightly over time, so I hurried to get here. I didn’t quite run though. It was more like the speedwalk where you don’t trot and don’t quite shove people out of the way to get through. There is still 25 minutes to go and I have one of the last ‘really good’ seats where one has an un-obstructed view of the screen at about the right distance. There is a ton of people milling around and the front half of the room is packed; the back half is filling up as well. Really. They should have used the keynote hall for Mark’s talk.

10 minutes to go and the room is almost packed.

5 minutes and there is an announcement asking people to put up their hand if they are next to an empty seat. People are still queueing up, but too bad for them.

Mark held a captivating talk about the different types of memory (virtual, physical, …) the paged and non paged pool, processes, threads, object and handles. It was really an interesting talk. But the very best thing was when the talk ended, and I was able to walk out, been able to say to myself: I already knew –ALL– of that. That was a proud geek moment. J

I am not going to go into detail here because that would take too much time, and it would be incomplete as well. If you care about that, buy Windows System Internals, 5^th edition.

The 6^th edition is coming out somewhere in spring next year, and will cover ‘7’ and 2008R2. Still, 5^th edition is definitely not a waste of time to read, because Vista/2008 is what we will be running next year if all goes well, and it is always good to know the gory details, even if I’ll never use it as anything else but a reference for understanding what the system is doing or for troubleshooting.

Wrap-up day 4

Whew, day 4 is at an end. I have to admit that I feel the strain of having to pay attention all week. Despite that, it is sooo worth it.

I learned a lot of great stuff today, and this is really the only place in Europe where you can get it. It was the first time I saw Mark Russinovich speak, and it was definitely something worth repeating.

After his talk I went went shopping for some toys for my kids. I can proudly announce that I took the correct train, and found it at the first try (after asking for help). Next I’ll be finishing this report, catch up with my mail, and then pack my stuff so that I can check out early tomorrow. I’m already looking forward to tomorrow evening when I can finally sleep in my own bed again.

Tech-ed Berlin 2009: Day 3

vanDooren — Wed, 11 Nov 2009 20:29:00 GMT

Yesterday evening I started reading in Windows System Internals 5^th edition, and then read some fiction and went to bed early.

People sometimes say ‘Oh wow you can go to tech-ed, be sure to go to this place or that and do some sightseeing...’. Tech-ed ends at 19:00, by which time I am tired from having to pay attention all day. Then I have to eat something, go back to the hotel, finish my report, and shower. By then it is past 21:00, and all I want to do is just a bit of reading and then sleep long enough so that I can pay attention all day again, next day. Seriously: if you don't stay for the weekend, the amount of time you can spend being a tourist is limited if you want to make the event itself worthwhile.

Anyway, I had breakfast as usual. I am not going to repeat my breakfast report every day unless something changes ok? By now we all know that if the hotel has bacon, I eat it. It is as simple as that. Never change a winning team. Bacon, coffee, orange juice, and the day begins.

CLI306: How to deploy Windows 7 on a stick.

I had to choose between this and DEV208: Triple boost your application with ‘7’, .NET4.0 and Intel multicore. The reason I didn’t go to that one was that it specifically mentions ‘Intel’ multicore, which leads me to believe that the talk is done by an Intel rep, and thus only a glorified marketing blurb for intel CPUs. After all, for all practical intents and purposes, the CPU type means nothing for the software development. Make no mistake it can have a huge impact on performance, but that is no different between intel and amd.

In hindsight, choosing the deployment session was perhaps the bad decision. This session was mostly about using the deployment workbench. It was basically an hour long demo with narration. The deployment workbench looks like a great tool, and I’ll definitely play around with it at home to see how it works. It has some nice features, like being able to import drivers in your setup, as well as applications.

It has always been possible to import drivers in a windows setup, but it involved a lot of manual work, text file editing, the ritual slaughter of a goat, and about 30 tries before you got the last setting right. Been there, done that, have the goat carcass to prove it.

All in all this was not an uninteresting talk, but the title was misleading. When someone says: Deploying ‘7’ on a stick, I would expect it means that you deply ‘7’ ON the stick and then boot from it. Instead, they deployed ‘7’ FROM the stick. They made a bootable stick that then installed ‘7’ onto the machine that the stick was booted in. Too bad, because that is not nearly as interesting to me.

INT308: Deep Dive in Windows Workflow Foundation

This session is hosted by Nuno Godinho.

I watched it for 5 minutes, and then decided that it was not for me and left, and went to CLI322.

CLI322: Windows 7 Applocker

I’d rather have gone to the 2008R2 failover clustering session, but that was full so I decided to check out the applocker session. It is interesting enough to learn more about, and since my daughter is nearly at the age when she can start using a computer, it may come in handy. J

Basically, Applocker is a technology that allows you (the admin) to create blacklists or whitelists of applications that can be run on a computer. These policies can be configured to have permissions based on user name or user group, meaning that these policies are no longer specific to a machine, but to users as well, and this can be very powerful.

With the policies you can control the execution of exes, scripts, and dlls. Currently there is no good way to work with managed applications yet if they are not exe based (for example web apps running in the Java runtime.)

The rulesets can be created using wizards, manually, or via powershell. It looked pretty impressive. It is also possible to build a reference machine, and then scan that machine for everything that’s installed and generate rules base off of that to give you a configuration head start.

And as with other policies that were mentioned yesterday (for example in the Kerberos talk) it is possible to deploy these policies in an audit mode, enabling you to monitor the impact of these policies on your environment before you actually enable them, thus allowing for a smoother implementation.

Lunch

Lunch was a winner today as well. I had poached salmon, broccoli, carrots, and pasta. I didn’t go to any of the lunchtime sessions because nothing interesting was running, and you can really only attend them if you run to the lunch hall, shove people out of the way in the buffet line, and then ram the food down your throat while running back to the other side of the conference center where the sessions are held.

Instead I took the time to eat, and then ambled to the community lounge to sit in a sofa, read my email and write the previous part of my report.

OFS218: What’s new in Office2010 for Developers?

This session is hosted by John R. Durant

My alternative would have been ARC306: The architecture of predictive programming, but I have not idea what that would be about, so for all I know it would have been totally useless to me.

Otoh, the title of this topic mentions developers (which I am) and office 2010 (which I don’t know much about) so there is a good chance I’ll learn something useful here.

First of All I should mention John’s presentation style. The man is a born speaker. Have you ever watched one of Chris Rock’s HBO standup comedy specials? You can find them on youtube if you haven’t. John is a bit like that. Despite the fact that I am not really the intended audience for this talk, he manages to make it interesting enough that this hour and 15 minutes zooms past.

As to the topic at hand, it is really a bit out of my league. He basically demoes a lot of the new data interfacing options in office 2010, which implement online – offline presentation capabilities, as well as an underlying sync framework to cope with data changes.

This is all very exciting stuff for people who are involved with enterprise document management / generation. Especially when sharepoint is involved. I really see the benefits for those people, as it enables them to do a lot of nifty things for document generation and presentation that is invisible or at least unobtrusive to end users.

In my job, this is not something I am involved in at all. Still, it was very interesting to see what can be done with tomorrow’s office technology. Once there was a time when I could still keep in touch with the different office interop technologies just by making some simple samples. Nowadays, the world of office automation is a vast landscape of technologies and options that is very hard to navigate for those who are not involved with it on a daily basis.

DEV309: The Windows API Codepack

This session is hosted by Kate Gregory, and I had to attend it for several reasons. I’m a system software developer (cunningly disguised as a system administrator), so the Windows API is something I am interested in. It is about managed code development, which is something I do more and more. And Kate is a superb speaker so I had faith that one of the only ‘real’ developer talks this tech-ed would also be a good one.

There was a long break before this talk, but I decided to turn up early enough to get a good seat. It has been my impression so far that developers really get the short end of the stick this tech-ed, and any real development session is jumped by the developers in the audience like a limping gazelle by a pride of lions. And whaddaya know: it is 20 minutes before the start of the session and the room is already filling up nicely. Go Kate!

<snip>

It is now a minute or 2 before the start of the session, and the room is getting packed. And it is a big room. Take that, tech-ed event organizers! Tech – ed should be about development, NOT boring IT pro stuff.

Anyway, Kate held an interesting talk about developing for Windows 7 features, using managed code.

Instead of showing lots of code, Kate showed a selection of Windows 7 features that make the difference between ‘XP/2003’ era programming and ‘7’/2008R2 era programming (For the sake of not embarrassing ourselves, well just pretend Vista never happened. J) and then showed how easy it is to use those features in your application, through the use of the Windows API Codepack.

The first topic she handled was the taskbar, and how your app can do all sorts of interesting stuff with the application icon. Then she discussed the application thumbnails and restart / recovery behavior. And finally she covered some aspects of making your application powerstate-aware.

All in all it was a very interesting talk, filled with stuff you can use right now, with very little time, and a very big payoff.

I wish I could say more about it, but this session had lot's of cool demos, and it is rather difficult to explain why it was cool, and what she made those features do. Go to the codepack website and play with the codepack samples. You'll be pleasantly surprised.

CLI310: Is Virtualization a silver bullet for compatibility?

This talk is hosted by Jeremy Chapman, and some other guy I didn’t catch the name of.

This is where I have to admit that I attended this pretty interesting talk purely by accident, since in all my naivety I had just looked at the title and thought: Virtual Machines. As it turned out, it was about application compatibility, and What Windows does in order to make sure that older applications work with ‘7’.

Interestingly, one of the speakers mentioned that ‘Virtual’ is now the new ‘.NET’ (anyone remember Microsoft .NET Server?) or ‘Live’ brand that is slapped onto every new technology, because it is a marketing buzzword.

The talk started off very well, with the explanation that in ‘ye olden days’, backwards compatibility was king. This started changing after Bill Gates’s famous TWC memo, but Vista was really the first new OS where backwards compatibility was clubbed in the back of the head, and then beaten up in a back alley by ‘security’ and ‘stability’.

As a result, there was a lot of wailing, and the gnashing of teeth, because now there was a ton of applications who were no longer allowed to do the naughty things they were used to doing. UAC and running as a standard user were the biggest application compatibility hit ever in the history of Windows. Btw remember folks: every time you turn off UAC, Steve Ballmer kills a kitten.

The speakers then gave specific examples of the different ways in which apps would be causing problems.

After that, they proceeded to discuss the various ways in which Windows tries to fix it. The first thing they mentioned were the app compat shims, that can be used to trick an application into thinking everything was ok. One such example is configuring the shim to give a specific Windows version when the application asks for it, because the version check is implemented wrongly by the application. There are a number of shims shipped by default, but you can also create custom ones by yourself if you need to.

And there are things like folders that are now in a different location or have a different name. These are now created as junctions to those new folders.

App-V was briefly discussed as a way to separate applications from each other, but I missed the earlier talk about them so I cannot say much about that.

The most interesting thing I learned was some background on how the new XP mode works. It is basically a fully activated Windows XP virtual machine running in the background, which shows the UI of the applications its running in the ‘7’ desktop. They even mentioned that it has the ability to install USB drivers. I have to try this at home, because it would finally allow me to use that Canon digital camera with the wonky software without having to install and configure a separate VM for it. Of course it’ll still run in a VM, but in a way that it doesn’t bother me so much.

Of course it is still a local XP vm, and you have to make sure it is patched, maintained, etc. For home use that is not an issue, but for enterprise use it is a pain. For that, the have something called Med-V, which is basically the enterprise version of XP mode, which allows admins to centrally manage and maintain those virtual machines.

I ended up in this talk by accident, but it was very useful, and gave me a better understanding about the ways in which Windows deals with compatibility.

Day 3 wrap-up

Another day filled with learning. The food was great, the company was great, and so was the schnitzel I ate for diner this evening. It was so unbelievably good, and again very cheap. Only 12 euros for the diner + 1 pint of warsteiner.

Tomorrow, tech-ed finishes at 18:15, so today I took some time to get directions to the nearest toy store, so that I could buy something for my daughters.

Tech-ed Berlin 2009: Day 2

vanDooren — Tue, 10 Nov 2009 19:26:00 GMT

To answer the question that you all have been asking yourself, I can answer with a resounding YES. The hotel serves bacon at breakfast. And as a matter of fact, it is possibly the best bacon I’ve had in years. The correct thickness, and fried just to the point between bending and breaking. It was kept in a bowl, resting on whitebread to absorb the excessive fat so it didn’t slide off my plate either.

They had a variety of bread, cereal, fruit and vegetables, different types of egg, salmon and a couple of terrines, yoghurt, fruit juices, etc. They even had over a dozen types of tea leaves. The only thing that disappointed was the coffee. Overall, the breakfast was superb.

I also have to say that this is by far the cleanest hotel room I can remember in a long time. The tiling in the bathroom is immaculate, as is the grouting. I could not find a single spot that was less than absolutely clean, so a big kudos to the KuDamm101 hotel.

My trip to the conference center was flawless this time, and I arrived in time to get a cup of coffee and read my email. The coffee is good btw. It is not the black bliss that was poured in Barcelona, but definitely above average.

I forgot to mention yesterday, but during the keynote speech it was proven yet again that computer geeks as a crowd are depressingly easy to please: all you have to do to make the crowd go wild is to throw a box of free t-shirts in the audience. Even bricks of 100 dollar bills would probably not have the same effect.

CLI302: How Windows storage is changing everything

This session is hosted by Mark Minosi. I saw him speak yesterday and so I knew he was a great speaker. I chose this talk because it ties in with VHD, which was mentioned yesterday in his ‘7’ talk and it seems interesting. The contenders for this session slot were VS tips and tricks, and parallel programming for managed developers.

Luckily, Steve’s talk on parallel programming is repeated on Friday. And the VS tips and trick is probably interesting, but not something I can’t easily figure out myself by looking at the slides afterwards.

The talk on VHS was interesting. VHD is technology for Virtual Hard Disks. And since the technology is cool, it is also used by the Windows Backup utilities to backup your files to virtual disk files.

VHDs are like the virtual disks we have all been using for a long time, via VirtualPC, VMWare or whichever virtual technology you happen to use. The difference is that you can mount them in Windows, assign them a drive letter, and use them natively like any other disk.

What you can also do is install Windows in one of these virtual disks, and then configure the boot manager to boot from that virtual disk. This is a cool thing to do.

Now of course, you might wonder what the difference is between this and just using VirtualPC. The answer is: not a lot. For plain yoghurt desktop use, I don’t think this is worth the bother. And annoyingly, you cannot run XP or Vista this way. Only ‘7’ and 2008R2.

The biggest difference would be that the booted OS runs bare metal. It is the sole OS, and gets access to all the hardware and resources, whereas a VM typically only has 1 or 2 CPUs, has to share memory with the host OS, and performs disk IO at a much slower rate. Additionally, direct access to other disks in the machine is not possible with VM clients.

So that might be an interesting option if you need to run different OSes in a multi boot environment without wanting to dedicate individual partitions to each one.

SRV203: Windows Server 2008R2 Overview

This session is hosted by Joey Snow. It is a high level overview of the new features of 2008R2 that make it worthwhile.

The first thing that was mentioned was that the virtualization and hyper-V technology for R2 got improved significantly. Items mentioned were live migration to other hardware (this was impressive to the developer in me), and the usage of new CPU technology to improve performance.

Remote Desktop got overhauled to support cool new things like remote application support and improved performance for media, making it possible to view e.g. an MPEG file on a remote server.

What was also nice was the system management software that includes a best practices analyzer that can scan your network, and then tell you if your DC, DNS, etc infrastructure follows the industry best practices (which are kept as XML config files so they are configurable), what the impact is if you don’t, and how you can resolve that.

The backup tool in R2 is finally becoming usable too. Microsoft finally got to see that we want to back up individual files and folders, and that we want to back them up to a logical volume instead of a dedicated physical disk.

Then there was also Direct Access, which allows for direct VPN connection to the corporate network, using IPv6 and IPSec. At the same time, you can still browse the internet without going through the corporate network.

App locker is a way to control which apps your users can run, via group policy and digital certificates, using blacklists or whitelists. And BranchCache enables people in branch offices to download files from the corporate network and caching them locally in a way that is invisible to the end users, thus relieving the server and network infrastructure.

And one of the things that I personally liked very much is the ability of Powershell to be executed remotely, just by adding 1 line to the top of the script. This allows me to write scripts that can be executed remotely on a server for doing administrative tasks without having to log on to the machine itself. By the way, Joey showed an Integrated Script Editor. It is not quite Visual Studio yet, but it looks very usable, with many nifty features and even features like breakpoints and stepping.

DEV203-demo: MFC stuff.

This was a lunch time session. I quickly ate my lunch and then got to the session. The food was great btw. The pork was perfectly cooked, and soft as butter. The baked potatoes and carrots were very good as well.

I did not attend this MFC session because it was about MFC. I hate MFC. MFC is the spawn of the devil. When God inspired Bjarne Stroustroup to start C++, he had templates in mind. Unfortunately, the devil got wind of this initiative, and caused delays in the formation of the C++ standard. So instead of using templates as God intended it to be, the MFC team decided not to use them and started on the object hierarchy road, paved wit good intentions, that lead to the current mess. ATL and WTL still followed God’s big plan, but it was too little, too late. MFC had a big head start, and is now here to stay, like original sin.

But I digress.

I attended this session because I assumed that because of the dearth of developer sessions, it would be a watering hole for C++ developers. And I was right. Kate Gregory was also there, and I talked to her for an hour or so. Kate has a talk tomorrow which I will attend. It was good talking to her. She is a C++ expert, as well as a nice person.

I did not hear anything from the MFC demo, so my C++ soul is still safe.

SVR315: IPv6 for the reluctant

Another talk by Mark Minosi. I wanted to attend this one because I don’t know too much about IPv6 yet, and since it is part of ‘7’ and 2008, and probably the way of the future, I felt this is an excellent opportunity to learn more about it.

Unfortunately, the session room was full and I was not able to attend this session so I chose the SVR205: introduction to Hyper-V and Windows2008R2

SVR205: introduction to Hyper-V and Windows2008R2

This session was hosted by Edwin Yuen and Jeff Woolsey.

The session was OK. It showed many features of Hyper-V, and I have to say I was impressed. For my environment, the difference between this and VMWare Server is negligible. Currently we run VMWare Server 2.0, but if I ever have the opportunity to switch, I’ll switch to Hyper-V R2. The management utilities are impressive, as is the live migration. What is even more impressive is that you can migrate to servers with a different CPU architecture without downtime.

Hyper-V accomplishes this by normalizing the set of instructions that the VM has access to. This made it possible to migrate a running VM from a P4 to a CoreDuo to a Core2Duo to a Core I7 nehalem without going down. And of course, everything is done via a powershell interface, making it possible to script everything you could want to do with your virtual infrastructure.

There was a lot of infrastructure management provided out of the box, and most of it is 100% FREE. I am not an expert in virtualization by any measure, but I think that this is seriously going to eat into VMWare’s revenue.

SVR302: Windows Crash Dump Analysis

This session is hosted by Daniel Pearson. My alternative choice would have been DAT206: SQL Server 2008 Power Hour. I didn’t really know which one to choose, but since this is in one of the smaller rooms and I was there, I just went ahead and chose this one. It is also more advanced than a SQL Server demo, and possibly I’ll learn some neat tricks here. The room is filling up quickly, and this session room will probably be full to capacity before the talk starts.

Basically, Daniel uses the ‘Not My Fault’ application to load the ‘myfault’ driver in order to cause a specific driver error, such as a buffer overrun, pagefault at dispatch level, or other bug. Then he demonstrates how to figure out the cause of the problem, using windbg.

He also used driver verifier to demonstrate how you can inspect suspect device drivers by performing more stringent checking and analysis at runtime. This has to be enabled explicitly, because it can cause a significant runtime overhead.

All in all it was an interesting session, but not as advanced as I would have expected really.

SIA401: Cracking Open Kerberos

And yet another talk by Mark Minosi.

I’ve always wanted to know more about Kerberos, and this is an excellent time to learn. It is a 400 level session so quite advanced, but I hope I know enough to be able to understand what he is talking about. Mark is a great speaker so that helps too.

Mark explained the process involved in authenticating a user on the domain, by following the Kerberos tickets. The explanation was really good and made sense. After a discussion on what Kerberos does and how it does it, he then explained the difference with NTLM (the old Windows authentication protocol), and why you should take steps to disable it where and when possible. He mentioned that around 5 to 10% of all authentication is still done via NTLM, even in a modern Windows domain.

There are several reasons for this, and they have a severe impact on functionality and security, causing weird problems (like admins not being able to join a computer to a domain) and possible attack vectors due to the weak NTLM encryption.

Mark then proceeded to explain about the new group policies in R2, enabling administrators to audit and block NTLM requests completely.

After that he explained about token bloat, service identity and authentication, and some of the edge problems that may cause Kerberos to stop functioning.

All in all this was a very good talk, and Mark’s gift for connecting with the audience made this session appear much simpler than it actually was. I had a math teach like that once in high school. The difficulty of a topic lies not just with the topic, but also with the ability of the teacher to explain. And Mark certainly has a gift for speaking.

Day 2 wrap-up

I saw a lot of great tech stuff today. On one hand I feel that it is a shame that there are not more developer sessions. I used to be able to choose between 10 developer sessions every hour, and now there are only a handful. The split is probably 60% IT 40 % dev. As Kate said to me: you don’t know you live in a golden age until it is over. The 1 week event type was chosen for economic reasons, so it will probably be so for the next couple of years.

On the other hand I now get to see some interesting sessions that I would normally not have attended, or which would not have been scheduled for the developer week. Since I wear both the developer and sysadmin hat, this 1 week setup has its advantages too.

There was a ‘party’ tonight in the exhibition hall, so I ate some of the food and drank a beer, bought a copy of Windows System Internals, 5^th edition and went back to the hotel. I have the 4^th edition of this book, and it was written at the time of XP and 2003. The 5^th edition covers the Vista kernel and the 2008 kernel. ‘7’ and 2008R2 are not covered (they are too new) but they are based off the same kernel as Vista / 2008, so that doesn’t really matter that much despite the fact that some of the cool new features are not yet covered.

Still, any self respecting geek involved with Windows should read these books, even though they have as much pages as a Robert Jordan novel. Whether it is system administration or software development: if you really want to –know- what you are doing, then you have to have a good understanding of the fundamentals. This book is by far the best such resource that is not covered under NDA.

Tech-ed Berlin 2009: Day 1

vanDooren — Mon, 09 Nov 2009 19:39:00 GMT

After a boring cab drive to the airport, I had an even more boring flight to Berlin. And that is exactly how I want all my flights to be. I don’t want it to be the thrilling and exciting near-death experience I had once, flying to Nice.

I arrived in Berlin safe and sound, and took a cab to the hotel. Sadly, the hotel is not near the conference center, on account of there not being any hotels nearby. The hotel is 2 short train rides away. It’s really easy to find. And of course, to those that know me it will come as no surprise that it took several tries for me to arrive at he correct location.

What sucks most is that a) my flight got rescheduled sometime ago (leaving 1 hour later than expected), delayed for half an hour, and the event agenda got re-shuffled since I booked. As a result, I missed 2 sessions. Because for some silly reason, someone decided that the keynote should be at the end of the day instead of the beginning.

Had I known this in advance, I’d have left for Berlin yesterday. I didn’t because I wanted an extra day with my wife and kids. Ironic, since they weren’t at home yesterday due to unforeseen circumstances. Next time I’ll just leave on Sunday, taking some extra time to travel.

Whatever. I am typing this while the keynote speech is starting. It’ll probably be an hour and a half filled with mind numbing explanations of why Microsoft technology is the greatest on earth.

I have to say I preferred Barcelona as the venue for tech-ed, for a number of reasons:

1) Walking down the street in November. Berlin: 5 degrees Celsius and rain. Barcelona: 20 degrees Celsius and cloudless skies.

2) Crossing the street from the hotel and being at the event in less than 2 minutes.

3) The venue itself. The messe is a complex of industrial looking buildings, with concrete, asphalt, etc, rather than the aesthetically pleasant looking ICC in Barcelona.

4) additionally, the idea of having 1 big event for developers and IT professionals is less than stellar. Because now, there are only half as much developer sessions as there used to be in Barcelona. Only 1 real C++ session, no large selection of .NET and C# and SQL Server sessions...

Still, I’ve had my first coffee of the day and I am starting to get a feel for the place. Tech-ed is still a good place to be. And if my knowledge of German cuisine is still accurate, the food will be good, plenty, and NOT drowned in olive oil.

CLI324: Windows ‘Lucky’ 7

This session was hosted by Mark Minasi

It was a good session, and basically enumerated the features of 7 that are either new, or changed from Vista or XP.

Mark is a great speaker, and managed to make the time fly while discussing the topics. It was not in depth so I am not going to repeat too much of it here. The things that got me interested most are the ability to image disks into files, like VMWare virtual disks. These disks can be shared, backed up and mounted. Very exiting stuff that would make my life easier, if we ever get to the point where we will actually use 7.

Other cool features are the ability to deploy to USB media, which would presumably allow me to boot from USB disk, as well as the ability to easily perform preconfigured installs.

When talking about Vista and how 7 compares to it, Mark mentioned that one Microsoft developer said ‘We are going to throw Vista under the bus’, comparing it with Windows Miserable Edition. Interestingly, In terms of raw speed, 7 is really not that much better. But when it comes to perceived speed, 7 is the clear winner due to being more responsive, and getting less in the way of what the user wants to do.

The talk was great, and the speaker connected well with the audience.

Sadly, this was the only technical session I will see today. As luck would have it, there is only 1 C++ talk this tech-ed, and I missed it. At least they could have scheduled some boring IT talks in the first 2 sessions but alas.

The actual keynote

The keynote itself so far has the hallmarks or every other keynote I’ve seen so far. A couple of tech delegates got singled out for public humiliation while a couple of IT bigwigs (presumably million dollar customers) sat on stage explaining how good their infrastructure is and how Microsoft helped them to enable it.

Bla bla bla snore.

I don’t want to sound jaded here, or un-appreciative of the fact that my company is letting me attend this event (I am really grateful), but keynote speeches tend to be hype and blubber, void of tech content and generally a waste of time. What was even worse about this keynote is that they didn’t show off anything related to Visual Studio 10. Instead, they demoed Server 2008 Hypervisor and Exchange 2010.

That said, it is interesting to a developer like me that with the newest release of 2008R2 and the System Management Center software, detailed knowledge and understanding of the low level OS guts are no longer absolutely necessary. Between the 2 of them, those applications let admins manage their infrastructure with only a modicum of nitty gritty knowledge. The software goes out of its way to be user friendly.

That is not a bad thing. It just feels weird that you can administer a complex system without having to troll through log files, understand dcom security configuration, and other arcane things.

At least tomorrow I’ll be able to dive deep in technical content, and hopefully start my day with bacon and coffee. At least 2 plates of the former and 2 big cups of the latter.

Wrap-up day 1

The travel was good, the weather not so much.

The windows 7 presentation was good, the keynote not so much.

I had a very good pizza in an Italian restaurant, for only 7 euros. Dirt cheap.

I am now making a schedule of which sessions I want to see, and when to see them. Some of the sessions I’d like to see are scheduled in the same slot, but some of them get repeated throughout the week so I can probably schedule my attendance so that I can see most of the people I want to see.

Tech-ed Barcelona 2007: Afterthougths

vanDooren — Mon, 12 Nov 2007 11:39:00 GMT

I learned a lot of new things, and all in all it was worth it to be here. I have to say that the added value was less than last year.

Last year was my first tech-ed, and I had not yet heard about WxF, LINQ or any of the new stuff in C#3.0. So basically everything was new at that time.

This time I focused on Vista, and performance and native development.

I admit that I have changed my mind about Vista. Before I tech-ed I was convinced that Vista sucked. I have tried it at home, but I had the usual problem of missing drivers, failing applications and a gazillion UAC prompts.

Note: I knew that the Vista kernel had a number of significant changes, all for the better, and I admire the new driver frameworks that ship in Vista. The suckiness I refer to is about the shell / user experience.

What also contributed to the problem was the fact that I chose to run the 64 bit version of Vista, causing me some compatibility problems on recent hardware purchases. Something as stupid as the Logitech webcam which had Vista64 drivers would not work no matter what I tried.

I still think Microsoft dropped the ball on making sure that vendors provided drivers for Vista64. It is not up to them to write drivers. Perhaps they should have spent more time on 64 bit evangelism, or made 64 bit mandatory to get the windows logo earlier than they did, or maybe used an incentive.

But security wise, I see the point now. It is a simple fact (and I admit I am guilty as well) that a lot of software was written without following the Microsoft best practices like not writing to files in ‘program files’ and not writing to global registry settings.

With XP they said ‘you shouldn’t…’, but with Vista the message is ‘You shall not…’

They took the advantage of the switch to 64 bit to throw a lot of crap out of the system, which is perfectly fine since you had to change / rebuild your code anyway for native 64 bit. A lot of stuff in the win32 API was designed in a time when security was a lot easier and the TCP/IP stack was optional. A major overhaul was warranted.

I applaud Microsoft – even though I cursed at the breaking changes – for following through and also banning practices that were not tied to the technology itself. It breaks a lot of stuff, and it has definitely hurt the uptake of Vista but I think in time, Vista will be able to put a serious damper on the proliferation of both malware and badly written applications.

It is also becoming more obvious that there is a renewed focus on C++.

There were 8,5 sessions on C++ and native code development, which is more than double of last year. The sessions were all packed with several hundreds of people in most sessions, and the knowledge level of the audience was pretty high.

As I said before: I think that the .NET hype has died and people are getting a more realistic message again. .NET and C#, F# and VB are playing an important role, and are the best solution for a lot of scenarios. But there is still an important role to play for C++ and native development.

And now something completely different.

I went to the MVP booth to pick up my keychain, and while I was standing there I started talking with a university student from an Eastern European country. She was here on a Microsoft invite, along with a group of other people from the same country.

She would not have been able to attend otherwise, since the entrance fee is shockingly high compared to the average income of the people in that country. Given that I found it very expensive as well, I can see her point.

She told me that it was hard to get a Visa to leave the country because she was a girl. Apparently, the thinking in her country is that girls try to get married to the first guy they meet in the airport so that they can stay there. When she goes back she has to go to the embassy in her country to prove that she has really returned from Barcelona.

In this day and age it is easy to think that people are free to do what they want and all borders are open, but situations like this still exist even more than 15 years after the fall of the Wall in Berlin and the Iron curtain.

But she also impressed me with her hope and enthusiasm. She and her fellow students are working very hard to modernize their schools and country, and if there are more people like her, there is no doubt in my mind that it will happen. Those people have a dream, and the determination to work for it.

Tech-ed Barcelona 2007: day 5

vanDooren — Mon, 12 Nov 2007 09:51:00 GMT

Yesterday evening the C++ guys (and lady) got together for an informal dinner. We met in the Hilton lounge and then took a heavily graffiti’d metro into the city center. The place we went to was Cal Pinxo. It was a very good restaurant, and the only slight problem was that the staff spoke very poor English.

The food was good, and the company was great. Steve Teixeira, Ale contenti and his wife, Kate Gregory; Jochen Kalmbach; Eric Mittelette; Eric Vernie; Gilles Guimard, Raffaele Rialdi and a couple of French and Italian guys whose names I can’t remember.

The evening zoomed past. We even managed to speak about other topics than C++ for at least part of the time. Of course one great thing about this group of people is that C++ could be the topic of casual conversation as well J

I skipped the first session this morning. There was nothing really interesting on the program, and I decided to pack my luggage and check out a bit later. This is similar to last year. I suspect that they put all the good stuff on the first couple of days, and kept all the less spectacular stuff for Friday because a lot of people are leaving throughout the day.

I arrived at 10 AM in the exposition hall and had a long chat with Steve Teixeira and a C# MVP whose name I can’t remember.

TLA405: Parallel and Asynchronous functions programming on .NET with F#

This session is hosted by Don Syme.

It was about the new F# language that ‘escaped’ from the Microsoft research labs. F# is a .Net language like C# with strict typing, but it is a lot easier to use in a functional way. It uses type inference to ensure strict typing, and supports anonymous functions and classes.

The main keyword in F# is let.

For example:

let data = (1,2,3)

data is a class with 3 int data members which are initialized to 1, 2 and 3.

Everything is still statically typed, but everything is inferred from its context so it is very easy for non programmers to pick up. In C# you have to know about delegates, asynchronous callbacks, … in order to do something usefull. F# is targeted mostly towards domain experts and math usage at this point.

There were some more demos, and real world uses of F#. One of them was the way in which the ad-targeting software of live search works.

Ad targeting depends on a lot of variables, like IP address and search query history.

The algorithms for training the targeting software was done through data analysis using F#, where 6 TB of data was crunched on a single machine in 2 weeks time, which is equivalent to 1 trainings record per ~150 us.

There are plans to add F# to the list of languages in Visual Studio with the next release of VS after VS 2008.

F# looks interesting, and if you are a domain expert it is something that will allow you to create high performance algorithms without having to be an experienced software developer.

SEC303: New cryptography: algorithms, APIs and architecture

This session was delivered by Rafal Lukawiecki.

The topic was the new suite of crypto algorithms in Vista, and what you can do with them.

This session was basically a more thorough highlight of the same content that was also shown in his first talk on day one (of which I have already written a report).

Microsoft is serious about security, and wants you to have the correct tools to generate secure applications. Vista uses those same algorithms internally, and nobody within Microsoft is allowed to use other algorithms without approval from the security committee.

If your application handles sensitive data in any way, consider upgrading to those new algorithms because 3DES and MD5 have been proven to be vulnerable to attack.

I did not sit this session out till the very end because I wanted to avoid the rush at the luggage storage.

Afterthoughts

It is over. I am not going to write up my afterthoughts on the plane. Instead I will sit back, read a good back (Wintersmith, by Terry Prattchet), have something to eat and ‘enjoy’ the flight home.

The afterthoughts will have to wait until Monday. I promised the weekend to be for my wife and kids.

Tech-Ed Barcelona 2007: Day 4

vanDooren — Fri, 09 Nov 2007 11:16:00 GMT

Yesterday evening I went to the local shopping mall to buy a present for my daughters. I had promised it, and I have to make sure that I am not going to be ‘bad daddy’ for leaving them alone for a week J

I have to admit that the conference is starting to weigh on me. As fun and valuable it is to be here, it is hard work.

TLA03-IS: Exploring the upcoming C++ standard C++0x and TR1

This session is hosted by Kate Gregory and Ale Contenti.

It is an open discussion where they will give a short overview of the upcoming release of TR1 and the more distant release of C++0x.

Originally, the name C++0x was used to indicate that it would be formalized sometime before 2010, but Steve Teixeira already indicated that x would be hex as well, in which case the name is still correct even if the standard gets approved in 2015.

Currently there are no plans to release TR1 for VC2005, even though it would work with current technology. C++ 10 will already include some C++0x features that are easy and don’t change anymore, and C++11 will then probably include the rest.

Concepts are a welcome new addition to template programming. They have the same goal as constraints in the .Net generic types: to insure that template arguments implement certain methods / operators. The syntax uses ‘concept’ and ‘requires’. The big difference with constraints however, is that everything is checked at compile time instead of runtime. So template code execution is just as blazing fast as before, but now there will be easy to understand compile time errors instead of the 50 line type name errors that all of us have learned to love.

The C++ language itself will get the notion of concurrency and threading primitives to declaratively insure atomicity of memory access.

Template syntax will be extended with the … syntax that allows for variable number of template parameters. This is great for scenarios where the number can change depending on how you use it. I actually know a way to use this in my current code, but I am not getting into it here because a) that would take me too much time and b) only experienced C++ programmers (like, all 3 who read this article, one of which is myself J) would understand and care.

Rvalue references are another addition. They are a bit like const references, but allowing you to change the parameter which could be a temporary value. Basically, with revalue references your function indicates that you don’t do anything usefull with the original value after the function was executed. This allows you to implement move semantics with compiler verification of what you are doing.

A great addition is that the ‘auto’ keyword finally gets a good use. It will do the same thing as the ‘var’ keyword in C#.

For example, if you have a variable like this
std::map<std::string, std::wstring> myVar;
and you want to have a local iterator, you can now declare it like this:
auto iter = myVar.begin();
instead of doing this:
std::map<std::string, std::wstring>::iterator iter = myVar.begin()

these are the little things that can save you a lot of time.

Decltype is a keyword that returns –at compile time- the return type of an operation. This seems silly, but you can use it to use templatize the return type of a function based on what it does.

For example, the result of short + short is another short, but for short + float it is float. Or even for short += short it will be int.

These things are notoriously hard to do with current template technology.

And then something I have wanted for a long time: lambda functions, aka anonymous functions. A lot of algorithms in the STL require you to define the beginning and the end of a data range, as well as pass in a function pointer for defining what the algorithm has to do precisely. A good example of this is the std::for_each() construct.

Currently you have to create a separate function for e.g. doing something like this:

void DoStuff(int i)
{
cout << i << endl;
}
void foo(void)
{
Std::vector<int> v;
v.push_back(0);
v.push_back(1);
v.push_back(2);
std::for_each(v.begin(), v.end(), DoStuff)
}

Now, the syntax for lambdas is not yet finalized so it might change, but it would be something like this:
void foo(void)
{
Std::vector<int> v;
v.push_back(0);
v.push_back(1);
v.push_back(2);
std::for_each(v.begin(), v.end(), <>( int i, cout << i << endl));
}

It might seem unimpressive, but when you consider that you’d have dozens or more of these DoStuff functions in your project, it becomes a really nice feature to just not having to care about declaring and implementing these 1 or 2 line functions.

Finally, if you want to know more about TR1 and C++0x, this is the place to be:

http://www.open-std.org/jtc1/sc22/wg21/

this is the site where the C++0x committee reports and proposals are published.

TLA409: Empowering developers: x86 and x64 Performance considerations when using Visual Studio 2008

This session was hosted by Robin Maffeo.

It started off with the same boring stuff that was in the previous AMD session (hardware changes and pictures of dies.

And then it got more boring.

I had expected to attend a session about things you have to watch out for when coding for x64, and I had expected it to be an advanced session (given that it was level 400). You know, I expect to learn something despite being an experienced programmer.

Instead, there were some general explanations of the different .NET garbage collectors and threading stuff. Like: use locks to solve concurrency, and lock as little as possible… DUH. This is a level 400 session. If you didn’t know that in advance you had no business coming to this session. Even for a level 300 session this would have been basic stuff.

The fact that a lot of people left the session halfway through proves that I was not the only one who thought this.

Then there was a short list (no demo) of the same C++ compiler things that were mentioned in the previous session.

At least this session gave me enough time to write up my report of the 9 AM C++ talk.

And Mr. Mafeo: if you insist on making fun of the competition with the claim that your CPU is a ‘real’ quad core while ‘the other one’ is only 2 dual cores glued together, you should also mention that said ‘pretend quad core’ has been handing your ‘real quad core’ its virtual ass on a plate for a long time, performance wise.

Nuff said.

INF308: Top 10 mistakes developers make

This session is hosted by David Aiken.

Originally I was going to Win312: Vista for managed developers: Besides .NET3.x but when I read the description, I discovered that the topics were the same that Kate had already covered in her talk about C++/CLI and Vista : a natural fit.

And in that talk I learned that the features covered in WIN312 are much more easily accessed from C++/CLI so I decided to skip it.

Use the right tool for the job. If I have to remove a splinter, I’d rather use a razor sharp scalpel than a spoon. Just because the spoon is safer does not mean that it is a better tool. Conversely, I would not eat soup with a scalpel. And – speaking as a moderator of the straightrazorplace forum – I can state with some confidence that my razors are sharp.

The idea about this session is that there are 10 things to do which are very easy, to make the life of an ITPro more bearable.

Why do we care about ITPros.?

Well, we don’t, but they are our biggest customer, and if they complain we have to stop our interesting work and fix their boring problem before we can back to our real work.

Install.

I don’t care if it works on your machine, we’re not shipping your machine. So mistake 1: Ad hoc configuration or making installation changes manually.Make a script so that everything is repeatable.
Mistake 2: Don’t make assumptions about security. File io, firewall settings, creating perf counters. Run and test applications with standard user rights.
Mistake 3: XCOPY install. XCOPY deploument really means XCOPY and then add registry entries, enable file permissions, create databases, create user accounts, open firewall settings, ..
Mistake4: Uninstall = Format c:\ always create and test an uninstaller.
Mistake 5: It is not good if an upgrade means a reinstall or worse. Create patch installers.
Mistake 6: your patch breaks everything else. Make sure you unittest your changes so that your patch has no side effects.
Mistake 7: your app comes without admin tools. Do provide admin tools. Instrument your app with WMI because ITPros can use that to configure the worls and its dog across a network already, and you get all the power for free. Also if your app needs to be configured, provide a powershell commandlet that does all these things. They can be used from MMC so you get that for fre as well.

Health.

Mistake 8: Your app is dead and nobody knows why. Create a health model for your app that provides useful information to the outside world. The upcoming health model will make this a lot easier to do.
Mistake 9: Provide a way for admins to test if your app works OK and use synthetic transactions. This means have a way to tag an operation as a test but let it be handled normally. The other end then knows that it was a test and can ignore it.
Mistake 10: Test your app in multiple scenarios. Apparently the feedback system at a previous PDC sucked so bad it had to be rewritten overnight. If more than a couple people used it at the same time it literally crashed the network.

This session was very interesting session. Even though my software will never run in ITPro environments, the points remain valid.

TLA407: Dealing with Concurrency and Multi-Core CPUs with today’s development technologies

This session is hosted by Joe Duffy.

The talk is about the different performance and responsiveness issues with parallel programming.

The first half of the talk was about showing what it means to use threads or a thread pool or a background worker.

Despite the fact that it was a good talk I found it all very basic, but I have been writing multithreaded apps since a long time. This was new stuff for a lot of people, and there are still lots of misconceptions about threading and CPUs.

For example, one person asked the following question: ‘If I have a 64 bit quad core system, can it run 8 32 bit threads at the same time’.

No question is stupid and it is not an unreasonable question to ask if you are a novice, but it shows that if you are experienced at parallel programming, you should know that a lot of people don’t.

There was a good demo in C# to show some parallel task for calculating a Fibonacci sequence.

The second half of the talk was about locking, and what you should do if you use locking. Monitor and lock were explained, as was the new ReaderWriterLockSlim. Kernel objects were mentioned as being less efficient, but useful for interop.

Other mechanisms mentioned were Monitor. Wait, Pulse, PulseAll and EventWaitHandle.

There was also mention of memory reordering (which the CLR prevents), the fact that native pointer sized reads and writes are always atomic if they are properly aligned.

I probably should have attended the session on new features in PowerShell 2.0, but that was a level 200 session and I should be able to flip through the powerpoint slides and get the gist of it.

INF307: Windows Server 2008 for developers: transactional NTFS

This session is hosted by Jason Olson.

The other sessions do not look that appealing to me, and I know nothing about transactional NTFS, so there is a good chance I’ll learn something new.

Jason is a great guy and he is currently doing evangelism for Windows Server 2008. He also has a development background and once Windows Server 2008 is kicked out of the door into the cold hard world of IT, he will be doing stuff in the parallel programming experience for .NET.

The meat of the session is: What is TNTFS (or TxF as it is called), Whys should I use it, and How do I do that.

If an NTFS transaction is started, you can create files via that transaction, and they will remain invisible to the entire system until they are committed. A rollback instead would remove those files and the system would never know that they even existed.

This session was all code and demo and no powerpoint. It was very interesting, but I could not take much notes and pay attention at the same time.

What was very interesting is that most of the code was in C++/CLI, and for a very god reason. All of the transaction stuff is in COM, and only after you set up the COM stuff can you do transaction File IO.

These things are pretty ugly if you have to do them in C# or VB.NET, so C++/CLI is a natural fit in this situation where you can do everything like He intended use to.

Not all hpe is lost for the managed programmers though. There are community projects underway to provide managed wrappers for the new Vista functionality. One of these projects is ‘Vista Bridge’ which bridges the new Vista APIs to the managed worlds.

Btw, Vista and Windows 2008 server are sharing the same code base so these wrappers will work on both.

There still a couple of teething problems with transactional NTFS for Vista but these should be solved in Vista SP1 or Windows 2008 server.

Also interesting to note is that more than half of the people in the audience were C++ programmers. (I’d say 60% or so).

Afterthoughts

You can hardly call me unbiased, but I think C++ has a great future ahead of itself. A Lot of work is going on to make C++ easier to learn, and easier to use productively (like adding regex, shared_ptr and notions of concurrency.

It will take several more years before we are there, but the most important thing is that all of this is happening.

I also managed to pick up a couple more free t-shirts, one of which simply says ‘geek’ in white on black. To get it I had to prove at the learning booth that I am an MCP (Microsoft Certified Profesional).

However, I have long lost my MCP card, and the web app that would check my MCP status based on my hotmail address crashed halfway through.

The lovely looking hostess then called a nice guy who decided to use the ‘Challenge based approach’ to verify my status. I had to list my certs, he chose one and then asked me : ‘Ok so what was on the exam’.

‘Uhhh’ since that was several years ago I had to think for a second (Windows 2000 Professional) and then was able to fire off enough exam content to convince him.

Tech-Ed barcelona 2007: day 3

vanDooren — Thu, 08 Nov 2007 10:40:00 GMT

My night has been less than ideal. The hotel maintenance crew did some work on the airco system in the hallway yesterday, and they did not adjust the flow valves correctly. So every time the aico kicked in, there was the awful sound of refrigerant cavitation.

I first called at 20:30 to the reception, asking if they could send someone to fix it. They were going to do that.

Of course, when the airco in the hallway turned itself off, the noise was gone and I forgot about it until 22:30.

I called again and told them I wanted to go to sleep, so they should do something quickly. They were going to do that again.

At 23:00 I had still seen nobody, and I was getting pissed off because I was really tired and I couldn’t go to sleep.

I called the reception again, and the clerk told me that they had called the maintenance guys, but noone had responded yet.

He then had the brilliant suggestion to leave a note at the reception for the maintenance crew the next day. Again I told him that that wasn’t going to do me any good, and he should do something NOW (I wasn’t shouting. Just). He must have gotten my point because promised to have someone check it out in 2 minutes.

It took 6 (I already was tying my shoelaces for going to the reception in person) but then a friendly non english speaking maintenance guy appeared. He looked at the airco grating, said ‘ah, si’ and left my room.

He returned with a ladder, and opened up the ceiling of the bathroom. Apparently the piping for the main airco runs through my ceiling. He closed a couple of valves, and if by magic: ‘ . . . ‘ blessed silence.

By then it was already 23:30 and so my night was a bit short. But with enough coffee and bacon this morning, I was good to go.

TLA313: Microsoft Visual C++ and windows Vista: a natural fit

This was another great session hosted by Kate Gregory.

When it comes to talking with the OS, C++ is the most versatile language because it has native support for all of the following:

C style functions exported from a DLL, using structs and callback functions
Consume COM, with or without a typelib or primary interop assembly.
Implement a COM interface (so that you can be consumed by the system).
Register for callback notifications on system events.
Call managed methods or use delegates.

This is important, because Vista comes with a wealth of APIs. Some of them are real .NET APIs, and some of the are downright .NET hostile.

Trivial: .NET direct	WCF, WPF, WF, … all of these are .NET APIs that have no native equivalent. Which doesn’t matter with C++/CLI
	Callable wrappers. These are native APIs with a .NET wrapper.
	PInvoke signatures
	Raw win32 APIs like for power management and vista wizards
	COM, like the search and organize APIs
.NET hostile	Common file dialog, network awareness API.

Anything above the line is more or less easy to use. Anything below the line is either hard, or an exercise in S&M.

Kate then had some nice demos that demonstrated that some things are equally hard / easy to do in C# and C++/CLI (like restart recover) and some things are only possible in C++/CLI (like the network awareness functionality).

The reason for this is that network awareness uses COM connection points and other stuff. The reason is simple: performance. If you want the OS to be fast, you have to be prepared to give up nicety at some point. It is perfectly possible (and probable) that someone will wrap this up in an assembly for .NET languages to use, but inside it will still be implemented using C++/CLI.

And finally, there is another good reason why some stuff HAS to be raw COM.

For example, take explorer plugins. An explorer plugin can be provided to e.g. show metadata for a file.

Then suppose a managed application –running on .NET2.0 – opens a browse dialog which uses windows explorer. That browse dialog will also load the explorer plug-in. It is a simple .NET law that a process can only load 1 version of the .NET framework.

I don’t know what exactly would happen if that plug-in was built on .NET 3.0. But it wouldn’t work. The only way explorer can be guaranteed to work is if all of its components are native code.

TLA329: writing maintainable and robust applications with VS 2008 and Team Edition for software devs

This session is hosted by Marc Popin-Paine and Conor Morrison.

I have the Team Suite in my subscription, but never really did much with it so I thought this was a good opportunity to get up to speed.

There are several exciting features with this edition of VS:

Code analysis: this is a static analysis of the code that can detect a lot of things that are not picked up by the compiler by default. The technology comes from PreFast, which DDK guys have been using for years. It works for both managed and native code. If you can be bothered to download the DDK and do some manual work, you should be able to use prefast on your code without Team Edition, though it will not be integratedin the IDE of course.
Code metrics: this is a way to measure the health of your code by a number of variables. It calculates / measures the following things:

Dependencies between types.
Depth of class inheritance.
Number of executable lines of code.
Cyclometric complexity. This has to do with the number of different possible code paths in your functions (branching and nesting of if statements etc.

Maintainability index. This is a formula on the previous measured metrics which says something about the quality of the code. Analysis of the windows code base and other code bases has shown that there is a direct correlation between the maintainabbiliy index and number of bugs in a piece of code.
Profiling: code can very easily be instrumented or sampled at runtime to measure the time spent in each function to diagnose performance problems. This is truly a neat feature and I already know in which application I am going to try this at home.
Unit testing: this has been available since a long time, but it has been made easier, and it also has been pushed into the professional releases of Visual Studio.
Code coverage with unit testing. This is quite neat. After a unit test, VS knows how much of your code has been executed during the test, and what’s even neater is that you can see visually in Visual studio which code that is, with different background colors for executed and non-executed code. Statistically speaking, as soon as you have > 70% coverage in your unit test, you can start to rely on the quality of the code.

The bad news of coarse –to me as a C++ programmer- is that some of these goodies are only for .NET. Unit testing and code metrics are only available for managed code.

Code coverage is available, but only from the command line.

It is of coarse a lot easier to implement these for managed code (because of all the meta data and reflection features) but it is still a pity that I won’t be able to get code metrics for my template classes.

SEC403: UAC: how it works and how it affects your code

This session was hosted by Chris Corio.

I was really on the fence about this one. I also wanted to go to ‘TLA301: advanced version control with TFS’ by Brian Randall. I know that Brian is a great speaker, and version control has become of interest to me lately.

Still, I chose UAC because I wanted to know more about it, and I can always view the presentation on TFS online later.

UAC is meant to push you to developing apps that don’t need to run as admin. A lot of apps only write to program files for example because the developers couldn’t be bothered to do anything else.

Either you make your app Vista aware with a manifest (and change your code if necessary) or you do nothing and it will run virtualized. However, this will be possible for a limited time only because virtualization only kicks in if your app:

Is not a 64 bit app.
Does not have a manifest
Runs as administrator.

Since 64 bit will become more common, and users will less frequently run as administrator, leaving a Vista unaware as-is is not a long term option.

So what happens when you log on as an admin?

The Local Security Authentication service verifies your credentials, and then creates a token with administrator token. The elevated privileges are then stripped from the token and your logon lesion gets a filtered token instead.

If you start a program that requires no elevation, it will run the same as for a standard user. If that app needs admin privileges, it will see that there is a real admin token available, and prompt you to confirm that it is OK to do so.

If an application needs to do anything that windows deems to be for admins only, it will fail to do so unless the application was elevated when it was created. It came as a surprise to me, but a process can only be elevated when it is created. This means that if you want your app to start without the annoying dialog and still have it do something privileged as an optional thing, there is only one thing you can do.

You have to put that ‘something’ in a separate executable and launch it via ShellExecute. It should also be possible to implement that ‘something’ as an out of proc COM server and launch it. Chris even mentioned it. But I have it on good authority that that is more along the lines of ‘Slaughter a goat, wait for the right constellation to align, make sure that a bunch of highly complex stuff is in the registry and then it might work’. So I am not counting that as a viable option atm.

Btw, the only way to launch something and trigger elevation is to use ShellExecute. CreateProcess doesn’t does that because it only uses the current token to launch an application. Trying to use it will cause a simple ‘permission denied’ error.

ShellExecute uses CreateProcess internally, figures out that the problem is elevation, triggers the UAC dialog to come on, which plays musical chairs with the admin and filtered token, and then launches the new process with the real admin token.

A quick word on virtualization.

If your app runs without a manifest, it will run in a virtual filesystem and registry. This is implemented in a file system filter driver which does all the redirecting.

The redirection is based on ‘copy on write’, so an app will access the real file in program files until it tries to modify it. At that time a copy is made, and the app will forever see that copy in the user local store.

Another bit of trivia: if your application needs to modify a global file so that is affects all users of the app, put it under ‘All users’ which is perfectly legit.

Finally, Vista also separates elevated processes from non-elevated processes. So you won’t be sending windows messages or opening process handles in an elevated process.

There are probably more things that were not mentioned, but I bought ‘Writing secure code for Windows Vista’ by Michal Howard and David LeBlanc in order to learn the finer points about Vista UAC.

I never thought I’d say it, but Vista UAC is starting to make sense, even though there is a significant amount of teething problems still to work out. SP1 should make life in UAC land bearable.

INF302: Building manageable applications end to end

This session is hosted by David Aiken.

I will start off with a confession. I know this will be quite shocking to some of my peers, but I consciously decided not to attend Ale Contendi’s talk ‘TLA404: MFC updates for VC 2008 and beyond’.

The reason is simple. I don’t like MFC.

…

Not that MFC is not a powerful technology –because it is – and not because it is slow – because it isn’t, but something about MFC makes me go ‘Ehhhw’.

Maybe it is the fact that an MFC app looks cobbled together with a lot of macros, or maybe it is the fact that the class hierarchy is very, very deep, or maybe it is because a lot of it feels like stuff was just glued on and then riveted in place to make it stick.

MFC is a good solution for the problem it has to solve. So are garbage bins and lawn mowers. I just don’t like them.

Now to the topic of the current session.

To make an app manageable there are several things to do.

Your app needs to expose health information and performance data so that IT Pros can better diagnose problems, and so that you don’t get called at 3 A.M because your app died and nobody has a clue what’s going on.
Deployment should be seamless. In the words of David : ‘Whoever thought of XCOPY deployment should be shot and buried’. The problem is that xcopy sounds like a great idea because it is simple. In reality, a complex app needs stuff in the registry, in the GAC, needs to register event ID message DLLs, …
Doing al of that stuff manually is very tedious, and in the case of an uninstall, a lot of crap will be left behind.
You should provide an administration and configuration tool for your app. XML sounds nice in theory, if you are the kind of person who can edit a 1000 line XML file and get all the bracketing right.

Microsoft is developing a new framework for Health modeling, of which a CTP can be expected in somewhere in January. There was a code demo but that didn’t quite work. The impression I got was that it would be fairly easy to instrument your code with event logging and performance monitors. It would also enable you to compile a management pack for Operations Center.

There would also be support for WMI in order for you to allow administrators to poke and prod at your application in the standard way they can use for all of their poking and proding at system components.

Microsoft have finally discovered that it would be a neat idea to enable your app to use group policy to override local configuration values instead of forcing admins to runs scripts on all computers to change your local XML file. Support for that is coming as well.

And finally, create your administration tool as a PowerShell cmdlet (commandlet).

These are .NET components that can be accessed on the powershell command line. It is trivial to slap a UI on a cmdlet if you want, but they are supported by default in the new management console. This means your app can be managed by an IT pro in the mmc they know and love.

TLA401: Debugging and crash dump analysis with VC++ 2008

Finally… the most anticipated session of today. For me, at least.

Debugging in C++ is a really interesting topic. Steve has been very elusive this week, was failed to show up at any of the C++ sessions so far. However, short of divine intervention there is no way he won’t be here AND host this session at the same time J.

Steve is one of the best speakers around, and he manages to insert a fair amount of humour in his sessions. If he is hosting a session he also talks the same way he would in a one on one conversation, so the atmosphere is relaxed and laid back. It may appear effortless, but I know that a tremendous amount of preparation is required in order to pull this off.

The focus of Visual C++ is and will remain native code development. VC++ is the only Microsoft tool that compiles to native code, and they want to make it as easy to use and as good as possible.

The secondary focus is to provide a great interop experience for interaction between native and managed code.

The compiler has some things that can help you prevent bugs from occurring. Some of them are things you normally only do in debug builds, like including crtdbg.h to detect memory leaks, and compiling with /RTC enabled to defect buffer overruns.

Things you can do both in debug and release builds are using the /GS and /SAFESH switches to mitigate the effects of buffer overruns before it is too late, and using the secure CRT and checked iterators.

These have become the norm within Microsoft, and they are used in all codebases.

It is also possible to analyse your code statically with the /ANALYZE switch (which is only available in the Team Edition of VS) You can further add SAL annotations to your code to add meta data to functions that help the analyzer determine if those functions are used correctly.

And then something that is common sense: use smart wrappers to encapsulate resources (which is also known as RAII programming).

In order to make your code debuggable, use the ENSURE macro when possible instead of ASSERT. ENSURE behaves just the same, except it throws an exception in release builds.

Another few tips for making debuggable builds:

Archive all symbol files for builds that are shipped. That way you have a much better chance of doing something useful with a crash dump. Technically speaking, you can also obtain those by rebuilding the correct version of your product, but in some cases that could be problematic (e.g. SQL, Windows, VC++ itself, …)
Use property sheets to configure project settings. These property sheets can be independent of a project itself. This way they can be reused among other projects.
Do automated testing on both debug and release builds. This way you find more errors because some problems only show up in release or debug builds.

The next part of the session was about the neat things you can do with breakpoints, like put conditions on breakpoints, or even use data breakpoints to break when a variable changes.

Trace points also make it possible to do something when execution hits such a point. The example that was shown was to jump past an erroneous decrement operation without having to stop or change the code. A side effect was that it seemed to make execution much slower though.

The STL finally has useful visualizers that e.g allow you to view vectors as arrays. I think these are supposed to work for lists and maps as well. In any case, you can finally view STL variables as Our Creator intended when he made the universe.

It is also possible to add your own visualizers if you edit autoexp.dat. This is fully documented in the file itself, though quite complex so you have to take your time to do it.

Edit and continue does not yet work in 64 bit mode, or for managed or mixed mode code. This is on the todo list but requires the cooperation of quite a few teams so that will not be for the release of VC2008.

Something that can be useful in multithreaded apps is the freezing and thawing of threads in the threads window.

Steve spent so much time showing all the debugging goodies that the session was almost over when he came to crash dump analysis so that was kind of a whirlwind demo.

Basically, he showed how to open a crash dump with WinDbg and find the cause of a crash, though the demo was very light on details. His main point was that if you ship software, you should register with winqual so that Microsoft can gather the crash dumps and send them to you.

You can no longer provide your own last chance crash handlers because this was something that hackers were abusing. They could install a crash handler, crash your program and suddenly they had the complete running state of an application with all its data.

This was a very good talk –the best so far IMO.

After the session I met with Rafael who is an Italian security MVP, but his passion is C++ so that redeems him ;-) I had seen him in other C++ talks and we have even been emailing since the beginning of this week regarding an informal C++ dinner, but I never met him so I didn’t knew who he was. Go figure.

Afterthroughts

Another day with 3 C++ talks. Kate told me that there are more C++ talks in Europe than at similar events in the US.

One thing I can say with certainty: I am going to put more effort into making my apps Vista aware.

I have tried to use Vista before, but I went back to using XP because the whole UAC crap felt so cumbersome. However, with SP1 it will be a lot better, and now that I start to understand WHY a lot of things are implemented like they are now, it is all starting to make sense.

Tech-Ed Barcelona 2007: day 2

vanDooren — Wed, 07 Nov 2007 07:40:00 GMT

I just found out that the session booklet only contains 2 pages for taking memos of 5 sessions. It is beyong me how they could have thought this would suffice.

In the next break I will have a look around in the exposition hall to see if I can get a notepad or some other source of paper.

DAT202: Overview of SQL Server 2008

This session is hosted by Francois Ajenstat. This is only a level 200 session, but I think it would be usefull to have an idea of the new features in SQL 2008. After all, it will be released in a couple of months time.

The session itself started a couple of minutes late because there was a technical problem with one of the controllers. I hope this isn’t a trend. Last session yesterday started with a power outage.

The first thing that is immediately obvious is that Francois is a gifted speaker. He really connects with the audience and has the kind of presence that makes it appear as if it is the most natural thing in the world to talk in front of a large audience.

Security:

SQL 2008 now has support for transparent encryption of table data without needing developer support, and can use external key management.
Every action in a database is auditable. This is very nice in regulated environments where auditing is of critical importance. You now get it integrated in the database, for free.
Database mirroring is made a lot simpler, and has ways to resolve errors and corrupt database pages, making everything more reliable.

Performance:

Both data and backup archives can be compressed on the fly, resulting in significant performance increases due to decreased IO.
SQL 2008 comes with an integrated resource governor, allowing you to allocate resources to users, jobs, or anything with a GUID. There was a nice demo of a concurrent execution of a payroll job (critical) and a simple reporting job (less important) that were fighting over resources.
The resource governor made it very easy to assign the payroll job to a fast resource pool that could use up to 80% CPU time, and a slow pool that could use 20% CPU time.
The performance monitor immediately showed the behavior of the jobs in reaction to this.
Performance data collection and analysis has been simplified.

Policy based management:

A lot of the behavior in SQL 2008 can now be managed through policies. For example, who can do what, and what should table names look like, and are free form queries allowed,… all those things can be be configured through a policy, just like normal group policies.

Misc:

SQL 2008 now has intellisense to help you write queries. This can be a real timesaver.
There is support for something called the entity framework. This is basically a way to map logical data from tables and stored procedures to conceptual entities, even though the data can come from different tables or data sources. This is nothing revolutionary, but it can make life easier for developers.
It has become very easy to expose data on the internet in various ways.
There are several new data types, making it easier to store unstructured data like a documents and MP3s, and spatial information like GPS coordinates.
There is a lot of new support for Business Intelligence stuff, like powerful integrated reporting tools, like graphs, controls, gauges, …

All in all this was a very interesting session. I am not a database expert so perhaps I missed or misunderstood some stuff, but it became clear that developing a database is going to encompass more than setting up a table structure and providing a set of stored procedures to access them.

WIN202: Introduction of the Microsoft Sync framework.

This session is hosted by Phillip Vaughn.

The sync framework is a new addition to the .NET framework. I don’t know anything about it, so I attend this introductory talk primarily to know if this is something I should care about or not.

The key idea is to provide you as a programmer with a simple means to enable your applications to use data while disconnected from the data store, and then automatically synchronize when the connection returns. Conflicts should be detected and resolved, and users should be able to concurrently collaborate on the same data.

It also increases performance because your application will work on local data which gets synchronized in the background.

The sync framework is

Powerfull

It supports conflict detection and resolution.
It handles connection and storage errors.
It handles all corner cases that are notoriously hard to solve, like: A works independently on a dataset, copies it to be, B changes it again, A changes its own copy again, both upload at the same time and halfway through the conflict resolution, the connection drops…

Flexible, because it can work with:

Arbitrary data stores.
Arbitrary protocols.
Arbitrary network topology (peer to peer, master slave)

And finally, it lets you be productive because:

Creating Offline capable apps with VS2008 is dead easy.
It has built in support for lots of endpoints and protocols.
The runtime is expandable.

There was a demo with a customer database app that synchronized data on a PDA, outlook, and Vista Contacts.

Then there was also a demo of a sample app called ‘Sync toy’ which can be used to synchronize files and folders. It is open code and it works really nice. So nice in fact that I am probably going to use it at home to spread the data from my fileserver across different disks in a ‘set it and forget it’ way to safeguard data from disk crashes.

They key to synchronization resolution is to use meta data to solve alls sorts of common problems.

The sync framework is really impressive for a first release, and I think it is really worth looking into if you develop applications with offline capabilities.

TLA323: What’s new in C++ 2008

This session is hosted by Kate Gregory.

I was hoping to see Steve Teixeira here as well, but he was missing in action.

This session is also hosted in one of the bigger rooms, and it was fairly crowded. If I had to guess, I’d say that there are about 200 or 250 people here. Last year all the C++ sessions were shoved in the smaller side rooms, but they were overflowing. Luckily, the event organizers have responded to that.

This talk primarily discussed the changes to the in which you use VC++, and the way you should make your apps work with Vista.

The first part of the talk handled UAC (User Annoying Component) and what you can do to make it less annoying. Basically, you can do 2 things:

Instruct the linker to insert a manifest, declaring that you run elevated, so your app triggers the confirmation dialog at startup.
Instruct the linker to insert a manifest, declaring that you run without elevated privileges. But if your app does something it would need elevation for, it will fail.
The third option is not to use a manifest, but you shouldn’t do that because your app will run in a virtualized file system with virtualized registry.

Another important issue: Visual Studio itself doesn’t need to run elevated anymore.

VC++ 2008 also comes with a class designer, which is really a class viewer which allows you to see a class diagram of the code. It is not a designer, because in a survey, all corporate programmers they asked indicated that they would still make changes in their code, not in a class designer.

The resource editor can now also work with the high res Vista icons, though you cannot edit them. The justification for this is that programmers generally don’t design high res images. That is done by graphics people, and they have their own tools for that.

There is a new compiler switch /MPn that allows you to compile files on n processors at the same time. In a project with dozens, hundreds or thousands of source files, this can make a big difference.

If your project depends on an another assembly, it used to be the case that your entire project would be recompiled when that assembly changed, because the only way VC detected change was based on timestamp. In a large project, this would trigger a full rebuild almost every time. Now VC looks only at the signatures of the public classes (the meta data). As long as that stays the same, the assembly will not be marked as changed.

And finally, VC2008 supports multi-targeting, so you can specify that your app runs on .NET2.0, 3.0 or 3.5 without needing to swap development environments like you need to do today.

This session zoomed past. I had high expectations because I saw Kate speak before, and I was not disappointed. This was a really great session.

TLA408: Multicore is here! But how do you resolve data bottlenecks in native code

This session is hosted by Michael Wall.

Despite the fact that this is a level 400 session, it is crowded. Another 200 or 250 people would be my rough guess.

The session started of pretty dry, with a lot of slides about the new AMD processor. Every slide was followed by ‘..but I am not going to talk about that’.

As soon as that was past it became a lot better, and the session started with a simple example to illustrate the difference between array based operations and linked list based operations.

The idea is that with array based operations, the memory accesses can be calculated in advance and anticipated by the processor, so a lot can be prefetched. With list based access this is not true anymore.

To solve this, you can use an array with list item pointers which can be prefetched.

The processor has something called a Translation Lookaside Buffer which stores memory page addresses. That list is limited, so your code should use its data as local as possible to keep the TLB from having to find different memory pages.

A cache line is 64 bytes long. If you need to access one byte, you will get access to the next 63 bytes almost for free. So if you can make those 63 bytes useful, that is another performance win. Split often used data (hot) and rarely used data (cold) so that caching is efficient, and use small data types where possible.

The cache itself consists of several layers, and you should avoid as many cache loads as possible. If you can avoid using variables until you really need to, you don’t disrupt the cache. You can also manually prefetch data with compiler intrinsics. _mm_prefetch can do that for you.

You can also use _mm_stream_ps, _mm_stream_ss and _mm_stream_sd to transfer data directly to RAM instead of letting it flow through the cache like you would normally do. Suppose you write data to a large array and you are not going to need it for a while. If you just write it like you would normally do, the entire cache is blasted with useless data. Using the intrinsics you can avoid this, and you also avoid having to flush the cache to RAM in the first place.

Compiling for smallest code (which might be less efficient) can sometimes yield faster execution times than optimizing for speed. The reason is that smaller code causes less cache misses. Using ‘whole program optimization’ also helps.

If your application is multithreaded, it should be made NUMA aware. NUMA means that CPUs can faster access local memory then memory that is local to another processor. If your app runs on multiple cores, you should use the available win32 apis like GetLocalProcessorInfo and SetThreadAffinityMask to make sure that your threads stay on 1 NUMA node.

And finally, 64 bit compiled code is usually faster than the same code compiled for 32 bit, for the simple reason that there are double the amount of registers available in 64 bit mode.

The applications that are slower in 64 bit mode usually because code size increases (and thus the number of cache misses) and because data size increases if your app uses a lot of pointers.

This session was interesting and contained some good information for developing performant code.

TLA302: Best practices for native – manage interop in Visual C++ 2008

This session is hosted by Kate Gregory and is about the additional STL implementation that is delivered with VS2008: STL/CLR.

C++ programmers –well, some of them – often use the STL because it is a high performance library that is very flexible as well. It also comes with a wealth of containers and algorithms.

The problem with the existing CLR is that it didn’t allow you to put managed pointers into the container classes. So you couldn’t simply have a vector of string^ because vector simply did not handle string^ correctly.

VC2008 now ships with a second implementation of the STL in a new namespace ‘cliext’ that is designed to work with CLR type. That STL has the same rules and features as the old STL, but it’s containers and algorithms are faster than any .NET equivalent.

The reason is that as opposed to generics, C++ programmers pay the piper when they hit the build button. The compiler checks all types and method accesses and basically everything else at compile time. If your code is wrong, you will get compiler errors. If it isn’t you will have fast code because all the checking has been done already, and isn’t done at runtime.

Converting from .Net collections to STL/CLR collections can be done by explicitly implementing the conversion routines, which is pretty trivial.

Additionally, you can’t pass templates across DLL boundaries. There are several technical reasons which I am not going to get into here, but those reasons are the reason that I cannot pas an STL vector directly to another assembly, even if that assembly also uses C++/CLI.

To solve this, every container implements a type ‘generic_container’ which is a .Net wrapper of the container, which can be passed across DLL boundaries so that other STL/CLR code can happily work with it.

There were a lot of code demos to show how easy it is to use if you are familiar with the STL.

At the end of the session there was also some attention for the marshaling library. This library contains template functions that allow you to marshal native types to .NET types in a very convenient was. Currently this library ‘only’ provides conversions for all string types.

But –C++ rules – since they are template functions, you can easily provide your own specializations for converting a .NTE Rect to an MFC RECT or whatever.

Again, there was a large audience here. About 200 people or so.

This session very good, with lots of praise to Kate.

Afterthoughts

Today alone there were 3 sessions that centered on Visual C++. And all 3 had great attendance. I think that is showing that after the initial .NET hype, a lot of companies are coming to their senses again, and realize that there are some good reasons why C++ exists.

There is a tremendous amount of new stuff in Vista that can only be accessed easily from the C++ side, and it is going to stay like that for a long, long time because of a little thing called reality, which has shown that a completely managed platform is not yet feasible.

C++ has a niche where it fits, and it is not going to be replaced by anything, anytime soon.

Tech-Ed Barcelona 2007: Day 1

vanDooren — Mon, 05 Nov 2007 19:55:00 GMT

Today I have mixed feelings about being here, because it is my oldest daughter’s first day at school. I wanted to bring her to school together with my wife, but unfortunately that was not to be. I spoke with her on the telephone this morning, and she was really happy that she could finally go to school.

I just got a text message from my wife to tell me that she didn’t cry.

Breakfast here is nice. They have all sorts of fresh and healthy stuff in the buffet, various sorts of bread and cereal, fruits, … I am sure it all tastes great, but I went with the fried bacon instead. Nothing to get me going in the morning like 2 plates of bacon, bread with honey and a cup of coffee.

I just registered for the MVP influentials boot camp, which is a private session for MVPs and community influencers. The idea here is to have discussion groups for separate topics, in which you can participate when you feel like. The content itself is covered under my NDA so can’t write anything about it.

It was basically talk about community issues, and not technical issues.

Keynote

The keynote was delivered by S. Somasegar, VP of developer division, in an auditorium that was smelling of paint fumes. It quickly became obvious where that was coming from. 2 grafiti artists were making paintings on the stage. They were wearing gas masks of course.

Those paintings were not part of the keynote, nor were they refered to so it is beyond me what the point was.

Apparently there are a million VS users worldwide, with 25% of them paying for the Team System environment. There are also 17 million registered downloads of VS Express.

The keynote revolved around the new features of .NET and VS:

LINQ, and the new Sync framework which makes it easier to synchronize between online and offline collaboration.
The new .NET technologies WCF, WF and WPF
Silverlight and popfly. Tools for easily creating and modifying web pages and web applications.

Microsoft is also going to deliver guidance on the use of new technologies through extensive demo applications, and by providing blueprints..

The future of MSDN is to expand with a code gallery, an already existing wiki page in which everybody can add comments or remarks to expand the usefulness of the documentation, and a translation wiki. This is a pilot project to translate MSDN documentation to different languages.

Another very noteworthy item is that VS2008 and .NET 3.5 will be released in November 2007. This is very good news, since it contains a lot of features (WPF, WCF, WF, …) that I care for, and it will also contain a lot of new C++ features of which I am not yet allowed to talk. But Luckily Kate Gregory, Ale Contendi and Steve Teixeira will expand on those, after which I can also talk about them.

Then there was a demo with the new silverlight web technology, which was pretty cool. Not being a web developer I couldn’t judge the impact, but according to Tom it was all neat stuff.

Another noteworthy thing is that VS2008 is developed using VS2008 Team Foundation Server. A 1000 developers working on the same project, managing 30 million lines of code… In my book, that is an important vote of confidence in the Team System technology.

The license for Visual Studio has also changed. You are now allowed to use VS to build applications for other platforms, like linux or BSD. Apparently, this was forbidden earlier. The IDE source code is also becoming available to help you write plug-ins.

The next version of VS is codenamed ‘Rosario’ , and will focus on organizational collaboration, QA and advanced developer tools.

SEC302: Windows Vista Security for developers

This session is hosted by Rafael Lukawiecki.

My other option would have been the session on VS2008 and its new features. That would have been interesting as well, but I already saw some of it last year (with the Vs2008 beta) and Vista security is annoying me seriously, so I wanted to know some more about it.

The goal of Vista is to achieve NIST Common Criteria Certification Compliance. This seems to be a gold standard, identifying an OS as secure.

Currently, Vista ‘seems’ to be more secure than XP, judged by the number of exploits and vulnerabilities in a given time since release. This period is not yet statistically significant, but so far it seems to be secure.

Vista has a number of features that make it more secure, and I will briefly touch on them here:

During boot, the system files are protected by bitlocker and TPM, ensuring that no off-line changes were made to system files.
Network Access Protection (NAP) allows administrators to force computers to update themselves to the policies of the network before being granted access to the corporate network. This is done by giving it an address that can only be used on a tiny subnet, just for the sake of enforcing NAP. Only if the system is up to date will it be given a network address on the corporate network.
Everybody is a standard user, and get dialogs for actions that require privileges.
IE7 has better protection against phishing and malware.
The restart manager can apply updates and reboot the system while the computer is locked and has applications open. After a reboot, the system and application are restored to their previous state if possible. Note that this needs explicit application support, which is currently only implemented by a couple of Microsoft apps, most notably Office 2007.
The service layer in Vista has been significantly hardened. Each service now has a unique SID that can be used to restrict the things it can do, and it can also be used by service programmers to define the only privileges they require to operate. Furthermore, the user account of a service is now LOCAL_SERVICE or NETWORK_SERVICE where possible, instead of LOCAL_SYSTEM as it used to be.
The number of layers in the service infrastructure has also been increased, separating high risk functionality from low risk functionality. A lot of stuff has been thrown out to make the high risk layer more secure.
DLLs are now loaded randomly at one of 256 possible locations. An attacker can no longer assume system DLLs to be located at fixed addreses, reducing the possibility for compromise.
System components obfuscate long lived pointers that are accessed infrequently. This is another way to reduce the attack surface of those components.
Vista has more support for Data Execution Prevention (DEP) and Non- Execute (NX) technology, preventing attackers from writing and then executing code into a memory space.
.NET 3.0 has improved CAS and evidence technology for increasing security and authorization.
.NET 3.5 will further implement trust levels between an application and its external controls, and reflection will be made opt –in for private members.
.NET 4.0 will have even better security integration, but I didn’t really understand those features since they were only mentioned in passing, and it will be some time before it is released.
Networking wise, Vista has received a hardened TCP/IP stack that has a dual implementation for IPv4 and IPv6. If you accept IP addresses in your GUI, be sure to allow both kinds or your app will not work correctly for IPv6 networks.
There is an application aware outbound firewall. This means that you can restrict applications from making outbound connection. This will greatly decrease the chances of malware making an outbound connection and sending your private information to an attacker. Btw, the IP stack is not vulnerable to modern day attacks.
UAC (the annoying pop-up feature) can be controlled through local policies. Older applications are not UAC aware so they will either be virtualized (running in their own virtual file system and with their own virtual registry) or constantly nag you.
The authentication subsystem has been overhauled, and Gina was one of the casualties. For those who don’t know, Gina was the DLL that took care of authentication on windows XP and earlier. If you wanted to provide a different logon mechanism, you needed to hack Gina to shreds. And there could only be one Gina active, so that wasn’t too flexible either.
Gina was shot in a back alley, and superseded by a new pluggable authentication subsystem in which multiple parties can provide an authentication mechanism like a retina scanner or a DNA sampler (hypothetically speaking).
Windows cardspace is the new claims based authentication model that can be used by web applications (or others) to authenticate you based on PKI certificates and a load of other stuff, without having to care about that stuff. It would allow single sign-on, and automatic authentication if the correct identity cards are in place. It will also allow authentication while respecting your privacy. For example a website could enforce an age limit without actually needing your date of birth.
Bitlocker is a technology that allows whole-disk encryption to protect your files, and can use additional items like USB dongles or password to further increase security.
There is a new cryptography algorithm suite available in Vista that is compliant with the NSA suite B requirements. This is to enable you to create secure applications, and provide you with a secure system, since Vista uses those algorithms internally for all crypto related stuff.
TPM allows you or the system to store secret information (like keys) in a way that they cannot be extracted though any other means. There was no in-depth discussion on TPM, but it relies on the availability of a TPM chip on the motherboard.

All in all this was an interesting discussion, and well worth the time. There are several more security sessions this week, and maybe I’ll attend one or more of them, but at least now I have an idea on the security infrastructure in Vista.

And I also know why it nags so much to do trivial things.

In between

I had a phone call with my oldest daughter at 17:30 between the sessions, and I was glad to hear that she had enjoyed herself on this first school day. She didn’t even want to come home from the after-school care, so my wife had to carry her out.

WIN302: .NET3.5 end to end: putting it all together

This session was hosted by Matt Winkler and David Aiken. It started with a power outage that delayed everything with 10 minutes. By the time they got the session going, it was already too late to join another session, so I left it altogether.

To summarize: they showed a demo application, using all the new .NET features, and then they TOLD you which feature they were using at a given time. ‘Now I want to see the food and order something, which is done with WCF. Now I do this, which uses that, yada yada yada…’

In other words: all talk, no code. No technical stuff was discussed, so I decided to leave.

It’s not that big of a disaster though, since there was nothing else I really wanted to see in this session slot. They kept all the good stuff for tomorrow and later.

So I used the free time to write my reports. Later today I will go to the welcome reception and check out the different booths in the exposition hall.

Welcome reception, afterthoughts

The welcome reception is a bit chaotic, though that can be expected if thousands of geeks and nerds decend on an exhibition hall where people are giving away a limited amount of free stuff.

Let’s see; I got an inflatable microphone (nice for my oldest daughter), an earth shaped stree ball (ditto), a signed copy of ‘The security development lifecycle’ by Michael Howard and Steve Lipner (It is beyond me why they were giving these away, but I didn’t argue) and a free tech-ed 2007 T-Shirt.

I drank some beer and ate some snacks, and decided to call it a day.

Tech-Ed Barcelona 2007, day 0

vanDooren — Sun, 04 Nov 2007 13:06:00 GMT

I just arrived at the CCIB and was able to register in less than 5 minutes. The travel itself was un-eventful.

I got picked up by a cab at home, checked in, idled around at the airport for some time and had the most boring flight ever. This is good. I don't crave excitement when I am floating 20000 feet above solid ground, with nothing between me and a minute of free fall but a couple of millimeters of aluminium.

I also met up with Tom Heylen, a former collaegue of mine who is now making a fine career for himself, working as a consultant for Microsoft, doing international projects.

My hotel is the 'Hotel barcelona princess' and is right in front of the CCIB, which is nice. The CCIB is the red building on the left side.

Of course this also means that I am away from the Barcelona city center and the 'Place de la Catalunia' but I am not that much of a tourist, and going to a bar by myself is not a hobby of mine. However, there is a big shopping mall with lots of restaurants and little shop where I can spend some time in the evening.

Besides, this also gives me the opportunity to catch up on some sleep. My oldest daughter has not yet adapted to dayliht savings time, while my youngest has. This means that I still go to sleep at 23.30, and get woken up at 06:00 every single day.

The weather here is very nice. It must be a good 18 degrees centigrade under a cloudless sky. I walked around in the afternoon, and spent some time on walking on the beach.

I took this one sitting on one of those huge stone blocks for breaking the wave crests. Unfortunately it is sunday and most everything around here is closed.

Ah well, I ate at an italian restaurant, and spent an hour or 2 on my room, tweaking my LineReader class to improve its performance. Without anything else to do, that seemed as good a way to spend my evening as anything.

Microsoft DevDays Belgium, Day 2

vanDooren — Sat, 31 Mar 2007 21:26:00 GMT

I have to admit a slept rather well last night. Train traffic greatly diminished after 22:00. The windows had double glazing as well, helping to reduce the noise.

What really insured my night’s rest however were the earplugs. Advice to newbie business travelers: always bring earplugs.

The hotel did not have bacon for breakfast.

I finished my day1 report last night so I used the extra time this morning to post that report and catch up to my email. Apparently, some spamming copany or other has discovered the contact form on my blog. I might have to disallow anonymous contacts soon, since the deluge of spam is increasing daily.

Improve Database application performance with SQL server service broker

This session is hosted by Bob Beauchemin. He looks like my boss’s twin brother. Really bizarre.

This session is one that I went to because there was nothing else that interested me, but now I am glad I went there.

It was 100% code demo. T-SQL code to be precise. It showed how you can design your database enabled logic to work with SQL transactions. The main advantage of using transactions is that your applications can keep on working if one or more of the back-end servers are offline.

This technology uses built-in message queues that allow you to have much faster transactions than what you would get with DTS (Distributed transaction server).

These queues turn the database actions into asynchronous operations.

This demo was very clear and concise, and one of the better code demos I have ever seen. Nuff said.

ADO.NET vNext – Linq, Object services and the data entity model

Originally I was going to go to a Workflow Foundation demo by Ingo Rammer, but I had already seen a beginner’s intro once at tech-ed.

I knew literally nothing about vNext and object services, so another code demo by Bob Beauchemin might be a better use of my time.

vNext, object services and the data entity model are going to be part of Orcas.

The data entity model is a new data model that is accompanied by 3 XML schemes for defining and mapping the data flow from a custom data store (like the registry, the GAC or whatever) to ADO.NET. The model contains hooks for 3d part provider writers.

Object services is a technology that allows you to work with object databases that contain data objects that can have inheritance and other object properties.

I have to admit that I still don’t know that much about it, let alone understand it, but now at least I know it exists.

Thinking Powershell

This session is hosted bu Bruce Payence, and is about the windows powershell.

This is actually an IT session, not a development session.

Powershell is the new .NET enabled command line interface. From the demos it looked really cool. It can use all available .NET components, so it allows you to do basically anything you could do with a unix or DOS command shell, as well as anything you can do with .NET.

It is also fully customizable via plug-in modules.

To show the power of powershell, there were a couple of interesting demos: a space invaders program and a couple of examples of really interesting uses of plug-in modules like an extension that allows you to ‘cd’ into the registry to get information.

Powershell cannot do anything that e.g. C# could not also do, but because you are creating shell scripts, it is much easier to string different programs together to do something.

Another nicety is that powershell can use both unix commands (ln, rm, …) as DOS commands (dir, copy, …).

One important improvement over standard unix style scripting is that you can pipe .NET types into other programs without having to format and parse everything to and from text.

At this point I should point out that the room was packed, and the majority of the people in the audience were older sysadmins, and not developers.

Everybody seems to find it perfectly obvious that 44/7 equates to 6.2857… That is a sure sign of not being a developer. I would have expected it to be 6. Whatever.

Anyway, Powershell looks really interesting. So interesting in fact that I bought a book about it. It looks like something that can be really useful in a sysadmin role. Since I am going to have to maintain a standalone production line network, it might be worth to dive into it.

Bruce is an excellent speaker. He also did a book-signing session at the book stand, so I had him sign my copy of ‘Powershell’. What can I say… I am a geek.

Continuous integration with and without Team System

Another talk delivered by Roy Osherove.

This session is about continuous integration. CI means that every time a check-in is done (or each fixed time interval) your project is checked out to a build server and built.

This way you can immediately verify if your (or someone else’s changes) broke the built.

Continuous integration has the advantage that you discover build problems as soon as possible.

Roy showed several tools that can help you to automate a build:

· Nant: works for smaller projects, but can be a tedious to set up if you are not an XML masochist.

· MSBUILD: same problem. XML hell.

· Team Foundation server MSBUILD: better, but is very limited in the current version of TFS. The Orcas TFS Build utility will be much better though.

· FinalBuilder: a 3d party tool that allows you to configure an automated build graphically. The very nice thing about this tool is that it comes with dozens of configurable actions like deploying build output, burning DVDs, running unit tests, … This was the favority tool of the speaker.

· Visual Builder. Comparable to FinalBuilder.

Having such a build system in place is only the first step, because now you’ll have to set it up so that it starts by itself with each change.

There are several tools for this:

Cruise control
Draco .NET
Something that I cannot read in my notes anymore

These were not really shown, but their use was explained.

Continuous building is also possible with TFS. This takes some custom programming. TFS supports 3d part plugins through .NET interfaces. With a custom plugin you can register to TFS events, like ‘check-in complete’ or other such events.

These events can be used to let the plug-in trigger a check-out and a rebuild. This takes quite a bit of programming, but there are already a couple of open-source plug-ins that you can use.

This session also came with a song, but it was not as nice as the one of his first session. It was very interesting, and convinced me of the necessity of having an automated build system in place if you are one a project with more than 1 other programmer.

Building WCF based services with WF enabled business logic

Another session delivered by Chris Weyer.

As with his previous sessions, he again began with the ABC story which I’d heard 4 times by now. Sigh… But I digress. After 15 minutes the session really took off.

Thinking about it, it would make perfect sense to implement WF functionality in a WCF service. After all, if you start a custom workflow, you’d want someone to be able to interact with it, no?

As it turns out, the current releases of WCF and WF make this very hard to do, and require a lot of custom programming.

Chris showed how you can do it, and demonstrated how his multimedia demo project implemented this.

He also showed how this is implemented in Orcas. Luckily WF and WCF are perfectly matched in the Orcas release of .NET, so that boades well for the future. One of these days, Chris will upload his demo project to his blog so that we can all look at it. It uses WPF, WCF, WF, SQL Server and some other stuff.

End of the day

The conference is over. I decided not to stay for the closing keynote. I don’t believe in keynotes. At least with the kick-off keynote you have the comfort that you can do something interesting when it is over.

The trip home took 2.5 hours because –surprise surprise- there was an accident.

I was completely exhausted from trying to remember and learn all these new things over the last 2 days.

But all in all it was very interesting, despite the lack of C++ (or any native code at all).

Microsoft DevDays Belgium, Day 1

vanDooren — Thu, 29 Mar 2007 06:19:00 GMT

Before going to the conference center ICC in Gent, I checked in to the hotel where I’ll be staying tonight.

It is located in a quite street with little traffic. I sure hope that I can sleep tonight because on arrival I discovered that there is a railroad right in front of my hotel room (like 10 meters away from my room).

Funny that they didn’t mention that on the website.

Ah well. I only stay there for one night. My room is very clean, comfortable and the people here are very friendly.

The ICC itself is only at walking distance from the hotel, located in a beautiful park. Luckily it was no problem to register for the event without the printed registration papers that I forgot in my car.

Keynote

For some reason, keynotes generally fail to excite me. Maybe I have just become too cynical after 9 years in the consulting business to be affected by a marketing whizbang speech..

It was a typical American keynote with lots of multimedia. Luckily the keynote speaker - David Chappel - managed to fill 1.5 hours of speech without boring me too much. That is an achievement in itself.

David delivered a good story that incorporated what he calls ‘The Brian May’ principles.

Work together.
Stretch yourself (specialization is for insects)
Know your tools.

Brian May was a guitarist for the rock band Queen. Apart from being a brilliant musician, Brian published an article in Nature as an astronomy grad student. He also built his own guitar.

David then went on to give a survey of .NET3.0, Forefront, System Center and Longhorn Server, explaining how the aforementioned principles apply to them and to the developers and IT professionals using them.

The keynote conclusion was that we can all be a rock star like Brian May in our own way.

WCF communication patterns

This session is hosted by Christian Weyer. I have seen him before in Barcelona and I hope this session is as good as the previous one.

I like to get a lot of WCF and WF information because I’ll soon be starting at my new company in the role as the sole Systems Engineer, responsible for systems integration and custom applications.

The beginning of this session is equivalent to the Barcelona intro session on WCF with the ABC story: Address, Bindings and Contract.

Then there was an explanation of the issues involved with WCF application scaling. Basically you have to start using asynchronous programming, threads and callbacks to avoid synchronous behavior.

This was coupled with an explanation of the different channel types in WCF:

One way. This is just a fire and forget method of sending messages without waiting for them to be handled. One caveat is that Sending itself is synchronous, so methods only return if the message is really gone.
Duplex. Communication channels are bidirectional, allowing a process to send a message and receive multiple return messages over the same channel. By default this is only possible with session based bindings.
Request reply. A process sends a message to someone else and then gets 1 reply afterwards.

WCF is extensible at each level of the WCF stack. You can extend channels, protocols etc, but it is fairly complex.

The demo was very similar to the demo in the architectural session in Barcelona last year. Only this time, Chris focused only on the WCF part of the story.

Visual studio team system for DB developers

This is one of those sessions I attend because there is nothing else that sounds interesting. It is hosted by Roy Osherove from Israel. He is a surprisingly witty speaker and interesting to listen to.

Roy gave a quick overview of Visual studio Team Suite and Visual Studio Team Foundation Server, and how they relate to the VSTS for DB developers.

Basically, VSTS for DB devs allows developers to develop databases (with tables, stored procedures, …) in visual studio, integrated with TFS.

This means that you have all the support of tasks, bug tracking, unit testing and nightly builds, but applicable to database designs.

This is really something because there is nothing comparable from any other vendor at the moment. DB design is usually kept separate from the rest of the source tree, and there is usually some level of asynchronous development, leading to integration mismatches and problems late in the development phase.

There were some demos of database unit testing, integrated with a nightly build system.

It was really impressive, and I can easily see the justification for spending a couple of thousands of euros for this tool in a DB development environment.

Using this will save you lots and lots of pain.

At the end of the session, Roy took his guitar and sang ‘the database development song’ to the tune of ‘Sound of silence’. Really. No joke.

And it was a nice song too. It was definitely something that people remember when the guys at home ask ‘So how was the conference?’. Oh well there was this guy that sang a song about databases… I can already image my wife’s face when I tell her this.

Regex

This session was also hosted by Roy Osherove as well.

Regular expressions are something I have not yet used ‘for real’ in any of my projects, but I can see the importance of a good understanding of regular expressions.

For those who don’t know what regular expressions are: a regular expression allows you to define a pattern that describes what a piece of text should look like, and then apply that pattern to some arbitrary input data. You would use regexes to verify input fields for telephone numbers etc.

.NET regex allows you to

Describe text using patterns.
Validate, manipulate or parse text.

2 tools that can help you develop regexes are regulator and regulazy, which are available for download from www.osherove.com

Regular expressions can save you enormous amounts of time and money because you don’t have to write custom parsing code that allows for all sorts optional fields and parameters.

The problem with regular expressions is that they can quickly become unreadable for other human beings.

The conclusion of this session was that .NET regexes are really powerful, they can save you a lot of development and debugging time, but should only be used where appropriate because of their inherent maintenance (readability) issues.

I really got a good idea of how I can use .NET regexes. This was a good session.

It ended with another guitar song about regular expressions, though it was not as good as the DB song.

WCF practices from the field

This session was hosted by Christian Weyer, and continued where his previous session stopped. The first 5 minutes and slides were the same. After that it quickly picked up pace with practical WCF development issues.

This time his code demo focused on hosting WF inside a WCF service, but without really looking at the WF part. Rather, the binding via WCF was highlighted.

The crux of his speech was that interop between WCF and other ( non WCF tools) is really not easy. Partly this is because WCF is still v1.

The default bindings are useless in 99% of all real world scenarios. This is because of the ‘security by default’ design which limits virtually everything into uselessness. The good news is that it is very easy to configure bindings, as long as you aware about which settings you should override immediately.

Some of the settings are very obscure and named illogical. For example, the ReceiveTimeout setting is really the session timeout. There is a tool in the SDK that allows you to configure these settings.

Another of his point is that the Microsoft slogan ‘choose any contract and use it with any binding’ is really a pipe dream. In real world scenarios there are so much binding parameters to be configured that you should instead choose one and stick with it. After all, there is little point in changing bindings just for the sake of it.

Binary data transfer across HTTP is the binding that is best in most of the cases, and you should only pick something else if there is a pressing need.

The whole point of WCF is message exchange. To allow objects to be sent over a wire, they have to be serialized. This can be done through several serializing methods.

XMLSerializer
BinaryFormatter and SoapFormatter
DataContractSerializer

The preferred one is the last one, as it has been custom tuned for WCF, though it can only be used if interop with other languages like e.g. Java is not a requirement. Or was that the NetDataContractFormatter? I can’t remember.

Anyway, there are a couple of important points for WCF servers:

Ideally they should be self-hosted in an NT service to minimize dependencies. IIS 7 is also an option, and it is said to be stable and robust. Unfortunately it carries an ugly stigma from the IIS4 and IIS5 days, when IIS was one of the most horrid pieces of crap to be connected to the internet.
Make sure your code runs with non-administrator privileges. This means that you have to create the connection points in advance, using a config tool. This is because they invoke http.sys which is unavailable to non-admin accounts because it runs in the kernel.

To consume a WCF service from the client side:

· Use svcutil or ‘add web reference’ to create an interop assembly. Or

· Use the .NET interfaces themselves. After all, they ARE the WCF contracts. Note that the first call is VERY expensive, since the whole WCF stack has to be created.

· Avoid session affinity, since sessions can be lost. NetNamesPipe, NetTcp and WspTcpBinding all have an implicit dependency on session semantics.

Some points in conclusion:

WCF supports almost any communication scenario known to man, but can be tedious to configure.
If interop is not an issue, use secure transport (http over SSL).
Security is a feature, and secure interop is a miracle (or better: a pipe dream)
WCF has built-in support for WMI, event logging, tracing, …

All in all a very good talk.

VS Orcas, improving end to end application level performance

This session was hosted by Jay Schmelzer, and was going to cover the following things:

· Advances for all VS languages: VB and C#. This one immediately had me miffed. Excuse me!?!? What happened to C++? Steve Teixeira (Group PM for Visual C++) seems to be convinced that C++ has a considerate amount of improvements as well. Better tell him that was cancelled.
I mean it’s not like I expect a wide audience to be interested in VC++, but if this talk is to be about Visual Studio, he could at least mention that C++ still exists.
After all, Tech-ed Barcelona showed that VC++ has still a lot of developer interest.

· .NET multiplatform targeting. This is kinda cool, since it allows VS to create applications for different .NET framework version. I.e. the .NET framework version is no longer coupled to a specific VS version.

· .NET 3.5 design surfaces.

· Web / Office 2007 apps.

This session was going to be a code demo. Cool, I like those.

…

Are you a Dilbert fan by any chance? I am. Several years ago I read a Dilbert comic (I still have it, but cannot publish it here obviously) that had Dilbert sitting in front of some important customers, demo-ing their latest product.

Dilbert starts the demo and says: “Our product does not yet have a user interface, but if it had, you’d see something here, here, and sometimes here. And then you’d be saying ‘I’d gotta get me some of that’. Any questions?”

Now picture a Group Program Manager in front of a 300 man audience. He is going to show the new VS features. He starts a database connection wizard or something. An empty dialog box appears.

He then says ‘This feature does not yet work. But if it did, you’d see this and that, and you would be able to yada yada yada and you would really like it yada yada’.

At that point I picked up my stuff and left. As novel as it was to have a code demo where you have to imagine the actual demo, I figured I’d avoid the rush and leave early to get dinner.

No offense to Jay, who is a good speaker, but this session was not up to par.

End of day 1

Overall a good day. It was kind of tiring, with a keynote and 5 sessions crammed into 1 day, but good nonetheless.

It was not quite as nice as tech-ed though. Some points for improvement:

You could only get drinks and snacks on the ground level floor. This means that after each session, there is a surge of people going for a drink.
No free wireless access. You had to go to 1 of 2 stands with 8 Ethernet cables and physically connect.
Coffee was served in little cups. I preferred the large cups I got in Barcelona, since you could easily take them with you to the sessions.

I accidentally ran into 2 former colleagues who now work for a small consulting company that offers services in the .NET and IT area. They were doing well, and it was nice catching up with them.

I had diner in a nice restaurant near the ICC, called ‘Grade’ www.grade.be

Should you ever be around the ICC, feeling hungry, it is a good place to eat.

Tech-Ed developers Barcelona: Afterthoughts

vanDooren — Mon, 13 Nov 2006 14:03:00 GMT

Tech-ed developers 2006 has come and gone.

Traveling back home was uneventful, despite the fact that Barcelona airport has to be the most disorganized and chaotic airport I’ve ever seen.

At least I was at the correct airport. On my way to the entrance I talked to an Irish guy who had forgotten that Ryanair’s definition of Barcelona is ‘Barcelona, give or take 50 km’.

Was it worth it?

Yes. I have to say that I learned a great deal about upcoming technology like .NET 3.0, C# 3.0, the next C++ release etc.

Despite what you might think, going to a conference is hard work.

There were 5 1 hour 15 minute sessions per day. Since most of them were about new things, you really have to pay attention. In between sessions I made short summaries. This means I was constantly busy from 9 AM to 7 PM.

But it was a great experience. Nice people, free food and drink. Also, hanging out with the Microsoft VC++ people was fun. Being an MVP gave me access to lots of inside information.

The best speaker of the conference was Kate Gregory, with her session on extending C++ projects with managed code.

Other good sessions were all of the C++ sessions, the one about team studio for software developers, the one about CAS and the ones about .NET 3.0

To all the people who were out there, thanks for making tech-ed 2006 a success.

Tech-Ed developers Barcelona: Friday

vanDooren — Fri, 10 Nov 2006 13:44:00 GMT

Today is the last day of tech-ed. Hopefully I’ll arrive in Brussels somewhere around 23:00.

I really start to miss my wife and daughter, so I am glad I’ll see them again tonight.

Yesterday evening was an uneventful evening in my hotel room. I decided to start reading that book I bought on WPF to pass the time.

After a cup of the Happy Juice I make my way to the final C++ talk of this conference.

DEV407: Visual C++ new optimizations

This session is hosted by Ayman Shoukry of the VC++ compiler team.

There are a good 50 – 60 people here. Less than other C++ talks, but I suspect that the reason has something to do with the fact that it is 9:00 on a Friday morning, after the community dinner on Thursday evening. Another reason might be that this session has nothing to do with the language itself, or the .NET framework.

Still, not a bad turnout at all.

C++ optimizations is a very interesting topic. It is for this kind of high level stuff that I go to a conference. The coverage was really in-depth, and covered the available compiler optimizations in great detail.

All in all this was a very good presentation with a good Q&A.

Single file optimization

For single file optimization, the VC2005 compiler has improved by 20 – 30 % compared to VC6.0. This alone is reason enough to upgrade if you have computational intensive programs.

Whole program optimization

Whole program optimization basically means that the linker can inspect the object files to see which functions get called where. It the passes the object files back to the compiler to optimize them in certain ways. The major 2 improvements are cross module inlining and custom calling conventions.

Profile guided optimization

If you use PGO, the linker instruments your code with probes. The 2 major probe types are counting probes (how many times is a certain code path taken) and value probes (saves a histogram of values for e.g. function parameters).

Then you run common usage scenarios on your app. The captured data will tell the linker how you use the app, and how it can optimize. It can then create a new binary, based on this info.

Btw, an instrumentized app (with all the probes) is slow. Very very slow. Think about a snail on valium, paralyzed from the neck down, crawling uphill. But that doesn’t matter, because the instrumentized app is used only for analysis.

PGO can yield 20% increases in some cases, because the default code path gets optimized really well. This will of course decrease performance on the non-default path, but since that is non-default, it shouldn’t matter that much.

PGO can use the following mechanisms for optimizing performance:

Inlining: the linker examines the call graph, and can decide to inline functions at each call site separately.
Switch expansion: the linker can extract cases from a switch statement if they are executed often.
Code separation: this will move blocks of code so that the common code path always falls through, and moves uncommon code paths behind it.
Virtual call speculation: this will introduce a type check whenever a base class is used to call a virtual method. If the class is the same in 90% of the cases, it is quicker to check the type and call the direct method than to execute the virtual call via the base class.
Partial inlining: this will inline only those parts of a function that is in the hot path, while leaving the cold part in a function.

One thing that is worth to remember with PGO is this:

There are some situations in which you should be able reproduce the exact same binary image from your source code.

E.g in the space industry, if ESA want you to rebuild version X.Y.Z of an application, it had better be the exact same binary image. It is simply not allowed to build a version that might have slightly different timing behavior because that would mandate a complete re run of all acceptance tests.

This means that if you have such a requirement, you have to put the *.pgc files under source control as well, so that the linker can always reuse a known set of instrumentation data to create an exact replica of what you shipped earlier.

Floating point optimization

/Op will be deprecated. The documentation states that it enables greater floating point consistency. The problem is that nobody really understands what it does. Not even the compiler folks themselves. And the old floating point model was outdated anyway.

There are 4 new floating points models that are designed to give you better control of floating point behavior.

/fp:precise: this is the default, and it gives you a compromise between speed and precision.
/fp:fast: this will yield the fastest code, but you are not guaranteed the last digit of precision. Whether this is acceptable or not depends on the application.
/fp:except: this will cause fp code to throw exceptions on the exact line on which they should occur, whenever there should be an exception.
/fp:strict: this implies /fp:except, and will yield the best precision possible, but with a performance penalty compared to /fp:fast or /fp:precise.

Now, if – at this moment – you are thinking ‘OMG M$FT is shipping bad code’ then this is the point where I tell you to calm down and sing kumbaya.

In case you didn’t know, there is a fundamental problem with floating point math. Not all numbers are representable in the IEEE floating point model.

One problem is that 1e20 + 1 is still 1e20 using the IEEE fp, because the mathematical result is simply not representable in that format. Hence the result defaults to the closest number that is representable, which is 1e20 again.

Another problem is that, while A + B + C is equal to C + B + A on a mathematical level, this is not true at code level. It all depends on the precision and the order of magnitude of A, B, C and the intermediate results.

This issue is there for ALL compilers out there, not only C++, but also in C#, Java or whatever language you are programming in.

Floating point math is extremely hard to understand, and the value of a result depends on the exact sequence of instructions. Given an equation, it is very hard to determine if the result is correct or not, because correct’ has a fuzzy boundary in the IEEE floating point model. You can only say that code is correct for a given definition of ‘correct’.

Private talk about Interop

Craig Kitterman (MSFT) invited me to a private talk about the interoperability community and what I could contribute to it.

There is no interesting session in this slot anyway, so I decide to accept.

This is MVP stuff so I won’t tell more of it.

DEV004: building a distributed application with .NET 3.0

This session is hosted by Christian Weyer.

It is to be a demo of building a distributed application. It sounds interesting enough to spend my time here.

It is a level 400 session so I hope I can keep up.

Turns out I can’t.

The speaker is very good, but the application is already finished, and he is demonstrating the architecture and talking about things like service contracts etc. A good talk, but wasted on me.

Goodbye

The last session slot does not have anything that could interest me. This makes sense because a lot of people are leaving already, and they would not want to waste A level sessions on this session slot.

I think I’ll catch an early ride to the airport and do some reading. The battery on my laptop is past its peak, so I can only use it for an hour anymore without needing AC anyway.

I’ll post my afterthoughts on tech-ed somewhere next week.

Tech-Ed developers Barcelona: Thursday

vanDooren — Thu, 09 Nov 2006 17:57:00 GMT

Yesterday evening my Tech-ed issued tram card decided to die on me. I hadn’t noticed, but as luck would have it, a bunch of auditors entered the tram, accompanied by some tough looking stewards with handcuffs and batons.

My card proved to be invalid, and the auditor said something about the magnetic band failing. He wanted to replace it with a new one, and I tried to tell him that I should get one with at least as many rides left as I would normally have.

At this point I should point out that he did not speak a word of English, and I obviously don’t speak Spanish. Luckily he decided to do the wise thing and gave me my card back, gesturing ‘it’s OK’.

This saved us both an hour of frustration, trying to understand each other and solving this in a way that would satisfy us both. The old ‘I am a dumb but innocent tourist’ trick still does the job.

Since I only have to take the tram 2 more times I’ll just keep on using it, instead of trying to get it replaced.

So after a healthy breakfast I now arrive at the convention center to get my first cup of coffee for the day. In fact the coffee is so good that I call them little cups of happiness.

The fact that I call them that does NOT mean that I am addicted, ok?! Now let me get to the caffeine altar to get my cup of happiness before going to the first session.

DEV321: Delving into VS team system for software developers

This talk is hosted by Brian Randell, and it covers Visual Studio Team System for Developers. We don’t use this at my company (because it costs $$$, and it is not our core business) but I have it through my MSDN subscription, and I figured I’d see what it was all about.

Brian is another good speaker, and keeps the tone light while covering all different topics. It is mostly a succession of demos, glued together by a minimum of slides.

The key idea is that testing alone is not enough to guarantee a high quality app, and there were some statistics to back this up, along with a graph that showed that cost of a bug increases the later it is found.

I’ll just go over the different topics in sequence.

Unit testing of managed code via VS, and generating the unit tests automatically. This is a really cool feature, and it can save you lots of time in setting up your test harnesses. Unfortunately this feature is not available for unmanaged C++.
Code coverage. This tool can show you how much of your code was really executed in your tests. This is useful to determine the amount of dead code in your app, as well as making sure that your tests cover most of the code you’ve written.
Static analysis. This allows you to analyze the source code itself to look for things that look suspicious. For managed code you use FxCop, for native C++ code you use PREfast.
dynamic code analysis. This is only available for native C++ applications, and it checks for heap violations, handle violations and locking errors while your code is running, and presents you with a list of problem spots that you need to correct.
Code profiling. This allows you to take performance measurements while your program is running to identify performance hotspots in your code. This can be done though sampling (which you do to get a first rough idea) and instrumentation (which you do get detailed results).
You don’t use instrumentation from the beginning because that would fill up your memory and hard drive very quickly.

Overall, this was a very good session that gave me a good idea about the capabilities of team studio for developers.

I think I’ll start using at least the analysis tools for some of my larger projects. Unit testing is less of an option because most of my code is unmanaged, but I might do it on some C# code just to get familiar.

All in all this was another very good session.

DEV365: porting .NET applications to 64 bit Xeon and Itanium

This session is hosted by Samah Tawfik of Intel Corporation.

This was another session I really wanted to see because 64 bit is going to become very real within the next year, and it is a good idea to learn about it so that I know what this will mean for me.

Not that I see myself developing for Itanium any time soon, but you never know what might happen, and chances are I’ll buy a dual or quad core Xeon in the beginning of next year, this this might be useful at a personal level too, because who doesn’t write his own custom apps for automating household tasks, right?

The architectural difference between 64 bit Xeon vs 32 bit Xeon can be described as:

Extra memory space
Extra registers
Double precision ints
Flat virtual address space
32 legacy mode, 64/32 compatibility mode, 64/64 mode

Then there was an architectural comparison between x64 and ia64.

Basically, the major reasons to upgrade to 64 bit are the extra memory space, and the extra registers and instructions that allow compilers to take advantage of extra features.

There was a benchmark that actually showed to 64 compiled code can be significantly slower than 32 bit code for smaller loads. The reason is that the 64 bit code is not yet able to take advantage of all the 64 bit features while still carrying the overhead of doing so.

Intel has a suite of tools that allow you to design, develop and debug application that take full advantage of 64 bit features and parallelism, and they integrate fully with Visual Studio.

For targeting .NET 64 bit you basically don’t have to care whether if will run on 32 or 64 bit, as long as you are not using P/Invoke or unsafe things. In that case you should set the CPU type to restrict the .NET assembly to run only in 32 or 64 bit mode. Not doing so can just crash your app because native DLLs are only loaded at runtime when a native function is executed for the first time.

The presentation itself was not very good. It was not bad either, it was just OK. This is not criticism towards Samah. I have done presentations like this myself since a long time, and I started out being very bad, progressed to mediocre and have now reached a point where I am just average.

Speaking in front of an audience and connecting with it is hard, and it takes a lot of skill. Not everybody is able to do this as good.

The Q&A session was very good however, and Samah handled difficult questions very well, and gave clear and concise answers. She knew what she was talking about and was well prepared.

One thing I learned was that if an app is only very computational intensive, it might not give you any advantage to 64 bit, at least if it is 64 bit .NET code. Just going 64 bit is not a magic bullet

Native code on the other hand would really be able to take advantage of 64 cpus because the native compiler can really optimize algorithms and play with registers and pipelines in a way that is not possible for the .NET JIT.

DEV320: What’s new in Visual C++ ‘Orcas’

This talk is hosted by Steve Teixeira, and we are all glad that he has his luggage back by now.

This conference room is actually one of the bigger ones, with room for roughly 200 people. It is slowly filling up but I suspect that it is not going to get very crowded, partially because this is session is about what’s coming in the future, instead of using what there is right now.

Still, there are at least a 100 people here.

Before I go any further I need to stress that Steve mentioned that the list of new featured is not set in stone, nor is there a fixed release date for Orcas. There is a very good chance that the featured mentioned below make it to Orcas, but there the feature list is not yet publicly committed to.

The Visual C++ mission is to enable provide world-class native tools while bridging next-gen technologies.

There are basically 3 major types of project that need C++

Projects that have to be crossplatform.
Projects that have a large existing C++ codebase.
Projects that need a large degree control over runtime behavior.

To cater to these different types of projects, Orcas VC++ is moving in the following directions:

Support platform technology and renew investment in unmanaged libs

New development for MFC libraries.
Making VC a good Vista LUA citizen
Supporting the Vista SDK

Advance interop with managed code

STL/CLR template library to provide a very easy template-based means of converting managed typed to unmanaged types and vice-versa

Developer agility:

Improve compiler throughput by enabling concurrent compilation of cpp files, as well as enabling the incremental build of mixed mode solutions by looking at assembly meta data, and only consider files changed if the meta data they generate has changed.
Allow targeting of multiple .NET platforms so that using Orcas doe not mean you have to upgrade to NET 3.x
Deliver a new C++ class designer

There is of course also a list of things that is going to be cut from Orcas:

ATL Server: this is going to split off from VC, and converted into a shared source project, kind of like what happened with WTL.
/clr:oldSyntax: it is going to be removed. With Orcas it will no longer be possible to compile the old Managed Extensions for C++ code. This is a good thing (I will write a separate article on my blog about this).
Pre Windows2000 targets are deprecated. Another ‘thank God’. Windows 98 was very good at the time it was released. It was much better than Windows 95. However, it is severely limited by the fact that the win32 API and the Windows system itself have evolved to the NT family of systems. Functionally, Windows 2000 was the marriage between the 9x series and NT4.0.
Windows Me is what happens if you extend a design beyond the parameters it was designed for. It should never have been. It is unstable, and all new functionality has been grafted on in a way that makes it look like the Frankenstein of the operating systems.
By removing support for those systems, large parts of the MFC library and other libraries and SDKs can significantly be cleaned up and reduced in code size.
/Wp64: this is a compiler switch that you can use to warn for 64 bit portability errors. It was introduced at a time when the 64 bit compiler did not yet ship.
Since the 64 bit compiler does ship, it makes no sense to support this switch anymore. If you want to know if there are 64 bit compilation issues, just compile with the 64 bit compiler.

Steve also explained that generally, things are deprecated in one release, and then removed in the next release.

However, this is not going to happen with all the unsafe C runtime functions that are now marked as deprecated.

Basically, Microsoft introduced a ‘safe’ version for each function in the C runtime which is susceptible to buffer overflow problems, and they needed a way to tell the programmers that you could better use the new functions instead of the old ones.

Unfortunately someone decided that this mechanism already exist in the form of the deprecating pragma and decided to use that, much to the horror of many C++ programmers.

The VC++ team has recognized the unfortunate message that they delivered, and this message will be changed in the Orcas release to give a better, less hostile message that does not contains the word ‘deprecated’.

The C runtime functions which are now marked deprecated will NEVER be removed from VC++. Because they are part of the standard C/C++ runtime.

All in all this was another high quality lecture.

DEV326: Not faster processors but more processors

There weren’t a whole lot of other options, so I chose to go to this session. My only other choice would have been DEV359: .NET hidden treasures, but after reading the intro I decided that since I already knew 3 of the 4 treasures they mentions, the session would probably be just a waste of my time.

Anyway, this session is hosted by Carl Franklin.

Great. This entire presentation is going to be code demos (yaay) but it is done in VB.NET. (barf). Couldn’t they at least have mentioned this in the session description?

I’m out of here.

DEV356: Using OpenMP and MSMPI to develop parallel high performance apps

This session is hosted by Saptak Sen.

Since the topic is OpenMP it is very unlikely to cover VB.NET. Now don’t get me wrong, the market for VB.NET is still huge, and I don’t belittle the people who use it, but I really don’t like the verboseness of the language.

Anyhow…

Windows 2003 Compute Cluster Server (WCCS) has the following goals / key concepts behind it:

Simplified deployment and submission and monitoring of jobs.
Leveraging existing knowledge and infrastructure to simplify HPC.
Allow programmers to use a familiar development environment.

WCCS is actually made up of Windows 2003 Cluster edition, and the Compute Cluster Pack (CCP).

The OS is used to manage the hardware and to provide a high bandwidth low latency interconnect.

CCP contains the support for standard MPI, job scheduler and CCS SDK.

OpenMP is supported by Visual Studio Directly, but only in C++. You can use OpenMP in a .NET application, but only if you use Visual C++. This is one of the areas in which C++ gets to have the cake.

OpenMP can get you big gains in the parallelization of long loops without loop dependencies.

The number of OpenMP thread can be set statically at compile time, or dynamically at runtime.

MSMPI is a networked protocol that allows you to distribute tasks by sending messages to different nodes in the HPC network. There is of course more to it than that, but that’s the gist of it.

There is a lot of scheduling, security and other stuff going on, but functionally, nodes can send messages to each other that trigger them to do something, after which they return the results. It is more complicated than OpenMP, but easier than programming everything yourself using Windows sockets.

The presentation wasn’t bad, but this technology is not likely to be something that I will ever use, except perhaps the OpenMP stuff, that might be worth diving into to learn the basics of it.

Tech-Ed developers Barcelona : Wednesday

vanDooren — Wed, 08 Nov 2006 17:29:00 GMT

So yesterday I went out with Ayman Shoukry (VC product manager), Steve Texeira (VC Product Group manager), Marcus Heege (VC MVP), Siddhartha Rao (VC MVP) and an Architect from MS whose name I forgot. I’ll update when I’ve had a chance to ask Steve.

It took us a while to find a restaurant, mainly because most proposals were vetoed by one person or another, but in the end we found a nice Italian restaurant. Well, it was either that or buy a large bag of candy at point.

We had a very nice evening, had nice food, had a few beers and talked about things like compiler trivia, politics and funny on-the-job stories. They were all very friendly people. I had a really nice evening.

Time flew and I left shortly after 23:00 because the last tram to my hotel area was at 23:45, and I did not fancy having to walk the entire distance or finding a cab.

So my night was a bit short, but luckily I was able to start with the breakfast of champions. The only thing better than having a plate full of bacon in the morning is of course having 2 plates of bacon.

I did not take the coffee anymore because it was very foul stuff, whereas the coffee at the convention centre is very good.

But I did drink 2 glasses of orange juice, so that counts as vitamins.

DEV323: C# 3.0, Future language innovations

This session was again hosted by Anders Hejlsberg.

As you might guess from the title, it was about new features of C#3.0.

C#3.0 is completely backwards compatible with C# 2 and C#1. Anything that compiles with earlier compiler will compiler with C#3 without problems.
contextual keywords: new features like LINQ use special keywords to create statements. But these are only keywords in the statement in which they are used. This means that your code won’t break if you have a variable named ‘from’ or ‘select’.
Local variable type inference: using the ‘var’ keyword, you tell the compiler to take the type from the right hand side, and place it on the left hand side, like this:
var myVar = new Array<int>();
Note that myVar is still strongly typed. The compiler just saves you the trouble from having to type in long type names twice.
Anonymous types: this allows you that have strongly typed variables of which the type is inferred by the compiler at compile time by looking at what you are constructing it with.
extension methods: the new ability to write extension methods allow you to define new instance methods for existing classes without changing those classes in any way. Very powerful feature.
Lambda expressions: I am a novice in this area, but if I understood it correctly, lambda expressions allow you to pass code as data, removing the need to explicitly create delegates to do something inline.
Tied to lambda expressions are expression trees. These make it possible to turn lambda expressions into expression trees that can then e.g. be parsed by a SQL generator to generate code for interacting with a SQL database.
Object initializers: these allow you to initialize objects when they are contructed by supplying values for public fields and properties.
tied to object initializers are collection initializers. These can be initialized at construction by supplying the data that has to be put in them. A requirement is that the collection has to implement IEnumerable, and have a public Add method.

All these powerful features together are used to build LINQ (see my blog from yesterday). Any incorrectness in my explanation is of course my own. I am pretty sure that Anders explained it correctly, but I am not that sure that I understood everything correctly after seeing it only 1 time.

DEV205: Code Access Security

To be honest, I am only attending this session because there is nothing else in particular that I wanted to see.

It was either this or DEV339: Creating Windows and Browser apps with WPF. However, I know virtually nothing about Code Access Security (CAS), whereas I already know a bit about WPF, and this should be easy enough to figure out by myself.

The nature of the software that I write for customers does not call for security measures. We typically have administrator access to the machines that the software runs on, and we are allowed to add firewall rules, do a custom DCOM or .NET security configuration, or change folder permissions to allow our applications full control.

This session is hosted by Keith Brown. For those who know Dutch cabaretiers, his sense of humor resembles that of Bert Vischer J, though not as ADHD of course.

Code from remote locations is run in a sandbox, and is not allowed to do much.

CAS protects the user from the software, rather than protecting the software from the user. CAS is there to insure that an application cannot do things that you do not entirely trust them to do.

For example, to call any native code or use the ‘unsafe’ keyword, your assembly needs to be granted FullTrust. Anything less and it will trigger a security exception.

Btw, A really cool toy is LUTZ reflector. It is a dis-assembler for .NET assemblies that will show you what the original source code looks like. You can use this tool for example to read the source code from the .NET framework classes.

Keith talked a bit more about using isolated storage and not using strong names for security because they aren’t. If you want to use strong names for versioning, you always have to use the same private key. Any cryptographic algorithm of which the private key cannot conveniently be changed is not secure.

On top of that, there is no way to recall lost or compromised keys, so string names should be thought of only in the context of versioning.

Apart from the general talk about dealing with running in partially trusted zones, Keith pointed out the assembly attribute AllowPartiallyTrustedCallers.

When used in a class library, this attribute tells the JIT that the library designers assert that this library is not doing anything that could be used as an attack vector for a malicious application.

While of course being convenient to use by the application, this also means that the library designer has to be really sure that it is indeed safe to be used in an unsafe environment. To be good, this should mean that the library developers do design analysis and security auditing etc.

DEVWD15: Hardcore .NET production debugging

This is one of the sessions that I really wanted to see because it covers –among other things – WinDbg – which is an incredibly powerful debugger.

Ingo is a very energetic speaker, and he really covered a lot of ground using different debuggers.

As with the C++ whiteboard discussion yesterday, the room was packed 10 minutes in advance, so we got an early start.

Ingo explained the basic debugging commands, and how to use them to debug applications that would not start, or leaking memory etc.

I am not going to make an overview of the different techniques over here. One reason is that I have forgotten the exact sequence of commands and actions for most scenarios by now. Another reason is that there is so much to write that I would be writing a complete article on debugging, which is not my intention right now.

I certainly learned a lot in a very short time.

Marcus’ generous offer

This meeting was attended by Marcus Heege as well. The people from Microsoft told him that they had to turn away more than 50 people during his session because the room was already full. Because of this, they asked him to repeated that session again on Thursday.

Unfortunately, he had to leave today so he asked if I wanted to host that session in his place.

However, it was supposed to be an ad-hoc whiteboard discussion. This posed the following problems:

I had nothing to start from (no written presentation to take over)
I had absolutely not prepared myself to do this. Extending existing projects with .NET code is an advanced topic. I know how to find my way through that forest if I am sitting behind my PC with enough time to search for solutions to the inevitable problems that will arise.
Imagine I am up there and there are people asking questions like ‘Why does my application crash / hang when COM does this and .NET is used like that.
Going ‘Erhhhhm….’ At that point would make me look foolish at that point, as well as letting down the expectations of the people in the session.

It was very kind of Marcus to suggest this, but he is an expert on this topic, and I am not.

I thought hard about it, but with great reluctance I decided to decline.

If it was merely the intention for me to give a presentation I would have taken the opportunity to go out there and do it because then I could have taken over an existing presentation + demo, practice it a bit and go Live(tm) with it.

As it was, this was just too dangerous, and too likely to end in a big disappointment for both myself, the audience and the tech-ed people.

DEV340: building data driver applications with WPF

This session was hosted by Ian Griffith.

I only attended this session because there was nothing else of interest to me, and I thought it might be nice to get some more information on this topic.

Unfortunately, I do not know more than just the basics on data driven apps.

His presentation quickly went into data binding, data context and other things that I have never used in an application, so I was out of my league very quickly.

That is why I decided to leave the presentation after half an hour so that I could write up my other experiences of this day so far.

I am sure that the quality of Ian’s presentation was OK, but it just was not a good topic for me.

Btw, me leaving early also gives me the chance to write this stuff and still be in time for the next presentation on C++/CLI.

It is delivered in room 119, which is one of the smaller ones. Given the success of Marcus’ talk, I expect that room to be packed very early by lots of interested persons.

Microsoft really needs to allocate bigger conference rooms for C++ sessions because interest is high.

DEV406: extending native C++ applications with managed code

WOW.

This was just the best session I have seen this tech-ed, or possibly ever.

Kate Gregory is a gifted speaker and can keep a fast pace AND bring a clear explanation at the same time. This 1.5 hours just flew by.

This session was about the different ways in which you can move large C++ code bases to use parts of the .NET framework.

It started with architectural explanation of what this means, and then showed a number of scenarios.

If this topic interests you at all, find the powerpoint presentation on the tech-ed site because they are of high quality. The presentation is of such high quality that you can use it actually as a checklist in adding managed code to existing projects, as well as getting a better fundamental understanding of this topic.

It is also worth to note that there were a good 150 people in this room with me, leaving only 3 or 3 empty seats. As I mentioned before, C++/CLI is a hot topic.

Tech-Ed developers Barcelona: Tuesday

vanDooren — Tue, 07 Nov 2006 19:35:00 GMT

After a healthy breakfast (Bacon and coffee) I was off to the convention centre. The weather is nice.

Wireless access is a bit slow, but I suspect that this has something to do with hundreds of users sharing a 11 Mbs network.

Keynote

It’s a keynote. You see one, you’ve seen them all.

This keynote focused on Technology, and what it can to for people.

There was an interesting demo from an 11 year old Pakistani girl named Arfa. She is certified in Windows C# applications and ASP.NET. She was very bright, and was learning technology to help people in her country by bringing technology to Pakistan. She was very young, but she was very mature also. I guess she did a lot of growing up in a very short time.

There was also some talk about the Imagine cup, a programming contest for students to design solutions for helping people with certain problems.

Then the real keynote by Eric Rudder started. He emphasized on integration of information between different devices, as well as connecting business with people, information and processes.

There was a demo of an integration exercise between Visual Studio and .NET3.0, Office and Ajax.

It was nice, but a bit long and lots of yada yada yada, integration, bla bla… It wasn’t bad, but I am here for technology, not marketing.

Then there was a demo of the LINQ technology in .NET 3.0 by Anders Hejlsberg. LINQ is impressive. It allows you to using SQLish syntax in source code to bind and manipulate information from all sorts of data sources and use them like you would use other native C# objects.

Another nifty feature is that you can copy XML data, and then paste it as the C# code to generate that data.

The funny thing was that Eric Rudder started his keynote with the quote ‘May you live in interesting times’. After which he said that these are interesting times indeed, and a lot is happening. He attributed this quote to Robert Kennedy.

Apparently, he did not know that that quote is the first half of an ancient Chinese proverb. The full quote is ‘May you live in interesting times, and attract the attention of the emperor.’

He also did not know that this is actually a curse wrapped in nice words. The interesting things refer to unrest, arrows being shot at you and general unpleasantness.

The attention part refers to you being enough of a nuisance to attract the attention of the emperor, after which your future tends to be very short and eventful. E.g hanging up side down in the scorpion pit or something else.

With that in mind, I wonder what we can really expect of Vista and the next generation of Visual studio, office and .NET.

DEV201 – Introduction to .NET 3.0 (Formerly WinFX)

This session is packed. A lot of people want to know what’s going to hit them with .NET 3.0.

This session is hosted by Dave Webster, who is a gifted speaker. He is one of those people who make it look easy to stand in front of a demanding crowd and talk about stuff.

The first thing (which I didn’t know) is that .NET 3.0 is really .NET 2.0 with some added features. When you install .NET 3.0, It will install .NET 2.0, and then install the WCF, WF, WPF and cardspace components in a .NET 3.0 folder.

WPF

Windows Presentation Foundation (WPF) is going to take UI design to the next level. It is going to break away the difference between ‘slow’ web application with strong branding (think www.virgin-express.com) and powerfull windows application with little branding (think any windows application that is not themed with lots of effort).

The way WPF does this is by providing a set of controls that directly interact with the Graphics card in your system. Hence the need for a good GPU if you want to run WPF.

There was a demo of the NY Times website that is really a web application with XAML mark up that looked like an actual newspaper.

This is very important, because we expect data to be presented in a familiar way.

This also showed that in the future, these types of application will be developed by a combination of a developer (who has to know how to code) and a visual designer (who has an expertise in UI design and markup).

My personal experience is that these 2 can almost never be the same person. The visual capabilities of WPF are astounding, but much too much to describe in much detail here.

WCF

Windows Communication Foundation (WCF) covers everything to do with remoting, messaging and transactional actions.

The high level idea is that everything is a message between endpoints. The WCF stack covers multiple layers.

Address layer: where do messages go or come from.
Binding layer: how is the data contained in the message.
Content layer: what is in the message.

It really makes distributed systems (like client server applications) much easier to write and design.

WF

Windows Workflow Foundation was first abbreviated as WWF, but to avoid confusion with the Word Wildlife Fund and the World Wrestling Foundation, was re-branded as (WF).

WF makes it possible for high level architects to design systems graphically as a process flow. This means that something happens, and there is a known process for handling the event or data.

What makes this different from designing a regular app is that it is very easy to integrate services and components from different machines, add in scheduling and user management, and all sorts of special behavior like a systems wide process flow chart.

This also allows high level architects to design entire systems without having to know much of the low level details of each component. Other developers can then use their in depths knowledge to implement the functionality of custom process steps.

Cardspace

Cardspace is the technology that will be used as an identity providing system for the internet.

Microsoft recognizes that the whole PassPort thing was essentially a flop because they didn’t realize at the time that institutions like banks would never start using something that was designed and maintained by Microsoft only.

The technology in CardSpace has been designed by a consortium of major industry players like IBM, Sun, Microsoft and others. This makes internet wide adoption much more likely. And hopefully this will happen over the next couple of years.

An interesting thing to mention is that the Cardspace stack (everything that you have to do to manage it) uses its own private desktop session. This means that no other applications on your system can access the CardSpace software.

This is essentially the same way that your Windows logon box is protected. Whenever you hit Ctrl + Alt + Delete, your get transferred to a desktop session that can only be accessed by winlogon.exe.

DEV225: WPF introduction

I had to choose between this session and DEV220: Overview of Visual Studio Extensibility and the Visual Studio Extensibility Program.

That looked really interesting as well because it would give me some more information on how to create project templates for C++. However, that topic is interesting on a personal level, but it’s not like I would need it much for my work, so I decided to learn some more on WPF instead.

This session is hosted by Mike Pelton of PollyTiles. The guy is a good speaker, and has a good sense of humor. Starting off a presentation by mentioning the John Cleese parrot sketch shows that you know what humor is about.

As for WPF: it is really an interesting technology. The key idea is that the functionality of your application is contained in code files, while the visual style of your application is contained in *.xaml files.

The reasoning is that by working like this, it becomes much easier for the programmers to care only about what an application has to do, while allowing the visual designers complete freedom to modify the visual style of the application.

Styles can contain a gazillion visual effects, as well as time lines. This allows for creating any arbitrary effects that you might want on your user interface.

Designers can use separate tools for creating those styles. These tools can be much more powerful than the default VC2005 editor, and resemble professional graphics tools like photoshop etc.

There is little more that I can explain but remember those user interfaces from Hollywood films of which we – professional developers – say ‘Haha, as if’?

Well WPF makes it almost trivial to design applications like that. The only boundary is your imagination. This also shows that the developer becomes the limiting factor. I can perfectly well make sure that an application does what it is supposed to do, but to make it look cool you really, really need a graphics designer.

DEV223: The .NET Language Integrated Query (LINQ) overview

This session was hosted by Ander Heljsberg. IT was a good session. No marketing fluff at all, just technical content.

Language Integrated Query (LINQ) is one of the most powerful advances I have ever seen in software tech.

LINQ solves the whole data!= objects problem.

LINQ supports an SQL like syntax that gets translated to extension methods and lambda functions by the compiler. Lots of buzzwords there, but what it really means is that the compiler will translate the SQLish syntax to true .NET code without requiring any modifications to the data in which those queries are executed.

This allows you to use simple syntax to filter and join data from all sorts of collections: arrays, tables, XML datuments, relational databases….

One of the key improvements here is that C# 3.0 supports anonymous classes. The compiler will build anonymous classes based on the LINQ query that you have written. This enables you to use both relational and hierarchical result sets in a strongly types way.

Anything you do with that data later on will be verified by the compiler because it knows what the result looks like, so it knows whether what you are trying to do with it is possible or not.

It is worth to note that the underlying queries are not executed until you look at the data that would be the result of it.

This means that you can have a result set the size of a database, and yet only execute true queries the moment you look at a piece of data. And even then, the only queries that will be executed will be for that specific data.

At this moment it is possible to work with data from .NET objects, from relational data sources and from XML.

Another good thing is that the low level plumbing that makes this all possible uses an open API that simply has a default Microsoft implementation. Anyone can insert his own plumbing (should you ever want to), and anyone can also create an interface that can work with LINQ.

One example of this is that apparently, someone is working on a LINQ interface to amazon.com, enabling you to perform LINQ queries on the amazon inventory, with all the power of LINQ at your disposal.

Another thing I found impressive is that there is a tool (forgot its name) that allows you to automatically create a complete .NET API for a SQL database.

This was only an introduction session to LINQ, so I do not have more than just this general understanding of it, but if you are a developer who uses C# or VB, be sure to get at least a basic working experience with it, because a) this technology will be big, and b) it can save you enormous amounts of time if you have to do complex things with in-memory data.

DEVWD13: Extending C++ Projects to .NET

This session was hosted by Marcus Heege, whom I know from the Microsoft private and public newsgroups. Being a VC++ MVP, this is one of the few sessions that I really wanted to see.

The session topic was extending existing C++ code bases with .NET functionality.

There weren’t any things discussed that I did not yet know, but there are some other interesting facts.

The room was packed. C++ is not dead by a long shot. Public interest is big because the installed base for C++ is very large.
The general public – even if they are aware of C++/CLI – know almost nothing about it. Microsoft needs to push more information to the public.

As for interop with existing code, there are a number of options, but the 2 good ones are

1. Add new cpp files, put C++/CLI code in there and compile only those with /clr

2. Put all managed code in a DLL, and export functions from it that use C++/CLI internally.

After the talk I had a lengthy discussion about VC++ with Ayman Shoukry (MSFT) and Marcus, but unfortunately I cannot blog about that because pretty much everything about it is under NDA.

At this moment I am at the MS booth with Marcus, Ayman and Steve Texeira, and we’re probably going out for dinner later.