Recently, I had the chance to revisit an article I wrote on Code Project. I had never written what I would call a tutorial before that article and I haven’t written one since, but it did get me thinking on why I wrote it, what I knew and what I learned from it. I thought I would share that here.

I have been bouncing around Code Project for years, and had seen many articles, read many comments. I rarely took part, as I didn’t feel I had the ability to comment or I just didn’t want to write something critical of another persons work. There was a post by a member that the articles contained on the site were of an increasingly poor quality. And I agreed. But, I had never contributed, is that fair of me?

I set off down the path of writing an article on interfaces. I planned on creating a tutorial with solid, working examples that could be applied to every day development. What I learned from this experience is that it is incredibly difficult to put together a real-world example of a concept such as interfaces. You’ll see if you take a look at the article that I eventually ended up on little more than a text book example. Further to that, the comments after publishing show that I really didn’t understand as much about interfaces as I thought I did, or that I just couldn’t apply the knowledge to an example.

So, what makes it so difficult?

From a real-world example perspective, the issue is that we can never provide enough code (either through proprietary restraints or pure code scale). Our brains work better at breaking things down into small, bite-size pieces. And showing a more fleshed out example of interfaces without spanning multiple articles you’re not going to get to show everything about them.

Some authors would tackle a sample system, something that allows you to see how the pieces fit in in the overall system. So, I might have expanded the article by several installments, put in a WinForm app that had buttons and you can see the results as we go. The issue with this is that those sample apps suffer another issue, they are too focused on the subject and never show enough about how the pieces fit into a real world system. Sure, they might show some very solid examples of interface usage, but a real-world system is rarely a single component. The time necessary to write up the other code, without explaining it outweighs the benefits of the sample in the first place.

After editing my article, I received an extremely lengthy comment from another poster telling me that I perhaps should have waited, that I didn’t understand interfaces well enough. And to an extent, I do agree, I didn’t understand enough to be able to show absolute proficiency with the subject. But, I did choose to try and share what I did know and understand with others. I put together an article that laid out an example, that described the usage and I hope that it helped a couple of people. I appreciated the comments from this new poster, and I took the time to read the response and will hopefully produce a better, more rounded article next time I choose to post something.

A huge part of my experimentation with Roast Potato is down to a recent fascination with the Expression. I’ve known since I started working in the .NET environment that it could do a lot with reflection. And through the development of a filtering system at work, I’ve found some of the extents to which that can be taken and seen some very impressive results.

With Roast Potato, my direction is more of an educational jaunt. If the library turns out to be useful in some capacity, then that’s awesome, I’d take a great sense of pride in knowing my work helped someone else along. But, I want to explore what can be done with expressions, how far I can understand them. This is the start of my ramblings on what I’m finding.

Once I had settled on a syntax for RP and spent a couple of nights fleshing out the Regex and other such fun, I got down to writing the tests, and I soon realized just how quickly some of the things I wanted to do could be achieved. For example;

var expressionValue = Expression.Constant( Convert.ChangeType( value, Property.Type ) );
 
return Expression.Lambda<Func<TEntity, bool>>( Expression.GreaterThan( Property, expressionValue ), Param );

The expression above does the following;

• Convert the object value into the type of the property we’re requesting (Price[decimal])
• Put that value into a constant value (just an Expression to wrap around the value and allow it to be constructed)
• Returns a constructed lambda expression using the GreaterThanExpression and passing it both the property we wish to be greater than and the value we wish to be greater than.

Given the query;

"Price gt '21'"

The resulting Lambda expression;

x => x.Price  > 21

We can then apply that against a collection of objects and filter out a list, and that’s the starting point of the roast potato library. The actual code to go and parse the fact that it’s a GreaterThan is more complicated than the part that does the heavy lifting once we’re there.

I don’t want to try and go too deep. I barely have a working understanding on Expressions so far and I want to understand so much more. Also, I want to get a working Roast Potato sample up and running so I can show what it can do. Then, I can hopefully learn what it is to understand.

