Microsoft,

I can't stay silent any longer. I've got to get this off my chest. For too long you guys have ignored users, like myself, that want to get the most from our machines and program for users that want the same.

For too long Microsoft has ignored users that find managed code an unacceptable solution to many of today's computing requirements. These users expect and need a modern language to include both SPEED, CONTROL and FUNCTIONALITY. They believe the problem with .NET is that it focuses too much on functionality at the expense of speed and control. For people who want to write in a language that generates the fastest possible code (which enhances the user experience at every level), C++ is still the only answer.

Now I know the people at Microsoft are smart. Very smart. Perhaps a little too smart. But I know that you guys can write this thing if you want. I can't understand why it hasn't already been written. Why can't you see the market potential? Java is a sloth. It's generates the epitome of bloat ware. They're toast as managed code will ALWAYS be behind the 8 ball because speed can't grow forever. Microsoft is discovering that now in Windows 8 and mobile. Thus, there's a HUGE potential for a language that offers a rich feature set like .NET that makes writing high quality applications faster but does not force a managed approach.

A managed approach is fine for environments that need RAD or don't care about speed. But that set does not include by any stretch, the totality of computer users around the world. Many of us still want our computers to run fast and solve problems that demand speed.

The proof of that is the persistence of C++. Despite Microsoft's best efforts, C++ has not withered away. Despite complete and utter neglect by the world's largest software company and in Microsoft-compliant universities, C++ is still in wide use. If that doesn't speak to demand I don't know what does. People want speed and they want to get the most from their machines and the programmers want to write applications that maximize performance so people can get the most from them. It makes their apps the best they can be and maximizes the user experience. Thus, this new language doesn't force garbage collection, it doesn't put anything between my bits and the processor above what is already done in C++. This language generates efficient native code AND offers the functionality of .NET. It provides conventional managed environment as an option. I know you guys can do it.

This is a flexible language that meets the RAD requirements of slothy business uses and excels at generating fast, efficient code with responsive, snappy, modern user interfaces and maximum performance for the rest of us. The only extra overhead required in this language is that the programmer needs to keep track of managing memory as there is no garbage collection. Perhaps there's some additional overhead with technology-specific solutions such as COM+ and others but they are options not requirements.

The garbage collection issue which is a big argument for managed code can likely be solved by better debugging tools built into the development environment. I could elaborate but I'm sure people that work on these problems have an idea what that might be. It's starts by keeping track of how and where objects are created and used throughout their life. If the will of management is there to deliver a simpler solution rather than a more complex one, the issue of memory leaks can be largely solved.

.NET is great for business applications with minimal speed requirements. But there's the rest of us that want to get the most from our machines and program for people that want the same. I'd even go one further and say that if even the average user could make a side by side comparison of the exact same app written in .NET and native code that had available the same modern API, the native code would win handily. Speed simply enhances user experience on every level and it's high time Microsoft stopped messing around with managed and acknowledge that reality. If you don't, I'm sure the market will sooner or later.

new method modifier 'keyword' enable new features: avoiding (), coma and point when call function

for example:

first, declaration

class SQLSyntax{

public int? keyword between(this int firstNumber, int nextNumber)
{
if(firstNumber>nextNumber)
return firstNumber;
else return null;
}
public bool keyword and(this int? firstNumber, int lastNumber){

if(firstNumber!=null && firstNumber<lastNumber) return true;
else return false;

}
}

usage:

//....do something

if (10 bewteen 5 and 11) //do something
else //do something

istead of

//....do something

if (10.bewteen(5).and( 11) ) //do something
else //do something

NOTE: if we use keyword params or a lot normal parameter we can avoid coma and use only space for split params (or not it can be under discussion)

Pros:
- simplyfy code
- special hilighting in IDE (as keyword)
- determinability (when we use keyword 'keyword' we cannot use (), coma or point when call method)

cons
- determinability isnt flexibility

With the global shift towards mobile and touch computing, it is so sad that the Microsoft leadership is still sleeping during this historic time in computing. Visual Studio 12 has just been released with the same dated controls/toolbox from the last PC era!!!

We need new touch friendly control and forms ASAP that create a great user experience. We are not living in the 1990s anymore and mobile touch computing is the future. Wouldn't it be nice to have the tools and controls to go with it????

Your answer might be metro apps - still can't figure out how to write one. But even Apple iOS uses touch friendly controls and forms for RAD - rapid app development. And so should you too!!!

Currently when we file a bug, can there is prefilled templates per user based. For example 90% of the bugst hat are filed are always to one same Area path or a sub path of the same. Also the iteration that i have is the current month. I could get a prefilled template with teh default priority of 2 for me and so that whenever I have to file a bug , I just need to fill in the necessary details.

Also , it could get he build number using some custom process that i could define like an exe running on the box or a shared file with the latest build number.

On the task board, navigate to it in TFS go to Work -> Board, we should be able to view, and change, a BPI or Bugs current state. The task that are assigned to the BPI or Bugs state is easily viewed and changed since they are in swimlanes, however, the parent WI on the left doesn't display its current state. If there are multiple big items for a release, it get laborious to open the PBI, or Bug, every time you see all task a completed state just to verify that the parent WI is now in the desired state.

See the red blob on the screen shot for an idea of what I mean. Now image having 50 something PBIs/Bugs to review for a release. A lot of time would be saved by simply showing the current state, and even more time saved by making it editable.

1) The property pages provide a large set of macros ($(...), %(...)).
For example '$(OutDir)$(TargetName)$(TargetExt)'.
Unfortunately there is no way to see the expanded text.
2) It would be fine to see the expanded text in a tool tip or to have a context menu item that allows switching between expanded/symbolic views.
3) Paths should be checked for plausibility/existence. Especially when using relative paths (e.g. ..\..\lib). It is not always clear what is the current directory.
4) It should be possible to convert an absolute path to a relative path.
5) It should be possible to navigate to a compiler option be searching for the abbreviation of a feature (e.g. /SAFESEH). Nobody knows by heart on which property page this option is.
6) Why is the property dialog not resizable?

When I'm refactoring member names in a class, it often takes quite a lot of time to scan the entire solution for references to this member (we have about 4,5k source files in 26 projects). It would be great if IDE could "predict" which members I'm going to refactor next (e.g. properties within the same class) and index them together with the current member being refactored so the next operation will be much faster.

Example:

public class PublishData
{
public string Name { get; set; }
public string Text { get; set; }
}

When I refactor the "Name" to "Title", the IDE, while scanning for references, would also "index" the "Text" property references assuming that I'm going to refactor it as well (and if my next step would be refactoring "Text" to "Body" the operation won't take that long since the IDE holds the references already).