Leading off the feature in the January issue of MSDN Magazine is Lucian Wischik’s fantastic look at Visual Basic .NET 14. As Wischik writes, the newest version of Visual Basic has been written from the ground up, in Visual Basic no less, to support a raft of compelling new features, functions and capabilities. To determine which features best merit mention in the article, Wischik decided to poll members of the Visual Basic Language Design Team. I asked Wischik about his experience writing the article, and what the latest version of Visual Basic means for the beloved programming language.

MD: I’m fascinated by the fact that Visual Basic is now open source. As a member of the team, what’s it like going from traditional program manager to public “steward of the language?” How does your job change?

LW: Most things haven't changed: our job has always been to serve our users, listen to what they ask for, and figure out the best cleanest way to satisfy their underlying needs. We've always written code that we're proud of, and come up with language designs that we're proud of in the end.

What's changed so far is buried in that phrase "in the end." Practical language design is a messy process that takes lots of eyeballs, lots of diverse opinions, lots of use-cases, and lots of iterations. We've been able to immerse ourselves in the Roslyn forums and get more eyeballs, opinions and use-cases more quickly than we did before, and so we've been able to converge on the final language designs quicker and with higher confidence.

In practical terms, the change is minor. It means that we discuss our language design meeting notes in the Roslyn forums, rather than just in internal email threads and hallway chats. In personal terms, we were worried about having people see how the "language-design sausage" is made. Would they be happy to participate, or become vegetarians? I'm happy to say the former!

We've not yet reached the end of our open-source journey. That's still to come. We look forward to a workflow more like that of TypeScript and F# on GitHub. We plan to push the boundaries next year with things like public Web casts of our language design meetings.

MD: How long has VB been officially open source and what kind of interactions are you seeing from the community at this point?

LW: Anders Hejlsberg clicked the button to open-source VB and C# live on stage at BUILD 2014 in April. It was an amazing moment. "The click that shook the world," wrote one person. "Microsoft's crown jewels are now open-source," wrote another. You can imagine how delighted we were by the reception.

Everyone uses VB and C# all the time, so we've had lots of interactions about parts of the language that people want changed. But few people write compilers as their day jobs, so there have been proportionately fewer code contributions to the compilers themselves. That's fair enough!

MD: The refactoring and analyzer functionality you write about, are those a product of the Project Roslyn effort? And are these capabilities that are enabled by the ground-up rework of the VB compiler?

LW: Yes, they were a primary objective of our rework. It would have been impossible to graft them onto the old codebase.

I think they are visionary features. In college computer science classes, we're taught that a compiler is a "black box" that takes in source code and spits out a binary. But what we've come to understand over the past two decades is that a compiler also exists to serve the IDE, to serve the interactive experience of writing code—and we've been able to embody that cleanly in the Roslyn codebase and its analyzers.

MD: Can you describe the task involved in migrating VB from its C++ roots to VB? How long did it take to rebuild the programming language from scratch as you describe, and what were some of the toughest obstacles you had to face to get there?

LW: After you've spent a decade building up your old codebase, it's a programmer's dream to be able to re-architect from scratch in the light of what you've learned—and management's nightmare. That's because you're investing a lot of developer-years just to regain the functionality you already had, even before you start to add any new end-user value. There's also the risk that you might fail to reproduce all of the quirks or bugs of the old codebase that people might inadvertently depend upon.

I'm glad that our management had the vision to let us do this rewrite. It's the strongest vote of confidence a business can make. We believe our product has such a strong future in the decades to come, that we can invest all our developer-years now to prepare for that future.

I asked Dustin Campbell for his opinion. He's been involved in the rewrite from day one back in March 2010, over four years ago. Dustin observes that Visual Basic is an immensely complex language, more so than C#. It has collected so many features over the years. There was just a large volume of work to get done! And the IDE experience for coding in VB had been carefully tuned over the past decade and users have built up great muscle-memory. We had to work hard to replicate that, and modernize it at the same time.

One of the most nail-biting moments was in December 2013 when we flipped the so-called "Big Switch." This was the moment when our entire division switched to using the new compilers—Visual Studio itself was now being built using the new compilers, and all the developers in our division were using them too. And it worked!

MD: Are you afraid that C++ developers will come after you for writing that moving off C++ to VB made VB14 considerably faster? Those sound like fightin’ words.

