Charlie Calvert's Community Blog : Future Focus

Future Focus: Document Map Margin

Charlie Calvert — Fri, 15 Aug 2008 21:42:53 GMT

We are continuing our series of posts about proposed features for the next version of Visual Studio. This post focuses on a new feature called Document Map Margins (DMM). Developers frequently work with huge source files that are difficult to navigate. The proposed DMM feature is designed to make it easier for you to find and track important features in your code and to visualize the overall structure of your file.

We are currently considering introducing two different views of your code. One might be called the Marker Bar view. It would be meant to help you find key areas in your code, such as breakpoints, errors, bookmarks, search results, etc. A second view, called thumbnail view, might present the developer with a condensed overview of the entire document. Both features are shown in Figure 1.

Figure One: The proposed Marker Bar View is shown on he left, and the proposed Thumbnail View is shown on the right.

Please remember that Future Focus is designed to give you an overview of proposed features about which we would like to get feedback. We are not promising that any of these features will be part of the product, and these features may change substantially if they are released. The goal of this project is to give you a chance to comment on proposed features, letting us know if you think they are worthwhile, and whether you think our proposal is well designed. In this particular project, we are not looking for overall comments on the future of Visual Studio or the C# language, but rather comments on the Document Map Margin feature.

Please comment in the Future Focus release area outlined below in the resources section, rather than appending comments to this post. Thank you for your support and your interest in our .NET languages.

Resources

Future Focus: Searching and Navigating to Symbols

Charlie Calvert — Fri, 11 Jul 2008 08:55:56 GMT

C++ PM Boris Jabes has added to our series of articles on features that are being considered for the next version of Visual Studio. In his post, Boris describes a proposed feature that will allow users to "find and navigate to a specific location in their solution." Boris explains that users can type in a string and the IDE will return a list of matching results drawn from the "symbol definitions and files in a solution." The feature is also designed to allow users to explore a solution by posing a potentially vaguely worded query and seeing a set of related results. This new search feature is not language specific, and hence can at least potentially be of use to all developers who use Visual Studio, regardless of whether they implement their programs in C++, C#, Visual Basic, or some other language.

Please take a look at this new Future Focus posting, and provide us with your feedback. Let us know if you think the feature is useful, if you think it is implemented properly, and if you have any suggestions as to how it can be improved. Future Focus articles are posted in Code Gallery, and space is provided there for you to comment on the proposed feature.

Future Focus II: Call Hierarchy

Charlie Calvert — Thu, 06 Mar 2008 10:46:00 GMT

The success of the first Future Focus post has made it easy for us to continue sharing our plans for the future of the C# language. The intelligent and thoughtful suggestions we received from the community about the Dynamic Lookup feature have had a significant impact on the C# team's plans for future releases of C#. The quality of your input was very impressive, and we sincerely thank you for your contributions.

Last month we looked at a C# language feature called Dynamic Lookup. This month we switch our focus to the Visual Studio IDE as we investigate a new feature named Call Hierarchy. This feature will be implemented the same way for both C# and VB developers. We will therefore ask for comments from both communities.

Changes for Future Focus

Your suggestions on Dynamic Lookup influenced not only the C# language, but also Microsoft's plans for how we share information on future releases with the community. The management here at Microsoft believes that other teams will benefit from feedback similar to what was garnered from the Dynamic Lookup post. As a result, we have decided to continue our Future Focus discussions on the MSDN Code Gallery.

The Code Gallery is a good place for these discussions because it is language and team agnostic. My blog is directly associated with the C# team, and hence it is not the right place to share a discussion of the Call Hierarchy feature, which will be of interest to both the C# and the VB teams. We hope that other feature teams will also share their plans for future releases, and we feel that the Code Gallery is appropriate neutral ground on which they can share their ideas.

Code Gallery as a Discussion Forum

The Code Gallery is a location where many types of resources can be shared. Most of the resources on Code Gallery are sample programs. But the Gallery can also be used to host general discussions such as the type that occurs when we ask for feedback on our future plans.

The Code Gallery has a number of useful tools inside it, but it may take you a moment to become familiar with its structure. From the main page of the Code Gallery you can access the various resources stored on the site. If you go to the C# and Visual Basic Futures resource page, you will be able to read about and comment on our plans for these languages.

The futures resource features a set of tags which you can use to navigate through the site.

The Home tab can be selected when you want to see an overview of all the discussions that will be hosted on the site. Right now you will be able to find two links, one to the Dynamic Lookup page on this blog, and one to the new page set up for a discussion of the Call Hierarchy on the Code Gallery:

DynamicLookup for C# (Jan 25, 2008)
Call Hierarchy for C and VB (Jan 25, 2008)

After reading about the Call Hierarchy, you will find links inside the article that point you to the appropriate discussion area. You can also click on the Discussions tab. There you will find one or more discussions, each marked by an icon:

Click on the text next to the icon in the the Code Gallery in order to enter the discussion. There you can provide the team with your feedback. On occasion, we may break out a discussion into a sub-topic on the Issue Tracker tab. There you will be able to drill into a particular issue in more depth, and cast votes for features that you like or dislike.