Tonight I uploaded the first version of Roast Potato Console, just a little sample app with some test data that you can type the query into and see it return the results. This app will eventually go away and I’m starting to believe that most of the need is for server side anyway, not a client/server side solution. But, I’ll leave that for another post and another day.

I’ve always been a disorganized person, both in my general management of time and resources and in my projects. Professionally, I have the job I’m doing to focus on, and although my thoughts are scattered at times and I struggle to always convey them, I get the job done. And I hope, well.

Personally though, I lose focus quickly, I find my mind being drawn to other topics quickly. One minute I might want to write the next great sim game, the next I want to write blackjack. I lack focus and will-power. Sometimes, I give up because I get bored, sometimes because I realize that I’m not coming up with anything new. Mainly, I just lack the attention span required to develop all components of a project.

Recently, in the course of my professional life, I’ve been very focused on providing a way to query data in all manner of ways, quickly and efficiently. But as the development has gone on, I’ve realized there are so many ways in which we can query data now, that there aren’t enough hours in the day to provide the ultimate solution. We’re going to have to bend a little here, and rewrite a little there. This has given rise to a new personal challenge for me, and one I’m committed to staying the course on. Now, I know I can’t take what I did for my employer and just run with that, that wouldn’t be allowed, but what I can take is the lessons I learned throughout the course of the project and see if I can’t come up with something that will benefit others trying to tackle these issues, working on them from a totally different perspective.

In order to try and focus myself a little more, I’ve chosen to make what I do an open-source  project. This way, if I stop doing it, there’s a chance what I’ve done will help someone else. It might also attract the attention of other developers that want to contribute, and at that point I have a commitment to my peers and thus I have to be more professional in my behavior.

The project I have started has, as all new projects must, a quirky name. I called it, Roast Potato. What, really? Why?

Well, to Roast is to query. And Roast Potatoes are among my favorite foods. So, I’m going to Roast a Potato (a source of data) using a Recipe. I haven’t figured out all the other quirky things yet, and I’ve only just started. But, this one is interesting me more and more, and with each .NET project I start personally, I keep struggling at the same points, what is it to get data from the server controlled by the client.

What I’m trying to aim for is a way to represent the data on the server in a standard way, and be able to query that data from the client without having to worry about all the wiring in between.

Ever heard of OData?

Yes, I’ve heard of it, I’ve used it and I really like what I can do with it. And I’m not trying to replace or reinvent the wheel here. What I’m trying to do is make a reusable and simple client side interface for some pretty complex server side functionality that I can understand. I’m also thinking of how I put this into a PHP form as well as .NET, so I intend to write client code once and two versions of the server.

Anyway, I’ll see where it goes and if nothing else, there’s some code out there to show people how to extract an expression from a string.

I’m sure I’m not the only person to ever try and document what I’m trying to do. But, I’ve never tried it before. So, it’s new to me.

I’ve recently had the opportunity to start asking myself questions about the way I think about code, the way I do code and what’s right and what’s wrong in my methods. I’ve never worked in any agile or xp process. I’ve not studied domain driven design enough to be able to say, “well… here’s how I did it”.

I’ve been given the chance to learn more about this, start doing some unit testing, some real software development and I intend to write down what I learn.

So, a couple of months ago now, my blog was taken off-line by some malicious idiots looking to amuse themselves by destroying what others had written. Not that I wrote anything of substance or anything worth keeping for that matter. The point is that I wasn’t harming anybody, I wasn’t speaking out against anything, I wasn’t even writing anything interesting!

So, at the time I vowed not to use WordPress again, but here I am, back using WordPress. Why?

Well, I’ve finally decided I have something to write about, so I need a blog. I can’t spare the time to put my own software into use, and the alternatives to WordPress look pretty poor by comparison. So, we’ll see how this goes.