Who’s the “typical VB.NET developer”? Is there one? There are millions of VB.NET developers in the world, and they each have their own unique story. We decided to talk to some of them to find out what kinds of applications they’re building, what technologies they’re using, and what their favorite features are. Watch the interviews and find out for yourself who today's VB.NET developers really are!

View the interviews

Are you a VB, too? Tell your story here or leave a comment below.

By now, many of you will have downloaded the recent beta that we posted to the net, and (hopefully) are getting excited about the features that we’ve been developing.  Recently, Beth Massi interviewed me about some of the work that I’ve been doing as a part of that effort.  I always enjoy interviews, and Beth is great at pulling out some of the more interesting aspects of a person’s work, but I’m always somehow left with the feeling afterwards that there’s something more that I wanted to say -- some different issue to which I forgot to draw folks’ attention.  You should therefore think of this blog entry as a follow-up to that interview, where I get to spend some time discussing the people-aspects of the job.

“People, process, product.” 

(variously attributed in current management theory)

In the course of the aforementioned interview, I spent a lot of time discussing process, and of course this blog site spends a lot of time focused on product.  I haven't talked much about the “people” aspect of it – and yet, that’s a really important part of the triad.  The product needs to address what people (our customers) need and what other people (our employees) can deliver.  The process, in turn, needs to be defined in such a way as to deliver the product to the people.  Process for process’ sake will inevitably result in the wrong product, which in turn will greatly annoy both the people developing the product as well as the people for whom the product is intended.

That’s not to imply that we don’t spend a lot of time on the “people” issue – in fact, it's the needs of our customers that drive us to create the best software we can.  I remember the first time I picked up a Visual Basic magazine and thumbed through it.  As I read it, I noted that many of the articles and “letters to the editor” involved features that I had written or that I somehow was responsible for.  And as I continued to read, I was suddenly struck by an almost frightening realization:  the effectiveness of my work, and of my team’s work, had a direct impact on the daily lives of our customers. 

Not just “customers.”  Millions of customers.  Yep, that’s a big number.

This was something that I suppose I’d always understood in an abstract sense, but reading this magazine really brought it home for me.  Previously, I’d joked about how I was getting paid by Microsoft for doing what was essentially a hobby for me – writing software for fun and profit, what a blast!  Suddenly, I realized that there was something bigger going on – keeping electric plants working efficiently, allowing the initiatives of various governments to run smoothly, enabling small businesses to keep on an even keel – it’s just an incredibly diverse ecosystem that uses our software.  I got a lot more serious about my attitude towards coding after that personal epiphany, believe me.  It’s a sobering thought as to how the work that any of us does impacts others, and it can be highly embarrassing when we get something wrong.  This is why, over the years, we’ve worked closely with not only MVPs but with a broad spectrum of our customer base to determine where we need to focus our attention.

Most of my “people” work these days, however, is focused within Microsoft – how we as engineers interact with each other in such a way that we can produce a better product.  Currently, within our division, we have over 30 product groups that somehow need to work together as seamlessly as possible for us to stay on track.  Visual Basic is a big part of that, but there are many other parts as well, and they all connect together in interesting ways to cover the broad spectrum of scenarios that we support.

 “What we’ve got here… is a failure to communicate.”

(Luke, in Cool Hand Luke, mocking the prison captain’s earlier words)

Over a dozen years ago, we started the first efforts to bring together the various pieces that would one day make up Visual Studio.  The first big step that we took was to start focusing attention on the “Vegas” shell (our internal codename for the shell that we still use in VS today) – all new products would leverage this shell for Visual Studio 6.0, which other established products (notably Visual C++ and Visual Basic) would use their old shells but would have some of their functionality supported by the new shell (which would, for example, wrapping their build functionality via special project types).  This pulling together of different groups meant that the “build manager” position for each team suddenly went up in importance.  Previously, this person simply needed to make sure that dependencies were in place and that daily builds got built.  Now, this person instead had to work directly with peer teams to pass code around and integrate it.  The problem was, each of these teams had different cultures and different processes doing things, and they’d never been pressed to evolve the skills required for this new sort of relationship.

