This has to be my favorite podcast description in a long while, and not just because I’m in it. As backstory, Alan Stevens (he of #AlanStevensAvatarWeekend fame, among other things) and I have occasionally had some spirited tussles on twitter about myriad topics including the role of (or in Alan’s opinion the evil of) drag and drop development.

After the most recent of these, Kevin Dente approached Alan and me and asked if we’d like to be on the show and hash things out there. The result is this podcast. Enjoy!

In this corner, Microsoft Developer Evangelist and author, G. Andrew Duthie. In the other corner, C# MVP, ASP Insider and Open Space Technology facilitator, Alan Stevens. This week, G. Andrew Duthie and Alan Stevens bring their recent “Real Software Development vs Microsoft Bubble Development” Twitter debate to Herding Code. It’s all the open and honest, fun-loving, snarky banter without the 140 character limit.

• Kevin kicks off the show by announcing our two fighters. Ding. Ding.
• Alan throws the first punch – He likes Herding Code because it’s about real software development rather than development in the Microsoft bubble.  It’s about the tool users rather than the tool builders and it’s about honest feedback.
• Andrew jabs back – He likes the stories from the trenches but he feels more credit must be given to the folks at Microsoft who are doing the right thing. In other words, don’t always assume the worst and snark about it.
• Scott K keeps both fighters on their toes – First taking jabs at Alan because some DevDiv developers dogfood Microsoft’s stuff (e.g. Visual Studio 2010 and .NET 4.0) and then lands a sucker punch on Andrew noting Entity Framework is developing in the dark.  Who could have seen that punch coming?
• The fight continues with talk about general disgust in drag and drop demos, the role of the Developer Evangelist, Microsoft’s goals and constraints, and the need for candid feedback.
• If you missed the Twitter exchange, you will definitely want to listen in as The Alan Stevens vs G. Andrew Duthie Debate continues this week on Herding Code.

Herding Code 52: The Alan Stevens and G. Andrew Duthie Debate Continues! | Herding Code

I am presenting at The Humanitarian FOSS (H-FOSS) Summer Institute at Trinity College (Hartford CT) on July 2nd. The H-FOSS Project is primarily for undergraduate computing students who want to get involved in building free and open source software for use by humanitarian organizations. Details below:

Presentation Title: Lessons learned and best practices in Humanitarian & Emergency Systems.

In recent years, two emergency events - South Asia Tsunami and Hurricane Katrina saw the deployment of Humanitarian systems to aid in the relief efforts. This presentation will give an overview of the event scenarios, lessons learned and best practices in developing and deploying such systems. In addition, the presentation will describe a system currently being developed by InSTEDD for deployment at the UNICEF's Operation Centre (OPSCEN) for Emergency management. Please note that this presentation shows how any system platform can be used during emergencies & humanitarian events.

Presenter Bio: Supriyo "SB" Chatterjee is an Architect/Tech-Lead based in Hartford CT. He has over 20 years experience in Information Technologies and has worked at various companies like Aetna, IBM, Microsoft, NASA, UNICEF and State of Connecticut. He holds graduate degrees in Computer Science, Business Administration and Economics. He is the former President of the Trinity Club of Hartford (alumni chapter).

This is both a cool use of Silverlight, as well as a great resource for understanding what Microsoft is doing or has done in your local community and/or in communities like yours around the world:

Simone has created another survey concerning AJAX usage with ASP.NET. The results are available, now, and it is really interesting to see that there are only small changes in the use of AJAX libraries for ASP.NET developers.

The most used Ajax/JS library among .NET developers is jQuery, which is used by the 71,4% of the users. Second comes the Ajax Control Toolkit with 58,8%, followed by the core ASP.NET Ajax library, which is used by 44,8%.

The 3 most used libraries are still the same of 2007, just with the opposite order (it was ASP.NET Ajax, the Control Toolkit and then jQuery).

He writes more about the results concerning my library:

And, despite becoming a dormant project, AJAX.NET Professional lost only 3% of the users.

Here are the results in more detail:

It is really interesting that there is only one big change, jQuery become the new #1, I use jQuery in combination with my own library since the very beginning, and this combination is still what I recommend to use.

If you have a look at the CodePlex download statistics you can see that Ajax.NET Professional is still alive:

And for those of you are interested: yes, I’m still developing my private version of Ajax.NET Professional. I have added several features that let me work with JavaScript, jQuery and ASP.NET more faster. One interesting feature I have added is the AjaxHashCode attribute that will append a __hash property to the JSON converted structure. This can be compared more faster on the client-side JavaScript code to indentify if there is a change in live data. Maybe I will have some time to publish my private version which is not 100% compatible with the public one, but maybe interesting for some of you.

Some days ago I had to work on an .NET application that has been ported from C++. This application is using VBScript as scripting host using the IActiveScriptParse interface. While the C++ compile was working fine on x64 the .NET port didn’t work.

To understand why it is not working I had a look at the target platform settings in the .NET project. By default Visual Studio is using Any CPU. The .NET runtime then will have a look at the PE header to identify if the assembly has been compiled with Any CPU, x86 or x64.

The IActiveScriptParse interface on x86 is mapped to IActiveScriptParse32 with the ClassID BB1A2AE2-A4F9-11cf-8F20-00805F2CD064. The easiest way to get it working on x64 was to mark the assembly as x86. You can do this with the target platform property in your Visual Studio project or by using the corflags.exe:

corflags.exe ConsoleApplication1.exe /32BIT+

Well, the effect is that the the application is running in 32-bit mode on x64 what I don’t want to. There must be a better solution to do the trick and keep the Any CPU target platform.

Let’s have a more detailed look in the C++ source code. The interface IID_IActiveScriptParse is mapping to IID_IActiveScriptParse32. When reading the source code file ActivScp.h I found that there is a x64 version, too. When I had a look at the OLE-COM Viewer I didn’t find it there. Ok, I will take the new ClassID C7EF7658-E1EE-480E-97EA-D52CB4D76D17 from ActiveScp.h and use it on x64 platforms. To device if you’re running on x64 or x86 you can check the size of IntPtr:

if (IntPtr.Size == 4)
{
    IActiveScriptParse32 x = (IActiveScriptParse32)Activator.CreateInstance(t);
    script32.InitNew();
    // …
}
else
{
    IActiveScriptParse64 y = (IActiveScriptParse64)Activator.CreateInstance(t);
    // …
}

Hm, that’s working in my .NET application, but not really nice. I will create a wrapper around the both interfaces as the method arguments are the same (except the size of the IntPtr, of course).

While searching for the x64 interface description I found that Microsoft already created such a wrapper. You can find this in _comimports.cs, but all members are marked as internal and a define is set to not compile the code, why? I don’t understand this.

Using the wrapper couldn’t be easier:

Type t = Type.GetTypeFromProgID("VBScript");
ActiveScriptParseWrapper wrapper = new ActiveScriptParseWrapper(Activator.CreateInstance(t));
wrapper.InitNew();
// …

I’ve created a feedback at Microsoft Connect, maybe we’ll get this or find a common solution for this.

Just one note: using C++ the compiler will always use the x86 version (IActiveScriptParse32). You need to add a define #define _WIN64 to explicit use the x64 version. Oh, that means the x64 compiled version before could use the 32-bit one? That is the difference I still don’t understand why it is different using C++ or C#. Is this a bug or a feature by design?

ASP.NET/VS2010 and NETFW 4

• Updates to FTP publishing in Visual Studio 2010

WF/WCF/REST/Identity Management

• Learning by example with 4 - All about the code samples you can download for WF/WCF 4.0
• Transactions are bad for REST
• Announcing FabrikamShipping, in-depth semi-realistic sample for the Geneva Framework
• Introduction to WF Designer Rehosting - Part 1 and Part 2

Roger Jennings has his latest excellent links.

Scientists hypothesize on existence of ReSharper for Visual Studio 2010. They argue pros and cons endlessly, bringing history to the table and even gamble around the odds if ReSharper can run in the new shining Visual Studio 2010 Beta 1.

You can know for sure, it runs! Want to know when it will be running for you? Read on!

See how the new Extension Manager happily shows ReSharper as an installed extension, making it a first class citizen in the new Visual Studio shell.

Here, our well-known ReSharper tool windows are shown participating in the improved Visual Studio docking system.

Can you see those unit tests running? Of course not, it’s a screenshot. But rest assured that development pleasure-inducing bits are being cooked up in large integration ovens here at JetBrains.

Next to integration ovens, there is a high-tech lab where die-hard developers in white coats are implanting smartness into ReSharper’s understanding of C# 4. Variance and dynamic, optional parameters and named arguments - all the features of new C# version are being mercilessly stuffed inside the most intelligent add-in for Visual Studio. Developers perform their cruel experiments with Visual Studio 2008, writing C# 4 code where only the previous version of the language is meant to be used.

Now, you might want to know when all the intelligence of ReSharper will be available for Visual Studio 2010? No need to wait for ReSharper 5.0 to come out! We plan to release preview bits compatible with Visual Studio 2010 for you to play and test in June, and June is just around the corner!

Groove is getting a new name - SharePoint Workspace 2010. More info at the MSDN Groove Development blog post here…

This is a major shift for Office Groove – having worked with it for a long time (MVP Award and MSDN Developer Network postings), this is certainly good for business!

We have recently crossed the bounds of our specialization to set a world record in data transfer rate by throwing a 450GB file from one machine to another in only 1 minute! It was surprisingly easy: all we had to do was find a fast-running developer and equip the guy with an HDD!
Fake world records aside, only 4 months since our previous milestone, we’ve collected and successfully opened a 450GB snapshot. We mean it. Anyone ever seen a .NET profiler lifting that much weight?

After expanding its functionality in previous releases, ReSharper 4.5 shifts focus to the issues of performance and memory usage. Making the tool agile, robust and responsive – and a bit smarter still – is the main idea behind ReSharper 4.5.

Read about the improvements and enhancements below or watch this Flash demo.

• Performance and memory consumption: When working on large solutions, you will feel a great deal of difference between ReSharper 4.0 and 4.5.
• New solution-wide warnings and suggestions: Analyze usage of non-private types and type members within your whole solution (or don’t!).
• Visual Basic 9 support: ReSharper’s cross-language refactorings and editing experience enhancements now support VB9 code.
• Improved setup for naming conventions, which are now supported by all ReSharper features.
• New Inline Field refactoring and enhancements in existing refactorings.
• Go to Implementation: Go from the usage of a class or method straight to its implementation, bypassing its declaration.

Download your free 30-day trial of ReSharper 4.5.

Upgrades from ReSharper 4.0 are free.

Have you ever wanted to really customize ReSharper, just the way you want it?

Now you can build your own, with our brand new ReSharper Configurator. Choose the analysis engine, select the feature packages you need, the supported languages, and even the colors! Go lightweight or feature-rich - it’s all up to you.

Click here to build your ReSharper now: http://www.jetbrains.com/resharper/build_now.html

The 19th Jolt Awards were finally announced last week. Our own .NET productivity tools, dotTrace and ReSharper, were named recipients of two Productivity Awards!

ReSharper was one of the top three Development Environments.
dotTrace was recognized as a top productivity Utility.

Thanks again for making our products a success, folks. Keep developing with JetBrains, productivity and pleasure!

Your wait is almost over: ReSharper 4.5 has gone public beta, and the official release is just a few weeks away!
 
After significantly expanding the set of ReSharper features in previous releases, we’ve shifted focus to the issues of performance and memory usage. Making the tool more agile, robust and responsive was our main goal when developing ReSharper 4.5.
 
ReSharper 4.5 brings a wide-ranging set of improvements that go way beyond performance enhancements:

• Performance and memory consumption: When working on large solutions, you’ll feel a great deal of difference between ReSharper 4.0 and 4.5.
• New solution-wide warnings and suggestions: Analyze usage of non-private types and type members within your whole solution.
• Visual Basic 9 support: ReSharper’s cross-language refactorings and editing experience enhancements now provide support for VB9 code.
• Extended setup for naming conventions, which are now supported by all ReSharper features.
• New Inline Field refactoring and enhancements in existing refactorings.
• Go to Implementation: Go from usage of a class or method straight to its end implementation, bypassing abstract classes and/or interfaces.

 
To get your hands on the public beta, download it now!

Maybe.

Dare had a pointer today to a programming.reddit story that talks about competing versions of a dustup between Joel and Greg Whitten back when Joel used to work for Excel. I could care less who’s right, but the interesting implication of the story is that Joel was the one who came up with the application interface for VBA. I’m not sure that’s entirely true—a lot people worked on VBA—but if it is, he might be responsible for nearly driving a former co-worker insane.

When I started at Microsoft, I worked on Access. Access used a version of BASIC called Embedded Basic (or EB) for its programmability story. EB may not have been perfect, but I always thought it was a really nice language engine—it was small, it was fast, and it worked really well with Access and its programming model. After Access 1.0 shipped, however, EB was discontinued in favor of VBA which was the new official programmability story for Microsoft. There were a few people left on EB whose job, as far as I could tell, were just to tell me “no” when I came to them and asked them to fix bugs. (My interactions with the EB team at this point inspired my program manager to tell me that one of my special skills seemed to be “being able to tell people to f**k off, but in such a nice way that there’s nothing they can say in return.” Suffice it to say, I didn’t have a great relationship with the EB folks.)

By the time we got to Access 95, we knew we had to move over to VBA. The head of the project stopped by and asked me if I was interested in maybe leading the effort to switch over to VBA. In what I can only describe as an extreme fit of sanity, I declined. Another coworker took on the job. Suffice it to say, it was nearly a complete disaster. VBA was designed to work well with Excel, which had a totally different storage, execution, and debugging model than Access. As a result, almost everything having to do with programmability had to be redesigned, often in some pretty hairy ways. From the outside, it seems like a miracle that it ever worked, much less worked well.

As you can imagine, this was pretty hard on my coworker, who was responsible for getting this working in Access. As I remember, the VBA team at the time (Joel was gone by that point, I think) was somewhat sympathetic but not overly helpful—after all, they worked really well with Excel and we had all these “weird” requirements. Anyway, I knew things weren’t going well when my coworker came into my office and told me, “I found this really stupid bug that I made, so I decided to rename all the local variables to say insulting things about me.” Then one day I came in to work and found my coworker wasn’t there. When I asked where he was, I was told that he’d been ordered to take several days off and fly to Vegas to unwind for a while. I believe they were worried he might totally go off the deep end.

In the end, though, we shipped, my coworker did not go insane, and everything ended up OK. But it’s interesting to think what might have happened…

The list of global software conferences has recently been extended with a new exciting member - the Great Indian Developer Summit, which will host the second edition of Great Indian Developer Awards (GIDA) this year.

Celebrating software development product excellence, GIDA is India’s premiere awards event with 100+ nominees shortlisted for this year’s upcoming edition, the event’s second so far.

Our own ReSharper was chosen as one of nine nominees in the Development Environments category, along with Microsoft Visual Studio 2008, Oracle JDeveloper, and six other outstanding development tools.

Other categories included Design and Modeling, Change and Configuration Management, Collaboration Solution Testing, Security, Content Management, Web Development, Mobile Development, Frameworks, and Database.

The winners will be announced and honored at the Great Indian Developer Summit 2009 to be held on April 25, 2009, in Bangalore, India. The awards jury is comprised of distinguished executives, seasoned industry professionals, and internationally recognized academia.

For more information on the awards and to vote, see official GIDA web site.

My interest in Scala can be traced back to a Phlly Lambda presentation given by Toby Dipasquale last January. More recently I was meeting with someone about a data visualization project and they mentioned they were using Scala for a couple of startups they were working on. For those of you unfamiliar with Scala here’s a blurb from the Scala language website:

“Scala is a general purpose programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. It is also fully interoperable with Java.

The thing that made Scala particularly interesting to me was that it was a functional language, and that it’s fully interoperable with Java. I’ve been using a couple Java libraries for some projects I’m working on and I haven’t been enjoying it all that much. My hopes were that I could use Scala to make those projects more enjoyable, while at the same time learning a functional language (although it’s not a purely functional language).

To help me on my journey of learning Scala I asked @codeslinger and @markchadwick for Scala book recommendations. Although, the pickings are slim, they both recommended Programming in Scala. A couple weeks ago I bought the PDF form of the book and began working my way through it. For anyone interesting in learning Scala I’d definitely recommend it. It covers a lot of ground, and is well written. Oh, and it also prevented my house from burning down!

Since I have the PDF version of the book I’ve been printing out chapters periodically (reading on a computer screen sucks). This past Saturday morning I was sitting around watching my kids make a complete mess of the house and decided that I wanted to continue on with Programming in Scala. As such I printed out the next chapter. As I walked upstairs into my office (which is in the attic) I began to smell something out of the ordinary. As I went further up the smell got worse. I didn’t think much of it, and grabbed the printouts and headed back downstairs. When I got downstairs I noticed the entire chapter didn’t print out, so I went back to the computer and re-printed the chapter. When I made my way upstairs the second time the smell was again worse then before and also more identifiable. It smelled like an electrical fire! It turns out that one of my computers more or less blew up, had ejected it’s CD tray and had smoke bellowing out the front. I have no way of knowing what would have happened had I not been so interested in reading more about Scala, but I’m glad that Scala and Programming Scala hooked me and led me upstairs to catch my exploding computer early.

So the moral of the story is that if you’re looking for a language to learn, consider Scala….it just might prevent your house from burning down! :)