LW: I'm not here to fight! What makes code fast is picking the right data-structures and algorithms for the job at hand. We had the opportunity to completely re-architect, picking better data-structures and algorithms in light of our experience. We could have gotten the same speed up if we'd re-architected in C++.

Paradoxically, one of the best changes was to build our compiler out of immutable data-structures. It sounds strange--after all, the act of typing amounts to mutating the text in the editor buffer. In the old codebase, with each keystroke, we'd mutate the syntax tree that the IDE held in memory. In the new codebase, we instead generate a fresh immutable syntax tree of your entire project, sharing as much as possible with previous syntax tree. Immutability lets us share vastly more than we ever could before.

VB and C# have one particular language feature that helped with performance—the async/await keywords. Thanks to these keywords, and thanks to immutable data-structures, we were better able to use multiple CPU cores. But async/await are coming to C++ as well, and are present in experimental form in Visual Studio 2015.

Folks, things are hopping over here at MSDN Magazine. We are kicking off the new year with a pair of issues: Our regularly scheduled January issue and our special issue of the magazine focused on Visual Studio 2015 and Microsoft Azure.

Definitely check out the special issue, which provides fantastic, hands-on insight about new tools and technologies revealed at the Microsoft Connect(); event in November. The issue includes features addressing cross-platform development, with looks at both Unity and Apache Cordova, as well as articles plumbing new functionality in C# 6.0. Mark Michaelis’ “How C# 6.0 Simplifies, Clarifies and Condenses Your Code” is not to be missed, and Alex Turner’s “Use Roslyn to Write a Live Code Analyzer for your API” is also a must read.

There is a lot more going on in the special issue, including dives into ASP.NET 5, Microsoft Azure SDK 2.5, and Visual C++ 2015. Also be sure to read MSDN Magazine Director Keith Boyd’s Last Word column, which offers a glimpse into the hard times and big changes that brought Microsoft to this point.

As if that weren’t enough, the January issue includes a package of three articles focused on updates from the Microsoft Connect(); conference. These include Lucian Wischik’s “14 Top Improvements in Visual Basic 14,” Manoj Bableshwar’s “Web-Based Test Case Management with TFS,” and Omid Afnan’s “Hadoop Made Easier for Microsoft Developers.” Beyond that, you’ll find coverage of Big Data, the TypeScript programming language, and some great stuff on Microsoft Azure development. Kevin Ashley’s “Occasionally Connected Data in Cross-Platform Mobile Apps” ties nicely into the cross-platform theme, as it dives into using Xamarin and Azure Mobile Services to enable cross-platform mobile apps.

Our columnists are in full throat in the January issue as well. Julie Lerman dives into the upcoming Entity Framework 7, and Dino Esposito looks at when responsive Web design might not be enough for mobilized Web sites. Also look to Bruno Terkaly and Greg Oliver’s Azure Insider article exploring “bring your own device” (BYOD) and the complex scenarios that rise up when mobile applications connect to enterprise resources. And there’s more where that came from.

2014 has been a remarkable year in software development at Microsoft, and has set the stage for what promises to be an amazing 2015. As the hectic holiday season winds down, take a moment to read our January issue and special issue of MSDN Magazine.

As I describe in this month’s Editor’s Note column, the October issue of MSDN Magazine is Charles Petzold’s last as a regular columnist. He is leaving our pages to take on a role as a programmer and writer at cross-platform tools provider Xamarin. Charles has been a columnist at MSDN Magazine since 2007, when he kicked off the Foundations column covering the finer points of WPF, WCF and WF along with co-authors Juval Lowry and Matt Milner. And Charles has been writing features for MSDN Magazine going back to 1986.

Now Charles is embarking on what he calls “a whole new chapter” of his life. He’s already busy at Xamarin, writing a book on Xamarin.Forms titled “Creating Mobile Apps with Xamarin.Forms.” The new C# and XAML platform enables developers to share UI code among iOS, Android and Windows Phone apps. He’ll also be presenting on Xamarin.Forms at the Xamarin Evolve conference next week, October 6-10, in Atlanta.