At the time, in addition to my coding duties, I’d acquired the build manager position for the VS Enterprise Edition product unit (comprising source code control and deployment teams), and thus the responsibility for coordinating with my peers on these other product units.  I can best describe those days as “dark.”  This was a challenging time for us, and most of the challenges arose because of a lack of communication between the teams.  Inevitably, whenever I would integrate some other teams’ code into our codebase, their code would have massive conflicts with our code, and I would spend 2-3 days getting things working before being able to return to my “normal” programming duties.  There were days where I and others worked very, very late to get things working again.

The other teams didn’t mean to break my team’s code.  Our team didn’t mean to break their code.  The problem was simply that it never occurred to anyone that their change would have a ripple effect with other teams in this shared environment, nor that they needed to communicate such changes.  Now, you could claim that there was a process problem involved – and you’d be right.  Our processes changed substantially as a result of this, believe me.  But the fundamental problem was a cultural (i.e. people) problem – each team was still acting as if they were on their own island, and every divisional problem took a backseat to their drive to provide their own core functionality.  There was no common language to describe the importance of one team’s scenario with respect to another’s.

Now, since then, we’ve made huge strides in inter-team communication.  Leaders from across the division, in all disciplines, regularly meet to discuss changes coming down the line.  The build manager position has evolved into the Build Facilitator Developer position (BFD), and they (sponsored by my team) also regularly meet to discuss policies and practices.  The division as a whole devises specific goals for a given product that teams need to incorporate into their feature planning.  As a result of improved processes and better communication, our downtime for build issues is the merest fraction of what it was a dozen years ago.  We’ve continued to evolve these practices which, along with new processes, means that even the difference between now and a few years ago is stunningly better with respect to build efficiency.

“I feel that if a person can’t communicate, the very least he can do is to shut up.”

(Tom Lehrer, That Was the Year That Was)

So, in the previous section, the communication I discussed was mostly tactical in nature – i.e. here’s what’s coming, and here’s what we’re going to do to avoid problems.   Another aspect of communication, though, is letting people where we are right now.  It’s a critical point, because the best way to avoid mistakes, or to recognize the things that worked and which should be made policy, is to fully understand how our past work led us to this point.

Now, my first attempts along these lines, back when I was the Visual Basic box lead, were not as successful as I would have liked.  In my eagerness to get all of the information out there, I evolved what started out as a small weekly bug report into this huge, massive thing, comprising about 6 pages of data which covered every single aspect of the product’s state.  If you wanted to know *anything* about the status of Visual Basic, you could find it in that weekly mail.

The problem was, no one read the whole thing.  It was simply too much information -- you couldn’t look at the report and know what data was important.  It wasn’t communication at all – it was death by drowning (in data).  Added to this was the problem that I (still) tend to be a very verbose person, using two words where one would suffice.  It actually *hurt* communication because I still had people asking me for data hidden away in my mail – I was wasting my time and theirs.

Eventually, something clicked.  I found out that people were at least reading the first paragraph, where I’d provide a brief recap of the previous week and thank the people who’d specifically helped out with the problems therein.  They read that part because it was *personal* -- it related to them, not in an esoteric “here’s how many bugs you have” context, but instead in a familiar “I did this” sort of way.  So, a few years later when I assumed my current job (which eventually included, among other duties, providing daily status to the divisional staff), I decided to re-think how I did my status reports.  The status I or others on my team send out is devised as follows:

-          What happened yesterday, why it happened, and how does it affect you

-          What’s happening today, and what the status is

-          What the most important resources are currently (i.e., builds and tools), and how you can access them

-          What are the most important issues to address today

That’s it – the whole thing takes less than a printed page of text.  It is a person-oriented mail, which gives kudos to folks that did something particularly well, and points out (in a clear but respectful way) areas where things could have gone better.  Additionally, I sometimes add a “Question of the Day” which answers (in 1-2 small paragraphs) a process-relevant question which one or more people have asked me recently.  This gets the focus on the issues that really matter to people in the division, and not just the ones that I think matter, so that everyone is made aware of them.  This format of status mail has been received much more favorably than the previous one.