Cheers,
Steve

Over the course of the last couple months I’ve been doing quite a bit of investigation and experimentation of existing network visualization libraries. There are a number of libraries available, some open source, some built specifically for the web, others meant for a desktop environment, some in java, others in flash, and round and round we go.

I’ve talked to quite a few people who have specific expertise in technologies for doing network visualization as well, ranging from flash to javascript to Silverlight to java. My conclusion thus far is that large scale network visualizations (300+ nodes) is hard. Once you cross the 100 node mark, you begin to have serious problems with laying out the network in a way that is usable by the user of the system that the visualization is within. Drop on top of that the desire to make the visualization interactive (zoom, click, drag, etc), as well as the desire to have the visualization software figure out the best layout for the network itself and you have a pretty difficult problem to solve.

I’m currently doing some prototypes myself using Silverlight. I don’t love the idea of using Silverlight since I doubt the penetration of Silverlight is as great as some have proclaimed, but, the advantages it offers are hard to look past. As a long time .NET/C# developer I’m very comfortable with the development tools used to build Silverlight applications, as well as the language within which to do so, C#. Silverlight appears to offer some pretty decent performance, and I suspect that it will get better as the VM improves. The major disadvantage of Silverlight, which I don’t know the validity of, is it’s lack of existing user base. Since it’s relatively new, and not many sites use it, I suspect the installed base of Silverlight is much less then something like Flash.