I asked Charles about his experience at MSDN Magazine and what he’s looking forward to in his new role at Xamarin. He described writing the DirectX Factor column, which launched in January 2013, as extremely demanding, as it dove into the sometimes-arcane world of DirectX and native C++ development. Charles’ first DirectX Factor columns focused largely on DirectSound, before shifting to Direct2D and the challenge of exploring 3D graphics in the DirectX environment. Charles will tell you that he enjoyed writing for MSDN Magazine because it helps him learn and master new technologies and concepts, and his foray into the DirectX stack offered plenty of that.

“Part of the impetus behind the DirectX Factor column was my desire to do something really challenging after nearly a decade in C# and XAML environments,” Charles says. “On average, I’m sure I spent more time programming and writing for each DirectX Factor column than any previous magazine writing. I enjoyed the experience immensely, but I think DirectX is intrinsically a full-time job. It’s complex and extensive and extraordinarily versatile, and I found that the minute I would move away from DirectX to do something else, all the DirectX would start dropping out of my head!”

Despite the steep learning curve, Charles calls DirectX “essential” for applications that need a high level of versatility and performance around graphics, text or audio. His last columns focused on the 3D aspects of Direct2D graphics, and in fact 3D has been a motivating technology for Charles over the years. He singles out his October 2007 Foundations column, titled “3D text in WPF,” as one of his all-time favorites.

“I remember seeing some animated 3D text in a TV ad and wondering if I could do something like that in WPF 3D, which I had recently been exploring,” Charles recalls. “I can still remember the difficulty of working out the code, but I also remember my joy at seeing the results.”

Moving On
Charles is leaving MSDN Magazine, but will continue to write—and learn—in his new role at Xamarin.

“I like challenges and learning new things. That’s a big part of the appeal of writing to me, and particularly writing for MSDN Magazine and its predecessor, Microsoft Systems Journal,” Charles says. “Often I would get an idea for an article for the magazine, but I wouldn’t know exactly how to do what I wanted to do – how to realize the vision in my head. Sometimes I never did figure it out, and I’d have to think of something else to write about. But I enjoy the process of getting to a point where I’m confident enough in my solution to the problem to write about the experience.”

But Charles says that working as a freelance writer was “no longer working well” for him, and that he had begun considering alternatives. When he started contracting for Xamarin earlier this year, it opened up an opportunity to work for the cross-platform tools maker on a full-time basis. He jumped at the chance.

Now Charles is with the Xamarin documentation team, writing his latest book, and preparing to talk about the Xamarin.Forms platform at the Evolve conference next week. And after that, who knows.

“I’m curious myself what I’ll be doing at Xamarin after the book is completed. There’s a lot of very cool stuff going on in mobile development, and hence within Xamarin, so I’m sure the fun work (and the challenges) won’t run out any time soon.“

It’s been our pleasure and honor to work with Charles over the years at MSDN Magazine, and our hope is that he will appear in our pages again in the months ahead, writing the occasional feature article on Xamarin’s tooling for C# developers writing cross-platform apps for Windows Phone, Android and iOS.

The July issue of MSDN Magazine is themed around the updated features and functionality of Microsoft Azure Web Sites, and reflects the rapid-fire pace of development we’ve seen in and around Microsoft’s cloud operating system. A package of five feature articles explores how developers can leverage the updated Azure platform to create and deliver powerful, scalable and manageable applications for the Web, quickly and efficiently.

Leading off the package is Yochay Kiriaty’s “Scaling Your Web Application with Azure Web Sites,” which shows how to modify Web applications to run across multiple instances and geographies. Up next are Apurva Joshi and Sunitha Muthukrishna, who show how to create and optimize resilient Web applications that can weather sometimes-hostile cloud environments.

Tejaswi Redkar authors a pair of features in the package “Building a Node.js and MongoDB Web Service” does just what the title says—it shows how to build a Node.js Web site that draws data from an Azure-hosted MongoDB database. “Hybrid Connectivity: Connecting Azure Web Sites to LOB Apps Using PortBridge” shows how to link and leverage cloud-based Azure Web sites and on-premises LOB applications.

The final article in the set, “Teaching from the Cloud” by James Chambers, explores a content-heavy development scenario, in this case developing an e-learning Web site.

Of course, there’s plenty beyond Microsoft Azure and Azure Web Sites going on out in the wild, and the diverse topics covered in this issue’s columns reflect that. Kenny Kerr’s Windows with C++ column explores the Windows composition engine and shows how an alpha-blended window can be reproduced using a composition surface rather than a swap chain. Julie Lerman tackles Entity Framework in her latest Data Points column, using a small Entity Data Model to work through problems developers might encounter when switching from the ObjectContext API to the newer DbContext API.

