Welcome to MSDN Blogs Sign in | Join | Help

jaredpar's WebLog

Code, rants and ramblings of a programmer.

Syndication

News

Now Reading

Expert F#

What's a better book to read when learning F#?

Essential WPF

Thus far the best book I've read on WPF. Gets right down to working with WPF and the goals/history.

Purely Functional Data Structures

Reading this book makes me feel like I'm back in college. It will really get your mind going and is best read with a whiteboard handy.

Blog Roll

Eric Lippert
Dustin Campbell
Jon Skeet
Coding Horror
Brian McNamara
Hub FS
Full List

Browse by Tags

All Tags » C#   (RSS)
Using F# Discriminated Unions in C# (Beta2)
While updating my VsVim editor extensions for Beta2 [1] I got hit by a change in the way F# exposed discriminated unions in metadata.  My extension consists of a core F# component with a corresponding set of unit tests written in C#.  It’s mostly Read More...

Posted Tuesday, October 27, 2009 8:00 AM by Jared Parsons | 5 Comments

Why is LINQ absent from debugger windows?
As the owner of the VB.Net portion of the overall debugging experience, I frequently hear the request from customers to add LINQ support into the Watch / Immediate and Locals window. Virtually every other type of expression is available in the debugger Read More...

Posted Wednesday, August 26, 2009 8:00 AM by Jared Parsons | 5 Comments

Filed under: , , , , ,

Understanding the is, was and will of programming
When using an API you must take care to understand not only what it returns, but also for how long the data returned will be valid.  This is very important to consider because programs must make either be making decisions on valid and predictable Read More...

Posted Monday, April 27, 2009 8:00 AM by Jared Parsons | 6 Comments

Filed under: ,

Immutable vs. Mutable Collection Performance
One argument I commonly hear against immutable collections is they are slow.  I’ve held the opposite belief for some time but shamefully had yet to look at actual numbers on the CLR.  Tonight I decided to change that by benchmarking one of my Read More...

Posted Monday, April 06, 2009 8:00 AM by Jared Parsons | 6 Comments

Filed under: , ,

Is it Serializable?
I’ve recently run across several APIs that have a dependency on only dealing with objects that are serializable (in the binary sense).  Unfortunately determining if an object is serializable is a non-trivial task and rife with problems.  These Read More...

Posted Tuesday, March 31, 2009 8:00 AM by Jared Parsons | 3 Comments

Filed under: , ,

Building a WeakReference Hashtable
Recently I ran into a situation on a personal project where I needed a hashtable like structure for a set of WeakReference values.  When poking around for an existing implementation I saw found several versions which were very thin, type safe wrapper Read More...

Posted Tuesday, March 03, 2009 8:00 AM by Jared Parsons | 9 Comments

Filed under: ,

A more usable API for a mutable thread safe collection
In my last post we discussed the problems with designing a safer API for mutable thread safe collections that employ only an internal locking system. The result was an API that was more difficult to mess up, yet pretty much unusable. Lets take a look Read More...

Posted Monday, February 16, 2009 8:00 AM by Jared Parsons | 17 Comments

Filed under: , ,

Why are thread safe collections so hard?
Writing a collection which is mutable, thread safe and usable is an extremely difficult process. At least that’s what you’ve likely been told all through your schooling. But then you get out on the web and see a multitude of thread safe lists, maps and Read More...

Posted Wednesday, February 11, 2009 8:00 AM by Jared Parsons | 52 Comments

BclExtras Library
I published a .Net utility library on Code Gallery today called BclExtras .  It’s a set of classes meant to be used in addition to the standard .Net base class libraries (BCL).  The main focuses of the library are functional programming, multi-threading, Read More...

Posted Friday, January 23, 2009 8:00 AM by Jared Parsons | 2 Comments

Filed under: , , ,

If you implement IEquatable<T> you still must override Object’s Equals and GetHashCode
CLR 2.0 introduced IEquatable<T> which is an interface that allows for type safe equality comparisons.  Previously, the best available method for comparing equality was the virtual Object Equals method.  The method is loosely typed since Read More...

Posted Thursday, January 15, 2009 8:00 AM by Jared Parsons | 0 Comments

Filed under: ,

NotImplementedException vs. NotSupportedException
In responding to a recent blog post , one of the readers, Jeremy Gray, noted that I was using a NotImplementedException where I should have been using a NotSupportedException .  At first I did not agree.  There was a method on an interface which Read More...

Posted Friday, December 12, 2008 8:00 AM by Jared Parsons | 5 Comments

Filed under: , ,

Immutable Collections and Compatibility with Existing Frameworks
When developing my immutable collections library , I spent a lot of time on usability. After all, if a library is not useful then what’s the point? A big portion of usability is being able to work with existing frameworks and technologies. For .Net and Read More...

Posted Wednesday, December 10, 2008 8:00 AM by Jared Parsons | 3 Comments

Comparing Continuations in C# and F# Part 3: Double wrong
Is it better to be wrong once or to be right then think you’re wrong but find out you were right but wrong about being wrong? Besides the obvious be right the first time, it’s certainly an educational experience.  Here’s the original sample: let Read More...

Posted Thursday, November 13, 2008 8:00 AM by Jared Parsons | 1 Comments

Filed under: ,

Comparing Continuations in C# and F# Part 2
In my last post I went over the differences between using a continuation in F# and C# . As it turns out I was right about the limits and symptoms but wrong about the reason. The F# code does indeed generate tail calls for part of the continuation. However Read More...

Posted Tuesday, November 11, 2008 11:38 AM by Jared Parsons | 3 Comments

Filed under: ,

Properly Incrementing an IntPtr
Just as native pointer types are moved around with pointer arithmetic in native code, it can also be useful to move IntPtr types around in managed code.  Say for instance there is an IntPtr available which points to a native array of Dog instances.  Read More...

Posted Tuesday, November 11, 2008 8:00 AM by Jared Parsons | 7 Comments

Filed under: ,

More Posts Next page »
Page view tracker