June 2010

Monthly Archive

The Morning Brew #626

Posted by on 22 Jun 2010 | Tagged as: .NET, Development, Morning Brew



  • C# Closures Explained – Justin Etheredge takes a look into the world of functional C# with a look at the sometimes confusing Closure implementation, cutting through the usual complex ‘long word’ definitions and illustrating with an example.
  • Basic Analysis of a Managed Memory Dump (.NET) – CClayton takes a look at the start of the process of debugging an application crash from a memory dump using WinDbg, looking at exceptions, threads and the stack of a managed process.
  • Measuring Browser Performance with the Windows Performance Tools – Walter vonKoch talks about the Internet Explorer Team’s use of the Windows Performance Tools from the Windows SDK in exploring and understanding the performance of the browser engine, showing the tools in use to give an idea of what they are capable of.
  • jQuery Fundamentals – Rebecca Murphey (and a number of other contributors) have published a nice guide to JavaScript and jQuery. Don’t be put off by the introduction (its in Portuguese) as the main content is in English, exploring the core of the JavaScript Language, and then moving on to look at jQuery (Core, events, effects, Ajax, plugins, and work is underway on a performance section too).
  • Document Well 2010 Plus: Hidden Options – Radames Cruz Moreno shares some of the user feedback on the Document Well 2010 Plus as included in the Visual Studio 2010 Pro Power Tools, sharing a few of the hidden options that the document well has which answer a few users comments.
  • Parallel Programming in .NET 4.0: PLINQ – Jennifer Marsman explores one of the Parallel Team samples showing how Parallel LINQ can be used within your application, and showing the comparison to standard LINQ performance
  • Eager Loading with Repository Pattern and Entity Framework – Gil Fink has been exploring the Repository Pattern in Entity Framework and in this post looks at implementing Eager Loading using his repository pattern. Be sure to check out some of the previous posts on this subject from Gil.
  • Productivity Improvements for the Entity Framework – Rowan Miller looks at some of the things that we can do to improve the productivity of us as developers when working with the Entity Framework 4, looking at some useful techniques for Code, database and Model first development using Entity Framework.
  • Readying myself for Windows Phone 7 "Hello, Operator?" – Mike Ormond shares the process of setting up a Windows Phone 7 Development Environment using the April CTP of the Windows Phone Developer Tools
  • Write Templates for Visual Studio 2010 – Kate Gregory shares a complete presentation package of a talk on Templating in Visual Studio 2010. This kit includes everything you need to be able to deliver the session, including videos of the demos, the slide deck and notes on presenting the session.
  • Capturing (and changing) a Web Site with Fiddler – Eric Lawrence highlights how the Internet Explorer team use the Saz file capture feature of Fiddler to capture, modify and replay web traffic to the browser.
  • Security Best Practices in Azure – Dave Thompson takes an introductory look at security best practices for Azure, giving an introduction to the key concepts along with links to further details on each.

The Morning Brew #625

Posted by on 21 Jun 2010 | Tagged as: .NET, Development, Morning Brew

Update: A rogue quote infiltrated this mornings edition – I’ve recified it now, and Sachin’s post on Frequent Commits along with Jose Reyes piece on Performance Counters should now be visible and working – Thanks to David Kemp for the heads up


  • What’s New in xUnit.net 1.6 – Brad Wilson announces the release of xUnit.net 1.6, the latest incarnation of this pure .NET testing library. This release adds in support for .NET 4, ASP.NET MVC 2, Visual Studio 2010, along with continuing support for VS 2008 and adding in No-Registration integration with TestDriven.Net, along with support for the .NET Client Profile.
  • Moonlight 3.0, Preview 7 – Miguel de Icaza announces the latest preview release of MoonLight 3.0, the Mono Project’s Silverlight Implementation. This release brings it ever close to supporting the full Silverlight 4 RTW API, along with video capture and various other improvements.
  • FxCop 10.0 – Microsoft highlight the inclusion of FxCop 10.0 (rather a large version number jump from 1.36) as a part of the Windows SDK for Windows 7 and .NET 4 package.
  • TestApi v0.5 Released! – Ivo Manolov announces the release of TestApi 0.5, the library of test and utility APIs to help test Win32 and .NET applications. This release includes major updates to the documentation, along with improvements to the implementations of a number of the testing APIs included in the package
  • Microsoft SQL Server 2008 R2 Best Practices Analyzer – Microsoft release the 2008 R2 edition of their DSQL Server Best Practices Analyzer which inspects the configuration of your SQL Server instances and reports on things that may be misconfigured.
  • Update to the WCF Load Test tool is available – Brian Harry highlights an update to the WCF Load Test tool from Visual Studio ALM Rangers which allows you to replay WCF trace files against your services to provide a means of load testing them.


  • How I use Inversion of Control containers – Krzysztof Kozmic answers one of the common questions he is asked about Inversion of Control, ‘how should it be implemented in my application?’, taking a look at the way he typically deploys the services of an IoC Container
  • Breaking if statements with pattern – Thang Chung explores a means of simplifying a complex set of nested If statements used to build the criteria for an advanced search form using the Chain of Responsibility and Factory Patterns,
  • Building data stores – Transaction log & Append Only &Indexing data structure &Table scans, index scans and index seeks, on my! – Ayende talks about the construction of a transactional data store, looking at its key concepts, exploring a way of supporting concurrency, providing efficient ways of finding data via indexing, and discusses the standard indexing optimisations available in RDBMS and their analogies in his own data store.
  • Covariance and Contravariance in .NET 4.0 – Paul Kimmel takes a look at Covariance and Contravariance support in .NET 4, looking a little wider than many of the posts on the subject and illustrating the principles with code samples.
  • How to select open source libraries – Daniel Marbach discusses how to find open source projects which provide functionality you require, along with considering how to choose between these projects, looking at licensing, community support, etc.
  • Prefer Additional Methods Over Additional Overloads – John Sonmez discusses the creation of additional methods (with specific names) instead of overloading a single method with lots of different sets of parameters, suggesting that the individual method names will make your code more understandable, and your API more consumable.
  • Mutation Testing – Jeremy Jarrell discusses the concept of Mutation testing, a way of testing how good your unit tests are by manipulating your actual program to change the behaviour of the system and checking that (some of) your test fail, and Introduces MutantPower a library built on Mono.Cecil which manipulates booleans in your code after compilation to mutate your program for you.
  • Git and our friction points and beginners mistakes – Gabriel Schenker continues his discussion of his teams migration to the Git Distributed Version Control System taking a look at some of the points of Git that took a little finding or adjusting to
  • Git/Mercurial: Pushing regularly – Mark Needham follows up on Gabriel’s post with a short discussion of their commit policy when using the Mercurial DVCS
  • Rewards of "Frequent Check In" – Sachin also discusses the merits of checking your code into the repository regularly.
  • ASP.NET Internals – Performance counters implementation details – Jose Reyes digs down into the implementation of Performance Counters in ASP.NET to help you avoid a number of common problems in your own implementations.
  • Parallel Programming: Task Schedulers and Synchronization Context – Alexandra Rusina takes a look at the use of the Task Schedulers and Synchronization Context to make communication with the UI thread easier.


  • NDC 2010 Session Recordings – Last week saw the NDC 210 conference, where a number of great sessions were delivered. The recordings of many of these sessions are now available to stream and download.

The Morning Brew #624

Posted by on 18 Jun 2010 | Tagged as: .NET, Development, Morning Brew


« Previous PageNext Page »