Let’s talk

Hopefully, some of what I’ve said above is relevant to the work that you do.  I, in turn, would be fascinated to learn more about how you, our customer, tackle the issue of communication both inside and outside your own business.  I’m certain that we’ve got a lot more to learn from each other beyond coding – the process of coding is really important, but without understanding how to communicate with the people involved, the code you and I create might just be the best thing that no one’s ever heard of.

‘Til next time,

  --Matt--*

A few months ago, Tina started a great series on Channel9 that walks through the history of Microsoft, year by year:

The History of Microsoft

In the first episode, Bill Gates talks about what it was like to build Altair Basic. He actually shows the tape that represents the instructions for Basic! Lots of rare footage, and an entertaining show on how it all started.

Episode #1: The History of Microsoft - 1975

For those of you who prefer text over audio, here's a recent InfoQ article that was released based on the podcast I did with Joe Stagner:

InfoQ: Is There a Future for VB.NET?

As part of the new VB/C# co-evolution strategy, Visual Studio Technical Fellow Anders Hejlsberg has broadened his role. In addition to being Chief Architect for C#, he now sets the direction for both the VB.NET and C# languages.

At TechEd, Anders participated in both the VB.NET and C# language presentations. In watching these sessions, you can see that the future trends and directions for the VB.NET and C# languages are now the same.

TechEd NA 2009 Session Video: "Future Directions for Visual Basic" by Anders Hejlsberg and Jonathan Aneja

In this talk, we discuss the future direction of the Visual Basic language both in the near and long term. Exciting features from the next release are demonstrated and discussed, including extensions to LINQ support, syntax simplifications, and improvements to the IDE. Larger trends that are likely to deeply influence the direction of the language are also covered, including dynamic binding, meta-programming, and scripting. Finally, we discuss how all these tie together into the roadmap for Visual Basic going forward.

The C# TechEd US video is not publicly available. For the corresponding C# presentation, please watch the following from PDC:

PDC 2008 Session Video: "The Future of C#" by Anders Hejlsberg

In this talk Microsoft Technical fellow and C# Chief Architect Anders Hejlsberg outlines the future of C#. He describes the many forces that influence and shape the future of programming languages and explain how they fit into C#. 

In the second part of my interview with Doug Rothaus, he describes the new implicit line continuation feature in Visual Basic 2010. Learn about the most common scenarios that no longer require the underscore character (_) in the topic, Statements in Visual Basic.

See the Video: implicit Line Continuation

--Kathleen McGrath
http://blogs.msdn.com/kathleen

The Misfit Geek, Joe Stagner, asked me this provocative question in a recent episode on his new podcast series: "Does VB have a Future?". Tune in to hear more details on my answer, which of course is YES! :) We talk about plans for increasing the VB.NET content across Microsoft, the great innovations that are happening in VB.NET, idea sharing that's been happening between VB.NET and C#, the similarities and differences between VB.NET and C# developers, and more!

Episode #2 - Lisa Feigenbaum from the .NET Managed Languages Group

In this episode - The Misfit Geek talks with Lisa Feigenbaum from the .NET Managed Languages Group about Visual Basic .NET. Does VB.NET have a future ? Does Microsoft love C# more than VB.NET? Listen and find out.

Resources ......

• VB Dev Center: http://msdn.com/vbasic
• VB Team Blog: http://blogs.msdn.com/vbteam
• VB Team Blog (my posts): http://blogs.msdn.com/vbteam/archive/tags/Lisa+Feigenbaum/default.aspx
• VB 6 Resource Center: http://msdn.microsoft.com/en-us/vbrun/default.aspx
• VB 2010 Resource Center: http://msdn.microsoft.com/en-us/vbasic/dd819153.aspx

There are a lot of great Entity Framework samples on Code Gallery that you can now find available in Visual Basic .NET. This was recently announced on the ADO.NET team blog. Browse through the list below and start downloading!

