Erlang vs Ruby

Great post on 2 of my favorite languages.

Responses are currently closed, but you can trackback from your own site.

So, I am going to be moving to London with my lovely young family. Shannon, my wife, Gabe (6 years) and Micah (3 years). We are currently considering neighborhoods and all that entails (schools, proximity to ’stuff’, the tube, etc).

We are currently looking at these neighborhoods that several friends have recommended for one reason or another.

• Blackheath/ Greenwich (seems like I would need a car, and it is a bit far out)
• St. John’s Wood (seems like a good bet, and it is North)
• Maida Vale (seems like it is a shade ‘lesser’ than st johns wood)
• Battersea (Seems like it is very much like Park Slope NY)
• Clapham (seems like battersea + better transport)
• Hampstead (I have heard this is akin to Brooklyn Heights in many ways)
• Islington (I am optimistic on Islington – not sure of schools, etc.)
• South Kensington (Seems good, may be too nice for the likes of me)
• Primrose Hill (see s.ken comments)
• Notting Hill (see s.ken comments)
• Holland Park (see s.ken comments)

The people who have recommended these neighborhoods seem to think that the other neighborhoods recommended are ‘a terrible idea’, so we surely will have to sort it out ourselves, but I am eager to sort out the right place soon

The best website I have found yet for general info on moving from the US to the UK is UK-Yankee, their forums in particular are great.

Lots more to come;
-Chris

Responses are currently closed, but you can trackback from your own site.

I have had a good deal of looking at and playing with Coherence for (.net specifically). Several people have been talking about using it in areas near mine. It has a few features that are quite similar to a solution that I have worked on for some time. In any case, I am a fan so far. My question is; is it a good enough event processing engine for the majority of use cases?

Essentially, most use cases for stream processing are solved without things like sliding lookback windows etc. Certainly – those ARE useful features and there ARE LOTS of use cases for them, but I have seen a few classes of applications be solved 100% by types of stream processors that DO NOT do those types of temporal things.

Imagine for instance that you want to see;

All booked trades. This is usually easy enough. Maybe you have some XML on the wind, maybe it is a tib message of some sort (RV/ EMS), maybe you put an object on the dist’d cache. In all cases, you are essentially putting your data somewhere, and notifying existing parties. I think the old standard for this was essentially, map your object to the tib, and to the database. This means you can save, transport/ notify, etc.

Mapping layers

This is of course 2x mapping code Not so great. With Coherence you have to write the code to serialize your classes to the correct forms (similar in many ways to implementing microsofts IXmlSerializeable ala sax parsing looking stuff). In the more recent Coherence for .net, not only can you implement IPortableObject (the serialization methods to get/ put to the cache), but you can also register external serializers. This is excellent in my opinion as you can have a 100% non-invasive solution. You tell the cache engine what class will serialize your given types, and you are good to go.

This is all well and good, but – you are still essentially going to get the 2x mapping problem… 1x for the cache serialization, 1x for the long term persistence (likely a database). This is not so great .

Continuous Queries

The fact that Coherence lets you register a ContinuousQuery is great. The filter syntax is not so pretty:

Filter filter = new AndFilter(new EqualsFilter(“getTrader”, traderid),
new EqualsFilter(“getStatus”, Status.OPEN));

It will work, and it will lend itself to higher abstractions above that lower level AST-like abstraction. It will call you back when your cache gets the relevant insert, update, delete, etc. Good stuff. This is the essence of continuous queries. My basic thought is that is ‘good enough’ for many, many use cases. Sure, the temporal stuff is good as well, but it is really unneeded for many problems.

My least favorite part of this is the mapping layers. These are layers that really do not add any business value, they are insulation, infrastructure, etc. Another missing link with coherence is the history of changes. Each change is going to change the entity in the cache, but the incremental changes, those are not held onto, unless you write code to do so.

Entity Capabilities

I guess this gets me thinking on how important it is to have entities that are;

• diff’able
• merge’able
• support incremental change broadcasting (If you have a 1 mb entity, and you mod 1 field, you do not want to broadcast the whole thing.)

I am a fan – of this Coherence business, but there are still other bits of the puzzle that must be thought about. How are you going to keep an audit history? What will you do for long term persistence/ reporting on those entities? How can you apply a sort of bulk change set to your entity? Etc.

-Chris

Responses are currently closed, but you can trackback from your own site.