The other piece of software that I’ve been spending a bit of time with is graphvis. Graphvis is good at creating network visualizations, and supports a number of different layout algorithms. Unfortunately the output isn’t always great, and it most certainly isn’t very interactive. What I’m experimenting with is using graphvis to pre-compute the network layout, and then feeding that positional information into the Silverlight visualization. The primary advantage will be that the Silverlight app won’t have to figure out the initial layout, however, it will be able to handle all the nice visualization and interactivity that’s desired. The question still remains, is Silverlight up to the challenge? Or is flash, processing, or a pure java applet more appropriate/capable? Only time will tell….

Sometimes during profiling sessions you notice that your application is running slow or hanging, only to realize that you have not turned off a debug switch. After that, you have to reprofile everything.
Other times, after hours of continuous profiling, you optimize a consuming method, and again, you have to start from scratch to see if the optimization actually worked.
We thought we could provide a less time-consuming option for scenarios like these.
Starting from version 4.0, dotTrace will be able to recalculate a snapshot without reprofiling your application. Just ask “what if this function is removed” or “what if I optimize this function by 40%” and get a prompt answer from dotTrace: it will display new time values and compare them to the old ones.

JetBrains tools continue to receive recognition and praise: three of them have been named finalists in this year’s Jolt Awards!

ReSharper, our intelligent add-in for Microsoft Visual Studio that you love so much, was honored as one of the five best Development Environments.

