Rick Minerich's Development Wonderland

Custom Serializing Objects for Use in a Debugger Visualizer

2008-05-07T19:02:00Z

I have a new CodeProject article up which details how to make a Debugger Visualizer in the case where you need to custom serialize the object. The actual classes I build in the tutorial are only useful with our DotImage project line. However, the process of creating a Custom Serializer should be useful to any .NET developer. In our case, we automatically serialize AtalaImages to PNG format by default. It turns out that PNG encoding and decoding is slow enough that visualizing a medium sized image...(read more)

Using PNG Predictors to Enhance GZIP/PKZIP/FLATE Compression

2008-05-02T20:25:00Z

I’ve been doing a lot of work in the PDF space lately. While implementing Binary Cross Reference Streams I was surprised to see that they could be encoded with PNG Predictors. This was surprising to me because binary cross reference streams aren’t images, they are byte tables: While the values vary, they are often within the same ranges. The first byte can only contain the numbers 0, 1 and 2 and are often the same, the middle two bytes are often the same and the last byte is generally increasing...(read more)

10 Hours in F#: Exploring Concurrency Through An Ant Colony Simulation

2008-04-25T19:33:00Z

Synopsis I gave an hour long talk today, here at Atalasoft, on Concurrency in F# . It featured some slides and a small ant colony simulation to demonstrate different kinds of threading. Overall, I liked developing in F# quite a bit; however, puzzling through the interpreter errors was a brutal process indeed. You can grab my slides here and my ant colony simulation here . The Long Version It all started two weeks ago… …I had been reading about F# on various blogs for months and had done little more...(read more)

Increasing the Size of your Stack (.NET Memory Management: Part 3)

2008-04-22T17:45:00Z

In the previous article I discussed a few of the benefits of stack allocation as well as a couple of C# keywords which help you to leverage those benefits. However, the one megabyte default stack size is too small for stack allocation to be used with a large dataset. Alternatively, in some threading situations one megabyte per thread/fiber can be too large and bottleneck your system. In this article I will discuss the different ways you can modify the stack size. Articles in This Series Part 1 –...(read more)

Improving Performance Through Stack Allocation (.NET Memory Management: Part 2)

2008-04-15T15:06:00Z

Articles in This Series Part 1 – Basic Housekeeping Part 2 – Improving Performance Through Stack Allocation Part 3 – Increasing the Size of your Stack Introduction In C#, when you create managed objects or arrays of value types, they are created on the Heap and you are passed back a reference to the memory in which that allocated object lives. This is normally a very good thing because it allows you to safely do what you need with it and have it be magically garbage collected when there are no longer...(read more)

Code Camp 9 in Waltham, a Retrospective

2008-04-07T16:02:00Z

I went to my first Code Camp this weekend. I was a bit wary at first because it was hosted by Microsoft and I hate Corporate Kool-Aid. Thankfully, that was kept to a minimum and the focus was where it should be: on the code. All of the panels I went to were worthwhile to some degree. However, three stood out to me as particularly informative or entertaining: Advanced Techniques for Everyday Development by Edwin Ames While this talk was all business and no glitter it was by far the most informative...(read more)

Basic Memory Housekeeping (.NET Memory Management: Part 1)

2008-04-03T21:25:00Z

This is the first in a series of posts I will be writing about managing memory in .NET. Before I move on to more complex techniques, I thought it would be good to cover the basics. Articles in This Series Part 1 – Basic Housekeeping Part 2 – Improving Performance Through Stack Allocation Part 3 – Increasing the Size of the Stack Disposing IDisposable Objects When an object implements IDisposable you can explicitly determine when it is finalized. In fact, IDisposable objects sometimes will not release...(read more)

Counting Processors in .NET: The Pros and Cons of Five Different Methods

2008-04-01T18:54:00Z