We ask that you refrain from starting a separate discussion on a particular topic unless there is a real need to do so. If you discover such a need, please use the tagging system to associate your new discussion with a particular topic. For instance, if you are starting a new discussion on the Call Hierarchy feature, then associate the "Call Hiearchy" tag with that discussion. I will try to monitor the site so I can offer help to people if they need or want it.

We Want your Feedback

I'm interested in hearing your feedback about both our plans for the future of C# and VB, and the way that we share this information with you. If you have comments on our plans for Call Hierarchy, please share them on Code Gallery. If you want to comment on the Future Focus project in general, and the recent move to Code Gallery in particular, please reply to this post. Thank you again for your suggestions, they are a valuable aid to the team as we work on the development of future versions of the C# language.

Future Focus I: Dynamic Lookup

Charlie Calvert — Fri, 25 Jan 2008 23:10:55 GMT

by Charlie Calvert and Mads Torgersen

What is Future Focus?

This is the first of a series of monthly posts designed to give insight into the C# team’s current plans for future versions of Visual Studio. Each post will highlight one or more key subjects that will impact users of the C# language.

It is important that readers of this column have the right expectations. The information in this column is meant to be a helpful guideline for C# developers, and not a binding commitment. We are not attempting to give a complete list of features in the product, but only to share what we can in a way that will be easily accessible to all C# developers. The Visual Studio schedule, unforeseen technical problems, intellectual property rights and competitive pressures may impact our schedule or our ability to share our plans. We will, however, do our best to keep you up to date on the latest news from the team as they design and implement future versions of the C# language.

Future focus is not designed to present a detailed specification of future features. Instead, its purpose is to outline in broad strokes, and easy to understand terms, the directions that team will take in the future.

Dynamic Lookup

The next version of Visual Studio will provide a common infrastructure that will enable all .NET languages, including C#, to optionally resolve names in a program at runtime instead of compile time. We call this technology dynamic lookup.

Work on support for dynamic lookup was begun in the CLR, but soon became part of the Dynamic Language Runtime, or DLR. The DLR provides the infrastructure on which a common set of dynamic tools can be built. For instance, the DLR provides the infrastructure for both IronRuby and IronPython. It will be the infrastructure on which the C# team implements dynamic lookup .

Support for dynamic lookup is already available in Visual Basic for .NET, where it is often known as “late binding”. The new release of .NET will provide C# developers with similar functionality, while at the same time providing a shared infrastructure for runtime name resolution across all .NET languages, including VB.

Useful Scenarios

There are three primary scenarios that will be enabled by the new support for dynamic lookup:

Office automation and other COM Interop scenarios
Consuming types written in dynamic languages
Enhanced support for reflection

Office Automation

In the next version of Visual Studio Office automation will be easier. Developers will be freed both from the need for using a bulky type library, and the need for including optional arguments in their method calls. The support for Office Automation will be part of a general effort to enhance support for COM Interop and Office PIA.

Consuming Dynamic Languages

Dynamic languages such as IronPython or IronRuby are becoming increasingly popular. At this time, those languages can call C# code, but we can’t easily call into their code. The next version of Visual Studio will simplify the steps C# developers take to call into IronPython or IronRuby classes. This will give developers access to a useful existing code base, and an alternative way to write new code.

Call Reflection

C# developers can currently use reflection to instantiate classes and call arbitrary methods that are not known at compile time. The dynamic extensions to the C# language will make it much easier to make such calls.

Syntax

The syntax that will be used for dynamic lookup has not yet been finalized. The code that I show here is therefore only a tentative sketch that reflect the team’s evolving plans.

The team is currently considering adding the keyword dynamic to the language and using it to demarcate a block of code:

static void Main(string[] args)
{
    dynamic
    {
        object myDynamicObject = GetDynamicObject();
        myDynamicObject.SomeMethod();         // call a method   
        myDynamicObject.someString = "value"; // Set a field
        myDynamicObject[0] = 25;              // Access an indexer
    }
}

All the code that occurs in a dynamic block will potentially support dynamic lookup; even if the accessed members are not known by the C# compiler to exist, it will allow the code. At runtime the DLR will look at the actual object referenced by myDynamciObject for members with those names. It will access them if they do indeed exist, otherwise an exception is thrown. Outside of a dynamic block developers can only call C# code statically, just as they do today.

The details of the compile time process have not yet been determined. For instance, the compiler might treat all methods in a dynamic block as dynamic and only attempt to resolve them at runtime. Alternatively, it might first try to resolve them statically, and if that fails it will attempt to resolve them dynamically at runtime. As we gain more clarity on our design of this technology we will publish many more details.

Summary

In this edition of Future Focus you have learned about the team’s current plans for enabling dynamic lookup in the next version of the C# language. You have seen one tentative plan for enabling this syntax. You have also seen that dynamic lookup will be enabled for three code scenarios:

Office Automation in particular and COM Interop in general
Consuming types written in Dynamic languages
Enhanced support for Reflection

Mads Torgersen is a Senor Program Manager on the C# team. He has been working closely with Anders Hejlsberg and other key members of the C# team as they develop the plans for the next version of the C# language. Charlie Calvert is the C# Community PM.