This evening my pandora radios navigate from Tab Benoit to Popa Chubby by Melvin Taylor, and from Buddy Guy to Robert Lowery … even better than a random selection on my hard-drive since my collection is quite limited!
But the evening’s question is not about blues nor guitar, it is a question about physic: isn’t my brain afraid of my headset? if my brain has a pure stereophonic analysis model to locate the sound source, it should conclude that it come from the center of my head, isn’t it? … I listen again, and yes, sound comes from there. Good brain, not as afraid as I am.
(hoping my favorite guitarist don’t mind that I borrow one of his title)
Some (mostly subjective) comments after few days playing around Erlang:
- The good: I have never before implemented a server (relatively efficient TCP proxy) so quickly. Asynchronous call are as easy as synchronous ones and network is invisible! that’s good! physician can wrote as many differential equation as they need, synchronous model are a strong hypothesis of the world!
- The bad: syntax! I was used to Prolog notation, but Erlang introduce too many meaning for punctuation while newline or indentation has no meaning at all! Anybody interested in Pyerlang (a syntax translator python-inspired)?
- The chubby: my next blog will be about transformation of a simple Erlang server to a (nearly) complete OTP application. Yes, OTP is a good framework, but learning it is far to be as easy as learning Erlang!
STM stand for Software Transactional Memory. How does it drive me to anarchy? because I get lost again following all the web links!
In fact I was wondering where to get some information about this mechanism used in some concurrency models. For those like me who like concrete explanation, I recommend to read this blog post from Joe Armstrong then beautiful concurrency for more details.
And if you are still wondering why I wrote the term “anarchy”, it’s just because I read about the work of Audrey Tang who integrated STM in Pugs (an Haskell implementation of Perl) … and she also appears to be a proponent of the Individualist Anarchism.
I recently jumped into the Erlang world, mostly seduced by the message-passing concurrency model (as opposed to the shared-state concurrency model) . This was a choice a priori without real objective (I mean without project, just as learning experience).
Now we have (project in my company) to implement an “efficient” and scalable server: fast, robust and highly-available (as any servers, of course). Coming from a really bad Python threaded-server experience, I’d rather read some hints before to go to any platform or framework (Stackless Python, Twisted, Erlang/OTP, Java, C/C++ …). Here are some available documents related to high performance network servers:
Wow! that’s tough to decide anything! Where I’m a bit surprised is that concurrency model choice is often viewed as Thread vs. Event, and each side argue about throughput , switching context cost, and latency. As I understand, message-passing and event is not the same: most of the event model I’ve seen do not enable pre-emption without relying on threads to manage some event loops. And I naively assume that pre-emption is a good choice to implement robust and available server.
To conclude, if I have to choose something today, I would still choose Erlang! Because it implements efficient lightweight process: easy as threads, message passing model, and pre-emption able . Furthermore Erlang proposes through OTP a whole framework for robust application, and I see a (good) framework as an invaluable experienced-user knowledge (thank you OTP folks!).
 Indeed Erlang feature an efficient implementation of so-called processes (also known as lightweight-thread, micro-thread, greenlet or tasklet … but the term process emphasize on the absence of shared-state common to many thread implementation). Erlang made also the choice of functional programming style as a programming guide to context independent code (unique affectation of variable, reduced side-effects).
 Having a lot of Python code, I had to compared Erlang vs. Stackless Python. In fact they share a lot of characteristics but Stackless has not the whole OTP framework and more importantly Stackless message sending block if there is no receptor of the message (more in this discussion about Stackless vs. Erlang).
I assisted to my first presentation about User Experience Design (as I discovered, UX Design is not only UX). Here is a quick summary of what I still remember.
From what I understood UX Design is defined by:
- enterprise impact
- human factor (~ergonomics)
A product specification can then be described by a list of features, where each feature is defined by:
- description (what is/does it?)
- functional test (how to test the functionality?)
- intend or goal (what’s the objective of the feature, for e.g. “make user happy”)
- how to test/measure the feature (particularly its goal)
Relative reading (added in my reading queue):
- The Design of Everyday Things [Donald Norman, 1988]
D. Norman introduced the term affordance about user interaction, and emphasize on the design of product: “make the task dominate, make the tool invisible”.