In the Change and Configuration Management category, the finalists included TeamCity, our distributed build management and continuous integration server.

And last but not least, dotTrace, our super-fast and efficient .NET profiling tool, was picked by Jolt judges as one of the best five Utilities.

Best of all, each of these products still has a shot at winning the big kahuna - the Jolt Excellence award, or maybe a Jolt Productivity award! We’ll keep you posted.

We thank you, our customers, for making our products a success.
Keep developing with JetBrains - and with pleasure!

Back in the days when R# 4.0 was still in the making, we were profiling it heavily in order to, you know, make sure it wouldn’t suck all your hardware resources out. Time and again we were getting thousands and thousands of threads accumulated in snapshots. Obviously, merging them was a real challenge.
Why, we thought, couldn’t R# guys be more accurate with threads, and wondered whether we would ever get a complete snapshot.
The thread exuberance issue in R# was eventually solved, but you know what? Even before that happened, dotTrace had never ever gone crazy profiling the Most Intelligent Tool for Visual Studio.
The message is: whenever you have a zillion threads in your application, it’s not a problem for dotTrace - it’s a problem for you.

Now that we’re past the PDC, there are a bunch of video resources coming out on VB 10.0 and Oslo. Here’s a roundup of what’s available so far:

• Channel9 has a video that I did with Don and Chris on M called, “Don Box, Paul Vick, and Chris Anderson: Introducing M”
• Channel9 also has a video Don and Chris did on their own covering Oslo, “Don and Chris explain Oslo in 5 minutes”

