Tech-ed Amsterdam 2012: Day 4

I played some more with my Azure devbox, and I have to say the responsiveness is great. I had another phone call from the home front, and I am looking forward to going home and see my family.

The weather here is clearing up nicely, and the park I have to walk through was just lovely. Lots of trees and little lakes, with gaggles of geese and ducks and fish. At one point I had to jump aside or risk being trampled by a horde of women in spandex.

Today there are several interesting sessions I am looking forward to, including the next one.

What’s new in Active Directory in windows Server 2012

This session is hosted by Samuel Devasahayam and Ulf B. Simon-weidner

ADPrep and DCPromo are now gone. Server manager makes it seamless, and ADPrep functionality now runs automatically when the first machine is promoted. It can also be run remotely, which is a nice feature for remote installation. Validation checks were added to make sure common errors were eliminated. What is nice is that all functionality is implemented under the hood as powershell comdlets, so everything is scriptable.

If there was a network hiccup, dcpromo would fail. This has now been made more robust. Again, for me this is less relevant because I always work on a LAN, but it is important for customers with distributed networks.

Increase management experience. Recycle bin GUI.

A common problem with virtualization is that rollback to snapshot messes with Active Directory. Everything created during the rolled back time period and can be inconsistent. Therefore it becomes necessary to figure out a way of AD to know where there has been a rollback or not. This seems to be done in cooperation with the hypervisor. What was interesting is that they still say that snapshot is NOT a valid backup / recovery method, which is explained later on/

The example that was shown was of a RID pool which started reusing parts of the RID pool that had already been given out. Support has now been added to detect such cases and deal with them in a consistent manner.

Interesting new functionality is the ability to clone domain controllers. That is kind of cool. Admins can now take a DC, and clone it into multiple copies -> easy deployment of DCs to branch offices, but also to create redundant DCs. There was a flow chart, covering the various steps that were taking internally, such as discarding the RID pool to prevent some of the problems mentioned earlier. You have to be careful that 3d party software might not like being cloned. DNS, FRS, DSFR are supported.

RID improvements. Currently, it is possible to deplete the entire RID pool of a forest, after about a billion RIDs. This  seems odd. There was a sequence of events identified which could lead to this problem. The only solution was to do an entire forest migration. If you have a forst that is big enough to encounter this problem, this is probably not a happy scenario. The list of possible causes was covered. One topic I’ll have to read more about is DC Reincarnation because that is related to our backup and recovery scenario. I don’t think we have any of these problems but it pays to make sure.

There was a mention of deferred index creation, which had to do with schema changes in large enterprisey networks, so not really applicable to me. Offline domain join (join across internet) is another feature that I can see being nice for customers with a large geographic distribution. Ditto for connected accounts. This feature allows you to connect your live id to your AD account. It is not possible to log into AD  with your live id though.

LDAP Logging has been improved, with added controls and behavior that is always nice for anyone.

AD Administrative center looks nice. There is now a single tool to manage AD. That has been long overdue. One of the things it allows you to do is to enable the recycle bin. The recycle bin already existed in 2008R2, but now it is integrated in the GUI. It is not yet nested for now (meaning OU and CN structure). It is not yet a transparent ‘undo’. There is also a history viewer which shows the history of your AD transactions, with the powershell syntax visible. That is really nice, both for debugging and scripting.

Password policies are not also granular, meaning it is possible to set different policies for different types of accounts. This is another thing that was possible before with 2008, but not via the GUI.

Clustered or load balanced services that share a security principal are now supported by Managed Service Accounts. This is also nice, considering that more and more servers are clustered. Replication and topology cmdlets are now supported for managing site topology and replication in a consistent and scriptable manner.

One thing that is again very interesting is Active Directory based activation, meaning you no longer need KMS to activate your clients and servers in a volume licensed environment.

WCL289: Windows 8 demos

This session is hosted by Brad McCabe

No powerpoint. One thing that is nice is that there is no loon screen. You get immediate feedback form your apps. Loging in can be done via password, swipe, or picture manipulation. The latter is interesting especially in tablet environment where it is easy to log on by tapping a couple of landmarks and then poking your wife in the nose J

The desktop is not a sea of icons, but rather a sea of tiles that are grouped together. The tiles themselves contain live information. The apps themselves follow this tiles paradigm as well, allowing you to flip through your application. For data drive apps that makes a lot of sense. I wonder if it will be as efficient for control type applications.

One thing that is interesting is that apps actually start to look like on tv, with animations, sliding panels and transparent surface, all without a lot of effort on the part of the application developer. That is all supported and provided by the Metro libraries and Windows RT subsystem.

