Monday, 02 July 2012
I'm headed to Australia tomorrow (I won't get there till Thursday though) and I'm going to be doing some C++ talks while I'm there. Both are aimed at folks who haven't been keeping up to date on all that's been happening in the world of C++ over the last few years.
On Tuesday, July 10th, I'll do a free Tech Breakfast on the new features of the C++ language in the standard once called C++0x and now called C++ 11. I'll demonstrate how a lot of these features are already in Visual Studio 2010 and some in Visual Studio 2012. It runs from 9am to 11 am in Sydney, and you do need to pre-register.
Then all day Wednesday, July 11th, I'll do a course on modern C++ development with Visual Studio 2010 and 2012. I'll cover language changes, tool changes, drill into my favourite feature - lambdas - and show some of the cool things they enable, and give you some advice on best practices for writing C++ today. This course costs $300 Australian and will be held in Sydney just once.
I realize many people who read my blog don't need to come and learn this material. But perhaps you know someone who does? There is room in both sessions for more people - and I want to reach as many people as possible, so please spread the word! Registration links for both session are on the SSW page announcing them
Monday, 26 March 2012
How's this for a renaissance? People are starting C++ user groups!
- The Jerusalem .NET/C++ User Group will cover both topics. They've had their first meeting already.
- The Central Ohio C++ User Group has also had its first meeting and will meet monthly.
- In Austin Texas they're calling it the C++ Meetup and the description sounds a lot like a user group
- The Belgian C++ User Group has its first meeting in April
It's so much fun to see this excitement springing up. There seem to be two popular topics for first meetings: either "What's new in C++ 11" or "Writing Windows 8 Apps". I think these two things arriving together - the huge language and library improvements (and the unexpected synergy of the language changes and the library changes) with the chance to write for Windows 8 in C++and XAML - is producing much more interest than there used to be.
And now the fun is spreading to Toronto! No, I'm not founding the group - I'm surely not the only C++ developer in Toronto after all. But I am honoured to be speaking at the first event on April 17th right downtown (pretty much Yonge and Bloor.) I'd love to dive deep into C++ AMP, or show how the Consumer Preview of Windows 8 is easier to code for, but I think I should begin at the beginning, so my talk is titled What happened in C++ 11 and why do I care? and has this abstract:
C++, both the language and the libraries that come with every compiler, is
defined by an ISO standard. The latest version of the standard, generally known
as C++ 11 after its approval last fall, was optimistically called C++0x
throughout the multi-year process that led to its adoption. Many of the language
changes (new keywords, new punctuation, new rules) and library changes
(genuinely smart pointers, threading, and more) have already been implemented by
vendors who were following the standards process closely.
In this session
Kate will introduce and demonstrate many of the highlights of C++11 including
lambdas, auto, shared_ptr, and unique_ptr. These are all supported in
Microsoft’s Visual Studio 2010. You can see how to make your code more readable
and expressive, easier to update, more correct (less bugs and memory leaks) and
faster, not by trading off among those possible constraints but by adopting
modern C++ which gives you improvements in all four areas at once. If you’ve
been ignoring the Standard Library, for example, you must see how lambdas make
all the difference and open a world of productivity to you.
A sneak peek of the next version of
Visual Studio will show you even more C++11 goodness.
If you've looked at my Pluralsight courses
, you'll know that my biggest challenge is going to be fitting this into an hour plus Q&A. This will be an overview, an overture if you like, and should whet your appetite for the meetings to come!
as soon as you can, please spread the word, and I hope to see you there!
Wednesday, 14 March 2012
People keep on releasing interviews with me. If you're willing to listen to them, I'm more than willing to keep on talking. There's remarkably little overlap in all of these.
On The Tablet Show
, Richard and Carl (yes, that
Richard and Carl) asked me about C++ in this wacky new world of Windows 8. We had the usual freewheeling conversation and covered a lot of ground in 49 minutes.
For PluralSight, Fritz
asked me questions about my latest course, and the industry in general. This one's just ten minutes, and there's a transcript if you'd rather read than listen.
Thursday, 12 January 2012
Perhaps not a great surprise, but today the precons for Tech Ed North America
were announced and mine is there too. It's well described in the previous blog post
and I'll be doing the same material at both events. So if Orlando, June 10th works better for you than Amsterdam, June 25th, terrific and I'll see you there! Registration
is now open.
Monday, 09 January 2012
Yay! Today I got news that registration is open for Tech Ed 2012 in Amsterdam, and with it confirmation that my preconference
has been accepted! This is great news for anyone who loves C++, because it's a C++ all day preconference! The title is C++
in 2012: Modern, Readable, Safe, Fast
and here's the abstract:
is gaining momentum as a development language, so whether you’ve never used C++
or stopped using it a decade ago, it may be time to brush up on your skills.
With a new standard release providing new keywords and capabilities, C++ is a
featured language for many of the new Microsoft technologies and enables
some amazing speed-ups of your application using libraries like PPL and C++
AMP. What’s more, Visual Studio offers tools to native developers that have
only been available for managed developers in earlier versions. This all-day
session will show you what all the fuss is about and give you the skills you
need to understand the advantages of C++ today and how to start applying those
benefits to your application.
Now, if you're an experienced and current C++ developer, you may not need to come to this session. But if you were thinking you needed a refresher, here's a great way to get one, and at the same time look at some of the cool new stuff that is available to you once you know C++. If you've never written a line of C++ code in your life, but you're solid in C# or Java so you know the basic syntax (if, while, etc) you should be able to follow this session, though it won't teach you all the fiddly bits of C++ syntax and make you a C++ developer from scratch. It should, however, give you the inspiration you might need to go and learn all that fiddly syntax, and understand why we have it. I am also hoping there will be a number of relevant breakout sessions you'll want to attend after getting a taste of what C++ developers can do, though we have to wait a little longer to find out about those.
I'm still working on the exact content, but my first draft outline looks something like this:
- Modern C++ with the Standard Library (demo of strings, shared pointers)
- Application Lifecycle Management for Visual C++ 11
- Leveraging Lambdas for the PPL and C++ AMP
practices for C++ developers today
This is 9am - 5pm (all day) the Monday before Tech Ed Europe starts, June 25th. You can register for the precon and Tech Ed now. And tell your friends! I would love to see a TON of registrations to ensure continued C++ content at Tech Eds around the world.
PS: Yes, I know that Tech Ed US is a few weeks before Tech Ed Europe. You didn't miss the US announcement; you shouldn't have to wait much longer for it though.
Thursday, 15 December 2011
The second part of my C++ Fundamentals course is now live
on the Pluralsight site. This one covers:
- The Standard Library - string, collections, and the like
- Lambdas - perhaps my favourite C++ 11 feature
- Exceptions - every C++ developer needs to understand exceptions
- Understanding Legacy Code - here's where you'll find out how C++ earned its reputation
These four modules build on the material I covered in part 1
- Context - to set the stage
- Tools - Visual Studio and Visual Studio Express
- Fundamental Types
- User Defined Types
- Flow of Control
- Pointers, Inheritance, and Polymorphism
One of the things I like best about this material is that char* strings and all the special cases to deal with them don't show up until the last module of part 2. Ditto the kinds of arrays you may have first learned. The kinds of gyrations C-style arrays and C-style strings put C++ programmers through are a large part of why people think C++ is hard. With std::string, std:vector, and other goodies from the Standard Library, C++ really isn't hard. Honestly!
Thursday, 01 December 2011
I'm in the middle of writing a number of SUPER COOL things that I will blog about as they finish. But interesting things happen even when I'm too busy to blog, and an interesting one happened today.
You know you should have a Pluralsight subscription, don't you? All the training you can watch (some of it by me) for as little as $29/mo? You can't go wrong. And if you're an MVP, or an RD, or a member of BizSpark, you don't even have to pay that! But if you don't have a free subscription and haven't paid for one yet, taking a free course is a great way to see what all the fuss is about.
Well, starting right now, you can do just that! Pluralsight and the Visual Studio folks are providing my Using Visual Studio course completely free. Just visit the Learn Visual Studio page at Microsoft and use the links. And if you like the course, consider getting a subscription - there are scores more that you will like.
Tuesday, 13 September 2011
I've been writing a course for Pluralsight that covers the fundamentals of C++ - types, expressions, basic syntax stuff, templates, pointers, polymorphism - and it has gone live
! During BUILD access to it is free. It uses Visual C++ Express, so you don't need to buy any tools to follow along. Lots of buzz at BUILD about C++, so if you want to see if it's a language you could use, here's a great way to find out.
I have more material coming on this, and some Windows 8 - specific material. This is just background. If you think you need to get up to speed on C++, here's how to do it. Let me know what you think.
Monday, 29 August 2011
For a long time now, whenever anyone asks me about support for particular C++0x (oh sorry C++11
) features in a given compiler, I've sent them to the list Scott Meyers maintains
. The format is kind of strange because it's exported from a spreadsheet, but the information is invaluable. If you'd like to see more compilers covered, try the wiki at apache
. Scott does gcc and Microsoft Visual C++; the wiki adds compilers from Intel, IBM, Oracle, and so on. You might be surprised to see the variations in coverage. Expect new versions to continue to add support as soon as possible.
Friday, 19 August 2011
I have talked about plenty of C++0x (soon to be known as C++11 or just plain C++) features over the last little while. Here's a nice summary by Danny Kalev
of the top features and why they matter. He covers lambdas, auto, the new ways to initialize instances (which hasn't been covered much elsewhere and contribute a lot to readability), suppressing default versions of functions (like constructors for example) or specifically requesting them (how cool is that?), nullptr (which I love because it eliminates a late night drinking argument about "what if someone #defined NULL to 3, would your code still work?", and rvalue references -- and those are just the language changes! His library coverage is super terse, but there are links in it if something (*cough* shared pointer *cough*) catches your attention.
There's no reason for a C++ developer to ignore C++11. This is big stuff, and reading these "what's new" lists from a variety of different people is essential for getting perspective on the changes. So read Danny's list!
Wednesday, 17 August 2011
Everyone knows that C++ is the language to use when speed matters. That's just a known fact. So here's a question: if you solved the same problem in both C++ and C#, using the generally available languages (the Standard Library for C++, the .NET Base Class Libraries for C#) and you didn't happen to know which parts of those libraries weren't implemented very efficiently, just wrote your apps -- which would come out faster and by how much?
Think you know? Of course, the answer is "it depends". Debug or Release builds? Laptop or handheld device? Whose implementation of the .NET Framework are you going to use - Microsoft or Mono? What chip are you running on? Oh, and to what extent are you deliberately setting C++ options that emphasize runtime speed? Also, did you choose an algorithm with a lot of generics or templates? C++ has a huge perf advantage there, but lots of benchmarks don't use generics or templates since they are solving one specific problem.An article on CodeProject
leapt into all of this feet-first and did some measuring. Along the way, "Qwertie" proved a universal rule of the internet: nothing will get you the answers you seek faster than posting the wrong answer. Want to know the exact date Bewitched switched Darrens? Find a place that discusses old TV shows and post your belief that there was only one, or that there were seven, or whatever, and people will correct you while the ads are still loading on their copies of the page. When Qwertie posted the first version of the benchmarking article, commenters were quick to say "but you made this mistake, and that mistake, and forgot this other thing" all of which led to a much better article.
Definitely worth a read. It gets you thinking about the things that truly affect performance. Absent-mindedly deploying a Debug build is going to cost you far more performance than your language choice ever will. Using a library in a performance-sensitive situation without understanding whether the library is high-performing or not will too. It's chock full of graphs like this one:
Don't read it to find out the answer to "is C++ faster than C#?" - we already know that. Read it to find out how to make your applications faster.
Thursday, 11 August 2011
I'm pleased to see that Kenny Kerr is writing his C++ column for MSDN
again. He's also blogging again and in a recent entry
, he provides some really plain-spoken advice to people looking for guidance:
- "You can of course still use MFC but I do not recommend it as modern C++ can do
a better job of supporting the Windows developer."
- "You should never again use auto_ptr for anything."
So there! I agree with these, especially the auto_ptr one. It was an attempt at a smart pointer that just wasn't smart enough. We have shared_ptr and unique_ptr now and they work in collections and are truly smart pointers. Use them and stop typing delete in your code entirely.
As for MFC, it does fill a need and I certainly wouldn't scrap a working MFC app just because the library is getting old (the facelift a few releases ago helped) but if I was starting a brand new application from File, New Project I would need a good reason to use MFC as my UI framework.
Tuesday, 09 August 2011
People often ask me what Visual Studio Ultimate offers that other versions do not. There's a handy chart on the Microsoft site:
The only problem is, if you don't know what "Architecture and Modeling" includes, it's easy to think there's probably nothing useful in there. So I was pleased to see a blog post by Susan Ibach from Microsoft Canada showing how easy it is to generate a sequence diagram from code, and how that can help you understand code you've inherited from a predecessor. That's one of the diagramming tools included in Visual Studio Ultimate.
Right click in some code, select Generate Sequence Diagram, set some options (does getting a property count? What about calls to methods of String or other .NET Framework classes?) and presto, you have a sequence diagram.
This sort of thing can save you a tremendous amount of time, and that means it can save your organization money. That's why some people buy Visual Studio Ultimate, after all. Having access to a tool like this is one of the ways I can "hit the ground running" when I join a project. If you need to do the same, make sure you're not ignoring a capability you already have.
Monday, 01 August 2011
I consider myself a pretty skilled debugger, and reasonably familiar with the things you can do in Visual Studio (My Visual Studio course Part 1
and Part 2
, for example.) Conditional breakpoints
in C++ and in C#
, breakpoints that only break every 10th time
they're reached, customizing the data tip
that shows when hovering over one of your own types, making data tips transparent
, and plenty more
have all been covered here in the blog over the years. But I still come across things I didn't know before, or didn't try before.
Take this blog post
by "Daan-Nijs" about the abilities of the watch window. I knew the first one, but the rest are new to me:
- Changing a value in the watch window
- Changing a type in the watch window
- Inspecting an array in the watch window
Then there's re-running or skipping code by dragging the instruction pointer - I only knew I could right click somewhere and say Set Next Instruction. Finally he includes a reminder of how to enable Edit and Continue. All this is for C++, but you're welcome to give some of the techniques a try in other languages and see what happens. Being a faster and more productive debugger will rocket you up the overall productivity leagues like nothing else.
Friday, 29 July 2011
Since Tech Ed came and went during my blogging hiatus, I didn't get around to providing links to some of the sessions you might want to see. It's time to correct that omission:
There were other sessions I attended, including a great interactive session that was not recorded called "C++ Renaissance at Microsoft: How the C++ Developers Can Get Involved" with plenty of conversation between Microsoft people and native developers. You might want to do a little searching on the main Tech Ed Video site
to see what interests you.
Saturday, 23 July 2011
So, you're a C++ programmer? You've written a Windows app or two in your time? Let me propose a little challenge to you. Write one. Only start with File, New and don't let Visual Studio generate any code for you. Write each line of it. Then explain it. No MFC, No ATL. That's what was asked of me a while back, and the result is a six-paper series
that has finally arrived on MSDN.
I have to say I really enjoyed the simplicity of the smallest Windows program possible. I also enjoyed making it better, which included making it more of a C++ program and less of a C one. I also covered a little Direct2D, a little COM, and a little "here's some other stuff you're going to want to read." If it's been ages since you wrote a Windows program in C++, or wrote one that wasn't all covered in barnacles from frameworks and libraries you might not want to rely on for simple things, I really suggest you give this series a read - it won't take long and you can use Visual C++ Express if you like - the first chapter includes links and instructions for getting all the tools you need. Better still, if you've never written a Windows in C++, why not give it a try and let me know what you think?
ps: Never blog that you're not blogging. Never blog about why you're not blogging, no-one cares. Just blog. Right?
Saturday, 02 April 2011
Here's yet another C++ team member on Channel 9. Boris starts out reviewing some "old days" things including the Intellisense background I pointed to recently. He explains in more detail why it's so hard to be the C++ team, needing to build an IDE for a language they can't control and that is used by such widely different people. I love that Boris appears to have framed and hung on his office wall someone's comment on a blog post. If you ever wondered whether what you type can make a difference, there's your answer.
With the history and reminiscing out of the way, Boris warms to a topic I haven't heard on Channel 9 before (though I have been hearing it in person) and that's the importance of C++ and specifically the Microsoft toolset, Visual C++, to the games industry. He also talks about how the games industry can be important to all the other developers as well, which I find intriguing. Definitely worth watching and not a rehash of the other C++ videos you may have seen lately.
Friday, 25 March 2011
Charles was busy during MVP summit! In addition to interviewing me
, he sat a number of MVPs down to talk about C++, being an MVP, and the like. They're from all over the world and they have widely different jobs, but you can see how much they love this stuff. And please notice -- they span a wide age range, too. The stereotype of C++ as the language for the grey haired developers is just a myth. If you wonder why anyone still uses C++, and why it's going to be very good for this industry that there are still C++ experts around, watching these videos will be an eyeopener.
By the way, Alon
is also an RD.
Wednesday, 23 March 2011
As you may have noticed the C++ team is really stepping up the communication lately. There have been hours of Channel 9 videos (I pointed you
to some good ones) and Diego has been blogging a lot. Recently he did a long post
(with references!) on Intellisense in C++/CLI - why it wasn't in Visual Studio 2010, why it didn't sneak in with SP1, and so on. Here's a level of transparency you just don't see these days:
...we simply underestimated the amount of work it would take to implement C++/CLI
in this codebase, and we couldn’t change our plans by the time we realized
it. ... In the end it was one of those hard cuts you have to make when dealing with
the real world resource and schedule constraints. It turned out that the work
was also too much work to fit into SP1. As soon as we wrapped up VS 2010, we
started work on C++/CLI IntelliSense, but it wasn’t ready in time for SP1. We
realize this wasn’t what you wanted to happen and an explanation doesn’t help
you get your work done if you are affected by this, but we want you to know the
Wow. Makes perfect sense and is actually a nicer reason than "we think you don't matter". Yet so few teams will hold their hands up and say this. It happens. It happens to every one of us pretty darn regularly. Kudos to the C++ team for not pretending it was all part of a plan from the beginning to leave it out. And do read the blog to understand just how much they were taking on.
Monday, 21 March 2011
If you listen to .NET-related podcasts, you've probably come across the Pluralcast before. David Starr talks to a wide variety of people and the passion shows, along with the skills. Last year
I appeared on the 'cast myself, talking about Visual Studio extensions. Now I'll be doing a small appearance regularly - still talking about Visual Studio and some helpful extensions or whatever else I want to share. There have been three of these so far:
- #36 - main guest is Scott Allen
- #37 - main guest is Craig Shoemaker
- #38 - main guest is Liam McLennan
I hope you enjoy the whole episodes, and learn a little something from them.
Saturday, 19 March 2011
I'm on Channel 9 a lot right now - partly because some things are getting published that were done a long time ago, and partly because being on campus for the MVP Summit makes it convenient to be interviewed. I love talking to Charles because he really cares about the answers to the questions he asks. So we talked for half an hour
about what it means to be an MVP, what C++ is useful for, what I like about C++0x, and that sort of thing. Since Charles started things off by mentioning previous conversations, let me toss in some links to those too - here's the Barcelona conversation
)and on the couch with the C++ guys
.) You can watch my hair change colour if you watch those oldest-to-newest. Diego was also nice enough to blog about this interview
, too, as was John Bristowe
of Microsoft Canada.
Thanks for the chat, Charles!
Thursday, 17 March 2011
Here's another pair of screencasts to simplify your Windows 7 development. Both cover Restart and Recovery - one is for native developers and the other for managed. As the screencast intros say:
Recovery and Restart (ARR) technologies enable developers to customize an
application's behavior when Windows Error
Reporting(WER) terminates the application due to an unrecoverable error.
For example, it enables an application to perform data recovery and cleanup
operations such as capturing application state and releasing resources before
termination. It also allows developers to specify that WER should automatically
restart an application that it has terminated.
I hope they help you do the right thing when your application blows up or the machine reboots.
Tuesday, 15 March 2011
You know I blog here a lot about Windows 7 goodies including taskbar integration. One of the questions I get pretty often is how to use tasks to communicate with the running app, such as changing your status, sending a new email, that sort of thing. I mentioned in an aside on another post that this requires launching some other application that communicates with the first
If you'd like to do that, it just got a little easier with the release of a "recipe" from Microsoft that packages up this concept and lets you use it with very little extra code. As it says on the Code Gallery page for the recipe:
This Taskbar Single Instance Recipe allows developers to easily develop applications that use "Messenger Like" tasks that change the state of the currently running instance, allowing it to react to incoming state-change notifications and act accordingly.
This Recipe includes:
- Native (C++) and managed (.NET) Source code for the Single Instance library
- Well documented native (C++) and managed (.NET) samples
To compile and run the recipe and samples the following items are required:
- Microsoft Visual Studio 2010
- Windows 7 – Note that only the samples require Windows 7.
Yes, this recipe is actually two recipes - one native and one managed, and comes with whitepapers explaining how it's done. I mentioned this in my Tech Ed Europe talk on Advanced Windows 7 development and it's finally released for you to use! Enjoy!
Sunday, 13 March 2011
Whenever new stuff appears in the Microsoft universe, native C++ developers can get to it first. That's because they can easily call Windows APIs or COM interfaces or however it's implemented. Managed developers need to wait until the new stuff gets added to the .NET Framework or to a particular managed technology, like WPF. Take taskbar integration, for example: adding tasks and destinations, getting a progress bar or icon overlay on your taskbar icon, and so on. From the very beginning you could interact with the taskbar from native code by making Windows API calls. The Code Pack is a popular managed wrapper from Microsoft that enables those interactions from managed code such as Windows Forms applications. In the early days of Windows 7, WPF developers also used the Code Pack - but now those capabilities are in WPF itself.
Does that mean that native developers get nothing new? On release day they gain the ability to call those APIs and that's that? Of course not. Native developers use frameworks and libraries to build their applications, and those frameworks and libraries in many cases are wrappers for Windows functionality. One of those is MFC and you should know that MFC has support for Windows 7 functionality.
If that's news to you, then watch my screencast on Channel 9 in which I cover jumplists and overlays with lots of demos. It's just one or two lines of code for each of
these. Users expect their apps to behave like
this. MFC makes it simple.
Friday, 11 March 2011
Writing samples and demos is tough. You want them to do more than say "Hello World" or draw a red square, but you want them to be simple enough that people can see the "new stuff" you're demoing (WPF, or Windows 7 taskbar integration) or multi-touch) in amongst the real business logic. It would be neat if they did something actually useful, because then you might keep it around on your machine and use it, but most things that are useful are too big to be demos.
Well here's a sample that lands in the sweet spot: Tasks.Show. You put in your tasks, things from your ToDo list, along with time estimates, and it keeps track of them and shows them to you. I like this view:
It uses touch to let you flick tasks into categories, and has taskbar integration to let you open a specific category, add a task, and so on. All the source code is available so you can see how it's done - it is a demo, after all. You can get more details and screen shots on the Windows Team Blog. Check it out!
Wednesday, 09 March 2011
I have two sessions
DEV303 | Modern Native C++
Development for Maximum Productivity
Breakout Session |
300 - Advanced | Developer Tools, Languages & Frameworks
C++0x, the next C++ standard, is almost upon us and it contains the most important updates to the language since the mid-90s. These new features bring more expressiveness and power to the native C++ developer. Microsoft Visual Studio 2010 has added support for some of these key features in order to enable these modern programming techniques. This session clarifies what features are in Microsoft Visual C++ 2010 and what is yet to come. It illustrates how new constructs such as lambda expressions enable better use of existing libraries and how your code can be simpler, safer and faster all at the same time. Also, see how simple it can be to implement concurrency in your application and how Visual C++ 2010 supports the difficult task of debugging parallelized code. If you are itching to show off how C++ is one of the coolest languages on the planet, this talk is for you!
DEV304 | Advanced Programming
Patterns for Windows 7
Breakout Session |
300 - Advanced | Developer Tools, Languages & Frameworks
Windows 7 development in managed code can be very simple, especially for those using the Windows API Code Pack. But there's more! Your integration with Windows 7 doesn't have to be limited to simple interactions with the new API. This session goes beyond the simple and into aspects of Windows 7 development that have in the past been left for you to explore on your own. See how to create a jumplist with a task that delivers a command to your application, as Messenger and Outlook do. Explore a simple and powerful recipe for connecting to Restart and Recovery with minimal effort. Discover how Trigger Started Services can reduce your power footprint while giving your users better responsiveness. Explore all that libraries have to offer beyond "File Open" and why using a library is a better approach than having a user setting for "save directory."
I'm looking forward to it. If you haven't registered
yet, you should!
Saturday, 05 March 2011
The pace of C++-relevant video releases on Channel 9 sure feels like it's increased. I watched a few recently (I download them and then watch them in my copious free time) and they happen to fit well with some links I've been carrying around for a while, meaning to share.
Let's start with Herb Sutter talking with Erik Meijer about C++ and whatever else they felt like talking about. The resulting Channel 9 video is a must-watch, and for once I didn't crank it to 1.5x or 2x speed as I usually do with video interviews. When they get into the part about deriving future<T> from T, you might want to pause it and go read Thomas Petchel's post on automatic type deduction. And during the lambdas-and-closures part, let me recommend a quite old post by Eric Lippert and a followup to it that discusses how these things work for C# and how it's a little different in C++.
Then another two-smart-people talk, with Mohsen Agsen and Craig Symonds. It's great to get the high-level perspective of the value of C++ to any software firm. I love that phrase, dark matter, and you may have heard it from me before. After you've watched that one, you need to go immediately to Tony Goodhew's interview where he puts some numbers out that will drop your jaw.
I know, I'm asking for like 2 hours of your life. Even if you don't develop in C++ any more, you should watch these three videos. You really should. Call it industry research if you like. And if you wish you knew a C++ developer, you do
Tuesday, 01 March 2011
Are you doing Scrum? Do you use TFS? Then you should check out Urban Turtle
. Brian Harry
did (yes, that Brian Harry) and he really liked it - his blog post makes a great introduction. It gives you rich visibility onto your project and lets you work with it your own way. You can download a 30 day free trial to see if there is a good fit with the way your team fits and works.
If you like it, let me give you a tip. If you go to DevTeach
in Montreal (which is so worth your while to attend on its own) you will get a 5-user license of Urban Turtle, which means you're effectively going to DevTeach for half price. And you can hear me speak on Windows 7 development, too.
Sunday, 27 February 2011
Here's an interesting blog post
. Say you use MFC and are wondering whether anything was added to it in a particular release. What tool would you use for that? How about CppDepend? If you've never used it, seeing how it provides the illustrations for this post should show you the appeal of it. Either way, you're going to learn something.
Friday, 25 February 2011
Pete Brown is a WPF guy and I've learned a lot from him. Now I get to watch him learn. Recently he wanted to write an add-in for IE and he decided to do it in C++. You can see how he struggled through it and get some tips of your own in the detailed post
he wrote about the experience. I agree with the commenter who said you should only run Visual Studio as admin when you know you're going to do a step (like registration) that requires elevation, and you should run non-elevated the rest of the time, and the one who tweaked the string code to take advantage of being in C++. If you have some tweaks of your own, stop by and add a comment.
Tuesday, 15 February 2011
Did you watch the whole "Introduction to STL" series on Channel 9
? As I said when part 10 appeared, there is no universe in which this series is really introductory. So when I tell you that Stephan has now started an advanced series
, you need to take it seriously. Here's how Charles entices and warns us:
This series, Advanced STL, will cover the gory details of the STL's
implementation -> you will therefore need to be versed in the basics of STL,
competent in C++ (of course), and able to pay attention! Stephan is a great
teacher and we are so happy to have him on Channel 9, and C9 is the only place
you'll find this level of technical detail regarding the internals of the STL.
There are no books. There are no websites. This is Stephan taking us into what
is uncharted territory for most of us, even those with a more advanced STL skill
Me, I'm enticed. And I'm watching. You should be too. (But watch the first ten first, or the minute you start to feel lost.)
Sunday, 13 February 2011
I've written about "banned APIs" before - let's start with this link and if you read it, it has a link to a previous post, and go on and follow that link and it has a link to a previous post and so on and so on. To summarize, there are three ways to ensure you are not using banned APIs in your C++ app:
- You can use the extension I blogged about. It highlights places in code you're editing or typing that calls a potentially unsafe function. That's great if you're typing fresh code,not so great if you just inherited a million lines of C++ and aren't sure if it's vulnerable to buffer overflow attacks.
- You can compile with /W4, and deal with all the C4996 warnings (and use code analysis or code review or generally find the places that someone has suppressed that warning.)
- You can include banned.h, which controls whether these unsafe functions are marked deprecated or not
None of that has changed. What I wanted to point out was a recent blog entry
from the SDL team alerting us that banned.h has been updated, and I also spotted a video
on TechNet (why a developer-focused thing is there I don't know) that shows it in action. If you write C++ code, you should be using one or more of these techniques.
Monday, 07 February 2011
The architectural tools in Visual Studio Ultimate are fantastic. Often, people think they're just for for managed code, though. Not so! Here's a page on MSDN
that shows how you can use Layer Validation to validate your architecture. You'll need the Modelling and Feature Pack and parts are a little fiddly, but it can be done!
No reason to assume the architecture tools are not for C++ developers, too.
Tuesday, 01 February 2011
Like a lot of folks, I have a Windows Phone and I enjoy it a lot. I've filled it up with (free) games and they pass the time quickly when I have to wait in line or otherwise have an empty minute or two. C++ MVP Marius Bancila had the same experience, but unlike me he responded by writing a version of the game in MFC so he could play it on his own PC as well as on a phone.
You can get the source from his blog post, and another post and its comments (mostly in Romanian - Bing Translate is your friend there) have a nice discussion of performance issues. After all, whenever two or more C++ programmers gather together, someone is going to have an opinion about performance. Take a look for yourself!
Sunday, 30 January 2011
There are some really amazing WPF applications out there, and many of them are extraordinarily beautiful. I am not very good at making beautiful applications, though the WPF themes
help avoid the "grey boxes on a grey background" look I usually achieve. Now if you want to develop an application that presents a whole new paradigm, there should be someone on your team who really "gets" user experience and how colours work together and so on. But what if you just want to make the same sort of apps you've always made, using the latest technology instead of something a little older? You want to think the way you thought when you were doing Windows Forms, for example, and use the same tools, but end up with a WPF application or a Silverlight application.
Well, Pete Brown has an interesting blog post
speaking directly to this kind of developer. He makes the case that for these kinds of applications, you don't need to add a designer to the team. Plenty of screenshots to support his theory - see what you think. I think I agree, myself. Because the post was last year, there's lots of interesting conversation happening in the comments, too, so be sure to read those while you're there.
Friday, 28 January 2011
Despite this rather famous xkcd comic, most developers would rather spend as little time compiling as possible:
But most of us how no clue why a build takes as long as it does, or how to make a project build faster. I mean sure a Clean and then a Rebuild will take longer than an incremental build. But beyond that, which is quicker - a debug build or a release build? Debug puts more information in, but it doesn't optimize - which wins? Does it make a difference if you keep Visual Studio up all day or if you close and re-open it from time to time? Are there options you can set that make your builds faster? All this and more is covered in remarkable detail in a new blog post from the Visual C++ team. You need to read it.
Saturday, 22 January 2011
The revisions to the C++ standard, headed to producing a new C++ standard which is still nicknamed C++0x, are proceeding at their stately pace, and will for months yet. But since a number of compilers are supporting
more and more of the functionality and syntax, which are pretty much locked down now, we can adopt much of it today. (I don't know why some people are running around claiming that because the standard isn't released yet, no-one should be using any of it, but when you bump into such people, you can send them to me.)
I came across an interview
with Bjarne Stroustrup, the father of C++, at CodeGuru. If you're wondering why the standard is so far behind schedule, what the very first C++ developer thinks about the very newest C++ developers (undergrad students), and how risk feels to a standards committee, then you will enjoy reading this, as I did. The lambda syntax on the first page isn't quite right, but you can fix that up if you need to. There are plenty of lambda examples here in my blog.
Give it a read!
Tuesday, 18 January 2011
I don't think I ever linked to this Tech Ed Europe talk. Ale Contenti talked about Application Lifecycle Management (ALM) features for C++ developers. Now it's featured
on the Visual C++ Blog. There are useful links in the comments, also.
I saw the talk live and I liked how personal Ale made it. If you wonder whether any large C++ projects rely on Team Foundation Server, you could hardly have a nicer example than this one!
Wednesday, 12 January 2011
Since midsummer I've been watching the "STL on STL" series accumulate on Channel 9. The lectures appeared as "part 1 of n", "part 2 of n" and so on until, in the bleak midwinter, part 10 of 10 appeared, so they must be done. Here are some links to them all:
There really isn't any universe in which the material this series covers can be called Introductory. When Stephan has finished introducing you to the STL, you will know an awful lot. And in this century, knowing the STL is a vital part of being a C++ developer. Many developers are scared of it: they think it's difficult and complicated. And to be honest, it can be. There's an awful lot going on and there is a lot to learn. Watching these videos, you can see how much Stephan LIKES this material, likes this library, and he's clearly not scared of it or trying to impress you with how difficult it is. He wants you to know all this. And if you follow along (and even do the homework!) you will catapult yourself forward in your STL knowledge and abilities. Take the time to do it, you won't regret it.
Monday, 10 January 2011
The Visual C++ team, in addition to tweeting and blogging regularly, is now accumulating a week's worth of links and stories at a time and publishing them at paper.li. If you don't compulsively check in to the C++ world every day, it can be a great way to stay in touch. Even if you do, you might discover a source you're weren't checking before. It's a little less obtrusive than other ways of sharing links, I think. Check out the C++ Weekly and the team blog post introducing it.
Wednesday, 29 December 2010
Visual Studio 2010 comes with a whole pile of project templates (C# WPF project, that sort of thing) and snippets. They get you started on new projects and save you a lot of time. But if you're a StyleCop user, they can frustrate you, because the code they generate for you can generate plenty of warnings.
The solution: new versions of these snippets and templates that are StyleCop-compliant. Plenty of XML comments, nothing left to default, generally nice code. Doug Holland has a blog post on this
with plenty of examples and links. Take a look!
Monday, 27 December 2010
I'm a big fan of Visual Studio 2010 extensibility; I've given talks at various places about extending Visual Studio yourself and using the gallery to find great extensions. I recommend specific extensions as part of other talks and there are many I can't live without. I came across a fun list by Terje
Sandstrom of the extensions they like to use at Inmeta. I completely agree about Pro Power Tools, but I would also add Presentation Zoom and Code Snippet Designer. By the way, the All in One Code Framework is also listed on the gallery. It's just a link over to the CodePlex site, but it's a way to find it if you missed one of the zillion links from my blog.
If you're using Visual Studio 2010 and you're not taking a little time to explore the gallery and tweak the way your copy works, you're missing a chance to be more productive and to enjoy Visual Studio more. Take a look!
Wednesday, 15 December 2010
Those hardworking elves at the All in One Code Framework keep releasing more samples
. They've added some ASP.NET samples (including a very interesting "get location from IP address" one) and some Windows 7 shell extensions, specifically a preview handler. Ah, the good old .recipe file type - an old friend of mine. But as always the samples are going to save you hours and hours of time.
Here's an index to all the samples
for you to explore. You might be a little astonished if you haven't checked it out before, they have:
Slowly but surely the samples are accumulating to live up to the name. This should be the first place you look when you want to take on a new task. Generally speaking, everything is available in native C++, C#, and VB (the exceptions are things you can't do in native C++, like ASP.NET) with the language included in the sample name (look at CppWin7TriggerStartService, CSWin7TriggerStartService, and VBWin7TriggerStartService for example.) And remember, if you don't see what you want - you can ask for it
Monday, 13 December 2010
At the moment these are announced
in the USA only. A full day of client development training for Windows 7, including IE9 and SL OOB. They say:
We will look at application compatibility and transitioning your applications to
Windows 7, integrating with the Windows taskbar, developing for IE9, utilizing
the cool functionality in the Sensors and Location Platform so that your
application better responds to its current environment, leveraging the
multitouch capabilities (especially in kiosk scenarios), and creating
Silverlight 4 out of browser applications. This event is a unique opportunity,
partnering classroom learning with hands-on-labs and leveraging experts to
advise you so we can help you “win” with Windows 7.
You bring your own laptop with VS 2010, the Code Pack
, the Windows 7 Training Kit, IE9, and Silverlight 4 installed (there are links on the bootcamp
page) and do the labs as you go. The training is all free and you'll get hands on experience right while you're there. (It doesn't say so, but my guess is this is all managed code and that the labs are in both C# and VB.)
And if there isn't one near you, you can help arrange one! It's all packaged as an event-in-a-box so all you need is a trainer who'll agree to deliver it and a room to hold it in. But check the dates and locations first -- there are over a dozen sessions scheduled already, so perhaps there's one near you.
Saturday, 11 December 2010
Back on December 7th, Jason Zander announced
the beta of Service Pack 1 for Visual Studio 2010. December announcements can often go un-noticed, but you should pay attention to this one. You can get the beta
and start using it in production immediately.
What's in it, and why does a service pack matter, anyway? Well this one brings Silverlight 4 Tools for Visual Studio "into the box", updates some MFC capabilities
, and fixes things people raised on Connect
. (Remember, complaining about missing features or bugs to your cubicle mates may make you feel better, but raising them on Connect gets them fixed. I should know, I submit things there and they get fixed.) STL has a comment on the VCBlog post
that spells out many of the fixes in detail.
Take a few minutes and update your Visual Studio, especially if you're a C++ developer, whether MFC or C++0x (or both, of course.)
Saturday, 27 November 2010
People say you can't get unit test support from Visual Studio for native code. That's not strictly true. Your tests will need to be managed code, but that doesn't mean the code you're testing needs to be.
As I hope you know, it's super easy to call native C++ code from C++/CLI - include the header, link to the lib. So here's the deal. Make yourself a lib that holds all the code you want to test. This can be completely native code, no problem. Build your UI (or your web services layer or your service or server or whatnot, I don't mean by UI an actual interface that a user clicks and types to, I just mean the part of your app that consumes your business logic) in native code if you like. Or in managed code, that's cool too. Then create a C++/CLI test project that includes the header for the logic, and links to the lib. There you go.
For the gory details including precisely what menu items to select and how to set up the project, John Socha-Leialoha
has you covered. I love his conclusion:
After so many years writing in C#, I never thought I would enjoy C++
programming again. I was wrong. Using TDD to write C++ code is almost as nice as
writing C# code, and I’m really enjoying the experience.
Saturday, 13 November 2010
Wow, these things get up there fast! My sessions were very well received and I had such a great time doing them! In the order I delivered them, they are:
- Women In Technology Panel - Claudia Woods, Freena Eijffinger, Paula Januszkiewicz, and Rhonda
Layfield joined me to take questions from the audience and talk about what was on everyone's mind. There's really no video - just the title slide for the whole hour. Please listen!
- The Windows API Code Pack: Add Windows 7 Features to Your
Application - This one includes screen capture so you can follow along in the demos. You can also download the powerpoints from this page, and as I mention in the talk, the demo code is the samples that come with the Code Pack.
- Modern Programming with C++0x in Microsoft Visual C++
2010 - I had a great time delivering this talk even though it was the first time I delivered this version of it. The attendees responded by putting the talk in the top ten for the whole conference - thankyou! It, too captures the screen and slides, and you can download the powerpoints.
- Advanced Programming Patterns for Windows 7 - Another talk I was doing for the first time and I enjoyed it too. If you'd like the sample code, stay tuned - I will blog when the recipes are released. The slides are with the video of the screen and slides.
If you came in person, thank you! If you couldn't be there, please watch the videos and leave me a comment. Speaking on technical topics really is the most fun you can have standing up, and I can't do it without audiences.
Thursday, 11 November 2010
Pluralsight has some great offers for user group leaders
that you should really know about. Even if you don't lead a group, make sure your leader knows, because some of these offers are for members. They're offering to send swag, subscriptions, and speakers (oh yes, that could include me, it sure couldn't hurt to ask, right?) to groups. What's more, unemployed user group members can have a free one-month subscription to the Pluralsight On-Demand! library
- a fantastic all-you-can-eat way to get your skills modernized and get you back working again.
I wrote Windows 7 and Visual Studio Extensions courses for the library, and am working on plans for my next one. These are great people who really want everyone to learn as much as humanly possible, and work hard to make that happen. Take them up on this offer and you won't regret it!
Friday, 05 November 2010
You may have noticed that the fall tour I'm doing features morning talks that go till about 11:30, and evening talks that start at 6pm. I've decided that between those two, I'll spend the afternoon in a coffee shop and host an "on the road coffee and code". As I explain on the Coffee and Code page I keep for this purpose, this is really informal. Just stop by, say hi, we can talk about whatever you like. If you were at the morning session, you might want to just walk with me from the venue to the coffee shop and continue the conversation. Or if you're coming to the evening session, you might want to try to find me during the afternoon to ask something specific, then head to the venue together. Or maybe you have a topic to discuss that has nothing to do with Building Awesome Windows 7 Applications in managed code: a C++ question, or an extending Visual Studio 2010 question, or whatever. That's great, and the Coffee and Code format is just the place for us to have that chat.
If you live or work near the venues for the fall tour, I'd appreciate your suggestions (by email or twitter) for where to hold these. Obviously we need wifi, power, and a table we can hog for most of the day. My default choice is Starbucks, but if you know a better one that I can easily walk to, please tell me about it. Once I've chosen the location I can finalize the times.
Looking forward to meeting everyone,
Monday, 01 November 2010
Here's something that happens to me a lot. I'm working on a project that is mostly Technology A, but I need a little Technology B. I want a sample or two to show me what it can do. I search the web, but often find mostly things written by people who don't know what they're doing and are posting their (possibly flawed) code into question-and-answer forums. I search MSDN, but often the newest technologies don't have their samples yet. I also remember to check if the All-in-One Framework people (I blogged about their coding standards document earlier) have anything. And if I still get nowhere I start asking people I know if they have one.
Well, now those helpful folks at All-in-One are kicking it up a notch. And remember, they cover all technologies and languages related to Microsoft tools. (Want to know more about them? Here's a fun video.)
And this goes back to one of my earliest blog posts - what you want may be what I need to give. Imagine it's your job to decide what samples to write. How are you ever going to find out what developers out in the big wide world want samples of? You could come up with a great idea and then find out people already had all the samples they needed for that. So that person wants ideas for samples. And here you are needing a sample. See how that works?
Just visit the wiki page and follow their instructions. It's a tad more complex than "shoot me an email and tell me what you need" and for good reason. Give it a whirl if there's something you need!
Sunday, 24 October 2010
, the reference application project from the C++ team that doesn't use MFC or the .NET Framework, is back with another sample. You've seen nice graphics in the way photos are treated, a ribbon UI, and now you can see social media integration with Flickr uploads
, touch support, and Windows 7 jumplist support. And remember, all the code is available for you to explore and learn from.
Take a look and see what you think. If you want to know how to build a modern UI and a modern set of functionalities (like web services) then this is the reference application for you.
Sunday, 10 October 2010
This is really fitting, isn't it? You have a product code named Dev10 and released as Visual Studio 2010 (with the tens not related to each other - see my history
of Visual Studio and Visual C++ version numbers and release names). And today is 10/10/10 no matter what date format you prefer. So today is a great day to take a quick survey
about Visual Studio 2010. Seven questions. I recommend you read them all before you start answering because they are asking about different aspects of the product and you wouldn't want to answer a question about speed with your thoughts about ui features. But it will take almost no time so go and do it.
Friday, 24 September 2010
Monday, 20 September 2010
actually slipped out at the end of August with little fanfare. But you really should check in to it. First, if you're already a Code Pack user, you'll want the update for the bugfixes and related tweaks. If you're one of the people who looks at the source code to this useful library, for example for an interop reference, you're going to find it much improved. One really obvious thing is that all the samples are now happy to convert to VS 2010 which had been an issue for me with 1.0.1.
As well there are three new capabilities: Shell Object Watcher, Preview Handlers, and Thumbnail Handlers. Shell extensions used to be offlimits from managed code because they run in process with either the shell or whatever process launched them (which could be anybody's app that uses the Common File Dialogs) and you were forbidden (but not prevented) from using managed code in that situation. The issue was that if the launching process was already managed code and it had a different CLR loaded, then weird things would happen
when your managed code wanted your own CLR. But now that restriction is lifted, so you can write preview handlers (which are out of process, so you were allowed to write them before) and thumbnail handlers (which are in process and therefore were native code only before) for your own file types. The Code Pack makes that pretty simple, all things considered.
Download it, install it, and if you have issues someone is reading and responding on the discussions tab
, so please join the conversation.
Thursday, 16 September 2010
It took a while for the session catalog to update online, but it's official now:
DEV311 - Modern Programming with C++0x in Microsoft Visual C++ 2010Session Type: Breakout Session
Track: Developer Tools, Languages
Speaker(s): Kate Gregory
Why wait for the C++ committee to finish the
specification when you can enjoy much of the power of C++0x today! C++0x, the
next C++ standard, is almost upon us and it contains the most important updates
to the language since the mid-90s. It even accepts the existence of multiple
threads for the first time in the history of the language. Needless to say,
these new features bring more expressiveness and power to the native C++
developer. Visual Studio 2010 has added support for some of these key features
in order to enable these modern programming techniques. This session clarifies
what features are in Visual C++ 2010 and what is yet to come. It illustrates how
new constructs such as lambda expressions enable better use of existing
libraries and how your code can be simpler, safer and faster all at the same
time. If you are itching to show off how C++ is one of the coolest languages on
the planet, this talk is for you!
WCL322 - The Windows API Code Pack: Add Windows 7 Features to Your
ApplicationSession Type: Breakout Session
Track: Windows Client
Accessing new Windows 7 features is a challenge from
managed (.NET) code. The level of interoperability required is out of reach for
many developers. The Windows API Code Pack for the Microsoft .NET Framework is a
sample library you can use in your own projects today that provides access to
new user interface features (taskbar jumplists, libraries, sensor platform and
more) as well as "behind the scenes" features that make your applications more
aware and responsive (restart and recovery, power management and more.) Discover
a shortcut to Windows 7 development for Microsoft Visual Basic and Visual C#
programmers and get started today.
I've done talks with these titles and abstracts before, but I'm not repeating those this time. I'm rejigging the demos pretty substantially and generally rewriting the talks. Register now, and I hope to see you there!
Sunday, 12 September 2010
Over six years ago, I helped to found the East of Toronto .NET Users Group
, because I didn't want to drive all the way across Toronto to attend user group meetings, and I was pretty sure I was surrounded by others who felt that way. The meeting location has varied over the years but is always in Oshawa or Whitby. That's about a 45 minute drive from my house, and never slows down because of rush hour traffic. I get to as many meetings as I can.
About a year and a half ago, the Markham .NET Users Group
kicked off, for much the same reason - wanting to learn more, but not wanting to drive for hours to get to meetings. And now our schedules finally mesh and I can speak there. It's also about 45 minutes from my house and immune from traffic problems.
So, on October 25th I will be speaking
in Markham, on Extending Visual Studio 2010
. I hope to cover both finding and using extensions and a tiny taste of writing your own. If you live closer to Markham than to downtown, or North York, or Whitby, then please come out and learn how to make Visual Studio your own! I'll be bringing some cool prizes, too - free Pluralsight training
, for example. Please register
so we know how many to expect.
Saturday, 04 September 2010
Back in July, I mentioned that my Extending Visual Studio course for Pluralsight was live. As I completed the course, it just kept growing and growing, so in the end it became two courses.
Customizing and Extending Visual Studio 2010 Without Code covers macros, snippets, templates, and so on - ways that you type stuff into a file, and thus make Visual Studio behave differently, but don't actually write C# or VB or C++ to make that happen. The modules are:
- Overview of Visual Studio 2010 Extensibility
- Why write extensions for Visual Studio?
- Visual Studio Macros
- Visual Studio Snippets
- Getting and installing extensions for Visual Studio
- The Visual Studio 2010 SDK
- Visual Studio Start Page
- The VSIX Format
- Deploying Templates
Customizing and Extending Visual Studio 2010 by Writing Code covers the rest of the story - cases where you actually write and compile code (in this course, the demos are all in C#) and thus make Visual Studio behave differently. The modules are:
- MEF, The Managed Extensibility Framework
- Writing Editor Extensions
- Testing and deploying editor extensions
- Visual Studio Add-Ins
- Visual Studio Packages
- Extending Modeling and Diagramming tools
Together, these courses total 9 hours. Please let me know if they help you!
Thursday, 02 September 2010
I'm having a Coffee and Code of my own in downtown Toronto on September 23rd all afternoon. Actually, I'll start at 11 and be there until 6 to catch the "stop by after work" folks. If you've heard of Coffee and Code at all, you know how this works. If you haven't, I've made a page on our web site about it
. Just drop in and ask me "Is it true that the C++ language is getting new keywords and stuff? How can that be? And does it really matter?" or "Do you have the Windows Phone 7 tools installed? Can you show me an app on the emulator?" or "Is Visual Studio 2010 really nicer than Visual Studio 2008?" or "What local user group meetings should I be coming to?" or whatever else is on your mind.
So stop by any time between 11 and 6 on the 23rd to the Starbucks at Yonge and King. I'll be at the big table at the back, just walk up and say hi. We'll talk about whatever is on your mind, maybe some of you will talk amongst yourselves, maybe you'll show me what you're working on. I'm looking forward to it!
Sunday, 29 August 2010
I somehow missed this John Robbins blog post
from back in May. He calls out an excellent presentation on writing data structure visualizers presented at BoostCon 2010. Here's the title slide:
Oh yes, this is a fun talk. I wish I had a recording, but the slides alone are entertaining and useful. I am already planning to put some of this code into practice, and I must find time to check the other talks, too. The links are in John's blog post.
Monday, 09 August 2010
Visual Studio 2010 has pretty cool Windows 7 integration. It gets jumplists right, for example:
But it could do more, and this little add-in adds some fun extras.
Here's a taskbar progress bar overlay during a build:
(If your build results in errors or warnings, you'll also get a taskbar icon overlay when it's done letting you know about them.)
And here we have handy thumbnail buttons - for build, debug, and start without debugging:
Give it a whirl! You can download it from the gallery, or use Tools, Extension Manager, Online Gallery right in Visual Studio and search for Taskbar.
Tuesday, 03 August 2010
Recently I had a nice chat with David Starr on the Pluralcast
about Visual Studio Extensions. This topic is just so much fun. Visual Studio is where most of us live all day, and making it work perfectly for us is incredibly appealing. The introduction of the VSIX format with Visual Studio 2010 takes so much of the deployment pain away and is really changing the landscape of who is willing to write and share handy little things that make Visual Studio a tiny bit different - in a good way.
If you want to find some great extensions, do check out the Visual Studio Gallery
or click Tools, Extension Manager and then click Online Gallery. There you can search for Triple Click, Ctrl-Click Go To Definition and many more. You can also look around to see if anyone's implemented your fun idea.
If you'd like to learn how to get in on the fun, please do check my course
- I am having such fun writing it and as always learning a few things I never knew as I go. Also check the links David has on the Pluralcast page - they will get you started.
Saturday, 24 July 2010
The Productivity Power Tools is a super cool pack of extensions that will make Visual Studio 2010 tremendous fun, and make you more productive. Now the team has announced a new version. This lets you turn individual tools on and off, so if you love Highlight Current Line and Go To Definition, but hate Align Assignments, you're in luck:
There's also new tools in the pack. Solution Navigator "merges functionality from Solution Explorer, Class View, Object Browser, Call
Hierarchy, Navigate To, and Find Symbol References into a single view" according to Adrian Collier, and lets you pin tooltips of information near the place in the code where you use them, pops up previews of image files when you hover over them in the tool pane, and just generally reads your mind to make you a happier and more productive developer.
This package had me at "Go To Definition" but these additions make it even more of a must have. You can install right from within Visual Studio 2010, too. Choose Tools, Extension Manager. Click Online Gallery. In the search box type Productivity.
When you see this dialog, click Install:
You'll be prompted to restart Visual Studio:
Click Restart Now and wait a sec. And that's all it takes! You really will love it.
Tuesday, 20 July 2010
I mentioned I've been recording videos. That's because I'm doing another Pluralsight course. This one is on Customizing and Extending Visual Studio. About half of it is live already:
- Overview of Visual Studio 2010 Extensibility
- Why write extensions for Visual Studio?
- Visual Studio Macros
- Visual Studio Snippets
- Getting and installing extensions for Visual Studio
- The Visual Studio 2010 SDK
- Visual Studio Start Page
- The VSIX Format
There's more to come, of course - I'm about half done. I'm really enjoying this material. You can get your work done a lot faster if you tweak Visual Studio to meet your needs. It doesn't have to cost you money and it doesn't have to cost you much time. Take a look!
Wednesday, 14 July 2010
Here is something I've been asked more than once, and seen asked on various forums as well. I'll paraphrase rather than quote one specific asker:
We have an application written 15 years ago that's been working flawlessly. But when we run it on Windows 7, the users can't find the files it writes. Worse, there are no error messages, so they think they've saved the files, but when they go to C:\Program Files\MyGreatSoftware\UserExports - the files aren't there!
Often, the question trails off into a rant about how sneaky and mean Windows 7 is to somehow prevent access to Program Files but not give error messages. The rant might also include a paean to how amazing the lost files were and how many workyears of productivity have been lost now that these files cannot be found, and why this means you can't trust Windows to do something as simple as write a file to the hard drive. Sometimes, the asker has established that this is related to UAC and they are recommending everyone turn it off to avoid this disaster. I thought I would make some less drastic suggestions.
First, your files are not lost. A few people know this, but they then claim the files are almost impossible to find and no end user will ever find them. Let's tackle this one first because if you know this trick you may be able to get by without changing anything else about your application. Tell the user to go to the place they expect to find the files, say C:\Program Files\MyGreatSoftware\UserExports. Then have them look in the toolbar for a button that says Compatibility Files. Click it. Ta-da!
Ok, now the next thing is, why the heck are your files being written there? Because you are trying to write to a protected area and you don't have a manifest. You have several things you can do about this, and they boil down to two main things:
One, don't write to a protected area. You can get this by installing somewhere other than Program Files (not a good idea) or by changing the application to write to a better place. Two, get permission to write to the protected area. This means running as administrator. Train the users to right-click Run As Administrator when they run the app, or train them to set the Compatibility Settings for the app (neither very likely) or ship the application with a manifest that includes requireAdministrator. Now matter how you arrange this second thing, your users are not going to like agreeing to the UAC prompt every darn time. So really, that brings you back to number one, don't write to a protected area. Use AppData instead - there's a simple function call to get that path on any machine (including older XP machines) and you'll be in fine shape. If you think your users can't find that, and the files are for the users and not just some internal settings, then use a folder under Documents - again, there's a simple function call that will get you the path.
If virtualization makes you nuts - that your code thinks it's writing to C:\Program Files\whatever but really it's writing somewhere else, and the OS is cheerfully lying to it and saying all the writes succeeded - then put a manifest on your app. Doesn't matter whether it's requireAdministrator or asInvoker. Doesn't matter whether it's embedded (VS will embed them for you from 2008 on easily, and there are tools that do just manifest adding) or just a file of XML in the same folder as the exe. Once the app has a manifest, virtualization stops. Of course this may mean the users get all kinds of Access Denied errors that they don't like. Now you see why virtualization was invented.
Should you rely on it? No. For one thing, it may go away in some future version of Windows. And it goes away when you add a manifest, which for many people happened when they migrated to a new version of Visual Studio. What you should do is understand it, including how to find the virtual store, so it doesn't make you quite so crazy.
Now go turn UAC back on,
Saturday, 10 July 2010
I'm not sure when this started, but DevX has a whole area for Visual Studio 2010 articles. They've got handy links to download a trial and a training kit, walkthroughs of creating extensions (a simple blogging one, and adding your own language to the IDE), and lots more. It's a combination of articles, webcasts, and downloads that cover not just Visual Studio but some of the things you can create with it and what's new in related tools. Of course I've seen some of the material before, but that just shows that it's comprehensive. Take a look around!
Friday, 02 July 2010
I love demoing restart and recovery. This is the feature that will bring many users to Windows 7 - getting your work back even after the application blows up. Sure, Word saves your document every 20 minutes - but why does it seem I always lose 19 minutes of work? In my simple demo apps, there's a form with one or two controls on it, and one is some text, and when the application blows up I write all the text out, and then on restart I reload it from wherever I wrote it to. It's simple and for most applications it's exactly what you want. But for some applications that approach won't work as well. For example, what if you have an MDI application and the user has 20 or 30 documents open, each with unsaved changes, when the application is terminated? There may not be time to save all those unsaved documents. And then on restart, perhaps the user doesn't want them all restored, or at least not with their real names... it can get complicated.
You are going to need to know your own application and make an intelligent decision about how to handle restart and recovery for your application. But it might help you to know how a certain MDI application near and dear to all our hearts does it ... Visual Studio. Visual Studio does a Word-like autosave every 5 minutes. When the application blows up, it doesn't do anything in particular on the way down. But when it's restarted, it takes a look at the files it has auto recover versions of and asks if you want any of them. You might, you might not, and as the user it's up to you. Zain Naboulsihas a tip-style blog post
that explains how it works and how you can control it. Read that for its own sake, since you're probably a Visual Studio user and should be using it as effectively as you can. But also take the opportunity to think about a good design for restart and recovery in your application, which is probably a little more complicated than one text box and one other control.
Thursday, 24 June 2010
Interested in playing with extensions to Visual Studio 2010? You should be, just for the fun and productivity of it. But in case you need extra incentive, how does this sound:
What will you create with Visual Studio 2010?
Enter the Summer of Extension Competition and let the US and Canadian Developer community know! Show your peers what kind of extension you can build for Visual Studio 2010 for your chance to be featured on the ReadWriteWeb website. Other prizes include a one-year MSDN Embedded subscription license (a $1,199 USD value!), an Xbox Elite prize bundle and a Natural Wireless Ergonomic Desktop 700 Keyboard and Mouse. Prizes will be awarded to winners in both countries.
Just create your extension, upload it to the Visual Studio Gallery, and tag it with rww to enter. (ReadWriteWeb and Microsoft are sponsoring the contest.) More details at ReadWriteWeb, where you'll also find some handy resources and links.
Tuesday, 22 June 2010
The last (at least for now) in my series of articles
on Visual Studio Extensions is live on Code Project. This one is on creating your own item and project templates
. Like all the articles, it's really a train-the-presenter package designed to help you deliver a talk on this topic at a user group or Code Camp. If you care about the topic and would just appreciate the shortcut of a deck, working demos, and speaker notes that combine to hit a good talk length, then this is just what you need. It's all highly supplemented by videos - of all the demos and in one case of the entire talk. A quick reminder of the 7 articles I have there:
- Introduction - explains the other talks and also has extensive notes on how to prep to deliver a talk someone else wrote.
- For Visual Studio 2008:
- For Visual Studio 2010:
If you would rather learn the material than deliver the session, I suggest you follow the first few steps I recommend in the Introduction for a presenter:
- If there is a recording of the entire talk, watch it from start to finish.
- If there are only recordings of the demos, open the slide deck and read the
slides to myself, pausing to play the demo videos at the appropriate points in
- Read through the speaker notes to see what the author suggests I add to each
slide as I present it.
You owe it to yourself to learn about extensions. Honestly, creating an item or project template will save you time the very first time you use it - it's quicker to make an use a template than to copy an old project and hand edit the file, project, and class names. And the astonishing array of free extensions on the Visual Studio Gallery
is sure to include something that will save you time and frustration. Give it a whirl!
Wednesday, 16 June 2010
I've written about banned APIs before
- for security reasons
some C Runtime functions like strcpy should not be used, and instead you should use replacements like strcpy_s that perform some checking before trusting the strings they're handed. You might also know that I really like
the extension capabilities in Visual Studio 2010.
So how can I resist a Visual Studio extension that gives you wigglies if you use a banned API?
You even get a handy tooltip suggesting replacements. This is a must-install for any C++ developer. You can get zip of the source (you'll need the Visual Studio 2010 SDK to build it) with a prebuilt VSIX in it from the Security Development Lifecycle blog
. It doesn't seem to be on the Visual Studio Gallery yet, but it should be! If you haven't met the VSIX format yet, prepare to be pleasantly surprised - it's a self contained one step installation vehicle for a Visual Studio extension. Just double click it and Visual Studio does the rest.
Wednesday, 02 June 2010
I posted a quick hit on MFC and Windows 7
back in April, mentioning the ribbon and showing you how simple icon overlays and jump lists are. Now Marian Luparu has a nice long article
in Visual Studio Magazine. He covers tabbed thumbnails, the ribbon, multi-touch, jump lists, and shell integration for your own thumbnails, preview, and search integration. Then he manages to mention graphics and animation APIs and parallelization. Can't argue with his conclusion:
Overall, Windows 7 is an exciting release for developers. With thousands of
new Windows APIs made available to native coders, Windows 7 provides an enhanced
experience for desktop applications.Visual Studio 2010 is the IDE of choice to take advantage of the Windows 7
platform. With enhancements in MFC and the ATL and the addition of new IDE
Designers and Wizards, Visual C++ 2010 gives you the opportunity to be on the
cutting edge in terms of leveraging OS functionality.
Check it out!
Friday, 21 May 2010
The C++ team gave me a heads up about a neat new initiative called Hilo. Here's a quick description:
“Hilo” is a series of articles and sample applications that show how you can
leverage the power of Windows 7, Visual Studio 2010, and Visual C++ to build
high performance, responsive rich client applications. Hilo provides both source
code and the written guidance that will help you design and develop compelling,
touch-enabled Windows applications of your own.
The articles are on MSDN - the first is there now - and the code is on Code Gallery.
I like this section from the article:
The rich user experience of Windows 7 is best accessed through a powerful,
flexible language, and that means C++: by using C++ you can access the raw power
of the APIs for Windows 7. To build the Hilo sample applications, all you need
is Visual C++ Express and the Windows SDK for Windows 7, both of which are
available as free downloads.
Hilo applications show how to design and develop an application for Windows
7. But while the code showcases the APIs for Windows 7, it is not wedded to any
particular application framework. Instead, Hilo implement a lightweight common
application layer that directly uses and highlights the APIs rather than
obscuring them. This common application layer is used to support all of the Hilo
applications. It illustrates the best practices for developing Windows
applications, and while it is not complete—it was designed simply to provide the
features needed by the Hilo applications—it does show the best practices used in
designing re-usable frameworks and can be extended to provide additional
Looking forward to reading more!
Tuesday, 11 May 2010
Programming is not one skill - it's a large conglomeration of skills. Some people are not very good programmers because they aren't very good at imagining their way through an algorithm. Others have great ideas and imagination, but it's painful to watch them type and they can't be bothered to learn how to use their tools (editors, etc) so they just take twice as long as everyone else to create the code. Still others are doing fine until their code does something unexpected, and then things fall apart, because they can't figure out what's going on. They step too soon, spend ages stepping through code that couldn't possibly cause the problem, then get impatient and end up skipping right past the problem. Worse, they don't seem to understand the capabilities of the debugger. I've watched people spend over 5 minutes patiently stepping into so that when they reach a particular line, they know how control reached it. Then I show them the Call Stack window and they say "oh".
I've blogged before about conditional breakpoints and tracepoints, hit counts, and so on. There is so much to the Visual Studio debugger that it is very hard to know it all. But the more you know, the better you are. And what's more, being a great debugger has more value than some of the other programming skills, because so much debugging happens at urgent times, is unexpected, and needs to be done as quickly and efficiently as possible. The difference in impact between being good and great is very large.
So how to be a better debugger? Partly, it's practice, especially practice with someone who's really good. That person can say "hey, what are you doing? Here's a way easier way to get there!" Even practice alone can motivate you to learn how to do something and get you reading the documentation or searching the web. You could buy a book, if anyone even buys books any more. You could take a debugging course, and spend a day or a week with someone who really knows every speck of this enormous tool. Of course, that costs money, travel time, and so on. Some of you will do it, and benefit from it tremendously.
But ALL of you can benefit from watching John Robbins' latest set of videos on Channel 9. It's in three parts and they total about three and a half hours. It hits the ground running and just doesn't stop. It's all using Visual Studio 2010 but the vast majority of the features he shows are in earlier versions too. I knew a lot of it (even the Go To Find box and the file opening etc) but I learned new things in the first ten minutes and continued to learn new things as they continued - both actual capabilities of the tool and interesting ways of thinking, like using hit counts on a breakpoint not to stop, but just to count how much some code gets run. I wish I could get the slides and code, but I guess some things need to be saved for the folks who actually take the course.
If you're a .NET developer, watch these videos. Now.
Friday, 07 May 2010
Jani Jarvinen (a Finnish C# MVP) wrote a nice article about using sensors with Windows 7. He mixes and matches .NET 4.0 and Code Pack capabilities, and has links to plenty more information. I like the screenshots and the step by step approach. Windows 7 really does make this so much easier than it used to be. He gets you started with both an ambient light detector and some simple location code.
A little more exotic approach comes from "gleat" who has a Code Project article using a Wiimote as the accelerometer. He starts out simple - here's how to download and install the driver - and then goes into writing a client in C#, leveraging Code Pack of course. But then he says hey, were you wondering how to write a driver? and wham! you're hip deep in C++. It's all well explained, though, so if you want to learn more about this, what a terrific way to start.
If all of this is making you wish you had Windows 7 somewhere to play with, but you don't want to buy it, don't have an MSDN subscription, don't qualify for BizSpark etc, then what you need is a free 90 day evaluation of Windows 7, right? I found that link on this handy Doug Turnure blog post from earlier this year that includes some video links I hadn't seen before. Have fun!
Wednesday, 05 May 2010
I was just looking up the session codes for my Tech Ed talks next month (my flight to New Orleans leaves a month today, at about this time actually) and spotted something unexpected:
DEV316 | Modern Programming with
C++0x in Microsoft Visual C++ 2010
Session Type: Breakout Session
Track: Developer Tools, Languages
Speaker(s): Kate Gregory
Level: 300 - Advanced
for the C++ committee to finish the specification when you can enjoy much of the
power of C++0x today! C++0x, the next C++ standard, is almost upon us and it
contains the most important updates to the language since the mid-90s. It even
accepts the existence of multiple threads for the first time in the history of
the language. Needless to say, these new features bring more expressiveness and
power to the native C++ developer. Visual Studio 2010 has added support for some
of these key features in order to enable these modern programming techniques.
This session clarifies what features are in Visual C++ 2010 and what is yet to
come. It illustrates how new constructs such as lambda expressions enable better
use of existing libraries and how your code can be simpler, safer, and faster
all at the same time. If you are itching to show off how C++ is one of the
coolest languages on the planet, this talk is for you!
WCL316 | The Windows API Code Pack:
Add Windows 7 Features to Your Application
Session Type: Breakout Session
Track: Windows Client
Speaker(s): Kate Gregory
Level: 300 - Advanced
Accessing new Windows 7 features is a challenge from
managed (.NET) code. The level of interoperability required is out of reach for
many developers. The Windows API Code Pack for the Microsoft .NET Framework is a
sample library you can use in your own projects today that provides access to
new user interface features (taskbar jumplists, libraries, sensor platform, and
more) as well as "behind the scenes" features that make your applications more
aware and responsive (restart and recovery, power management, and more.)
Discover a shortcut to Windows 7 development for Microsoft Visual Basic and
Visual C# programmers and get started today.
The first digit carries meaning, but the last two don't. So I don't really know how they both got to be 316. Since I often have trouble remembering my session codes, this should halve the effort for me .
PS: I checked whether the Brian rule still applies. You can too, by just dropping down the "Speaker" box on the session catalog page. I'm happy to report there are 9 Brians and I reached 9 obviously female names (ignoring Alex, Chris etc) while I was still in the C's. Good news, in my opinion!
Tuesday, 27 April 2010
MFC had some Windows 7 support starting with the release in between Visual Studio 2008 and Visual Studio 2010. There was a ribbon, for example, though there was no designer. In Visual Studio 2010 there is a ribbon designer, very nice, and tons of UI fun as well. In this post I'd like to focus on some MFC support for taskbar interactions. Any idea what these two lines of code do?
HICON i = LoadIcon(NULL,IDI_WARNING);
Here's the visual evidence:
Yep, you load an icon and then you set it as an overlay icon on your taskbar. Nice and simple.
How about this:
You need to know that m_jumplist is a member variable of type CJumpList - a new type in MFC. Here's what that code causes:
This is remarkably little code to be all up to date and modern, isn't it?
If you want more info on C++ and Visual Studio 2010, here's a nice article by Sumit Kumar and a Channel 9 talk with Pat Brenner. Enjoy!
Sunday, 25 April 2010
Once again Carl and Richard are driving across the country to celebrate a Microsoft launch. This time it's for Visual Studio 2010.
As they say on the roadtrip page:
Carl and Richard are loading up the DotNetMobile (a 30 foot RV) and driving to your town again to show off their favorite bits of Visual Studio 2010 and .NET 4.0! Richard talks about Web load testing and Carl talks about Silverlight 4.0 and multimedia.
And to make the night even more fun, we’re going to bring a mystery rock star from the Visual Studio world to the event and interview them for a special .NET Rocks Road Trip show series.
Along the way we’ll be giving away some great prizes, showing off some awesome technology and having a ton of laughs.
So come out to the most fun you can have in a geeky evening – and learn a few things along the way about web load testing and Silverlight 4!
You can track their progress online, too! Looks like a blast.
Friday, 23 April 2010
I like to introduce myself, in C++ circles, by mentioning I was using C++ before Microsoft had a C++ compiler. It's often interesting to watch people try to handle the concepts behind the sentence - mostly, that for some languages you can buy compilers from more than one vendor. And once upon a time, C++ existed as a language, and Microsoft sold compilers, but it didn't have a C++ one yet. Then eventually (OK, in 1992) the C product Microsoft sold became a C/C++ product (compiler, linker, debugger etc) and then the next year Visual Studio came along and with it Visual C++. And Visual C++ 1 included the Microsoft Foundation Classes 2, so that for a while the version numbers of Visual C++ and MFC were out of sync. Eventually there was a version skip to catch up (there was no Visual Studio 3). For quite a while we all worked with Visual C++ 1.52c and every speck of that version number was significant. So as you can see, the version of a product is not a simple question with one answer.
So, here we are, welcoming Visual Studio 2010. Lots of people called it Dev10 while it was under construction. But was the 10 short for 2010? It was not. It was just 10, as in the number after 9. Visual Studio 2008 was 9, and Visual Studio 2005 was 8. You can see these numbers on the shortcuts to your sln files, by the way:
OK,so VC8 means Visual C++ 2005? Basically. As long as you realize that it doesn't mean version 8 of the compiler. Because the C compiler transitioned into the C/C++ compiler, the version numbers came with it. VC8 includes version 14 of the compiler. Confused yet? If so, you're in good company. Here's a tabular explanation, though it only goes back a decade. You want more details? Wikipedia has them, of course. Me, I am going to enjoy Dev10 and watch for news of Dev11.
Monday, 19 April 2010
I am accumulating Visual Studio 2010 links at quite a pace. Let's have a bunch in this post:
Saturday, 17 April 2010
When I show off Windows 7 features and talk about how you can add them to your apps, I usually show a "sad trombone" moment featuring Visual Studio 2008, like this:
(I really like jumplists in the start menu, so I thought I would show that in my screenshot instead of the classic right-click-on-the-taskbar jumplist. They're the same.) But this jumplist isn't useful. It isn't all the .sln files I've opened before, or the projects, or anything really except some random bits of XML, icons, schemas, and code files that I dragged in to Visual Studio over the past few months while I had some real solution open.
Now this isn't poor Visual Studio's fault. It was released before Windows 7, before anyone knew that the MRU list kept by the OS itself would be important. As I've explained in presentations before, there's a reason this happens. You see, when you double-click a .docx file, Windows looks up who handles those, launches Word to open the file, and accumulates that file name on the MRU list for Word. Cool. Ditto for .txt and Notepad, etc. But Visual Studio is different, and it's different so that you can have Visual Studio 2005 and 2008 side by side on your machine, and use .sln for the solution file names in both products. You double-click a .sln file and what actually runs is a little launcher that looks inside the .sln file to see if it's a 2005 or 2008 solution and then runs the right Visual Studio and passes the solution to it. Cool. But as a result Windows isn't accumulating what you opened with Visual Studio 2008, it's accumulating what you opened with the little launcher. The jumplist for Visual Studio 2008 therefore contains only things you opened directly with it, and that's not a very useful list.
OK, so I know why. And it's nice to know, btw, that Visual Studio 2010 gets it right. And in my presentations, I usually leave it at that, encouraging you to add the one whole line of code to your app (if you're using Code Pack) so you "don't be that guy".
But wait! What if you want a good jumplist for Visual Studio 2008? Especially if you don't have Visual Studio 2005 installed any more, so you don't care about the whole pick-what-version-to-launch feature? Well, you could try this suggestion from Josh Einstein. I like that he doesn't explain it much and says "If you need more instructions then the hack probably isn’t for you." His instructions, terse as they are, are for 64 bit Windows 7. A commenter supplies the 32 bit version.
I actually haven't tried this yet. Don't want to set my computer on fire or anything . But if you feel like living on the edge, give it a whirl!
Tuesday, 13 April 2010
Is it a good omen when mornings start out beautiful? I think it might be:
Normally, when I go to a conference, the first day is a little slow. I might go to the keynote, or I might not. If I do, I wander in to the back row 5 minutes before it starts (hey, I'm leaving plenty of seats for the paying attendees) with my coffee in my hand. So reaching the keynote room at 7am, full of pep and vigour, was fun!
No sooner was the keynote over than I was headed for the Channel 9 stage to record half an hour of Q&A with Twitter people.
That's available online too. And if you want more, some of the sessions are appearing on Channel 9, too. Not filmed on site, but the content matches. Get your Visual Studio 2010 from MSDN downloads, or if you're not a subscriber you can take the Professional Edition for a test drive.
Sunday, 11 April 2010
I've never been backstage for a big keynote before. There's a lot going on back there. Each demo runs on its own machine, so if one messes up it doesn't hurt the others. There are monitors everywhere showing what's on all the cameras and what's going out as the feed. There's one half for the camera and production people, and one half for the demo people. Here's a glimpse of the demo half:
Crowded, noisy, hot, and people are standing in your way sometimes. Best seat in the house!
Also, I'm just loving the signs throughout the Bellagio. There are all different ones (water, wires, light bulbs etc) but I think this is my favourite:
Watching something launch feels like it wouldn't be exciting, after all how long have I been working with this product? But you know what, it is!
Friday, 09 April 2010
This trip to the launch gets more exciting by the minute! Check this out:
The Channel 9 team will be broadcasting live, unscripted, and 100% interactive
from DevConnections 2010 in Las Vegas as part of the Visual Studio 2010 and
Silverlight 4 launches.
Join us Monday April 12th, from 8AM (PST) for Bob
Muglia's VS2010 Launch keynote then stay tuned for more than seven hours worth
of Visual Studio 2010-themed demos, interviews and panel discussions on Channel
. . .
Day 1 Schedule April 12th 2010 (Pacific time)
8:00 AM DevConnections 2010
Day 1 Keynote.
10:00 AM Welcome to VS2010: Doug Handler and Brian
Randell with Dan Fernandez.
10:30 AM Live Q&A with Bob Muglia,
President Server & Tools Division with Dan Fernandez.
VS2010: Native Code. Kate Gregory and Richard Campbell with Charles Torre.
11:30 AM VS2010: Managed Code. Lisa Feigenbaum, Tim Ng Dustin Campbell
with Charles Torre.
. . . then some other people, who I love, but I can't paste it all in here. . .
To be part of it, use Twitter with @ch9live somewhere in your message. We'll see it and that's all it takes to join the conversation!
I count 11 Regional Directors (many of whom are also MVPs) on the guest list. What a way to spend the day!
Saturday, 03 April 2010
I've been accumulating a ton of links relevant to Windows 7 development, so let's use some of them up:
Mmmm, I feel much more caught up now.
Thursday, 01 April 2010
C++ developers generally care a lot about how fast their code runs. In many cases that's the reason they wrote the application in C++. Every release of C++ development tools (compiler, optimizer, linker etc) typically has some effort invested in producing code that runs faster, even if that means the tool itself runs slower. It's tempting to think that the gains would have levelled off by now - after all, C++ has been around for a very long time. But a recent post by Lin Xu of the C++ team
shows how you can take you 2008 project and rebuild it in 2010 (using the right options of course) to see up to a 16% speed increase with no code changes by you. Lin also discusses the extent to which this will slow your build process.
Visual Studio 2010 and Visual C++ have a TON of important new features for native developers, which I'll cover shortly. But let's just start with this one - faster applications - for the moment.
Tuesday, 30 March 2010
It's thirteen days to launch. Yesterday I was able to confirm I will be attending the Las Vegas event. I'm stoked! The speaker line-up is amazing:
In addition to insightful keynotes by Bob Muglia, President, Server and Tools
Business and Scott Guthrie, Corporate Vice President, .NET Developer Platform,
see key members of the Visual Studio team including Doug Seven, Sean McBreen,
Chris Sells and Andy Conrad. Also see favorites from the third-party community
including Juval Lowy, Michele Leroux Bustamante, Billy Hollis, Tim Huckaby,
Rocky Lhotka, Dan Wahlin, Steven Smith, and Rick Strahl. Listen to a live
recording of .NET Rocks! with Carl Franklin and Richard Campbell.
That's 8 RDs in that paragraph. Are we an amazing community or what? There is so much good stuff in this release that I haven't been able to play with it all yet, so I'm really looking forward to having some smart people show me what I need to know quickly.
If you can't be there in person, you'll miss some of the fun, but not all! Code Project is running a Tech Summit so you can "experience the Microsoft Visual Studio 2010 launch alongside the Visual Studio
team." Live video sessions and even a virtual swag-bag for attendees.
One way or the other, be there!
Sunday, 28 March 2010
I've mentioned before
how Windows 7 Boot-to-VHD makes working with betas so much better for me. In fact just last week I built a new VHD image to do something new with the RC of Visual Studio 2010. It took a few hours off and on, while I was puttering around the house, to install Windows, install Visual Studio, install Office, install the zips of code that someone had sent me to test, install Camtasia, and so on. I didn't begrudge the time, but I was trying to set up something very specific for a test. If you'd just like to play around a bit and see what all the fuss is about, I bet you would like it if someone made a VHD for you and you could just download it and use it.
Well Presto! Brian Keller has done just that
. And he hasn't just installed Visual Studio on it, but a whole pile of hands on labs, the sample data and configuration that the labs need, and so on. In fact it's three VHDs depending on your virtualization tool - Hyper-V, Virtual PC 2007, or Windows 7 Virtual PC.
If you're getting excited about the run-up to launch and starting to ask "oh, is there good stuff in this version of Visual Studio?" then this is a really simple way to get yourself closer to seeing for yourself just how much good stuff there is. Have fun!
Wednesday, 18 November 2009
Developer Night in Canada is a fun podcast from John Bristowe and Joey deVilla of Microsoft Canada.
Episode 1 - my friend Joel Semeniuk. He's talking about the tool formerly known as Team Systems, and about the way he makes software. The Work Item Manager I told you about gets a mention too. Worth a listen!
Tuesday, 10 November 2009
Yesterday was the first day of Tech Ed. I went to Marian Luparu's talk on Visual C++ 2010. He did mostly demo, and showed a ton of hot new C++ features.
If you missed this one (it was the very first talk of the conference) be sure to look for the recording.
After lunch I headed out to be part of the anniversary celebrations. Despite the rain, it was a great outing, and the crowds were very orderly. I had a bratwurst and took a few pictures:
No place I'd rather be.
Wednesday, 04 November 2009
My three favourite Windows 7 features are the taskbar, default printers network-by-network, and boot to VHD. That's cheating really because "the taskbar" covers a lot of ground - jumplists, previews, previews with buttons in them (pausing media player, closing anything), notifications, and progress bar overlays. As you can see by all those links, I've already blogged most of those features - and most of my Windows 7 category is taskbar-relevant.
But I haven't yet blogged about boot to VHD and I really need to. The rise of VPC over the last few years has made such a huge difference for me and my tribe. Whether it's a safe place to put a pre-beta (typically the uninstall instructions for CTPs and private builds are "format your C: drive") or a carefully configured TFS or Sharepoint setup, a virtual PC is a great place to play or to demo a technology. The only downsides are performance, and sometimes access to hardware peripherals or networking. Boot to VHD fixes those two downsides, and it's better than having a separate laptop or a slide in/out hard drive (a solution I used years ago on the only laptop I've ever met with that capability.) Not only does it weigh a whole lot less than a separate hard drive , you can access the "host" hard drive while you're booted over to the guest. That means I can work on a demo or presentation and leave the powerpoint or the demo script on my "real" drive and edit them from the guest.
The only downside is that it is boot to VHD. Not "put the host machine to sleep and then bring up the guest machine." So you have to be prepared to close all the apps you have open, which for me can take some doing. But that's the only problem.
How to do it? I followed the nice clear instructions by Adrian Kingsley-Hughes. Print them out, because you're not going to have access to your machine while you're doing this. Scott Hanselman has a similar set of instructions, but they're not identical and I didn't follow them myself, so if you want to, just remember like he says "This is advanced and may hurt you, your computer, or your cat" so don't complain to either of us if something bad happens. He has nice pictures and some links to useful references too. If you really want to wander into "Danger Will Robinson" territory, take a look at Jon Galloway's post which covers the whole "wait, what about activating my copy of Windows?" story. I'm just ignoring that myself since most of these virtual machines are going to live for a month or so.
If you're running Windows 7 Ultimate, and you ever install beta or pre beta software, or otherwise ever use a virtual machine, learn how to do this. You won't be sorry.
Saturday, 31 October 2009
Have you ever heard someone make a definitive statement about a particular feature of Visual Studio or the .NET Framework that you knew just wasn't true? Did you ever wish for a Snopes equivalent you could send them to? Well, your wish has been granted.
Give it a whirl
and see the official position on some popular (but unfounded) beliefs.
Wednesday, 21 October 2009
I remember, back in the day(*), being so confused about NULL. At first I thought it was a keyword, a special value of some kind. Then I learned it was just the same as 0. Or maybe 0L. I worked with people who said it was wicked to use it, and you should always type the 0 yourself. I worked with people who said it was wicked not to use it, because it made your intentions clear to humans. I even worked with people who used it in for things other than pointer-setting or pointer-checking. I argued with people who thought if(p) was or was not more clear than if (p != NULL) and, late at night when we'd been drinking, about what would happen if some other value than numerically zero meant "null pointer" and what that would do to the world's code, and how to write our code so that could never hurt us.
But that was long ago. These days I've pretty much internalized NULL (and for the record, I'm an if(p) gal) and no longer think about it. One of the reasons I don't have to think about it is that I don't write a template library that's used by millions of developers. If I did, I might have to worry about template-argument-matching and how compilers are supposed to deal with being given an int and knowing to match that up to a Something* -- but then again, only if the int has the value of zero. It's been a pretty clever trick for a really long time, but with the advent of perfect forwarding in C++0x (thanks to rvalue references) it just becomes impossible to always pull off that trick. Luckily, the same language changes that led to rvalue references also held the solution - the literal nullptr that isn't an integer with the value 0, but actually represents a pointer-to-anything that isn't pointing anywhere right now.
For the gory details, a wonderfully transparent look at how the team decides what to do in a release and what to hold for later, as well as some delightful glee at being able to do stuff, some amazing understatement ("somewhat arcane" indeed) and moments later "the world explodes!" you have to watch STL on nullptr. BTW, he deliberately pronounces it null-putter so people can tell he's not saying "null pointer" which would still be NULL. He even gets into nullptr vs nullptr in the land of /clr and how the double underscore (seriously) rides to the rescue. Major whiteboard action and in the end you'll know a little more about why the magical STL (the library) works, why it's faster in VC++ 2010, how the team (including the human STL) thinks and works, and the insides of my favourite language.
* that would be before Microsoft had a C++ compiler, over 20 years ago. Four and a half years ago I reflected that I was very close to having 20 years of C++ experience.
Monday, 19 October 2009
My download is underway right now. And while I wait for two gig of beta good stuff to reach my hard drive, I thought I'd share some of the announcements from Microsoft around Visual Studio 2010.
- The launch will be March 22nd, 2010. I will have more details on that over the next few months.
- The SKUs are being adjusted and simplified. I never met anyone who used just the Developer Edition, Architect Edition, Tester Edition or Database Edition of Visual Studio Team Systems. We all used Team Suite. So now we'll all use the Ultimate Edition. It has even more stuff than the old Team Suite did. People who don't want the source control and work item tracking and modelling and diagramming and schema/data management and all the other great things in Ultimate will get Professional. Some of them will get Premium, which sits in between the other two. Plus all the free Express SKUs will continue to get you what you need to just build an app right away without spending any money at all. (Already a subscriber? You'll get more without paying more, which is hard to argue with.)
- MSDN has a whole new look (way more blue, lots of links to fresh blogs and announcements) and some cool new benefits like free Azure hours. If you're paid to make software, you should have an MSDN subscription. If you can't afford it and your company is new, take a look at BizSpark which makes it free. If you're not new or your company doesn't make software, look at the partner program. But for everyone else, this is what you need.
If you totally haven't been paying attention and have no idea what the excitement is about, start with this What's New document and these highlights (featuring screenshots and plenty of links).
And finally, after many years of ,
get ready to start loving and
Thursday, 15 October 2009
Inspired by the Visual Studio Documentary, Rico Mariani is writing his own history
. So far he's up to 8 parts and they make for great reading. He goes into some of the technical challenges the teams faced, and talks about cancelled and sidelined projects along the way. He's made a category for it so you can read the whole thing start to finish ... but I'm reading as he goes and not waiting till it's done. Do read in order though, starting at Part 1.
Friday, 09 October 2009
You have to see these. Roughly half an hour each, featuring
an RD and at least one former RD, it’s a cast of luminaries and also has some
funny-looking-back archival footage. I learned a few things, remembered a whole
bunch more, and smiled and laughed a lot. Check them out. Apparently there’s a
whole series to follow with the full interviews with all those folks. I like
this chronologicallish approach with different interviews interwoven, but I’m
sure I’ll watch the long ones too when they come out.
Here’s who’s in it:
- Anders Hejlsberg
- Soma Somasegar
- Dan Fernandez
- Alan Cooper
- Bill (archive footage)
- Tim Huckaby
- Tony Goodhew
- Dave Mendlen
- Jeff Hadfield
- Jason Zander
- Mardi Brekke
- Dee Dee Walsh
- Scott Guthrie
They are both on Channel 9 (and read the comments too): Part 1 and Part 2.
Saturday, 03 October 2009
I suppose using Source Safe is better than using no source control at all. But it's slow, it can't handle non-text files usefully, it totally doesn't work over a slow network, and it corrupts its database from time to time for no discernible reason. It can't handle multiple people having a file checked out at once, so that forgetting to check in a common file (especially a project or config file) can either completely keep others from working or can make people get in the habit of working outside of source control for long stretches of time. It has had its day and you should replace it.
But let's say you're an all-Microsoft shop and you don't really have the time and energy to go looking for products from other vendors. You like knowing all your stuff works together and you're not entirely sure how you would integrate some other product into Visual Studio and into your workflow. You know someone who works somewhere that doesn't integrate their source control into Visual Studio and it causes them a lot of trouble. You looked at Visual Studio Team System and Team Foundation Server briefly, but at first glance all you saw was Big! Complicated! Expensive! We Don't Need All That! and you've never looked again. Or you talked to a guy who paid someone thousands of dollars to install and it took weeks. You can't afford that and don't like installation nightmare stories.
Sound like you? Sounds like lots of folks I know, and some I mentor. Well I have good news. Word about Visual Studio 2010 is starting to come out and I am liking what I see so far. Take this article by Brian Harry, TFS 2010 for SourceSafe Users. He says that there will be a version of TFS in the 2010 product line that will be as cost effective as Source Safe, can be installed on a domain controller (for folks who really only have one server kicking around) or on your laptop (Vista or Windows 7) and can be installed in a simple Next, Next experience that can take as little as 20 minutes. Wow! He includes the screenshots of the install experience to show you how simple it is.
And you don't just get source control when you do this. You get work item tracking and integration, build automation, all integrated into Visual Studio. If you're using a Team SKU of VS, you're good to go, or if you're using a Pro SKU you just need a TFS CAL and to install Team Explorer and you're good to go. Integrated work item tracking and source control with automatic notifications on checkins and work item changes saves most developers an hour a day. Add that to what you lose swearing at Source Safe and you just HAVE to give this a try.
Sunday, 30 August 2009
As you probably know, we're on our way to a new version of the .NET Framework. There's so much that is new in it you could hardly know where to start. I'm just letting the information wash over me in other people's blogs, and trying things out with the beta from time to time. I spotted two related things in the last little while.
First was Improvements to Interop Marshaling in V4: IL Stubs Everywhere
on the CLR team blog. The takeaways here are faster performance, consistency between the 32 and 64 bit worlds, and better debugging. Since there is still a lot of native code hiding underneath your managed calls to library functions, everyone cares about the faster performance aspect. Read the post for all the details if interop matters to you the way it matters to me.
Second was COM Interop Gets Much Better in C# 4.0
on DevX. I've always avoided C# for COM interop work because it doesn't do optional parameters, and most COM work is rich in them, especially working with Office, which I used to do quite a lot of. Less casting, no need for PIAs, no more fake values called "missing" or some variant thereof ... it's all good. And here again the magic words "improved performance".
Two small things to note with a non-small impact on your life as a developer.
Saturday, 22 August 2009
I've done several Tech Ed talks, in Europe and the US, in which I've demoed lambda expressions, a new language feature coming in C++0x and implemented in Visual Studio 2010. If you missed your chance last year to watch my Tech Ed Europe talk, it's still available on page 3 of the "last year's highlight's" page
. But that's 80 minutes and covers more than just lambdas. If you would be up for investing a tenth of that time, try this Channel 9 piece
featuring Thomas Petchel. He's obviously VERY familiar with the STL and he illustrates perfectly how writing dinky little functions to initialize arrays can be tedious and time consuming, and how lambdas make them faster. If you watch that and like what you see, go ahead and give my Tech Ed talk a listen as well.
Wednesday, 12 August 2009
There was a bit of a kerfuffle in the C++ standards world in mid July arising from the summer meeting of the ISO C++ committee. Agreement couldn't be reached on how to implement concepts. In the end it was decided not to include them in the next version of the standard.
What are concepts? They improve the experience for template consumers. C++ templates are amazingly powerful, but using them can involve a lot of guesswork and a lot of swearing
. They're pretty easy to write, and just by typing a line of code you create a requirement, a pre-requisite, for anyone who wants to use your template. If you write a template that takes two instances of class T called t1 and t2, and then somewhere it says t1 + t2
or t1 < t2
, then your template can only be used with types T that have the operator + or the operator <. Anyone who uses it for some other type is going to get an error message that might be useful, but might be your typical nasty template-related error message. That makes templates easy to write, but hard to consume. Short of actually reading through the code for the template, you can't know before you try compiling whether or not your consuming code actually meets the requirements for using the template.
Generics in .NET deal with this through constraints - the generic writer identifies the interfaces that must be implemented by any type that will use the generic - IComparable or IEnumerable etc. If you want to use the generic, you implement the interface, and the compiler will help you get that done with readable error messages.
So that was the heart of concepts. Some sort of decoration you would put on your template to say "here is what I expect of those that use me." How important are they in general, and how important to C++0x?
- concepts’ presence or absence in C++0x just won’t make much difference to most
users - Herb Sutter
- [concepts were yanked out and that is] a major setback for C++, but not a disaster - Bjarne Stroustrup
- removing them was our best available option both for C++0x and for concepts as a
language feature - Doug Gregor
- Not the end of the world, but disappointing nevertheless - Alex Fabijanic
What do I think? I think that template consumers fall into two large categories - those who consume templates they wrote themselves, and those who consume the STL. If you wrote it, I hope you know what it needs, and if it's the STL, well you can paste your opaque error message into a search engine and someone's blog will tell you what you need to add to your class to use that template. I don't think there are a lot of people consuming poorly documented and sparsely used templates. I agree that concepts could result in that sector growing some day, but that few developers are walking around wishing for them or feeling the pain of not having them. I'm sure it's a disappointment to everyone who put so much work in to them, and who will continue to work on them towards inclusion in a future version of the standard, but the rest of us can relax and get ready to see the other C++0x goodies included in a standard where x might actually fit in a hex digit.
Wednesday, 29 July 2009
I didn't even know there was a Visual Studio Project Team blog, but the entries lately sure have been C++ relevant:
Brian Tyler says "Our areas of responsibility are those surrounding projects and solutions in
Visual Studio - specifically the C++, C# and VB project systems - but we're
involved in other code bases in those areas as well." and explains that he's going to start the blog with these C++ topics because the conversion of the VC++ project system from VCBuild to MSBuild was a major effort in VS 2010.
I'm really happy about the VC directories thing. It made moving projects from one machine to another very brittle that things like which version of a header file you got were machine-specific instead of project specific. The blog as a whole is a must-read if you're going to do any C++ work in Dev10.
Friday, 17 July 2009
It's been a while since I did a series of posts on debugging tips:
So here is not so much a tip as an announcement. You see , it's no coincidence that my examples for conditional breakpoints were numbers (some index into a structure is greater than 346, or Xid is 1234.) Until now, you couldn't really use strings in conditional breakpoint expressions. But the cool news is that, starting with Visual Studio 2010, you can!
You can't just call arbitrary functions including your own foo(whatever), but you can call a pretty impressive list of variants on strlen and strcmp. The details on are Habib Heydarian's blog. Just one more reason to want Visual Studio 2010!
Thursday, 25 June 2009
The Build a Better App site is all about applications. They've gathered tutorials, videos, and useful libraries for folks who are building client applications. You'll see some old friends of mine on the main page - Code Pack, Tim Huckaby's recent guidance paper, and so on - along with plenty of things I haven't linked to from this blog. But there's more, like profiles of some of the people whose work is on the site (love the fish, Tim) or videos showing the Windows Forms to WPF converter in action, Code Pack demos, and so on. Speaking of videos, Build a Better App has their own channel on YouTube, as well. Jono Wells is twittering on behalf of the site, and blogging too.
If you were at Tech Ed USA, you probably saw the Build a Better App team - they had a colourful presence and fun stickers and clings. There's a slideshow of some of the "better app requests" from attendees and while I doubt anyone will be coding a cloak of invisibility any time soon, there were some pretty cool requests in there.
Take a look around, and if you want to submit some content for the site, let me know and I'll connect you to the right people.
Thursday, 28 May 2009
Stephan has blogged some breaking changes to the STL in beta 1 of VS 2010. These are breaking in the sense that your old code, which worked, might not work when you move it to the latest release. I had this with a demo (not real code) that didn't bother #including <iterator> because it was including something else that included it etc. So my old code wouldn't build in Dev10. Simple enough fix to add the #include.
That alone (4 simple problems, and how to fix them) makes the post worth reading. But it's also a fantastic example of the transparency and visibility the team blog provides. Look at this sentence:
In VC10 Beta 1, I added operator->() to CAdapt, allowing v[i]->Something() to compile unchanged.
Not "we added". Not "it was decided to add". Not "some faceless decider, whose motives and reasoning are not accessible to the mere mortals who just read our decisions, added". Simply "I added". Stephan, STL, a real person whose posts we can recognize by font alone, added an operator. I think as C++ developers we are a very lucky lot, to have this kind of window into how and why the tools change as time goes by.
The conversation continues in the comments, btw. On the C++ team blog, if a post interests you, you should always read the comments too. Folks ask stuff and team members (not always those who posted the original) answer.
Tuesday, 26 May 2009
Oooh, I like this a lot.
That is a little snippet from a query of work items in VS2010 (cropped from a larger pic obviously). You can add a work item and then add other work items that are part of it, break it down into smaller pieces just as though you are in project. This is a huge deal for me! I found this as part of an incredibly long and comprehensive post (with a dozen screenshots) on Brian Harry's blog. This is going to be a must-upgrade for me just for the VSTS stuff - and I love the new editor, and plenty more besides. So far not a single project I've upgraded has had any issues, they've all just worked.
Thursday, 16 April 2009
Well, a lot. Brian Harry has provided a feature list, and a secret decoder ring to help you decide which blogs to read to learn more over the coming months. My personal favourite? "Work item hierarchy & linking". If that means what it sounds like it means I will have a much simpler life when planning a project the way I often do - starting with big things and later breaking them down into small ones. I'll be watching for more details on that.
Saturday, 14 February 2009
Here's another Channel 9 Video you need to watch: Rico Mariani: Visual Studio Today, Tomorrow and Beyond - Your Questions Answered. I love that in addition to planning for version 10 of Visual Studio, he's planning for 11, 12, and to a certain extent 13. To have the courage to start on a feature that won't really be done for ten years is very impressive. I'm looking forward to "Dev10" for a lot of reasons ... even more after watching this video.
Sunday, 01 February 2009
While I was in Redmond I met Alon Fliess, who like me is a C++ MVP and is exploring Windows 7 (and Vista before it) from a native point of view as well as a managed one. About two months ago he mused about the "rebirth" of C++ in these times, not just because some of those operating system APIs are easier to get to from native code, but also because of new native capabilities (the continued MFC updates, the native Web Services library, the concurrency services) that just keep being added to the arsenal available to C++ programmers. (He has some helpful links in the blog post - you could also search through here if you like.)
I think it's a good point. If you know C++, now's a good time to use it. If you don't, then hang around (at least virtually) with those who do - we can point out some cool things. And thanks to the magic of interop, wrappers, and C++/CLI, perhaps we can make some of those cool things a little easier to get to from managed code.
Sunday, 23 November 2008
Because Visual C++ is a great tool for making Windows applications (and has been for well over a decade) a lot of the Visual C++ users I meet are Koolaid drinkers like myself. We use Microsoft tools to write software for a Microsoft platform, and a fair number of us use Word and Outlook and Powerpoint and rarely touch an application that didn't come from Redmond. But one of the cool things about C++ as a language (contrasted to VB and C# for sure) is that it is also used by people who don't use any Microsoft tools, or who use Visual Studio but nothing else, and people who are not developing for Windows. These people are not drinking the Koolaid and their opinions can be very helpful. They keep track, for example, of which standards features have been implemented in which compilers.
I came across this article on the future of C++, and the article itself didn't have much extra information for me (though the insight into the "bias" of StackOverflow was interesting.) But the comments! Wowza. I'll be reading Andy's blog from now on, and I recommend you read at least this post. It's a good one.
Friday, 14 November 2008
Tech Ed draws to a close and the website of videos gets updated. This is a general-access-no-login-required highlights site. The mechanism for extracting individual links seems broken, so I'll show you what to click on:
Thursdays wrapup includes footage of the Norway country party (North American speakers typically pick a country to visit for country drinks, and my gang chose Norway) and the Speaker Idol finals (I was recruited as a last minute replacement judge for the finals only.) Speaker Idol impresses me every year because it shows all of us (speakers, track chairs, etc) people who are really good but have not spoken at Tech Ed before. How good? I have a session in the top ten this year, and one of the very few people who is outscoring me is last year's Speaker Idol winner, Jeff Wharton.
The afore-mentioned session in the top ten is here, the full video. Doesn't seem to be downloadable, so set aside 80 minutes and learn about shared_ptr and lambdas. The abstract is inaccurate - I didn't do anything on STL/CLR or marshalling - that was last year. The attendees didn't seem to mind that I tossed out half my planned talk and replaced it with content that had been announced at the PDC .
There are 63 videos all told (though 5 are from last year) and they range from a few minutes long to, well, 80 minutes. See what you missed, and maybe see you next year!
© Copyright 2018 Kate Gregory
Theme design by Bryan Bell
newtelligence dasBlog 2.3.9074.18820
| Page rendered at Tuesday, 25 September 2018 17:34:49 (Eastern Daylight Time, UTC-04:00)
On this page....
|Do you know an Australian who needs a C++ refresher?
|C++ User Group in Toronto
|More Interviews! The Tablet Show, PluralSight meet the author
|Yes, my C++ Precon will also be at Tech Ed North America
|My C++ Precon at Tech Ed 2012 Amsterdam
|My C++ Fundamentals course, part 2
|My Using Visual Studio course, free
|My Pluralsight C++ Fundamentals course is live! (and free for a little while)
|Which compilers support which C++11 features?
|Nice C++11 Summary by Danny Kalev
|Put your stopwatch where your mouth is
|Some guidance from Kenny Kerr
|Sequence Diagrams with Visual Studio
|Things you didn't know the Watch window could do
|Tech Ed USA - Recordings
|Developing for Windows in C++
|More Channel 9 C++ good stuff
|More C++ MVPs on Channel 9
|Some transparency around C++/CLI Intellisense
|Pluralcast and "Visual Studio Kung Fu"
|My Interview on Channel 9
|Two more screencasts - Restart and Recovery
|Windows 7 Recipe - Taskbar Single Instance
|My screencast - Windows 7 Taskbar Integration with MFC
|Fun WPF Sample - Tasks.Show
|My Tech Ed Atlanta Sessions
|C++ Videos just keep on coming! (and some helpful links)
|Urban Turtle - Scrum and TFS
|Two In One - See What's New in MFC, See How CppDepend Works
|Watching a Managed Developer Come Back to C++
|Advanced "STL on STL"
|Banned APIs revisited
|Validating a Layer Diagram - for Native Code
|MFC applications in unlikely places
|Moving to WPF and Silverlight - fear of not being a designer
|What affects build speed in Visual Studio?
|Stroustrup interview on C++0x
|What does TFS offer C++ people?
|STL wraps up the STL series
|Did you notice the Visual C++ Weekly?
|StyleCop user? You want these snippets and templates
|Some recommended Visual Studio extensions
|More Samples from the All in One Code Framework
|Windows Development Bootcamps - free day of training
|Service Pack 1 for Visual Studio 2010 is in beta
|Want unit tests for your native C++ code?
|Tech Ed Videos are Up
|User Group Leaders: great Pluralsight offer
|Coffee and Code in Montreal, Mississauga and Ottawa
|Get Microsoft to write you a code sample (really)
|Hilo Uploader - Photos to Flickr with WWSAPI
|Take a survey about Visual Studio 2010
|Would you like a month to stuff your brain with the Pluralsight library - free?
|Version 1.1 of the Windows API Code Pack
|Two Sessions at Tech Ed Europe
|Speaking at the Markham .NET Users Group, Oct 25th
|My VSX Course became Two VSX Courses
|Hosting a Coffee and Code
|A must read for C++ devs
|Visual Studio Add-in for Windows 7 Taskbar extras
|My Pluralcast Episode
|Visual Studio Extension - Productivity Power Tools
|My "Extending Visual Studio 2010" course is live
|Finding files you're sure you wrote
|DevX Visual Studio 2010 Showcase
|Another approach to restart and recovery
|Summer of Extensions - win fabulous prizes
|Your own VS 2010 templates
|Banned APIs flagged for you
|Native C++ and Windows 7
|Be a better debugger
|More sensor fun in Windows 7
|My Tech Ed Session Codes
|MFC and Windows 7
|.NET Roadtrip is underway
|If VC10 is Visual Studio 2010, what is VC8?
|Visual Studio 2010 Links
|Do you wish Visual Studio 2008 showed solutions in the jumplist?
|How was launch? Terrific!
|Keynotes are complicated
|Channel 9 ... live from the launch
|Windows 7 developer links
|Make your C++ code run faster
|Visual Studio 2010 Launch
|Virtual images for testing Visual Studio 2010
|Developer Night In Canada
|Tech Ed Europe Day 2
|Windows 7 Boot to VHD
|Visual Studio Myths Debunked
|nullptr is here! (seriously, it does actually matter)
|VS 2010 Beta 2 is on MSDN
|Rico Mariani and the history of Visual Studio
|Visual Studio Documentary
|You're not still using Source Safe, are you?
|Interop changes in the .NET Framework 4
|Lambda expressions mini demo
|Concepts will not be in C++0x
|VS Project Team Blog
|Conditional Breakpoints can use String functions in Visual C++ 2010
|Build a Better App
|Breaking changes for C++ STL in beta 1 of VS 2010
|Work item hierarchies in VSTS 2010
|What will be in VSTS 2010?
|Rico Mariani on the Future of Visual Studio
|C++ Renaissance on Windows?
|Interesting C++ Perspective
|Tech Ed Developers EMEA wrapup
Pluralsight Free Trial
Click Start a FREE 10-Day trial