ADO.NET Entity Framework Query Samples (Download)

ADO.NET Entity Framework Query Samples is a small Windows Forms program which contains several basic Entity SQL and LINQ to Entities queries against that NorthwindEF Entity Data Model (a modified version of Northwind). Its goal is to help you learn the features of the different query languages available in the Entity Framework, and to let you visualize how the results and the translated store queries look like.

Transparent Lazy Loading for Entity Framework (Download)

This sample shows how to use code generation to add support for transparent lazy loading to Entity Framework. It includes code generator (EFLazyClassGen), supporting library (Microsoft.Data.EFLazyLoading) and sample test applications. EFLazyClassGen generates VB code that can be used instead of object layer generated by EdmGen or Entity Framework Designer. Generated code adds support for lazy entity objects that store their data in the form of flyweight objects. Object data is initialized on first access or navigation which means objects can exist without having non-key data loaded. http://blogs.msdn.com/jkowalski/archive/tags/EFLazyLoading/default.aspx has a series of articles that describe the library and its usage.

Persistence Ignorance (POCO) Adapter for Entity Framework (Download)

EF POCO Adapter enables Plain Old CLR Objects (POCOs) to be tracked using released version of Entity Framework V1. It consist of a code generator, supporting library and a test suite and examples. Entity Framework V1 programming interfaces are wrapped with corresponding APIs that work with POCO objects and do necessary translation between POCO and Persistence-Aware objects. See this blog post for more information about the project and its usage.

ADO.NET Entity Framework Documentation Samples (Download)

Description: The ADO.NET Entity Framework samples that accompany the Entity Framework documentation on MSDN. This is the download location for the CourseManager project that you create when you complete the Entity Framework quickstart. You will also find other Entity Data Model tools walkthrough projects as well as the samples described in the Entity Framework documenation.

ADO.NET Data Services IUpdateable implementation for Linq to Sql (Download)

Sample implementation of ADO.NET Data Services IUpdateable interface for Linq to Sql Data Sources. The easiest way to use this is to define a partial class for your DataContext type and provide the implementation there.

ADO.NET Entity Framework Extensions (Download)

The ADO.NET Entity Framework Extensions library includes utilities that make querying stored procedures, creating typed results from DB data readers and state tracking external data much easier in the Entity Framework. A sample application demonstrates several patterns using these utilities, including stored procedures with multiple result sets, materialization of CLR types, and registering entities in the Entity Framework state manager.

In this interview, Doug Rothaus, a programming writer on the Visual Studio User Education team, describes the auto-implemented properties in Visual Basic 2010. He also demonstrates some of the code examples in his Help topic: Auto-Implemented Properties.

See the Video: Auto-Implement Properties.

--Kathleen

The team at PreEmptive Solutions recently posted a great blog article that walks through all the latest features in VS 2010's Dotfuscator Software Services - Community Edition (previously known as Dotfuscator CE). Browse through the article to learn what's new, or download the beta to follow along in the IDE.

What's New with Dotfuscator in Visual Studio 2010 Beta 1 by Bill Leach

I recently received this letter from the Visual Studio Extensibility team, that I thought would be interesting to readers of this blog. Whether you're building Visual Studio extensions or downloading them from others, there's news here for you.

News from the Visual Studio Extensibility team…

Are you building new tools to simplify your life or change the way people work?  Check out the opportunities to create innovative extensions for Visual Studio 2010.

Examples of cool things you can do:

·         Overlay rich metadata on top of the editor to bring new information to your fingertips

·         Develop new project templates to accelerate your work (examples: New Project Dialog)

·         Create innovative user interface elements using the WPF Shell