The same functionality exists between touch and mouse / keyboard. Touch is all about how you interact with the edges, mouse uses edges and right click. And it was mentioned yet again that devices and desktops have the same kind of user interface.

Apps following a share contract can easily exchange information, even though they don’t know anything about each other. The search contract allows users to search apps as result providers.

The traditional desktop still exists, and can be used side by side together with the new Metro style UI.

Windows 8 has a new concept called storage spaces. All devices can be pooled together in a storage pool and storage spaces. You can allocate larger sizes than physical space, and more space can be provisioned as it is needed. Not quite sure how this is more useful than the ability to use dynamic disks that can be grown. It also supports mirroring and parity.

Windows To Go was demonstrated running off a stick. This was similar to the demonstration already shown during the keynote yesterday.

Dev317: Going beyond F11, Debug Faster and Better with Visual Studio 2012

This session is hosted by Brian A. Randell.

I think I saw Brian speak on earlier tech-ed events. He is a very good speaker if memory serves me well. Very animated and able to drag the audience along for the ride. He also understands the value and use of silences.

I was first considering to go to wsv326: ‘Windows Server 2012, a Techie’s perspective’, but after looking at the summary, it seemed to overlap with the Active Directory session I saw earlier this morning. It would probably go a bit deeper on things like Kerberos and Compound identity, but that is not really something that is applicable to me. The chance of running a Windows Server 2012 environment before 2015 are slim as well.

Another candidate for this session slot was DEV314: Azure Development with Visual Studio 2012. That looked interesting, but I am unlikely to develop for the cloud or develop multi tiered applications, so not really that useful to go to.

Install SP1 for fixing bugs in unit testing and making it more performant.

Debugging: use just my code. Shows only your code in the call stack, and not other DLLs and frameworks. Otherwise the entire stack is shown. Source stepping in the .NET code is also supported with the parts of the source code and symbols that have been opened by Microsoft. This requires source stepping and source server support. Keep looking at the options menu for debugging because that is where some old and new features are still unknown.

There was an explanation of the various neat things you can do with breakpoints, like making them conditional or counted. This is rather old stuff really. I didn’t know pinnable data tips though. These are like tiny quickwatch windows which are shown over the code, and which are updated while debugging. They are visualizations of live variables.I thought that was neat. There is also a breakpoints window showing al breakpoints and various information.

Remote debugging finally works in VS2012. It existed already, but didn’t really work that well. This feature was seriously improved for Windows 8, for the purpose of remote debugging applications on ARM or other devices. It works tethered and over WiFi. You need to install remote debugging tools on the target platform.

Debug->Attach to process (machine name and process selection). From then on you can set breakpoints and break into the debugger.

For the paying versions of VS, all tools are available with the installation CD. Express users have to download  it manually. Then it has to be installed, and you have to run the remote debugging configuration wizard. This is basically to give access and configure firewall rules if there are any.

The profiler has also had improvements, making it possible to get more information about your application as it runs, even inside the simulator. Analyze ->Launch performance wizard. There are 4 profiling options that are more or les invasive. Each has its benefits and problems. CPU sampling can show hot code and call path issues. This can help you identify the most interesting places to optimize them.

Love, hold and protect your pdbs. If you distribute applications, you need to track your pdbs make sure you have all versions. With TFS, you can automate this process and link it to the version of your code that was built. For me this is not an issue, since I don’t have TFS. With the applications I distribute, I distribute the pdb files along with it.

At the end of the talk, there was a description about intellitrace. This is particularly useful if you inherit someone else’s code. It is a historical debugger, which needs Visual Studio ultimate. The output is an i-trace file, and contains the CLR profiler debugging and profiling APIs, and you can navigate up and down the stack frames with Visual Studio. Everyone can collect logs, including users and testers. You can collect intellitrace events, as well as method entry and exit.

There was a demonstration showing thee features, and it really looked nice. If you have a business model where you distribute a lot of applications to big customers, this is very worthwhile. Mind you, if you only have small customers it is nice as well, but you boss probably needs an argument why spending all that money is a good idea.

SIA302:  Malware hunting with the sysinternals tools

This session is hosted by Mark Russinovich.

My attendance here is a no brainer. Firstly because the only other interesting thing in this slot is Windows 8 Metro, and Steve will be covering that as well. Besides, it was already demonstrated this morning as part of the windows 8 demo. And secondly, if there is no really compelling counter argument, you just can’t –not –go listen to Mark Russinovich. He is to nerds and geeks all around the world, what Justin Bieber is for pre teen girls.

