Code Crafter

Why is composition harder than inheritance?

2011-08-17T13:01:00.001-04:00

(just some random thoughts...) Let's take this Java example: class Base { public void method() {} } class Derived extends Base {} See how easy it is for Derived to "reuse" code from Base? Derived is a subclass of Base, and in its constructor it calls Base's constructor, constructing a Base before constructing a Derived: class Derived : Base { // this is what gets generated

DCI Example with NRoles

2011-06-03T22:52:00.009-04:00

The DCI (Data, Context, Interactions) architecture is a style that proposes an interesting separation of concerns between the domain model of a system (what the system is) and its behavior (what the system does), normally associated with its use cases. The rationale is that, since these parts incur change at different rates, isolating them from each other results in a system that's easier to

NRoles: An experiment with roles in C#

2011-05-29T06:05:00.008-04:00

In the last months, I've been developing in my spare time a proof-of-concept post-compiler with Mono.Cecil to enable roles in C#: NRoles. Roles are high level constructs that enable better code reuse through easier composition. They are very similar to traits as described in the traits paper (pdf). Set up NRoles is hosted on google code. You can get the latest source code with this mercurial

More Macros in Nemerle

2011-04-22T13:34:00.000-04:00

After a very brief introduction to Nemerle metaprogramming, what follows is some motivation and better expression macros examples. Historically in C#, the using statement has been abused (guilty!) to provide a more convenient syntax to operations that have natural wrap up code which should be executed at the end of a logical scope. To enable a class to be usable like this, it just needs to

Metaprogramming in Nemerle

2011-04-14T20:59:00.006-04:00

Nemerle is a generally unknown .NET language that nevertheless has many impressive features. Its syntax is close to C#, but it has many functional programming constructs, like algebraic data types and pattern matching, that are not found in the Redmond language. It also has a very powerful metaprogramming system, where special constructs can participate in the compiler's execution pipeline and

C# Mixins With State

2011-03-24T09:53:00.003-04:00

With the C# quasi-mixin pattern, one of the biggest limitations is that the mixins can't introduce state to a class. An alternative was for the mixin interface to require the composing classes to implement a property that the mixin would use as its own, as demonstrated in this example. In the .NET Framework 4.0, the ConditionalWeakTable class can be used to associate arbitrary

Interface Implementation Through Aggregation

2010-11-09T09:26:00.006-05:00

It's very tedious, mechanical and error-prone to implement an interface where all its members just delegate the call to some field or property that also implements the interface. For these C# types: interface I { void M1(); void M2(); void M3(); } class C : I { public void M1() { /*...*/ } public void M2() { /*...*/ } public void M3() { /*...*/ } } To implement the interface I

Roles in C# Implementation

2010-10-29T13:55:00.004-04:00

After seeing what roles in C# might look like, let's see the necessary transformations that would enable them. This is one possibility that a C# compiler could use to implement roles without having to make changes to the underlying CLR. Roles A role is transformed into a set of types: an interface (which the compositions will implement), a static class with the role code, and a class that

Roles in C#

2010-10-26T11:28:00.008-04:00

Traits (pdf) are described as composable units of behavior, and are a natural evolutionary path for languages like C# or Java. Microsoft must be seriously looking at them, since it's sponsored some research about Traits in C# (pdf). I'll describe what I think is an extension to the traits idea that would make a great feature in C# (and in Java, VB.NET, ...): roles. Roles are already a reality

Working Effectively with Legacy Code

2010-08-04T22:31:00.017-04:00

It's a known fact of life that code bases, if not actively nurtured, deteriorate with time. Maintaining, fixing bugs, extending, creating new features; all exert forces that push a design beyond its original intended boundaries, breaking the envelope of its original frame. Not long after its first release (sometimes, even before it), there's not even a trace of design, there's no conceptual

A more understandable IComparable

2010-04-21T12:04:00.009-04:00

"Any fool can write code that a computer can understand. Good programmers write code that humans can understand." - Martin Fowler In the .NET framework the IComparable interface is used to compare values: public interface IComparable { int CompareTo(T other); } The comparison is done with the CompareTo method. It returns zero if the current object is equal to the passed in

Scala Traits Under the Hood

2010-03-10T12:52:00.008-05:00

Scala is a very feature-rich language built on top of the JVM (there's also a version on the CLR, but the focus is clearly on the JVM). Besides its functional features, it introduces a number of constructs that facilitate large scale components development and code reuse. Scala has traits, which are a great tool for orthogonal code reuse. In its simplest form, a trait can be used just like an

C# Quasi-Mixins Example

2010-02-12T12:31:00.007-05:00

As an example, I'll adapt one of the mixins found in the book Fundamentals of Object-Oriented Design in UML to use the C# quasi-mixins pattern. Given the following (simplified) domain classes: namespace Domain { public enum Medium { Email, SnailMail, IntergalacticMail } public class Customer { public string Name { get; set; } public string Address { get; set;

C# Quasi-Mixins Pattern

2010-02-04T12:46:00.020-05:00

Extension methods are an interesting feature of C#. They allow for behavior to be added to existing classes. For example, a ToXml() method can be added to class Object, effectively making that method available everywhere: public static class XmlSerializableExtension { public static string ToXml(this Object self) { if (self == null) throw new ArgumentNullException(); var serializer =

Revisiting IDisposable

2010-01-31T18:10:00.016-05:00

In my last post, I've introduced a better alternative to the official pattern for implementing the IDisposable interface in .NET: public class BetterDisposableClass : IDisposable { public void Dispose() { CleanUpManagedResources(); CleanUpNativeResources(); GC.SuppressFinalize(this); } protected virtual void CleanUpManagedResources() { // ... } protected virtual

A Better IDisposable Pattern

2010-01-26T18:28:00.019-05:00

In .NET, objects that implement the IDisposable interface are objects that need special cleanup code to run deterministically when they're not needed anymore. (Another interesting use of this interface is to delimit a scope, but I'll focus on the original cleanup use case in this post.) public interface IDisposable { // cleanup resources void Dispose(); } Most .NET languages have a

Java: BigDecimal's Big Problems

2009-10-13T16:45:00.012-04:00

In Java, the BigDecimal class has a failed abstraction around equality comparisons that will inevitably lead to bugs. There are 2 problems: 1. the method compareTo is inconsistent with the method equals Equality (equals) of two BigDecimals takes scales (number of decimal places) into account, whereas comparison (compareTo) doesn't. So, new BigDecimal("1.00").equals(new BigDecimal("

C# Static Classes are not Real Classes

2009-09-18T12:28:00.015-04:00

In C# and in Java, there's a common idiom to provide utility functions as static methods of classes that cannot be instantiated. This stems from the limitation that these languages don't allow the definition of any function outside of a class. This can be seen as an anti-pattern, because what's missing is the ability to declare functions, not only classes; like in C++. The class has to be

Optional Parameters and Method Overloads

2009-08-08T17:31:00.014-04:00

The ability to declare optional parameters is another feature that will be introduced in C# 4.0. A natural complement to method overloads, it generally helps code to be more concise. Until now, method overloads have been used for the awkward responsibility of creating default values for what otherwise would be much better expressed as optional parameters. Many overloads have been created for

Named Parameters Increase Readability

2009-08-01T14:29:00.006-04:00

When reading C# code, sometimes there are method calls which aren't readily obvious. The method can have too many parameters, or a series of parameters of the same type. This can make things a little confusing. A more aggravating case is that of boolean parameters. It's hard to find out what true or false mean in some cases. var creditScore = customer.CheckCredit(false, true); Normally, we

F#: Why the rec?

2009-07-30T13:18:00.015-04:00

I've been looking into F# for a while now, and I think it's an awesome addition to the .NET framework. It's more expressive and concise than C#. It's functional by heart, with discriminated unions, pattern matching, tail-call optimization, and it also supports object oriented programming (being a .NET language, it just had to) and imperative programming. Its type inference creates the feel of a

Painful SQL Server Pagination

2008-08-01T12:45:00.014-04:00

When I used MySQL back in 2000, I took for granted the ability to paginate result sets in the server with the simple LIMIT clause. (Other open source databases, like Firebird and PostgreSQL, have similar constructs.) Querying for a page of the result set is as simple as this: # Fetches rows 21-30 # 20 is an offset, 10 is the number of records to fetch select * from Users limit 20, 10; You

C# Extension Methods and Null References

2008-07-19T09:18:00.036-04:00

With extension methods in C# 3.0, you can create methods that operate as if they were instance methods of other classes. You can "add" methods to any class, even to core classes like System.String and System.Object. This example creates two string extensions: public static class StringExtensions { public static string HtmlEncode(this string input) { return AntiXss.HtmlEncode(input);