There are a great number of different ways to count the number of processors available to the .NET developer. In this post I will go over some of the more common methods and their pros and cons. The Envirionment.ProcessorCount Way Code: Environment .ProcessorCount; Supported Platforms: Windows 98 Or Greater, .NET 2.0 or Greater Pros: -Easiest Method -Value Cannot be Changed by The User -No External Calls (All .NET) Cons: -.NET 1.1 Incompatible -Logical CPU Count Only Misc: -Counts Each Core -Counts...(read more)

Script# converts C# into Javascript

2008-03-27T20:11:00Z

Many people in the .NET community seem to really like the Script# compiler. What it does is compile C# into JavaScript instead of MSIL. The compiler also optimizes the output so the the Javascript is as small and fast as possible. It even has full Visual Studio integration as well as a unit testing framework. Nikhil Kothari has a fairly long blog post about it. You can find the documentation and download it from it's website . Share this post: email it! | bookmark it! | digg it! | reddit! | kick...(read more)

Improving .Net Performance With Ngen: The Native Image Generator

2008-03-26T14:47:00Z

One of the most often cited reasons to not use .NET is that it is initially compiled to an intermediary language (MSIL) and has to be recompiled every time you run it. In many high performance environments this wasted time is simply unacceptable. To combat this Microsoft released a tool with .NET 1.1 called NGen (Native Image Generator) which allows you do precompile MSIL to real machine code and in so doing avoid much of the extra run-time overhead. What Do I Get From Generating Native Images? -Faster...(read more)

IS - The Meta-Meta Language-Language (and parametric compiler)

2008-03-24T19:48:00Z

Ian Piumarta and some very smart folks over at the Viewpoints Research Institute have been working on a meta programming language named IS which is specifically designed for implementing other languages. The project actually has several names (IS, idst, cola, jolt, &c), as far as I can tell the current development version is called cola . The key idea behind IS is that each layer of compilation is represented as pipeline of meta-extensible transformations: These transformations even extend to...(read more)

Clojure Impressions

2008-03-21T13:25:00Z

Last night the wmassdevs Group hosted a Clojure presentation by Rich Hickey . Clojure was born of Rich's dissatisfaction with the current state of the concurrent programming and so was built from the ground up around the idea of making this task less painful. Previously, I had never really looked closely at Clojure but I was struck by some of the really inventive ideas rolled into it. Immutable data structures have been heralded as the solution to all of our concurrent programming woes but copying...(read more)

The Evolution of Lambda Functions in C#

2008-03-20T14:24:00Z

Howard Dierking over at MSDN has a really interesting Blog post entitled " Lambda, Lambda, Lambda! " in which he described the evolution of the lambda function in C#. It seems fairly simple on the surface: 1.0 Introduced Delegates, 2.0 Introduced Anonymous Methods, and 3.0 Introduced Lambda Expressions. I had been wondering what made Lambda Expressions in C# so much better then Delegates or Anonymous Methods other then the shortened syntax. It turns out that the really interesting thing about Lambdas...(read more)

Google's Leptonica

2008-03-17T18:21:00Z

Google's underground army of PhDs is secretly cranking out huge numbers of really useful and interesting libraries and tools . Within the next few years, these tools are going to drastically change the landscape of much of the software industry. The reason: Most of these tools are available as open source with very non-restrictive licenses. Things that were once hard to implement and expensive to buy will be commoditized . A great example of this is a little known project called Leptonica . Managed...(read more)

Immutable Data Structures in OO Languages.

2008-03-13T17:53:00Z

One of the big reasons for the recent push towards functional programming languages is concurrent programming. Everyone is worried about how the switch from more megahertz to more cores is going to impact how they program.

I was reading an article entitled F# Primer over on msdn today. It stated that the reason F#, and other functional programming languages, are so much better when it comes to concurrency is that they encourage the use of immutable data structures. However, what is keeping us from using the same idea in our existing C# or C++ code? With an immutable producer-consumer model couldn't you achieve the same effect? Don't get me wrong, I think F# is a great language with concise and elegant syntax. But I don't see why you couldn't achieve similar results with C#'s readonly keyword or by using objects that only allow the setting of values in the constructor while having read only properties.