I am sitting outside the theatre waiting for the doors to open, because I am anticipating a big turnout for this talk. I’m also making sure m batteries are charged again.

The room is filling up completely. People are being encouraged to move to the middle of the seats because according to the woman trying to fit everyone in the room ‘People are not going to crawl over you; 98% of the people here are males!’

I didn’t take notes here, since the entire session was a demonstration of how to use process explorer to try and remove malware from a system without repaving it. It was an interesting demonstration, but not something I would attempt myself I think. At the end he also discussed Stuxnet and Flame, and how sophisticated they were. Stuxnet in particular is a bit scary. Not what it does, but how well it does it and remains hidden.

DEV367: Building Windows 8 Metro style apps in C++.

This talk is hosted by Steve Teixeira. As with Mark’s talk, I just can’t –not –go, regardless of what the other sessions would be.

Actually I am looking forward to this talk for several reasons. I am going to get back in C++ programming, and since Metro is currently the way forward, and C++ is now finally a first class citizen again, Metro is the way to go. It will be very useful to see a demo on this topic so that I can hit the ground running.

And let’s face it, if you are like me (if you are a C++ programmer, that is a strong possibility) you think that a grey dialog with a square button is an example of good UI design. Throw a listbox on that form and you’re the man. Yet if you want hip people to think your app is hip, you need your app to look like the other apps on their hip device. With metro, a lot of that work is done for you so that is good I suppose.

I rushed to this room after Mark’s talk, because Steve’s session was packed yesterday, and there is only half an hour between Mark’s session and Steve’s.

C++ supports all 3 app models: XAML, HTML/JavaScript, and DirectX. As was already mentioned before: the designer now treats C++ as a first class citizen. And Visual C++ is optimized for Metro, from project templates to Intellisense, designers, and deployment managers… the works.

After creating a standard XAML program, you can use the manifest designer to define the ways in which windows treats your program, and also the capabilities you specify your app needs, and how it gets packaged.

C++/CX is a set of language and library extensions to allow consumption and authoring of Window RT types. It is 100% native code C++. The syntax looks like C++/CLI, and uses many of the same conventions. In fact, just by looking at it you might be lulled into thinking you are looking at C++/CLI.

It is deeply integrated with the STL, which makes sense as everything is native. An important remark was to use only C++/CX at the surface area of your application, and keep the rest in ISO C++. That way your codebase remains portable, while still having a surface that is consumable by WinRT clients.

Important detail: Exceptions don’t travel across module boundaries. They get translated to an HRESULT and then rehydrated into COMException. So not only does the Exception types don’t transfer, but you also should not derive from these exception types, because the translation will not know your exception type and you will lose your hierarchical information.

Metadata of your app or dll will automatically be stored in the .winmd metadata file.

C++/CX also has partial classes. This is neat, and is what was needed to allow the IDE to work on your class and consume it without getting in your way. Your UI is completely configured via XAML,  which connects to your code.

Hybrid C++ / Javascript: high level programming where it matters. HTML project  with js, and not 1 bit oc C++. This is the UI project, not functionality behind the buttons. Then the WinRT project got added to the solution. The html project can then just consume the WinRT component.

These 2 options of programming look really similar, and you do practically the same thing. I guess the only reason to pick one over the other would be which you would be more comfortable with.

Note on deployment: the model is built on the idea that apps are distributed via the store. However, this does not really work for developers (J) or enterprises or other scenarios. To provide this functionality, you can package your application. The package comes with everything it needs to install it on a different machine, and even includes the necessary information for remote debugging.


Today was the most interesting day so far. Or rather: the day in which the sessions were varied, and all were interesting. The Active Directory stuff looks great, and in my opinion this should have gone in Win2008. My guess it was all related to lack of time, and they finally had the time to finalize and polish the things that were implemented in a rudimentary fashion in 2008.

Windows 8 looks great, and I think it will go places in the consumer market. Now if only Microsoft won’t drop the ball, and make Windows 8 devices available in the European consumer market. Previous devices like the windows phone and the Zune were a success. I think Zune wasn’t even released here.

The debugging talk was interesting, and I learned a couple of new tricks. Brian is always a good speaker to listen to.

And I am stoked about the Metro development with C++. It looks really userfriendly, and you don’t need to jump hoops like with previous designer experiences. It makes me wonder about the future of WPF btw. There is a large installed base for Windows forms, and those certainly have their place.

My impression is that they came up with WPF to implement some of the ideas that made it into Metro, but without any real underlying strategy, platform support or concept of platform diversity at te time when it was implemented.  

Leave a Reply

Your email address will not be published. Required fields are marked *