The Pearson folks also recorded some vidcasts they call OnMicrosoft. If you go to the previous link, you can see all the videos posted, but the ones of interest to this blog are:

• Lisa and I did one on “Visual Basic 10: New Features”
• And also one one “Future Directions of Visual Basic”
• Then we moved on to talk in general about “"Oslo" -- Microsoft's Modeling Platform”
• And got specific on “The "Oslo" Modeling Language: "M Grammar"”

There are other Oslo vidcasts on the site, so check them out as well.

Yesterday I gave my valedictory address on Visual Basic at the PDC. I think the talk went well and it was a lot of fun, if not a little sad that it’s one of the last times I’ll be giving a talk about Visual Basic. We covered a lot of exciting stuff, some of which should be familiar to readers of the blog. I’ll let people know when the video is up on the Channel9 page for the talk, should be some time today. For those of you who don’t want to sit through the talk it went something like this:

• First, we talked a bit about the role of Visual Basic at Microsoft as the language that makes Microsoft platforms really accessible to programmers.
• Then we segued into talking about the increased commitment that the languages groups are making to ensure that Visual Basic and C# coordinate language features so that users of one language aren’t left out in the cold when the other language adds some useful feature. This isn’t to say that we’re going to do things in exactly the same way, or even that the languages will have exactly the same feature set, but that we’re committing to ensuring that the fundamental capabilities in the languages stay in better sync than they have over the previous eight years.
• Then Lucian did a really wonderful demo of VB 10.0, which is shipping in Visual Studio 2010. He showed (IIRC) the following features that should be familiar to the readers of this blog: array literals, collection initializers, automatic properties, implicit line continuations, statement lambdas, generic variance, and a feature that embeds primary interop assembly types in your assembly so you don’t have to deploy the PIA. I may have missed some, so check out the video when it’s posted!
• Finally, we talked about some of the trends that we see affecting Visual Basic going forward and talked about some of the work we’re starting to do for post-VS 2010 to move the Visual Basic compiler to managed code and open it up to the world so that you can take advantage of the services that it provides.

