Contents tagged with Concurrency
-
[ANN] DC ALT.NET – 1/27/2010 - Clojure
The next meeting of DC ALT.NET will be held on January 27th from 7-9PM on Clojure with Craig Andera. Previously, he gave a talk about spending some time in Common Lisp and some of the lessons learned during his adventures. You may have noticed a lot of talk around this language, especially in the Java community. Where trends are concerned, momentum has shifted from Groovy to Scala and now to Clojure just in terms of sheer interest. It’s one that’s on the top of my list to dive deep into this year. So, what is it and what should we care?
-
Introduction to the Reactive Framework Part V
In the previous post of the Introduction to the Reactive Framework series, we covered how to create new IObservable<T> instances, either from scratch or from existing sequences. What this allowed us to do was turn an operation which was previously interactive, such as iterating over a collection, to a reactive, where I could have multiple listeners reacting to the same collection concurrently. This has nice implications for allowing us to scale our application in interesting ways. This time, let’s take another angle on making asynchronous programming easier.
-
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.
-
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.
-
Dryad/DryadLINQ and Project Trident Released
There has been a lot of talk going around involving the Microsoft Worldwide Partner Conference 2009, but another event, largely overshadowed, was the 10th annual Microsoft Research Faculty Summit. During this summit, Tony Hey, the Microsoft External Research Vice President, announced the release of two tools to help transform research in the academic world, Project Trident and Dryad with DryadLINQ, which you can watch here. These tools are available freely to academic researchers and scientists and can be downloaded here. So, what are they and why should we care?
-
F# – Async Running with Continuation Scissors
As you may have noticed, I’ve been covering a bit about concurrency on this blog lately, and for good reason. Between Axum, Erlang, Scala and F#, there is a lot to explore with actor model concurrency, task based concurrency, data parallel applications and so on. In the next couple of months, I have some talks coming up on concurrency and in particular with F#. I’ve been covering a bit of that with F# and mailbox processing, but I wanted to step back a bit into the asynchronous workflows and hitting against a well known API.
-
Axum – Ping Pong with Ordered Interaction Points
UPDATE: Removed code and explained that what I had was not intended behavior
-
When Side Effects and Laziness Collide
While working on a side project recently, I came to rediscover some of the consequences of one of my earlier posts on “Side Effects and Functional Programming”. It’s important that we realize that when we are creating our programs to beware of lazy evaluation and side effects.
-
Actors in F# – The Bounded Buffer Problem
In the previous post, I covered an example of an auction simulation using asynchronous message passing and a shared nothing approach using the MailboxProcessor class in F#. The auction example was a great piece to demonstrate scalability by adding additional clients to create a sort of bidding war between them. Once again, with this approach, we’ve eliminated the need for locks and other concurrency primitives.
-
F# Actors Revisited
UPDATE: Removed ref cells to use two recursive loops