currently, one .NET process shares one GC. making as program gets bigger, cost of GC gets worse and worse and there is no clear way to avoid this problem. most of time, due to this issue, people creates outer proc just to avoid GC cost when doing big analysis or allocation heavy operations. and remote data between these two processes.

please, make better solution and this. explicitly moving data between processes are pain in the ***. this problem basically makes .NET only for small apps. but not for serious apps.

...

one solution I can think of to mitigate this problem is ,instead of this, create a local GC concept, that auto-matically tracks whether a object lives inside of the local GC or references/referenced by objects lives outside of the local GC. and if it references/referenced objects lives outside, promote it to the master GC (the current GC that freeze everyone).

I believe this local GC concept + existing generation GC will reduce time each GC run which ends up making GC cheaper (less object graph to track on each GC) because on top of existing allocation based policy, we now have context.

most of time, when app runs, it runs things in isolation and only small set of objects are actually shared, most of others stays inside of this isolation from the creation to the end.

this is especially true as app going more and more concurrent and immutable.

two features run parallel in different threads sharing GC is a good example since an allocation that should be considered short live now might become gen 1 or gen 2 objects because a features runs in other threads do a lot of allocations.

please, do something to make GC cheaper (how cheaper, please make me never notice GC running when I run very plain, normal big apps such as VS or Roslyn)

The new file compare functionality is great!

Problem: Code compare is still lacking one extremely important piece – “code block comparison”. E.g. A file with multiple (let’s say 6) functions. During refactoring, we decide to move function #2 from its current location, and place if after function #5 in a region. No modifications to the function are made and therefore, the code really has not changed. The compare will still identify a code block has been removed from one file and added to the other.

Proposed solution: If VS was to leverage the “Code Clone” functionality as part of the file compare, this would put it ahead of many of the competitor comparison tools and there would no longer be a need to use third party file comparison products.

Problem: HTML fields, including the newly modified Description field (System.Description) are still handled differently from regular fields and are not added to the data warehouse. This makes it difficult to generate reports that contain any of these fields. This includes the new Feedback Request and Response – both of which use the System.Description field.

Proposed solution: Find a way to include these fields in the data warehouse such that it would allow reporting.

Problem: Formatting is different from the regular paradigm – not sure why. Font size 1 thru 5? Users have become so accustomed to Word and font sizes that this has become an irritation for some of my users.

Proposed Solution: use the standardized fonts and font sizes that are used across other Microsoft products like Word etc.

Problem: It is difficult to understand (easily) what has been removed from a Work Item at a glance. Yes, the History can be used but that can mean sifting through many updates to find a change. Strikethrough has become a standard within many organizations.

Proposed solution: Add Strikethrough to the Formatting toolbar.

Hey experts!

I have an amazing idea to unleash tremendous powers with LightSwitch, (as always :-)), that makes use of the new OData features in LS 11.

However, my idea quickly stranded because it would need the "feed.entry.title" field to be filled in. According to Matt Thalman (http://social.msdn.microsoft.com/Forums/en-US/LightSwitchDev11Beta/thread/7de404e9-83ab-4333-9dc3-50819a2454b2), this was not implemented by design, but would be nice to see implemented non-the-less. I personally suggest simply filling in the selected entities "summary" property, the simplest thing that could work...

To make it clear what I "need", I created a random (and I mean totally random) LightSwitch application, and looked at the ApplicationData.svc/Table1Items url. It returns me the following:

<entry m:etag="W/"'Pieter',17,'Hallo'"">
<id>http://localhost:62978/ApplicationData.svc/Table1Items(1)</id>
<category scheme="http://schemas.microsoft.com/ado/2007/08/dataservices/scheme"; term="LightSwitchApplication.Table1Item"/>
<link title="Table1Item" href="Table1Items(1)" rel="edit"/>
<title/> <!-- THIS field right here is what I need to be filled in -->
<updated>2012-05-09T09:30:45Z</updated>-
<author>
<name/>
</author>
<content type="application/xml">
<m:properties>
<d:Id m:type="Edm.Int32">1</d:Id>
<d:Name>Pieter</d:Name>
<d:ProductId m:type="Edm.Int32">17</d:ProductId>
<d:HelloMyField>Hallo</d:HelloMyField>
</m:properties>
</content>
</entry>

Sometimes, when I'm coding, I need to search in the intellisense's dropdown for certain kinds of elements.

That is, when I need to add an event handler and I don't recall its name, I have to search through all elements (methods, properties, enums, etc) til I find mine.

If I could filter the list by "events", it could optimize the search. Same when I'm looking for "methods", "properties" and etc.

What about adding tabs on top or below the list, so we can filter and find members quickly by those types?

I suggest:

All | Methods | Properties | Events | Enums