I've been to talks like this one before, so not everything was new (in fact, very little was to me...which is probably a good thing, I guess). So, not as much struck me as interesting...but this is a (very) brief run down of some main points to take away...

1. Critical Problems are always...
1. IntraProcess: resources within the process like memory and CPU, or
2. InterProcess: contentions for resources outside (files, network, etc.)
2. Important CPU Counters to monitor for CPU utilization
1. % Processor Time: Useful in multi-CPU environments
2. % User Time: Determines how much work user-mode code in your app (therefore, typically YOUR APP) is taking,
3. % Priv. Time: Determines how much time the kernel is spent working on particular tasks given to it by your app.
3. Good CPU performance tools:
1. Visual Studio Performance Profiler (available in Team edition),
2. Kernrate viewer (available on MSDN),
3. Intel's performance profiler (forgot the name...oops)
4. Visual Studio Performance Profiler has the capability to profile in,
1. Sampling Mode: where it samples every N CPU cycles; this method is typically less intrusive, but given that it's time-based can miss things.
2. Instrumentation: performance code and bit are inserted into the runtime code, which takes up more time for it and gives it a larger working size, but is sometimes the only option for certain scenarios (like testing for Priv. Time slices).
5. Memory Problems:
1. Check for immense paging,
2. Tools:
1. Perf Counters, TaskManager, SysInternals' ProcessExplorer
2. CLRProfiler V 2.0
3. VADump (very cool app)
1. take note of the OtherData vs. Heap values in this as this determines what is native/managed resource leaks (usually) respectively.
4. Also Check out User Mode Dump Heap (never heard of this tool, personally), sometimes called "UMDH".
6. Key blogs:
1. http://blogs.msdn.com/ricom/.
2. http://blogs.msdn.com/maoni/.

Went to a lunch time session on Windows MapPoint; and there are some cool advances going on there. Version 3 is out, so I would recommend checking it out as there are some new features built into it.

Some highlights:

1. Check out http://dev.live.com/virtualearth/sdk for a wonderful array of samples and examples for what is capable and how to do it.
2. MapPoint is available as a web service too for smart clients, etc.
3. Check out MapCruncher, which is a service that lets you upload your own maps and morph them to support the same functional capabilities of MapPoint using the MapPoint services. Check it out here: http://research.microsoft.com/mapcruncher.

Some cool stuff, folks.... 

Brief TechED Linq summary:

1. The point is to work with data like you work with objects
2. System.Query is the entry namespace
3. The LINQ infrastructure is built into the .Net Framework, so it's not a language extension but a first-class piece of .Net. This means it's language agnostic.
1. LINQ uses pluggable data sources to power itself. These can be done by third parties.
4. LINQ can query all objects implementing IEnumerable<T>
5. LINQ works with SQL Server by generating "interop-like" assemblies that wrap the database types and calls around something the LINQ framework can query (objects).
6. The LINQ Query Visualizer looks very cool, it's used during debugging times to see the SQL statements that the LINQ framework generated; also gives you the ability to tweak these statements and test them.
7. LINQ to XML:
1. System.Xml.XmlLINQ
2. VB.Net has now added support for XML Literals where XML can be written inline with VB.Net (without the "" quotes).
8. Check out http://msdn.microsoft.com/netframework/future/linq.

A quick run down on a few of the new changes in the Windows VISTA kernel:

1. I/O prioritization optimizations
1. Things like larger I/O packets to reduce read/write requests
2. File bandwidth reservations for long-running applications that may require time slices on the disk for a range of time (like Windows Media Player)
2. User Mode Drivers
3. No fixed-size memory preallocation of kernel regions at boot time; memory allocation can be dynamic.
4. SuperFetch
1. Notes patterns and prefetches application (and even application private memory) into VM.
5. ReadyBoost
1. Extends VM on external drives
6. Boot Configuration DataTable; boot.ini is has been replaced by the data table
1. Location D:\Boot\BCD
2. BCDEdit is the command line editor for this
3. BootMgr replaces pieces of NTLDR
7. New interactive logon manager
1. GINA has been replaced with a more dynamic, pluggable alternative
8. Kernel Transaction Manager (for transactional kernel actions)
1. File system is now transactional by nature
2. API is programmable through CreateTransaction/CommitTransaction/etc.
3. Interfaceable through commandline interface (transact command)
9. Volume Shadow Copy
10. Crash Recovery/Diagnostics for unhandled native exceptions (non-managed) isn't handled by Dr. Watson anymore, which was loaded into the address space of the crashing application as this was a bad alternative for apps with severely corrupted stack frames: No more "just dissapears" application crashes.  
11. BitLocker drive encryption
1. Implemented using filesystem filters
12. Code Integrity Verification
1. All drivers under 64-bit Windows must be digitally signed by Microsoft for verification of stability.
2. Mark noted that roughly 1/3rd of all blue screens today are occuring due to 3rd party drivers for which there are, currently, available updates that would have fixed the problem.
13. Protected Processes
1. Cannot have a debugger attached
2. Many statistics and bits of information are hidden from view, cannot be seen or analyzed.
14. Address Space Load Randomization
1. Very cool feature: randomizes where libraries and moduels are loaded into memory so that fixed-location attacks are mitigated.
2. The system randomizes 256 different locations; enough since most code that would need to inspect each 256 of the variants would be too large to fit in many buffer overrun attacks.
15. User Account Control
1. Running applications with reduced security tokens even when administrator - have the option to run as Administrator when Administrator.

I just got done with a good WCF talk given by Steve Maine. My note taking these days is more used as a way of reminding myself later what to look at, or what I think others might find interesting. So....here are a couple points anyone should take with them:

1. .Net Remoting is not dead: in fact, it's quite alive some of WCF actually utilizes it,
2. Make sure you understand the basics behind Encoders, Channels, Operation Selectors and Operation Formatters.
3. Pay special attention to the powerful extensibility tools called Behaviors.
4. Check out the new site (published less than 24 hours ago): http://wcf.netfx3.com.

Dude, the link I sent out about the TechEd bags was TOTALLY NOT what the bags turned out to be like....*rolls eyes*. Totally gay.

I just got out of a talk concerning another topic about which I know very little, but I tried to understand the most I could: wireless networking and the advances being made in VISTA for it.

Altogether a great talk, the guy clearly knew what he was saying. One of the biggest advances I pulled away from the talk was that the diagnostics, configuration and deploymenting of configurations capabilities have increased ten-fold. Group policies are big and these policies as well as other wireless profiles can be managed, diagnosed and deployed through a new, scriptable, commandline tool called NETSH. You can script this tool to do anything from dump a list of errors a user on your network has experienced to settnig up a profile for securing a computer or group of computers.

Another interesting thing I took from this talk was that the user interface for novice users has been greatly increased for diagnosing errors..."hopefully" most problems will be diagnosed with a bit more information than simply "Could not Connect" - and attempting to fix the problem will bring up relevant dialogs than can be used to actually fix the issues. Exciting stuff...I wish I knew more. I *do* have the new release of VISTA, perhaps I can start playing with the wireless capabilities now.

I landed safely in Boston as of last night and the conference is now in full swing. My first session was on developing and, mostly, deploying VSTO-based products. I haven't done much VSTO stuff personally, but I have an interest in the topic and thought I might attend. So notable points from the talk:

1. Take a look at the VSTO Client Troubleshooter for analyzing your clients' machines when something goes bad,
2. PIA (primary interop assemblies) now can be deployed as a redistributable for the Office system,
3. Take note of the Publish Wizard, and also note that it does nothing for setting permission settings (full trust permission is required for both the document and the application),
4. There is something called the VSTO Application Manifest Editor that can be used to analyze (and edit?) the application manifests for your apps,
5. Use the .Net security tool if you wish to manually set the permission settings for the app,
6. When the deployment wizard creates a new module "out there", it'll copy off a backup of your application manifest in the old app's directory.
7. For advanced deployment scenarios, use an MSI Installer (and there are inherit difficutlies that you must surmount).
   1. Take a look at this blog here (and take special note of any references to white papers, as he elluded to the fact that these white papers are a must read for deployment): http://blogs.msdn.com/pstubbs (more specifically http://blogs.msdn.com/pstubbs/archive/2006/06/12/628068.aspx).

I'm not a VSTO expert, so some of this information is kind of picked up "off the cuff" so if you happen to be one and you note something wrong, please feel free to leave a note for others. I'm just passing along what I tried to understand amidst falling back into a sleepy state....*yawn*