Tech-ed Amsterdam 2012: Day 3

Last night I spent some time registering for Azure. It just took 5 minutes to sign up, and then sign up for the Virtual Machine functionality. All you need is a live id and a credit card. I’m still running on the 3 month trial for the moment.


Via the Azure management console you can configure the services that you use, and it is indeed as easy as it was said to be. One thing I found interesting is that a bigger machine is not more expensive than a small machine. It is just that IO for the small machine is cheaper. Interesting concept. Geographic distribution seems to be humongously expensive though. However when you think about it: if you want geographical redundancy for your own data center, it is going to cost you some real money as well.


The machine is running Windows 2012 RC, and I installed Visual Studio 2012 RC on it. Azure even was kind enough to give me the option to save the RDP file on my desktop. The one issue I can see is that I had to supply a DNS name for inside the cloud, and the one I picked originally was taken. Now, for me it is not a big deal to pick something else, but one has to wonder how many names will be picked by domain squatters.


The wireless is working flawlessly today. ‘Today’ has not yet officially started of course. It is still 45 minutes before the start of the first session, and the place is still deserted. The tables in one of the seating halls are still mostly empty, there is silence, and there is good coffee without lines at the machine. I bet I could get more work done here just sitting at a table, than sitting behind my desk at work. Silence is really undervalued.


Keynote


This is a first for me. Having 2 keynotes in a row. I wonder what the point is. I did notice there is no closing keynote on the last day, probably because people tend not to show up. I guess moving the keynote is one solution, but not having 2 would be another.


Perhaps they’ve decided to do it at this moment because the delegate party was yesterday, and they anticipate that there will be many delegates with a hangover, or who might have trouble getting out of bed at a reasonable hour.


As I am waiting for the keynote to start, I am enjoying the music. They’re playing pimped up versions of songs like ‘somebody that I used to know’, with a lot of bass beats added to it. Not that I am a big fan of techno music, but I have to hand it to the organizers: they do know how to provide good sound. The quality is crisp, and the bass is strong. As a friend of mine used to say: you shouldn’t so much hear the music as feel the music. If your chest cavity is not resonating with the drum beats, the bass isn’t loud enough. I bet a Rammstein or Manowar song would sound great in this hall. There is no acoustic echo at all despite the high volume. Hint for the organizers: Hire Rammstein as the warming up act for the keynote.


Totally off topic: the coolest t-shirt I have seen so far is a simple black one with the text ‘I can see dead servers’. Thumbs up to whoever thought of that.


Apparently, the reason for the keynote split is that they wanted to have one for server 2012, and one for Windows 8. Initially I was not too thrilled about Metro, but in an environment that also contains tablets and phones, it does provide a compelling platform.


What does look impressive is that you get a Windows 7 VM with Windows 8 for running things in windows 7 mode. This is similar to the Windows XP mode that was available with Windows 7. What is new is that with a simple click, you can mount the virtual disk to explore it, or you can even add it to the boot menu, and boot directly from the disk image, thus giving you complete control of the hardware and all features (like 3D acceleration).


Another enhancement is that the touch gestures are supported via RDP. It’s not just the mouse input but the actual gesture messages.


What I thought was interesting as well is the Windows on a stick deployment. You can install windows on a memory stick and configure it fully, and then insert the stick in any computer and boot from the stick. You get full access to all hardware, except for the local disks which are hidden. This way you get all access to your own hardware (using the machine as nothing but a bunch of dead electronics) as well as isolation from any malware or other stuff which might be on that pc and which you really don’t want mixed with your (corporate) data and systems.


There was a mention that Metro apps used a new platform called WinRT which is separate from Win32. I guess that makes a lot of sense. Win32 is a dated subsystem, geared towards a paradigm which is essentially synchronous in nature. Win32 is full of blocking calls and synchronized concepts. You don’t want this behavior for tablets and phones. Blocking is bad. Whatever blocks should be handled asynchronously. To that effect, WinRT is ideal. It will probably cause more context switching and a bit more overhead, but feel more responsive. On server side, Win32 is just fine.