·         Upload your extension to the Visual Studio Gallery (http://visualstudiogallery.com) to find it in the Extension Manager

            Other things you should know:

·         With v2 of the Visual Studio Gallery that went live on 5/14, you can use the Extension Manager to find products from the ecosystem from within Visual Studio

                *(with Beta1, the Extension Manager will only surface extensions posted to the Gallery in the VSIX file format; Beta2 will include the MSI format)

·         We just released the new SDK along with the new Shell redistributables, look for them at the dev center: http://msdn.com/vsx

·         If you’re developing extensions for VS 2010, you’ll want to stay tuned to the dev center for more information

                                    Fun things to help you get started – these can be found in the Extension Manager (Tools>Extension Manager): search for Editor Extensions

FAQ:

                What is the Extension Manager and how do I find it?

The Extension Manager in Visual Studio enables developers to discover Visual Studio Extensions from within the product itself. It consumes data directly from the Visual Studio Gallery, giving developers direct access to partner and community products that extend and enhance Visual Studio.  If you have a free or free trial version of your product hosted on the Visual Studio Gallery, a developer will be able to download and install that product directly from within the IDE.  (In Beta1, the in-product experience will show only extensions uploaded as a VSIX.  In Beta 2 we will expand the in-product experience to also include extensions uploaded as MSI and reference links to other download sites.)

The Extension Manager enables a developer to install, upgrade, uninstall, enable, and disable extensions, making it easier to manage a portfolio of extensions. 

To find the Extension Manager:  Tools>Extension Manager.

                So this means the Visual Studio Gallery can now host downloads?

Yes, we’re excited to announce that the Visual Studio Gallery can now host your downloads.  Keep in mind that at this time the gallery does not include a commerce framework so we recommend creating a free or free trial version of your product that can be hosted on the Visual Studio Gallery.  Of course we still support reference links for users who prefer to host their own downloads.

                What else is new @ the Visual Studio Gallery?

Thanks to some great work by the MSDN team we’ve moved the Visual Studio Gallery to be part of MSDN.  Some of the benefits:

·         The new navigation model supports all types of Visual Studio Extensions and has sections for Tools, Controls, and Templates

·         The integration with MSDN now gives users a chance to take advantage of a shared profile across all MSDN properties.  Contributing to the gallery can enhance your MSDN reputation giving high quality contributors the recognition they deserve.

·         Visual Studio Gallery contributions offer an optional discussion board to separate your reviews and give contributors an opportunity to post updates, respond to feedback, & discuss bugs.

·         All entries include a usage chart to give contributors a sense of which of their products are getting the most traffic on the Visual Studio Gallery.

                What’s the deal with the VSIX file format I’ve heard about?

Both the new Visual Studio Gallery and the Extension Manager work with .VSIX files, which is a new deployment model for extensions, similar to a renamed .ZIP file.  This transition provides Visual Studio users a new low-overhead, reliable way to deploy Visual Studio Extensions. There’s tooling available to help you with this, and you can find instructions and other helpful tips at the Visual Studio Extensibility Dev Center:  http://msdn.com/vsx.

                Questions?

                Email catherine.crim@microsoft.com

Ever wonder how we build Visual Studio and the .NET Framework? I mean literally. You know, the build process that spits out a product at the other end?  Well I sure did and it's not just hitting F5 people ;-).

In this interview I sit down with Matt Gertz, frequent VB blogger and also the guy in charge of the builds in Developer Division (he has a long title, but I forget what it is :-)). He explains how the build and test processes work on a team of two thousand people all on Team Foundation Server. I must say it's pretty darn impressive. Many thanks to Matt for taking time out of his busy schedule to do this interview!

How We Do It: Building the Visual Studio Product Line

Enjoy,
-Beth Massi, Visual Studio Community

To learn more about Visual Studio 2010 and .NET Framework 4, Kathleen McGrath is highlighting new documentation about these products with a weekly blog post and a daily tweet.  If you want to learn more about the new features and scenarios, check out her blog at http://blogs.msdn.com/kathleen and her twitter feed at http://twitter.com/kathleenmcgrath.

Mary Lee, Programming Writer.

In my post “M. G. Phone Home,” I discussed how to write a simple phone application for Windows Mobile, using Visual Basic, which accesses the Bluetooth service.  What I didn’t discuss was how to deploy it to the phone via CAB.  Since I purchased a new phone yesterday (a Samsung Saga, running Windows Mobile 6.1), and I’ve discovered that I need the same app on it, I thought this would be an opportune time to discuss how to do this, since it’s not obvious and slightly different from the distribution of “normal” applications.  If you want to follow along, you can find the code at my Temple of VB site (direct release link is here).