The back-of-book columns kick off with James McCaffrey’s Test Run column, titled “Distorting the MNIST Image Data Set,” that provides a demo program that generates deformed images to create training data for an image recognition system. Ted Neward’s column this month is titled “Fun with C#” and explores how developers can often resolve a programming problem in F# and then transfer the code over to C#. The Modern Apps column by Rachel Appel this month covers the basics of enabling application authentication on the Windows platform, while Charles Petzold’s DirectX Factor column shows how developers can use custom effects in Direct2D to approach authentic 3D programming functionality.

Our back page, as ever, is dedicated to David Platt and his Don’t Get Me Started column. This month, Platt takes a moment to appreciate the venerable Windows XP operating system as Microsoft sunsets support for it.

So when Platt wrote a column titled “The Silent Majority: Why Visual Basic 6 Still Thrives,” back in June 2012, I should not have been surprised. That article produced a flood of responses from developers arguing both the merits and flaws of Microsoft’s legacy VB6 programming language. I should have been even less surprise when, exactly two years later, Platt penned a second column exploring the enduring appeal of VB.

“VB6 and the Art of the Knuckleball” ponders the question of how a modest programming language like Visual Basic can endure for so long, and enjoy such ardent support among its supporters. I caught up with Platt and asked him about the column, and some of the response he’s seen from it.

You wrote about VB6 a couple years back. What motivated you to return to the topic?

Not only did that 2012 column got more comments than anything else I’ve ever written, by a factor of ten, but the comments kept coming and coming, even a year and a half after publication. I’m greedy enough to do anything for that many page views. And certainly the opportunity to once again set VB adherents and detractors at each other’s throats works well with my back page columnist mission of pouring oil on troubled fires.

You've seen a lot of user comment and feedback. What's most surprised you about the user feedback?

It’s not just the passionate response from those who love VB; I expected that. I’m floored by the rage of those who hate it. Not just, “I don’t want to use it,” or even “It encourages bad patterns, so I won’t let it into my shop,” but “VB is evil and should be wiped from the face of the earth.” Do these guys really have nothing better to do than lambaste someone else’s choice of development tools?

Why do you think it is that Visual Basic produces such passionate response among developers?

Those who love VB6 clearly fear it being taken away. There’s less of it every year, and the new world of mobile devices generally doesn’t allow VB6. But the bus drivers do not want to become fighter pilots. They are happy being bus drivers. They wouldn’t mind a shiny new bus, with air conditioning and GPS. And they’d especially like it if someone would open up roads for their busses onto new devices.

For the detractors, there is probably a certain amount of an adolescent’s sneering at their younger selves, as my 14-year-old daughter winces when I show her baby pictures. They enjoy wallowing in H.L. Mencken’s definition of Puritanism: the haunting fear that someone somewhere is happy. Or perhaps they fear that management is going to take away their fighter planes and make them drive busses instead.

Do you really think Tim Wakefield could survive a nuclear war?

With his knuckleball, maybe.

As Michaelis points out in his feature, C# 6.0 won’t be a revolutionary change, but it will help eliminate a host of coding annoyances and inefficiencies that can bog down your programming efforts. He goes on to single out a few of his favorite features in C# 6.0, including the $ operator (string index members), primary constructors (without field parameters), using static, and declaration expressions. Definitely give this articles a read.

Also highlighted at the Build Conference was the new Microsoft Application Insights facility in Visual Studio 2013 and Visual Studio Online. Application Insights is a set of services that provide actionable insight into a production application and integrates that data back into the development tools and process. The tool is great for understanding application health and responsiveness, feature effectiveness, and usage patterns. Charles Sterling’s feature Next-Generation Development with Application Insights dives into this new facility, which was unveiled at the Visual Studio 2013 launch late last year.

Also notable in the May issue is Stephen Cleary’s closing installment in his excellent series on combining the async and await keywords with the tried-and-true MVVM pattern. This month Cleary explores the services layer and addresses asynchronous services. I also encourage you to check out the other two features in the series—the April issue feature on asyc implementation of ICommand, and the March feature on data binding to an asynchronous operation.