There was a brief mention of some changes to the Visual C# language (like the ‘await’) keyword which adds support for the fact that stuff happens asynchronously. That way, you don’t have to chain asynchronous events (like e.g. reading a block of file data and then shoving it in a decoder) with your own glue logic. Those things look obvious and interesting, and it makes me wonder why there is no C# language session about language changes to Visual C#.


DBI308: Practical uses and Optimization of new T-SQL features in SQL Server 2012


This session is hosted by Tobias Ternstrom.


It is a good thing I turned up early, because with 20 minutes to go, this room is packed and people are being turned away. This is for 2 reasons. This is the only remotely interesting session at this slot, and it is hosted in a rather small room. There is room for 150 to 200 ish people if I had to take a guess.


Tobias is a very good speaker. Swedish guy, and with a good sense of humor. The session went by quickly, and was very interesting for someone like me who uses and encounters T-SQL regularly without necessarily being knowledgeable enough to keep up to date with all changes.


The first thing he covered was a new way of generating ID values. It basically provides the same functionality as the IDENTITY field in normal database columns, but with the advantage of being unique across tables. In that respect they are like GUIDs, but you have a guarantee of getting sequential numbers.


Then there is the new ‘THROW’ keyword which can be used for exception handling in T-SQL within a try-catch construction. For now, the throw does not work across stored procedures, but that is on the todo list. I also learned a couple of things about RAISERROR that were new to me.


One very exciting feature I am looking for is the new support for window based calculations and aggregates. This feature allows you to calculate aggregate values across only a window of rows around the current row, or for example compare values with the previous row, where ‘previous’ depends on how your window is defined. Doing this with the current supported features involves either cursors or sub queries  which are error prone, ugly, and can make execution times explode.


The only problem with window based ranges is that once you start using them, it will be very hard to go back to your existing SQL2008 systems J


And finally, there are a lot of new functions that are basically only syntactic sugar, but which make life so much easier. Often, these are keywords that mirror what other environments like Excel do, and which are just very convenient and save you a lot of manual typing.


And for those who don’t know yet: Sweden once had a 30th of February J


When you are working with times and dates, you can get very weird edge cases and this is one of them. This is not really relevant to the topic at hand, but it does serve as a nice example that you can mention whenever someone says that time and date are easy.


DEV350: Using Windows Runtime and SDK to build metro style apps


This session was hosted by John Lam.


The room was packed. The session started with an overview of Metro, and how it uses the new Windows RT subsystem. There was an overview of the differences, like the fact that everything in RT is non blocking and asynchronous.


That concluded the powerpoint part of the session, and John proceeded with the demo. He built a metro style app in js, demonstrating the various things that were involved in making the application do something sensible.


I didn’t make any notes during this session, since it was all demo, and the entire demo pdf can be downloaded as well. It did again show the strength of Metro development.


It is worth mentioning that John is a very good speaker, and can take the audience along for a demo ride without rushing things or talking too quickly.


DEV368: Visual C++ and the Native Renaissance


This session is hosted by Steve Teixeira. My attendance here is a no-brainer. Steve is one of the best speakers at the whole of tech-ed. Even if C++ were not my favorite topic, I’d still be here.


I turned up an hour early for this session. Not because I expected a rush, but because I wanted to have a quiet place to type about the previous sessions. I didn’t get around to that because Steve was already there so we had the chance to talk.


One on-topic thing we talked about was standard conformance of the C++ compiler, which is a goal they are going for. When I asked about the ‘export’ keyword, Steve said it was removed from the standard. That kind of surprised me because I remember some ‘over my dead body’ quote from one of the committee members. I have to say it was a good decision. I remember an article by EDG which are the smartest compiler guys around, and they said that implementing it was very hard, and that it didn’t really work the way you would expect it to work.


Combined with the fact that there is no ABI for templates, it makes sense to finally get it out of the standard. If you can’t make the compiler standards compliant, then make the standard compilers-compliant J either way improves compliance.


Meanwhile, the crowd shuffles in steadily. Earlier on I joked to Steve that I had come early to beat the rush. By now the room is completely packed, and there were 10 to 15 people standing in the back of the room. A quick calculation says that there are about 130 to 140 people, which is amazing. I’d never have guessed that. I would have expected that it would be the same 30ish people I’ve seen in the other C++ sessions.