(By the way, I’ve modified the app’s code slightly from what I wrote in that previous blog -- I have assigned an icon to the application in the project’s properties, because I got tired of seeing the default, non-intuitive icon.  If you do this also, make sure that, after doing so, you select the icon in the project’s files and, in the property grid, set its “Build Action” to “Embedded Resource.”  If you don’t do that last step, you won’t see the icon on the phone.)

Once you’ve got your phone app completed and debugged (as discussed in the aforementioned blog), choose “File-> Add->New Project.”  Select “Smart Device CAB Project” under the “Other Project Types->Setup and Deployment” tree node, and give the project some meaningful name (ResetBluetooth, for example).  Select OK so that the project is created. 

In the property grid for the new project, make sure that “Manufacturer” and “ProductName” are set however you want them to be, since they will be visible in the program list on the phone.

Now, in the Solution Explorer, right-click the new project and choose “Add->Project Output.”  In the resulting dialog, make sure that the first project is selected (the one with the actual code), choose “Primary Output” and click OK.  The CAB project will now always contact that project to get its outputs when creating the CAB.

You’re not quite finished, though.  You need to add a couple of shortcuts so that you can actually interact with the program on your phone once it’s installed.  To do this, bring up the CAB project’s File System Editor if it’s not already visible (right-click the project, choose “View->File System”).  In the left-hand pane, you should see “Application Folder” and “Program Files Folder.”  “Application Folder” is where the code will end up; don’t change anything about it. 

However, “Program Files Folder” is empty, and you need to add a shortcut to the program in it.  Select that folder, and in the right-hand pane, right-click anywhere and choose “Create New Shortcut.”  In the resulting dialog, navigate into the Application Folder and select “Primary Output from ResetBluetooth (Active)” (or whatever you called your original program).  Click “OK.”  The Shortcut will be selected for editing, and it will have an atrociously long, descriptive name – give it a more sensible name like “Reset Bluetooth” or something.

You’re still not done, though -- you need to add one more folder.  Right-click the “File System of Target Machine” node in the left-hand pane and choose “Add Special Folder->Start Menu Folder.”  Inside that new folder, add the same shortcut to the primary output that you added in the “Program Files” folder, and give it the same sensible name.

Now you’re done.  Build the CAB project, and you’ll find the CAB file in its Release subdirectory.  You can copy that over to your phone via the usual ActiveSync mechanism, and then run it on the phone to install it.  (I usually map a phone key to that program so that it’s trivial to launch the application – check your phone’s manual for instructions on how to do that.)  And that’s it!

‘Til next time,

  --Matt--*

The public availability of Visual Studio 2010 and .NET Framework 4.0 Beta1 was announced today on Jason Zander's blog:

http://blogs.msdn.com/jasonz/archive/2009/05/20/general-download-of-vs2010-net-framework-4-0-beta-1.aspx

Below are some resources to use as you download and start using the Beta.

Cheers,

Lisa Feigenbaum | Program Manager | VS Languages

VB, C#, and F# 2010 on MSDN

These are the best one-stop shops for information on what’s new in VB, C#, and F# in VS2010:

VB: http://msdn.microsoft.com/en-us/vbasic/dd819153.aspx

C#: http://msdn.microsoft.com/en-us/vcsharp/dd819407.aspx

F#: http://msdn.com/fsharp

Additional VS2010 resources

·         VS2010 Download page

·         VS2010 Walkthroughs

·         MSDN Library: What’s New in Visual Studio 2010

·         VS2010 Connect

·         Forums: VS, VB, C#, F#

·         Samples: VS, VB, C#, F#

·         Language specs: VB, C#, F#

·         IronPython 2.6 CTP for .NET 4.0 Beta1

·         IronRuby CTP for .NET 4.0 Beta 1