This past weekend I’ve been reading Roubini and Mihm’s [Crisis Economics](http://www.amazon.com/gp/product/B00B9ZHWK6/ref=as_li_qf_sp_asin_il_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=B00B9ZHWK6&linkCode=as2&tag=krekrasblo-20), a worthwhile read if you’d like to understand *what went wrong*. ![Crisis Economics](http://cache0.bdcdn.net/assets/images/book/medium/9780/1410/9780141045931.jpg) I’m “just an ordinary guy” when it comes to international-scale economics; and like most people probably... Continue reading

Here is just a short note on the unfortunate choice of name for the concept Eventual Consistency. To many non-native speaking people, it sounds like Maybe Consistent. Many languages have a word derived from the latin word eventualis (German: eventuell,... Continue reading

"Monitors are *nothing* like Unix signals"
Of cause you're right; signal handlers interrupt the receiving process and are very difficult to get right, erlang monitors are easier to work with and less intrusive... but the analogy with SIGCHLD was the best I could think of as something that people may know as a useful way to get cross-process exit notifications in an os-like context.

Whenever developers fall in love with Erlang (as many tend to do these days) they are too often busy promoting it to their friends and colleagues as a cool language for *concurrency* and *functional programming*. Which is a pity, for several reasons. 1. It intimidates people. 2. It's wrong. ##...

Whenever developers fall in love with Erlang (as many tend to do these days) they are too often busy promoting it to their friends and colleagues as a cool language for *concurrency* and *functional programming*. Which is a pity, for... Continue reading

Riak doesn't come with means to do secondary indexes out of the box. This limits many applications of Riak; and it's a bit tricky to implement correctly oneself. The module [`riak_link_index`](http://github.com/krestenkrab/riak_link_index) provides a mechanism that can be applicable for some... Continue reading

Thanks for the reference to monoids; you're much stronger into those foundations than I am, I'm just a hacker.
Once I get a first one or two implementations off the ground (I'm working on Erlang and Java for now, surprise!), it would be great to have people help implement it in other languages too and provide one coherent set of implementations for easy use.

> This post introduces a new data structure - the vector map - which solves some issues related to storing collections in MVCC data stores. Further, vector maps have some super nice use cases for "occasionally connected" systems. > The idea warrants a more rigorous discourse, but I need to get it...

The last few weeks I've been working on understanding vector clocks (or rather, [version vectors](http://en.wikipedia.org/wiki/Version_vector)). When working with distributed data stores like [Riak](http://wiki.basho.com) and [Voldemort](http://project-voldemort.com/) which are using this to manage consistency, it is important to have a deep understanding... Continue reading

At the Erlang User Conference in Stockholm, I received the thirteenth "Erlang User of the Year" award, and was presented with the traditional gift, a beautiful hand-carved Erlang logo made in wood by Kanevad in Gamla Linköping. I have to... Continue reading

Erik has been hacking the interpreter the last few weeks, and now we're finally at a state where it is useful (though there are still some issues). ### Interpreter?? Yep, now Erjang has two modes of operations. - The default... Continue reading

Right. these numbers are fairly vague, and the voting system is far from ideal, ... but we still get ~85% of attendees to cast a vote which is well beyond what we could do with any other setup.
If you however, for each talk, multiply the #attendees by the approval rate (used above); the top "positive infludence" list looks like this:
Dan Ingall's Keynote: 40 Years of Fun with Computers
Bill Buxton's Keynote: On the Role of Design
Jonas Jacobi: HTML5 WebSockets
Dion Almaer: HTML5 vs. Apps
Tim Bray: Doing It Wrong
But such a list is double-biased by people's expectations.
As for further details on numbers, we only share those with the speakers themselves and the track host/pc members who invited the speaker. Sorry.

Here's a quick tally of the top talks at last week's [GOTO Aarhus conference.](http://gotocon.com/aarhus-2010) The rating is based on the red, green and yellow "exit-poll", computed as (#green - #red) / #total votes. > Make sure to [evaluate the conference here](http://bit.ly/8ZOGKJ) and > joi...

Here's a quick tally of the top talks at last week's [GOTO Aarhus conference.](http://gotocon.com/aarhus-2010) The rating is based on the red, green and yellow "exit-poll", computed as (#green - #red) / #total votes. > Make sure to [evaluate the conference... Continue reading

It's been quiet on Erjang for a while, and I've been busy with other things. Going to JavaZone two weeks ago however, got me all psyched up again on my little Erlang on the JVM project. I met some guys... Continue reading

### I Hate Time-Outs A recurring issue in the design of concurrent and/or distributed systems is to choose those dreaded time out values. It seems that they are inevitable, doesn't it? They seem arbitrary, baked-in in an way that often... Continue reading

In Erlang, all inter-process communication is performed by a simple mailbox-per-process model plus selective receive. This allows a process to elegantly disregard certain messages, hiding complexity in certain cases. But the model also has some issues. Continue reading

I've spent some time trying to get Riak up and running on Erjang, and here's a note on current status. We're very early, but it is basically "up and humping". - runs on a "hacked" R13B4 with crypto-2.0 copied from... Continue reading

Just a little note to let you know that I spend a day hacking a new [Riak](http://basho.com/) client library for Java based on the protocol buffers API. You can find it here at [github.com/krestenkrab/riak-java-pb-client](http://github.com/krestenkrab/riak-java-pb-client). We're currently evaluating Riak for some... Continue reading

I do agree with Roberts comments; and in that sense I am as much a "language lawyer" as him; and I whole-heartedly believe that the power of Erlang lies in the clear separation of process states; and all the good that comes from that.
At it's core, exposing (potential) mutability the way I propose is dangerous, but not more so than what is made possible (and easy) with NIFs. In the grand scheme of things, NIFs are bad for you, in exactly the same way as this kind of Java integration is bad for you. The only "issue" with the Java interface is that it is so much *easier* :-)
Rather than writing NIFs as a tool to get performance, it would be better to make the VM faster, and this is a gradual transition that has happened in Java space: ten years ago "native code" was fairly common in Java applications (for stuff such as data base drivers, or to make a certain small piece of code faster), but now the JVMs are fast enough so we do not have to do that, and we have all come to believe in the power of a "managed environment".
Where the real value of a direct interface to the VM's environment is -- as far as I can see -- when it permits you to *reuse* some existing high-quality component or service which would be meaningless or prohibitively expensive to rewrite in Erlang. Clearly, my toy examples of using Java HashMaps directly in Erlang code are the wrong ones to bring forward.
So how to improve the Java API that I proposed?
One way I have considered is to impose restrictions on a JavaObject pseudo term, so that it is usable only in the process that created it. In practice, I would implement this by having each such foreign object reference carry an owner reference, and only the correct owner can use it in ways that would expose it's state. Perhaps you can send it to another process in a message, but outside the creator you can not use it as a target or argument of another java method; but perhaps it can be matched against some special tuple like {java_object, OwnerPID, ObjectID}.
This would be completely possible, but perhaps it would just be an invitation to hide the shared mutable state inside some java code somewhere?
Another aspect of the API is to consider if it is implementable in BEAM also; perhaps with some hooks in error_handler and/or code_server to create modules on-demand if they match an existing Java class in a JVM loaded in a linked-in driver.
BTW: looking forward to see this in action in combination with LFE too!

At the recent [Erlang Factory](http://www.erlang-factory.com/conference/London2010) I had a lot of fun pairing with [Krzysiek Goj](http://twitter.com/kgoj), extending Erjang with a new API for calling Java code. After the conference jetlag, I spent a night hacking on making this a bit more usa...

Yes, JavaObjects get garbage collected; right now I have no map with object identities or such. If you want to preserve the identity of a JavaObject then you must keep it around yourself (i.e. you cannot decompose it with pattern matching, and then stitch it together again; only the original reference will do).

At the recent [Erlang Factory](http://www.erlang-factory.com/conference/London2010) I had a lot of fun pairing with [Krzysiek Goj](http://twitter.com/kgoj), extending Erjang with a new API for calling Java code. After the conference jetlag, I spent a night hacking on making this a bit more usa...

At the recent [Erlang Factory](http://www.erlang-factory.com/conference/London2010) I had a lot of fun pairing with [Krzysiek Goj](http://twitter.com/kgoj), extending Erjang with a new API for calling Java code. After the conference jetlag, I spent a night hacking on making this a bit more... Continue reading

Erjang already runs the Eshell, mnesia, mochi-web, and self-hosts the Erlang compiler. Last weekend was spent running micro-benchmarks and optimizing some tight loop stuff such as small integer performance, loops and function application. This has resulted in an over-all improvement for the "estone" Erlang performance test by a whopping 50% Continue reading

I have no idea when these tests came about, but I assume they must have been there for many years. I found them in the source checkout - perhaps they are not in the source tar, only if you check out otp from github? Dunno.
You can read about the "real" test_server here http://bit.ly/9FRMVf

Here is just another update on Erjang progress. Two weeks ago I started looking seriously at running some of the OTP tests. There's a lot of them part of the standard otp distro, and so it's a great source of bug hunting context for Erjang. ### A simpler `test_server` But, but, but, ... the `t...

Here is just another update on Erjang progress. Two weeks ago I started looking seriously at running some of the OTP tests. There's a lot of them part of the standard otp distro, and so it's a great source of... Continue reading

Today I released the first version of [Triq - Trifork QuickCheck](http://github.com/krestenkrab/triq#readme) (or `triq` for short), a free clone of [QuviQ eqc](http://quviq.com). While `triq` is being developed for the purpose of testing [Erjang](http://github.com/krestenkrab/erjang) it is "plain erlang" all the way, with... Continue reading