Speaking about people, the session had a graph early on about the age statistics for C++ programmers, to prove that we are not all greybeards. The average age turned to be about my age demographic: late 20s early 30s. As could be expected, the age curve dropped off with increasing age. There was one guy in the survey who was allegedly 92 years old. He was probably still waiting for a build to finish.


Steve talked about the renewed interest in C++, and some of the reasons for it. For one, with the variation of computing equipment (like ARM devices) cross platform portability is starting to matter again. And with C++ for the processing and for example XAML support for the GUI, C++ is a compelling option. Especially considering that memory footprint and cpu cycles have become important again with that variety of devices.


The fact that the language standard itself was finalized also has a great deal to do with it. Things like the auto keyword and shared pointer made a huge impact. There was an example with some old style C++ code on the left and the equivalent (using modern syntax) on the right. The right part was as readable as e.g. C#. Yet 10 years ago, we’d have looked at the example on the left and said ‘Yep, that’s some good clean C++ there’. It is kind of obvious why many people didn’t want to touch C++ with a ten foot pole.


With the new Metro style programming (which will be shown more in-depth tomorrow) a key point is that C++ apps can finally use the same designer and same designer patterns as C#, VB.NET or js programmers. This means you have up to date tools, AND you have the option to make your C++ app look cool.


With the introduction done, Steve covered things that Kate already touched upon earlier, like PPL and AMP. The demo was awesome. It was basically the visualization of a piece of paper, on which you could draw using touch. And then (again, using touch) you could take the page and flip it, with a live 3D rendering of the page as it would look if it were a real piece of paper. There were some additional ripple and wave effect that could be turned on and off. That was really impressive from a performance point of view.


Another important part of the demos covered the way you would design a Metro app in C++. I am not going to go in detail about that here, since this topic will be handled more in-depth tomorrow.


At the end of the demo there were some intelligent questions, which is not a surprise, given an obviously intelligent audience. When the session slot had ended and there was some time for one-on-one questions, Steve was immediately swamped. Clearly, interest in C++ is on the uptake.


DEV311: Taking Control of Visual Studio through extensions and Extensibility


This session was supposed to be hosted by Anthony Cangialosi and Anthony Lindeman. There was only one presenter, and I didn’t found out there were 2 names on the planning until after the session, so sadly I can’t say which of these 2 people presented the session.


I chose this topic because at this session slot, there was little else that was relevant to me, and VS extensibility is something I played with before. Incidentally, my experiences with VS extensibility were mentioned right at the beginning of the demo as ’the bad old days’.


It used to be that just for being allowed to use the extensibility SDK you had to register and be approved, and sign paperwork and jump through various hoops. Documentation and examples were not too great either in those days.


These days, you can extend without prerequisites and all you need is the Visual Studio SDK. From there, you are all set and you can start building both your VS extension and the deployment package needed to distribute it in a proper manner.


Here I didn’t take many notes either, because like the Metro session, it was largely demo driven. In this particular demo, the presenter started with sample boilerplate, and fleshed it out as he went along. The demo was ok. It looked interesting, but for now not something I can really use.


Wrap-up


Today was interesting. I learned a lot about Metro, and seeing it in the whole picture instead of just as a new type of desktop, it is starting to make sense.


The highlight of the day was of course without a doubt Steve’s talk. The session itself was of course interesting, but what made it special was that the room was packed. And again I think it is weird that there are more talks about C++ than all other languages combined. You won’t hear me complaining though.


Internet was up during the entire day with only a single glitch (as far as I noticed) so that is a definite improvement.


I also got my free book on Windows 2012 Server, which is nice. Speaking about books: to my amazement I discovered that this year, there is no bookstore in the exposition hall, or indeed anywhere on site. Whoever made that decision should have his head checked, because tech  books sell like hotcakes on tech events like these. Geeks love tech books at least as uch as free t-shirts.


 I’ve bought books every year I’ve been to tech ed. The guy at the MS Press booth had gotten many complaints already, and while he was explaining the situation to me, several other people dropped by and said ‘What?! No books!?’


By the end of the day I was dead tired and glad to get back to the hotel. I think I’ll turn in early tonight, after spending some more time playing with VS 2012 on my Azure machine.

Leave a Reply

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

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>