Matthew Podwysocki's Blog

Architect, Develop, Inspire...

  • F# First Class Events – Composing Events Until Others

    After a comment on my last post in regards to First Class Events in F#, I thought I’d revisit them briefly before going back to the Reactive Framework series.  In particular, this comment was in regards to implementing the until combinator using F# First Class Events.  As part of my hacking during this series, I came across a rather identical solution to the one that was posted, so I thought it’d be worth exploring.

  • Introducing the Reactive Framework Part I

    During my series about first class events in F#, I made frequent mention of the LiveLabs Reactive Framework (Rx), without going into much detail as to what it is.  Now that the series is complete and we understand both how F# first class events work, as well as their integration into F# async workflows, let’s take a look at the Reactive Framework in this multi-part series covering the history, implementation details and more. 

  • Functional Programming Fundamentals Lectures

    Earlier this year, I had the privilege to record a Channel 9 video session covering functional programming basics with Erik Meijer and Charles Torre.  We covered some of the basics, but at some point you need to go back to the fundamentals in order to truly learn this paradigm.  With that, Erik with the help of Charles, have kicked off the Channel 9 lecture series on Functional Programming Fundamentals.  This series is meant to be a journey into some of the ideas behind functional programming, following along with Graham Hutton’s excellent Programming in Haskell book.  Many of the concepts described in this series are in Haskell first, but many apply as well to F#, and even C# and VB.NET.  What better way to talk about Haskell and functional programming than to learn from one of the authors of the Haskell 98 Report.  I highly encourage everyone to check out this series!

  • Generically Constraining F# – Part III

    In the previous post, we talked about some of the generic restrictions that you could do in F#.  I showed some of the basics and how you might use them to your advantage.  We covered the type constraint, null constraint and explicit member constraint.  This time, we’ll cover the rest of them including:

  • Generically Constraining F# – Part II

    In the previous post, we talked about the basic problems with C# generic restrictions.  We covered how it was possible in fact in the CLR to do these restrictions and sure enough the F# language supports them.  This time, we’ll go deeper into what kinds of generic restrictions are possible and how we might use them.  But, before we begin, let’s revisit our previous example.

  • Pondering Axum + F#

    It’s been a while since I’ve posted about Axum as I’ve been posting about other asynchronous and parallel programming models.  After two releases of the Axum standalone language and lots of good user feedback, it’s time to ponder what could be with Axum.  Overall, the goals of Axum to provide an agent-based concurrency oriented system is important as we consider the emerging hardware trends.  Many of these ideas would in fact benefit most languages, whether mainstream or not.  With all the success that it has had, there have also been some issues as well, which leads me to wonder, what else could we do here?  Let step through some of those issues today and see where we could go.

  • No:SQL (east) 2009

    As you may have noticed, there has been a lot of talk around NOSQL “movement” lately.  The name, NOSQL was created to describe non-traditional data storage engines and techniques to address concerns of data sets of horizontal scale.  Innovations such as Google’s BigTable and Amazon’s Dynamo have led to a rise in a new wide variety of new technologies and ideas around pointed problems as data sets at scale, like CouchDB, Redis, MongoDB, Cassandra, Voldemort and many more.  These NOSQL technologies have little unifying them together as they use such techniques as Column-Oriented, Key-Value Stores, CAP Theorem, and no one to rule them all, but underlying them is that they are different than the “traditional” RDBMS solutions of SQL Server, Oracle, MySQL and so on.  These NOSQL solutions are starting to turn up in good numbers for specific use cases and not meant to be the end all solutions.

  • [ANN] DC ALT.NET 9/10/2009 – Webmachine with Kevin Smith

    This month, DC ALT.NET is moving the meeting a little forward this month and teaming with NOVALANG and the Erlang Users of Arlington/DC to talk about the Webmachine REST Toolkit.  We at DC ALT.NET continue to strive to push developers to look outside their normal surroundings and comfort zones and this month is no different.  Details are below:

  • F# First Class Events – Async Workflows + Events Part III

    So far in this series, I’ve covered a bit about what first class events are in F# and how you might use them.  In the first post, we looked at what a first class events mean and some basic combinators in order to compose events together.  In the second post, we looked at how we might create events and publish them to the world through classes.  And in the third post I talked about how to manage the lifetime of a subscription.  In the fourth installment, I corrected my usage of the old create function and instead to use the Event class to create, trigger and publish events.  In the last part, we’ve been talking about asynchronous workflows and eventing together, and this time we’ll pick up on that discussion.  Before we get started, let’s get caught up to where we are today.