If you attended the talk, please evaluate the session! It helps me become a better speaker and helps us give a better PDC. And feel free to stop by the tools lounge today, I’ll be hanging out there most of the day!

While I was hanging out at the Addison-Wesley booth, I picked up a copy of two updated editions that I’d been eyeing. One is the updated C# Programming Language specification that includes a lot of hard work by Mads:

And the other is the updated Framework Design Guidelines:

Both look just awesome. I think they’re also supposed to be giving out this sooner or later:

So I can hopefully pick up one of those too!

It has been a long time since I actually worked on the IndiaStockQuotes component. Just had sometime over the weekend and fixed some bugs in the component and got out a new release. Also upgraded the component from .NET 2.0 to 3.5. I dont yet use any 3.5 specific features, so you should be able to recompile the source agains 2.0 and still get it to run.

Check it out at India Stock Quotes

When you open a VS 2005 project in VS 2008, Visual Studio offers to migrate the project to the new format. Usually there should be no problem with this and all your project files, solution files, Test cases etc should move seamlessly to the 2008 format.

But if you do build your project you will notice that your output assemblies actually target .NET Framework 2.0 and not 3.5. This is basically because the migration retains the targeted framework to make sure you application does not fail. The method to change this setting after migration is not easy to find.

For VB projects, this setting is actually hidden inside, My Project -> Compile -> Advanced Compiler Options dialog. Obviously, this is not very easy to find. (See Image)