Rounding out the May issue are two more features. Bill Heys and the ALM Rangers team offer a look at feature toggles as an alternative to branching for parallel, concurrent feature development. Also known as feature flags or feature switches, feature toggles lets you check new features in to the main branch so they can be continuously integrated and tested at build time. Finally, Brannon King’s “Dangers of Violating SOLID Principles in C#” looks at the time-worn principles of SOLID-- Single responsibility, Open for extension and closed for modification, Liskov substitution, Interface segregation, and Dependency injection—from a whole new angle.

Don’t miss out on our May issue columns, either. Charles Petzold leads the charge this issue, with his DirectX column exploring how to make 2D graphical objects seem to acquire depth and body and float in 3D space. Petzold has been chipping away at Direct2D and now Direct3D in recent months, introducing the powerful DirectX graphics subsystem to developers who might otherwise hesitate to wade into the deep water. Don’t miss it!

What motivated you to write your March feature article "Building a Netduino-based HID Sensor for WinRT?"
There are two general categories of sensors in the hobbyist or maker sphere: digital and analog. I’d written an earlier sample on the MSDN samples gallery demonstrating the integration of a digital sensor. So, in the March article, I wanted to describe how a developer could build an analog-based device and render real-time data in their store app.

As you you've noted, a great deal of activity among hobbyists and academics is currently based on open source tooling and software. What benefits does the new HID API in WinRT offer to this community?
The new HID API lets a maker, industrial engineer, or hobbyist integrate their device with the Windows platform. Since this API supports the Windows Runtime, they can integrate their HID device with hand-held tablets, in addition to the large universe of notebooks, laptops and desktop machines. And, because the API supports WinRT, a developer or maker can choose their language: Javascript, VB, C# or C++.

You may have noticed that our Windows Azure Insider column in the same issue walks through a Windows Azure implementation that includes programming an Arduino device that executes commands sent remotely by mobile clients. Coincidence? Or does this simply reflect the reality that there are a lot of cool applications to be built around low-cost, Arduino-type hardware?
At first glance, I think the HID API for WinRT and the Azure Service Bus are complementary. Let’s say I’m a fitness device manufacturer creating a competitor to the FitBit or Nike Fuel Band. I’ll want a store app so that the user can configure their device and, likely, so that they can collect data after each workout (or at the end of each day). But I may also want to create an online community for my users, where they can opt-in and compare workouts, status, etc. For this community, the Azure solution appears to be a viable option.

4. Were there any specific issues or challenges you had to work around in the course of your article?
There were two challenges that come to mind. First, the LM35 requires a very “clean” input voltage, but the voltage source on the Netduino contains a bit of noise. As a result, I needed to incorporate software filtering in the firmware, where I maintain a running average of readings.

The second has to do with the sparse documentation for the .NET Micro Framework, which isn’t as robust yet as, say, Microsoft’s .NET Framework. To work around this, I relied heavily on the Netduino forums and the experience and knowledge of the makers and developers there.

5. What advice would you give developers interested in getting started with app dev around Arduino-type devices? Are there any common misconceptions that should be avoided?
I believe they’ll find Netduino devices to be reasonably priced and well designed. In addition, the Netduino forums are a great source if ideas for projects as well as input and advice from other developers. And, you can’t beat being able to author firmware in C# with a free version of Visual Studio Express.

You just published a video on Channel 9 highlighting Microsoft's HID platform and WinRT API support for analog and digital Netduino-based devices. How widely known is the new support in WinRT for HID devices? What kinds of opportunities does it create for developers?
Great question: Our first video, for the motion-sensor appeared on Channel 9 in late January and has had over 10,000 views. The second video, for both projects appeared a day ago and has generated over 2,400 views. So, I believe we’re getting the word out.

In terms of opportunities, these projects give the Maker, the academic and the industrial engineer a sense of what they can do with a programmable microcontroller like the Netduino and one or more input devices. The first project, based on a motion sensor, shows the power of combining multiple APIs in a Windows Store app. This sample uses the HID WinRT API to monitor the PIR sensor and then, with minimum code, uses the media capture API to capture video using the camera on a tablet or PC.

Prior to the HID WinRT API, developers needed to pound out a COM/Win32 app in C++ to interact with a HID device. But, using the new WinRT API, they can write far less code in the language of their choice, be it Javascript, VB, C#, etc.