In C# projects this setting is a lot easier to find in Project Properties -> Application Tab itself. I am not sure why the VB team actually made this setting so difficult to find.

I wanted to let people know that an (almost) final VB 9.0 language specification has been posted on the download center. The spec is missing some copy-edits from the documentation folks, but is otherwise complete. Since I'm not going to get a chance to incorporate the copy-edits until I am back from vacation in January, I wanted to get the spec out there for anyone interested in documentation of the XML features that weren't present in the previous version of the spec. (I apologize for the lateness of this vis-a-vis the release of the product itself, it's been a busy fall.)

This updated language specification corresponds to Visual Studio 2008 and covers the following major new features:

• Friend assemblies (InternalsVisibleTo)
• Relaxed delegates
• Local type inferencing
• Anonymous types
• Extension methods
• Nullable types
• Ternary operator
• Query expressions
• Object initializers
• Expression trees
• Lambda expressions
• Generic type inferencing
• Partial methods
• XML Members
• XML Literals
• XML Namespaces

Questions, comments or criticisms can be sent to basic@microsoft.com. Thanks!

In case you missed the announcement, VS 2005 SP1 is released. You can get it here. Beta support for Vista coming soon!

I discussed a little while back that we've made a few hotfixes available to address some performance issues people have seen with VB. There's now a program that makes these hotfixes available as a regular download, rather than forcing you to call support. I'd recommend anyone running into performance problems give them a try...

It’s been over two years since I blogged.  Although I remain happily (perhaps even ecstatically) working at Microsoft, I left the CLR team and the Developer Division about a year ago.  I’m now on an incubation team, exploring evolution and revolution in operating systems.  This is a fascinating area that includes devices, concurrency, scheduling, security, distribution, application model, programming model and even some aspects of user interaction (where I am totally out of my depth).  And, as you might expect with my background, our effort also includes managed programming.

Anyway, this blog will remain available indefinitely.  It continues to be useful for certain technical details which are unavailable elsewhere.

In the meantime, if any readers are interested in working on a deep systems incubation with me and a team of truly outstanding developers, please send me email (cbrumme).  We are holding to some very high standards for this effort in terms of insight, experience and hard work.  But if you are like me, I am confident you will find it a dream opportunity.

My original posts on Finalization and Hosting had some hokey XXXXX markers in place of content, where that content hadn't already been disclosed in some form.  Now that the Visual Studio 2005 Community Preview is available, I've gone back to those two posts and replaced the XXXXX markers with real text.

Also, it's obviously been a while since my last post.  I started writing something this weekend, but the weather here has been spectacular and I was compelled to go outside and play.  I'll try to have something in the next couple of weeks.