Planet Trapexit - Erlang/OTP News

Erlang Solutions
- Jobs: Subcontractors, Stockholm Sweden

Thu, 02 Sep 2010 11:30:28 +0000

We are looking for subcontractors available on a full time basis with immediate start on a rolling three months contract.

Roles will involve working as part of a small team of Erlang developers from our Stockholm Office.

You should have experience of developing reliable, fault tolerant applications in Erlang. Experience with linux/bsd, networking, riak and erlang web/nitrogen is highly desirable.

Knowledge of SMS communications protocols, SIP, Telecom and embedded will assist in your consideration for this role.

Immediate start to contract if you are the right person. Rates to reflect skill level and aptitude.

Process-one Blogs: TextOne for iPhone, with photo sharing!

Thu, 02 Sep 2010 08:43:34 +0000

Our iPhone version of TextOne, the simple and fast messenger for smartphones, has received a nice photo sharing feature.

TextOne, the simple, light and fast smartphone messenger, is now offering a new feature to share photos with your friends.

Easy, a new icon appears at the top right of the conversation screen, you just need to tap it.

There, you can choose to take a picture or select one from your albums... and add the text you wish.

This will appear in the conversation as a taped instant photo, like any other messages.

You can also browse the photos exchanged with your contacts.

Of course, this also works with TextOne Pink!

Photo sharing in TextOne will let you share good moments with the people to whom you are close. Or alternatively play ;-)

And finally, you can play with it

Damien Katz: What's New in CouchDB 1.0 Security 'n Stuff

Wed, 01 Sep 2010 00:36:22 +0000

Today, I get a little help from Rebecca. She's writing a CouchApp, an application that is served right out of CouchDB and that lives in the browser. It has no middle tier application server in Ruby or Java. The application and display logic is written in JavaScript, the user interface is HTML & CSS, the backend is CouchDB and uses Ajax to shove JSON back and forth.

What's new in CouchDB 1.0 -- Part 4: Security 'n Stuff: Users, Authentication, Authorisation and Permissions

Programming in the 21st Century: Common Sense, Part 1

Tue, 31 Aug 2010 06:00:00 +0000

There's a photo of mine in the September 2010 issue of Popular Photography. I'm excited about it; my photo credits are few and far between, and it brings back the feelings I had when I wrote for magazines long ago. Completely ignoring the subject of the image, there are couple of surprising facts about it.

The first is that it was a taken on a circa-2004 Canon PowerShot G5, a camera with a maximum resolution of five megapixels.

The second is that it's a doubly-compressed JPEG. The original photo was a JPEG, then I adjusted the colors and contrast a bit, and saved it out as a new JPEG. Each save lost some of the image quality. I was perfectly willing to submit the adjusted photo as a giant TIFF to avoid that second compression step, but was told not to worry about it; the JPEG would be fine.

Yet there it is: the five megapixel, doubly-compressed photo, printed across almost two pages of the magazine. And those two technical facts are irrelevant. I can't tell the difference; it looks great in print.

Now it is an impressionistic shot, so it could just be that the technical flaws aren't noticeable in this case. Fortunately, I have another anecdote to back it up.

Last year I was in New Mexico and took a lot of photos. After I got back home, I decided to get a few photo books printed. The source images were all twelve megapixel JPEGs, but the book layout software recommended a six megapixel limit. I cut the resolution in half, again twice-compressing them. When I got the finished books back, the full-page photos were sharp and beautiful.

The standard, pedantic advice about printing photos is that resolution is everything. Shoot as high as possible. Better yet, save everything as RAW files, so there's no lossy compression. Any JPEG compression below maximum is unacceptable. Double-compression is an error of the highest order, one only made by rank amateurs. And so it goes. But I know from personal experience that while it sounds authoritative, and while it's most likely given in a well-meaning manner, it's advice that's endlessly repeated in a loose, "how could it possibly be wrong?" sort of way and never actually tested.

Erlang Inside: Russia’s numerous contributions to the Erlang community – Dmitrii Dimandt, creator of erlanger.ru

Mon, 30 Aug 2010 16:58:43 +0000

Erlang Inside is sponsored by Inaka Networks, Erlang consultants combining experience with Telecom to build high performance web applications. This week, Erlang Inside has a guest post from Dmitrii Dimandt, a Russian developer and creator of the site erlanger.ru. I’d like to talk about the Russian Erlang community and what it’s doing with Erlang. In [...]

Chicago Erlang User Group: 6/2/2010 OTP Plus

noreply@blogger.com (Barry Nicholson) — Sun, 29 Aug 2010 21:15:00 +0000

Here's the video from the group meeting on 6/2/2010 on "How to use OTP". OTP makes coding with Erlang just so much easier. OTP just abstracts so much coding away. Jon Patton discussed using gen_servers and Tristan Sloughter discussed using gen_supervisors. Great talks guys!!A couple of other impromptu talks were also given. Martin Logan talked about terminology and how we can discuss and

Nicolas Charpentier's blog: Next language to learn: Haskell

Sat, 28 Aug 2010 19:36:45 +0000

Remembering ”The pragmatic programmer: Fro, Journeyman to Master”, each developer should learn a new language each year. This year, I will give its chance to Haskell. Why Haskell ? Scala was a candidate for this year but Haskell has a strong reputation in the functional world. I came to functional with Erlang because of its concurrent and distribution [...]

Programming in the 21st Century: Personal Programming

Sat, 28 Aug 2010 06:00:00 +0000

I've mentioned before that this site is generated by a small Perl script. How small? Exactly 6838 bytes, which includes comments and an HTML template. Mentioning Perl may horrify you if you came here to read about Erlang, but it's a good match for the problem. Those 6838 bytes have been so pleasant to work on that I wanted to talk about them a bit.

I've used well-known blogging applications, and each time I've come away with the same bad taste, one that's caused by a combination of quirky rich formatting and having to edit text in a small window inside of a browser. I don't want to worry about presentation details: choosing fonts, line spacing, etc. It's surprising how often there are subtle mismatches between the formatting shown in a WYSIWYG editing window and what the final result looks like. Where did that extra blank line come from? Why do some paragraphs have padding below them but others don't?

I decided to see if I could bypass all of that and have a folder of entries marked-up with basic annotations, then have a way to convert that entire folder into a real site. And that's pretty much what I ended up with. The sidebar and "Previously" list and dated permalink are all automatically generated. Ditto for the atom feed and archives page. The command-line formatter lets me rebuild any page, defaulting to the newest entry. If I want to change the overall layout of the site, I can regenerate all of the pages in a second or so.

There are still legitimate questions about the path I chose. "Why not grab an open source program and modify it to fit your needs?" "You do realize that you decided to write an entirely new system from scratch, just because you didn't like a few things in existing programs; surely that's a serious net loss?"

My response is simple: I did it because it was easy. If I get annoyed with some feature of Microsoft Word, I'm not going to think even for a second about writing my own alternative. But the site generation program just took a bit of tinkering here and there over the course of a weekend. It never felt daunting. It didn't require anything I'd label as "engineering." I spent more time getting the site design and style sheet right, something I would have done even if I used other software.

Since then, I've made small adjustments and additions to the original script. I added the archive page nine months later. Earlier this year I added a fix for some smaller feed aggregation sites that don't properly handle relative links. Just today I added mark-up support for block quotes. That last one took ten minutes and four lines of code.

If this suddenly got complicated, if I needed to support reader comments and ten different feed formats and who knows what else, I'd give it up. I have no interest in turning these 6838 bytes into something that requires a grand architecture to keep from collapsing. But there's some magic in a solution that's direct, reliable, easy to understand, and one that fits my personal vision of how it should work.

(If you liked this, you might like Micro-Build Systems and the Death of a Prominent DSL.)

Damien Katz: Why Large Hadron Collider Scientists are Using CouchDB

Fri, 27 Aug 2010 02:51:27 +0000

A nice article on ReadWriteWeb: http://www.readwriteweb.com/enterprise/2010/08/lhc-couchdb.php

And the case study: http://www.couch.io/case-study-cern

Erlang Solutions
- Jobs: Junior Systems Engineer at Erlang Solutions, London, Stockholm or Krakow (travel to client locations may be required)

Thu, 26 Aug 2010 11:30:30 +0000

With our portfolio of customer facing projects increasing in all our offices, we are looking for talented individuals to join our young and dynamic teams. You will need to be passionate about Erlang and believe it can be the next Java. The right candidate will join a small team of highly skilled systems engineers developing software in Erlang/OTP. You will gain valuable experience in exciting state-of-the-art systems within the Telecom, Financial Services, Banking, Messaging, Automotive and Logistics sectors. As our clients are spread on six continents, fear of flying is unfortunately a “no no”.

1.    Responsibilities:
•    Research, design, development, test and support of Erlang and related software
•    Develop solutions using distributed concurrent programming, software
            packaging and release
•    Write code in Erlang and occasionally in other languages such as C, Java, Clojure, Haskell, Scala & Objective-C to name but a few of our favourites.

2.    Skills and experience required:
•    Be passionate about Erlang
•    A minimum of 1 year’s Erlang programming even if it has been a hobby or
      academic project
•    Experience with other languages such as C and Java, and it's always good to have another perspective
•    Knowledge of Distributed Computing, and revision control software
      (preferably GIT or Subversion)
•    Experience of implementation of soft real time servers
•    Experience with interconnection protocols (HTTP, XMPP, SMPP, ...)
•    Experience with Linux, OS X and Solaris operating systems
•    Experience with web front-end development will be a plus
•    Experience with Agile Methods, including Test Driven Development will be
      an advantage
•    Problem-solving and thinking laterally as part of a team, or individually, to meet the needs of the project
•    Good verbal and written communication in English
•    Good customer facing and presentation skills.

3. Minimum Education, Certification, Training:
A degree in Computer Science, preferably a Masters.

4. Eligibility:
The right candidate will work in a rapidly expanding company and community, receive a competitive salary with full benefits and stock options. Applicants will be considered only if they are currently eligible to work in the EU, but remote work will be considered for ideal candidates.

Erlang Solutions
- Jobs: Senior Systems Engineer at Erlang Solutions , Location: London, Stockholm or Krakow (travel to client locations may be required)

Thu, 26 Aug 2010 11:15:28 +0000

With our portfolio of customer facing projects increasing in all our offices, we are now looking for talented individuals to join us. They will need to like travel, be passionate about Erlang and see a future in this technology area.
The right candidate will lead and programme in a small team of highly skilled systems engineers in developing Erlang/OTP software to meet customer requirements.
Selected candidates will be leading the development of state-of-the-art Erlang systems in the Telecom, Financial Services, Banking, Messaging, Automotive and Logistics sectors.

1.   Responsibilities:
•   Research, design, development, test and support of Erlang based software
•   Develop solutions using distributed concurrent programming, software
            packaging and release
•   Write code in Erlang and occasionally in other languages such as C, Java, Clojure, Haskell, Scala & Objective-C to name but a few of our favourites
•   Evaluation of open source Erlang killer apps
•   Mentoring and coaching junior staff.

2.   Skills and experience required:
•   Be passionate about Erlang
•   Superstar programming skills in Erlang/OTP, possibly 3 or more years
•   Experience with other Programming languages
•   Knowledge of Distributed Computing, and revision control software
      (preferably Git and Subversion)
•   Experience of implementation of soft real time servers
•   Experience with interconnection protocols (HTTP, XMPP, SMPP, ...)
•   Experience with web front-end development is an advantage
•   Experience with mainstream operating systems, including Linux, OS X &
      Solaris derivatives
•   Experience with Agile Methods, including Test Driven Development
•   Experience of planning, estimating and leading a team is an advantage
•   Good verbal and written communication in English
•   Good presentation skills and public speaking experience.

3. Minimum Education, Certification, Training:
A degree in Computer Science, preferably a Masters.

4. Eligibility:
The right candidate will work in a rapidly expanding company and community, receive a competitive salary with full benefits and stock options. Applicants will be considered only if they are currently eligible to work in the EU, but remote work will be considered for ideal candidates.

Erlang Solutions
- Jobs: Open Source Support Engineers at Erlang Solutions, London, Stockholm or Krakow (occasional travel may be required)

Thu, 26 Aug 2010 11:15:28 +0000

We’re looking for people with world class technical and communication skills and a strong desire to see Erlang become the next Java. Experience in supporting and troubleshooting Open Source applications, preferably in Erlang, is a must.
If you know what open source development is all about, we definitively want to hear from you. Experience of trouble-shooting C applications or virtual machines is certainly a plus.

1.     Responsibilities:
·      Maintaining Erlang / OTP systems and distributions
·      Working closely with Erlang enthusiasts, the open source community as well as customers’ operational and technical support staff on community patches
·      Maintaining SLAs and response times with our clients
·      Experienced individuals will help establish the support process as well as service levels and agreements

2.     Skills and experience required
·      Be passionate about Erlang
·      Superstar trouble-shooting skills in Erlang/OTP
·      Experience with other languages, including C and Java
·      Experience contributing to or enabling open source
·      Familiarity with Git and other revision control systems
·       Database administration skills in Couchdb, Riak, and obviously Mnesia
·       Experience with Ejabberd, Rabbitmq, Disco and other open source Erlang killer applications
·       Comfortable with Linux, Unix, Vxworks and other embedded/desktop operating systems
·       Experience of providing software support as well as being in previous customer facing roles will be a distinct advantage
·       Good verbal and written communication in English.

3. Minimum Education, Certification, Training: A degree in Computer Science, preferably a Masters.

4. Eligibility:
The right candidate will work in a rapidly expanding company and community, receive a competitive salary with full benefits and stock options. Applicants will be considered only if they are currently eligible to work in the EU, but remote work will be considered for ideal candidates.

Erlang Solutions
- News: 25 August 2010: Erlang User Conference Registration Open with a Very-Early Bird Rate!

Wed, 25 Aug 2010 16:47:09 +0000

Registration for the Sixteenth International Erlang User Conference and Erlang University courses are now open. The first 100 people to register will receive a Very-Early Bird Discount and pay only SEK 750 including VAT! DON’T MISS OUT as last year's conference sold out.

The Sixteenth International Erlang User Conference will take place in Stockholm, on the 16th November 2010.

In addition to the conference itself, there will be the Erlang University - three-day Erlang training courses from 17th to 19th November. There will also be a day of Erlang Tutorials on the 15th.

Registering for one of the University courses: Erlang Express or OTP Express includes entry to the Erlang User Conference, so don't waste time and register now!

Speakers and talks will be announced shortly.

Erlang Factory News: Erlang User Conference Registration Open with a Very-Early Bird Rate!

Wed, 25 Aug 2010 13:46:30 +0000

Damien Katz: The Little Comedian

Sat, 21 Aug 2010 01:53:18 +0000

Gwen: Knock knock.

Me: Who's there?

Gwen: Knock knock.

Me: Who's there?

Gwen: Knock knock.

Me: Who's there?

Gwen: Banana!

Me: Banana who?

Gwen: Orange you glad I didn't say orange again?

Us: BWAHAHAHA!

Process-one Blogs: Tsung 1.3.3 has been released

Thu, 19 Aug 2010 16:18:31 +0000

Tsung 1.3.3 fixes severals bugs. It fixes support for SSL with erlang R14A.

Tsung 1.3.3 brings some minor bugfixes.

fixed parent proxy not working in 1.3.x (tested with 1.3.2 and 1.3.0).
fixed url substitution is broken in some cases
fixed Tsung not using sessions with low probabilities
fixed SSL not working with erlang R14A
fixed failure when a proxy is used and an URL substitution is set
fixed HTTP cookies support when a proxy is used
fixed hanging at the beginning using distributed setup
fixed "if" statement, which is not allowed in a transaction

Erlang Solutions
- News: 19 August 2010: Ulf Wiger CTO of Erlang Solutions will be presenting at Cracow Grid Workshop ‘10.

Thu, 19 Aug 2010 14:02:15 +0000

Presenting at the conference which runs October 11th - 13th in Krakow, Poland, Ulf will look at how Erlang is breaking out of the clusters of the last century and entering today's cloud computing environments.

The main objective of the Cracow Grid Workshops, which were initiated in 2001, is to support the community of researchers, developers, and practitioners who work in the fascinating field of e-Science, grid systems, and their applications. It will also be celebrating its 10th Anniversary this year.

For more information please visit the CGW ’10 website.

Erlang Solutions
- News: 17 August 2010: Ulf Wiger of Erlang Solutions will be presenting at Yow! Australia 2010 in Brisbane and Melbourne

Tue, 17 Aug 2010 08:47:07 +0000

Ulf will be giving a talk titled, Erlang Warps Your Mind: Concurrency-Oriented Programming , and two workshops, Erlang: A Language for Programming Reliable Systems and Erlang/OTP System Principles.

During “Erlang Warps Your Mind: Concurrency-Oriented Programming” he will try to show how learning Erlang will make you a better programmer.

“Erlang: A Language for Programming Reliable Systems”, a hands on tutorial, will give you an introduction to the Erlang programming language.

During “Erlang/OTP System Principles" you will get an insight in to the theory and concepts behind Erlang design principles, learning how concurrency design patterns they are used to build industrial grade systems.

The YOW! Australia 2010 Developer Conference offers outstanding opportunities to learn more about the latest practices, technologies and methods and for building innovative software solutions with the opportunity to hear and meet international software experts and network with the other talented developers in Australia.

Melbourne Dates: The talk will be 2-3 December with the workshops on November 30th to December 1st.
Brisbane Dates: The Talk will be 6December 6th-7th with the workshops on December 8th-9th.

For more information on the conference, click here and for more information on Ulf’s presentations click here.

Erlware: ErlangCamp - Erlang and OTP Workshop in Chicago Oct 23 and 24

martinjlogan@erlware.org (Martin J. Logan) — Sat, 14 Aug 2010 13:18:50 +0000

ErlangCamp is here! You may have seen the announcement on the erlang.org already. ErlangCamp is a two day hands on workshop for those interested in learning how to go from novices or experienced levels of programming Erlang to being able to confidently write production grade Erlang/OTP services. ErlangCamp is an opportunity to learn from those who have done a ton with OTP and Erlang and put many

Damien Katz: WARNING: CouchDB 1.0.0 Data Loss bug

Fri, 13 Aug 2010 18:42:41 +0000

Update August 13, 2010. A data recovery tool now available: http://wiki.couchone.com/page/repair-tool

if you are running CouchDB 1.0.0 with the default delayed commit setting, you are subject to serious data loss on restart. See this page for instructions how to force all outstanding commits and configure your server at runtime to run in the safer full commit mode: http://couchdb.apache.org/notice/1.0.1.html

The page also includes details of the bug and a postmortem.

0.11.1 and earlier are unaffected. Servers with delayed commits turned off are unaffected. 1.0.1 will be coming shortly that fixes the problem in all configurations.

DO NOT COMPACT THE DATABASE! Compaction throws away any lost updates permanently.

Data recovery is coming. The CouchDB core contributors are working on a utility to reliably recover lost updates, so no data is lost as long the database file is not compacted.

Erlang Solutions
- News: 12 August 2010: Hans Nilsson of Erlang Solutions will be presenting at Java Zone 2010

Thu, 12 Aug 2010 14:16:56 +0000

In his talk entitled “Introducing Erlang to the OO Community”. Hans will look at whether anything at all can be modelled without objects? He will describe why Erlang, originally invented to handle the next generation of Telecom products, has become successful in a much wider range of sectors including embedded devices, messaging systems, banking and e-commerce.

He will also introduce the Erlang programming language, describing how to do more with less. Hans will be giving examples on the syntax and constructs which allow Erlang programs to be 4 : 10 times shorter than their counterparts in Java, C and C++ while achieving 99,999% availability. He will provide examples not only of the Ericsson success stories, but also from banking, finance, distributed databases, instant messaging and web2.0, describing how Erlang has found its role in these market segments.

For more information click here.

Jordan Wilberding: ErlangCamp Chicago 2010

Mon, 09 Aug 2010 19:29:06 +0000

I am happy to to announce ErlangCamp Chicago 2010 (http://erlangcamp.com/) has gone live and is ready to take registrations. This has been in planning for quite a while between Martin Logan, Eric Merritt, Tristan Sloughter, and myself. We are trying to help build the Erlang community here in the U.S. We hope by providing an [...]

Chicago Erlang User Group: ErlangCamp Chicago 2010 Registration Open

noreply@blogger.com (Jordan Wilberding) — Mon, 09 Aug 2010 01:31:00 +0000

We are pleased to announce ErlangCamp Chicago 2010 (http://erlangcamp.com/) has gone live and is ready to take registrations. If you want to learn how to build production ready Erlang/OTP systems, this workshop is for you.

EazyErl!: erlang: Simple Debug macro

noreply@blogger.com (rolphin) — Sat, 07 Aug 2010 14:46:25 +0000

When testing things I need some quick way to debug "a la" printf() style. Old habits :)

Here's is the simple debug macro I use:

-ifdef(debug).
-define(DEBUG(Format, Args), io:format("~s.~w: DEBUG: " ++ Format, [ ?MODULE, ?LINE | Args])).
-else.
-define(DEBUG(Format, Args), true).
-endif.

Write it down in a "debug.hrl" file, then you only need to add this line in any file header:

-include("debug.hrl").

This simple macro gives you the module name and the line number. This saves me a lot of time.

Then you need to define the "debug" atom to let your macro do what you want. The compile:file/2 handles options for this, the syntax is {d, debug}

You can also use some simple helper module to compile multiples files using simple regexp:
Here's the code:

-module(utils_compile).

-export([c/1, c/2, d/1, d/2]).

c(FilePattern) ->
 c(FilePattern, "../ebin").

c(FilePattern, OutDir) ->
 filelib:fold_files(".", FilePattern ++ ".erl$", false, 
 fun(X, _Acc) -> 
  io:format("Compiling ~p~n", [ X ]), 
  compile:file(X, [{outdir, OutDir}, report]) end, []).

d(FilePattern) ->
 d(FilePattern, "../ebin").

d(FilePattern, OutDir) ->
 filelib:fold_files(".", FilePattern ++ ".erl$", false, 
 fun(X, _Acc) -> 
  io:format("Compiling (debug) ~p~n", [ X ]), 
  compile:file(X, [{outdir, OutDir}, {d, debug}, report]) end, []).

ejabberd@jabber.ru: ejabberd 3.0.0-alpha-1 - for alpha-testing only

Fri, 06 Aug 2010 22:01:26 +0000

This first alpha includes three major changes compared to ejabberd 2.1.5: exmpp library is used, gen_storage for a database abstraction layer, and Massive Hosting which isn't yet usable.

Many tables have changed both in Mnesia and MySQL/PgSQL/ODBC. Fortunately, now ejabberd is able to create tables, update the tables and reformat their content in Mnesia and also in external databases. Or at least it should do.

Erlang Inside: ErlangCamp Chicago 2010 – Oct 23rd/24th

Fri, 06 Aug 2010 17:35:32 +0000

Incredibly cheap at $100.00 USD - Two days of Erlang/OTP sessions in Chicago - check it out. http://erlangcamp.com/

1011 Ltd Blog: Why Google Wave "failed"

Fri, 06 Aug 2010 09:19:00 +0000

Google Announced this week that they "don't plan to continue Wave as a standalone product", which was a surprise. The twitterverse and technology press went crazy with the news. Even the Financial Times reported on the demise of Wave. I've been involved on the fringes of Wave, building clients, gadgets, prototyping servers, using the web client extensively, but since Google I/O 2010 I don't think I've touched it. Why did it "fail", and how can other projects learn from the mistakes?

Damien Katz: CouchDB Diplom Thesis

Fri, 06 Aug 2010 00:30:46 +0000

It's whooping 163 pages containing all the nitty-gritty-researchy details on why CouchDB is the number one choice for writing distributed applications in both the small and large scale.

Diplom Thesis: Realisation of a Distributed Application Using the Document-Oriented Database CouchDB by Lena Herrmann

Erlang Solutions
- News: 05 August 2010: Announcing the call for submissions for the Erlang User Conference 2010 in Stockholm.

Thu, 05 Aug 2010 14:33:09 +0000

The 2010 Erlang User Conference in Stockholm will be held on Tuesday the 16th of November. Monday the 15th of November will be dedicated to Erlang Tools Tutorials, the Erlang User Conference will take place on the 16^th November. With The Erlang University training courses being held on the 17^th- 19th November.

We have now opened the call for talks and tutorials for the 2010 conference. Talk submissions should be 30 minutes in length, including five minutes for a Q&A session. Tutorial submissions can be of 1.5 or 3 hours in duration and should be aimed at a technical audience. For your chance to present at the Erlang User conference 2010 submit a talk via the EUC2010 Submissions page. The deadline is the 10^th September at the latest.

Damien Katz: We are hiring open source contributors!

Wed, 04 Aug 2010 23:36:27 +0000

We are hiring front end and back end engineers, documentation writer, trainer, release engineer and managers. Must have an open source background. See our jobs page for more info:

http://couch.io/jobs

ejabberd@jabber.ru: ejabberd 2.1.5 - Fifth bugfix release

Tue, 03 Aug 2010 16:35:54 +0000

ejabberd 2.1.5 has been released. It contains several minor bugfixes and a few improvements.

This is a short list of changes:

Erlang/OTP R12 support fixed
Erlang/OTP R14A support added
OpenSSL 0.9.8 or higher is required
BOSH: New optional connection attribute process-delay
C2S: Don't ask for client certificate when using tls
C2S: Inform client that SSL session caching is disabled

Process-one Blogs: ejabberd 2.1.5 and exmpp 0.9.5 bugfix releases

Tue, 03 Aug 2010 15:35:28 +0000

We are pleased to announce the bugfix releases ejabberd 2.1.5 and exmpp 0.9.5.

Regarding ejabberd 2.1.5:

The main changes are:

Erlang/OTP R12 support fixed
Erlang/OTP R14A support added
OpenSSL 0.9.8 or higher is required
BOSH: New optional connection attribute process-delay
C2S: Don't ask for client certificate when using TLS
C2S: Inform client that SSL session caching is disabled
CTL: Fix problem when FIREWALL_WINDOW options for erl kernel were used
CTL: Some systems delete the lock dir; in such case don't use Flock at all
Caps: Support all the hash functions required by XEP-0115
Config: Fix typo in --enable-transient_supervisors
Config: New configure option: --enable-nif
Extauth: Support parallel script running
MUC: Allow admins to see private rooms in disco
ODBC: Correct handling of SQL boolean types
ODBC: Discard too old queued requests (the caller has already got a timeout)
ODBC: Fixes wrong SQL escaping when --enable-full-xml is set
ODBC: Use ets instead of asking supervisor in ejabberd_odbc_sup:get_pids/1
Pubsub: Enforce disco features results
S2S: When logging s2s out connection attempt or success, log if TLS is used
Shared Rosters: When account is deleted, delete also member of stored rosters

Release Notes

Check the Release Notes for a more complete list of changes:
http://www.process-one.net/en/ejabberd/release_notes/release_note_ejabberd_2.1.5

If you upgrade from ejabberd 2.0.5 or older, read carefully the release notes of ejabberd 2.1.0 too, because there were several changes in the installation path and the configuration options.

Links

The list of solved tickets since previous version is available on ProcessOne bug tracker:
http://redir.process-one.net/ejabberd-2.1.5

ejabberd 2.1.5 is available as source code package and binary installers for Linux 32 bits, 64 bits, Mac OS X Intel, and Windows:
http://www.process-one.net/en/ejabberd/downloads

Regarding exmpp 0.9.5:

Brief summary of changes:

Add method to retrieve underling connection properties
Configurable Zlib support
Fix BOSH that didn't work
Modify exmpp_component to use exmpp_socket instead of exmpp_tcp
Negotiate zlib compression before OR after SASL
Raise requirement to Erlang/OTP R12B-5
Replace calls to OTP module ssl_pkix with public_key
STARTTLS support
Session enhancements
Stream compression support for session

Links

exmpp home page:

http://support.process-one.net/doc/display/EXMPP/ or easier to remember: http://exmpp.org/.

Download exmpp 0.9.5 source code package from:

http://download.process-one.net/exmpp/

You can also check the ProcessOne Labs page:

http://www.process-one.net/en/labs/

Damien Katz: Getting Your Open Source Project to 1.0

Sun, 01 Aug 2010 17:38:17 +0000

The project I founded, Apache CouchDB, recently hit 1.0. I'm very proud :)

Awesome 1.0 cupcakes from Sauce Labs.

It's been a long time, but we finally produced a release that's complete, performs well and is rock solid.

Already CouchDB is on over 10 million machines. It's used by big respected websites (like the BBC) and groundbreaking organizations (Mozilla and Canonical). We run on most *nix, OS X, Windows, and even Android phones. Have dozens of frameworks and client libraries available. There are 2 books available for sale right now. There is a venture capital backed startup, Cloudant, that offers CouchDB hosting and scales to huge datasets. And I'm CEO of another venture backed ($2 million invested) 12 person start-up, Couchio.

So how did I get here? It took a lot of time and effort (almost 5 years!), and the help of a lot of people. Here are some tips of what it took to get CouchDB to 1.0.

Why?

Successful open source projects need a reason for being. You need to decide why you are creating a project and what problems it solves. Whether it's one or many reasons, you need to figure out what they are and explain them.

Perhaps you are making something new, that hasn't existed. Why hasn't it existed it before? No had the idea? No one had the will to carry it through? Or maybe you are making something that's already in existence, like an HTTP server. What are your reasons? Simpler, faster, more features, different license?

If you are just doing it as a learning exercise, that's fine. But don't expect to attract a community until you can explain why it's useful beyond you own personal goals.

With CouchDB, my reasons were:
1. A schemaless document database with views, bi-directional replication and conflict detection to enable disconnected operation would be really useful.
2. I wanted to understand more about creating distributed systems and database internals.

No one cares about reason #2 except for me. But the first reason is compelling.

Make sure you can tell people why your project exists and what it's good for. And put the reasons on your project site where people can find them.

Code Comes First

Don't start a project unless you have a deep commitment to being a strong coder.

Now I'm not saying you must be a strong coder to participate in a project. Not at all. I'm saying that you must be strong coder to lead one. Maybe you'll get lucky and somehow attract a some really good coders to your project. But most really good coders go to projects with already solid codebases, or start their own.

Also, you don't have to be a strong coder when you start out, but you should know the basics and have a strong desire to learn and get better. Don't expect to attract anyone to your project until you have a substantial amount of working code that isn't a big ball of spaghetti.

With CouchDB, I always emphasized the quality of the high-level design and code implementation. We cannot under any circumstances lose or corrupt your committed data, or get things into an inconsistent state. Reliability and durability are absolutely imperative. Any design or implementation that doesn't meet these goals doesn't make it into the project.

Some projects might not have an emphasis on the reliability, but on absolute performance. That's a fine choice to make, but make sure your users know what they are trading off. And then actually deliver on the performance.

As the project moves along, you will need to ensure the code quality (reliability, performance, resource, usage, etc) is improving over time. If you aren't a good coder, you won't be able to do this.

Know What You Aren't

Almost as important as knowing what your project is trying to accomplish, is know what it isn't trying to accomplish.

When your project starts to get traction, but before it's done, you'll get a lot of people who want the project to work more like things they've used in the past. New users might think your goals and abilities are cool, but they'd trade it all for just a little more. They'll want everything your project does, plus a pony.

The problem is feature and scope creep. Even if you are successfully keeping the project on track, the community may get slowed down dealing with people trying to make it something it's not. Stating clearly what your project isn't trying to do or be helps make it much easier to explain what you can't implement or change.

Now, you can't define everything your project isn't. (It's not a video game. It's not accounting software. It's not a banana. It's not a rainbow. etc.). But you can find the things it's related to, overlaps with, or might be confused with, and explicitly say it's not those things.

With CouchDB, because we are a database, people often asked us to add features that were in traditional RDBMS's, but didn't fit well with the CouchDB data model. Not being intimately familiar with CouchDB's model and how it all fits together, they don't realize that what they're asking for simply doesn't work. But because we explicitly stated on the project site we aren't a relational database and aren't trying to replace relational databases, it made it much easier to explain why those features weren't a good fit for what CouchDB is trying to accomplish.

So if you don't clearly define what your project isn't, often people will try to make it into those things. This can damage the community, as moving forward is slower and people feel like they aren't being listened to. Be explicit what you aren't, and it makes it much easier to focus on what you actually are.

Don't Do Everything (Well)

So you are superstar coder, your code is clear and concise and high quality, you write clear complete documentation, your create all the tests, and you fix every bug. You are awesome!

Thing is, you might be awesome, but until you actually get a community behind the project, the project will be limited in an absolute sense by what a single person can produce. And if you are doing everything, that's not a whole lot. Trying to do everything well means you'll probably never actually release anything.

Unfortunately, at first, you _will_ need to do everything. But just don't do everything really well. Instead, you'll have do some things crappily, and then move on. In addition to writing all the code, you'll need to: Create a project site. Explain your project. Write documentation. Do the releases. Start a bug tracker. Create a mailing list and answer questions. And you'll have to do most of these things poorly if you want to keep moving the ball forward.

You'll have to do some things poorly. But you'll need to pick a few things that you do really well and execute on those things. (The code should be one of the things you do well).

And everything you do, you'll need to make it easy for others to participate. To add patches, to update and create documentation, make bug reports and send patches. And make it clear that help is desired.

Don't get hung up on trying to make everything perfect. That just paralyzes you. But by picking a few things to do well, you will attract people to help you with the things you aren't doing well.

Community Wants to Help

Open Source is awesome in the way it attracts people who just want to help make something cool. Many people want to contribute their time, but only if they think their help will amount to something in the long run. They don't want to spend time and effort on something that doesn't yet show potential or might be abandoned if the creators lose interest.

If you have a solid codebase, then it becomes much easier to attract people to your community. If people can recognize there is at least something high quality about your project, but it's lacking in some areas, people will want to help you in those areas. But you have to have the high quality pieces in place. People don't want to be the one excellent contributor to dreck. They'd rather not have their efforts associated at all.

They do want to be a part of something great. They want to add their work and make it even better. They want to contribute to projects where the total excellence of the project reflects well on them and their efforts. They want to make the world a better place, and don't want their efforts wasted.

And people who like making the world a better place are exactly the kind of people you want to attract. You want people to have pride in their contributions, and to feel like they are really positively affecting the things they care about. Those people have lots of projects to choose where they can add their time and talents. If they feel their efforts on your project are wasted, they are gone. Make sure the people who show a strong desire to contribute aren't ignored, and feel like their efforts will eventually amount to something.

Being a part of Apache has helped CouchDB tremendously. Partially it's because Apache has helped our visibility and credibility. But it's also because we've adopted the "Apache Way", which is more focused on the community aspects of a project than on any specific contributor. Without our amazingly active community, CouchDB would be far behind where it is now.

Community Is Often Incompetent

Unfortunately, many people who will want to help you will produce contributions of poor quality. You will have deal with this "help", and do so diplomatically. The best way to point out the shortcomings with their contributions is to identify what needs improvement without denigrating their overall effort. This can be hard, and many don't want to hear why their efforts aren't up to the project's standards.

Sometimes you have to hurt peoples feelings. But it's better to be honest then to have the quality of your project brought down. If they can't handle the feedback, so be it. The good news is the people who do listen to constructive criticism and actually improve the quality of their contributions are incredibly valuable. Look for these people and nurture their involvement.

With CouchDB, we try to listen to all members of our community, but we only grant commit access to the ones who have shown high quality contributions. Our committers are our first line of defense against poor code and design.

Paul Graham Was Right

It seems to make sense to choose a mainstream language for your project. The more mainstream it is, the larger the potential community you can attract. While that's true to an extent, the quality of the community is more important than its absolute size. Much more important.

Using a mainstream language means you are also competing for contributor's time from other projects in the same language. So the pool is large, but in the end, you still have to attract quality developers from other things competing for their attention. And the competition might actually be stronger in that larger pool.

The more mainstream a language, the more likely it is that a random developer knows it because it's what they use at work. They aren't necessarily interested in being more productive, being more reliable, or whatever. They are interested in getting paid, and they choose their language not for elegance, power or performance, but for the number of job openings available.

If you pick a non-mainstream, more esoteric language, you tend to get a higher quality of developer. You tend to find people who absolutely love programming and building, and choose their languages not based on the scale of pay, but because they make the developers and projects more powerful. So while the total pool of contributors is smaller, they tend to give a higher quality of contribution. You get a much better signal to noise ratio.

As Paul Graham explained in Beating the Averages, the exotic languages tend to attract devs who love to learn and expand their toolbox. You'll attract more of the types of devs who don't mind creating new code to fill in the gaps, or diving into source to find a bug. They aren't afraid of what they don't know, they actually get excited by the chance to learn and do something new.

But if you pick enterprisey language X, you might find you are spending more of your time fixing problems and dealing with developers who just don't "get it". If you aren't careful, this can drown your project and bring the total code quality down to the point where you can't find good devs to help you anymore. With the less popular, esoteric languages, that tends to be less of a problem and you get a higher quality of contribution in general.

Use Your Brain

I can keep listing all the stuff we did, but you aren't creating the same project under the same circumstances. Pretty much everything I've said here, we've not followed at some point during the project. Often it was to the detriment of the project, but sometimes it just didn't make sense to blindly follow a rule or guideline.

You have a brain, and using it is the most important thing to remember at anytime. Projects can't follow cookie cutter rules. Even the "Apache Way", as I've discovered, means different things to different people, often at different times.

So take my advice here with a grain of salt, and use your brain to figure out what's actually important to you, your project and it's community. Good luck!

Hypothetical Labs: Part 1: Introducing riak_core

Fri, 30 Jul 2010 17:30:09 +0000

What is riak_core?

riak_core is a single OTP application which provides all the services necessary to write a modern, well-behaved distributed application. riak_core began as part of Riak. Since the code was generally useful in building all kinds of distributed applications we decided to refactor and separate the core bits into their own codebase to make it easier to use.

Distributed systems are complex and some of that complexity shows in the amount of features available in riak_core. Rather than dive deeply into code, I’m going to separate the features into broad categories and give an overview of each.

Note: If you’re the impatient type and want to skip ahead and start reading code, you can check out the source to riak_core via hg or git.

Node Liveness & Membership

riak_core_node_watcher is the process responsible for tracking the status of nodes within a riak_core cluster. It uses net_kernel to efficiently monitor many nodes. riak_core_node_watcher also has the capability to take a node out of the cluster programmatically. This is useful in situations where a brief node outage is necessary but you don’t want to stop the server software completely.

riak_core_node_watcher also provides an API for advertising and locating services around the cluster. This is useful in clusters where nodes provide a specialized service, like a CUDA compute node, which is used by other nodes in the cluster.

riak_core_node_watch_events cooperates with riak_core_node_watcher to generate events based on node activity, i.e. joining or leaving the cluster, etc. Interested parties can register callback functions which will be called as events occur.

Partitioning & Distributing Work

riak_core uses a master/worker configuration on each node to manage the execution of work units. Consistent hashing is used to determine which target node(s) to send the request and the master process on each node farms out the request to the actual workers. riak_core calls worker processes vnodes. The coordinating process is the vnode_master.

The partitioning and distribution logic inside riak_core also handles hinted handoff when required. Hinted handoff occurs as a result of a node failure or outage. In order to assure availability, most clustered systems will use operational nodes in place of down nodes. When the down node comes back the cluster needs to migrate the data from its temporary home on the substitute nodes to the data’s permanent home on the restored node. This process is called hinted handoff and is managed by components inside riak_core. riak_core also handles migrating partitions to new nodes when they join the cluster such that all work continues to be evenly partitioned to all cluster members.

riak_core_vnode_master starts all the worker vnodes on a given node and routes requests to
the vnodes as the cluster runs.

riak_core_vnode is an OTP behavior wrapping all the boilerplate logic required to implement a vnode. Application-specific vnodes need to implement a handful of callback functions in order to participate in handoff sessions and receive work units from the master.

Cluster State

A riak_core cluster stores global state in a ring structure. The state information is transferred between nodes in the cluster in a controlled manner to keep all cluster members in sync. This process is referred to as “gossiping”.

riak_core_ring is the module used to create and manipulate the ring state data shared by all nodes in the cluster. Ring state data includes items like partition ownership and cluster-specific ring metadata. Riak KV stores bucket metadata in the ring metadata, for example.

riak_core_ring_manager manages the cluster ring for a node. It is the main entry point for application code accessing the ring, via riak_core_ring_manager:get_my_ring/1, and also keeps a persistent snapshot of the ring in sync with the current ring state.

riak_core_gossip manages the ring gossip process and insures the ring is generally consistent across the cluster.
What’s the plan?

Over the next several months I’m going to cover the process of building a real application in a series of posts to this blog where each post covers some aspect of system building with riak_core. All of the source to the application will be published under the Apache2 licensed and shared via a public repo on github.

And what type of application will we build? Since the goal of this series is to illustrate how to build distributed systems using riak_core and also satisfy my own technical curiosity I’ve decided to build a distributed graph database. A graph database should provide enough use cases to really exercise riak_core while at the same time not obscuring the core learning experience in tons of complexity.

Thanks to Sean Cribbs and Andy Gross for providing helpful review and feedback.

Learn You Some Erlang: Errors and Processes

Thu, 29 Jul 2010 12:30:00 +0000

Errors and Processes might be the last chapter released before Learn You Some Erlang hits its one year mark (see: http://ferd.ca/learn-you-some-erlang-a-year-in.html). Thanks to all dedicated readers and reviewers. This chapter covers the building blocks of error management with concurrent Erlang: linking processes together, handling different signals sent between processes when they crash, monitoring actors and naming them. This should be the last material required before we build a real concurrent application in Erlang.

Programming in the 21st Century: Stop the Vertical Tab Madness

Thu, 29 Jul 2010 06:00:00 +0000

In One Small Step Toward Reducing Programming Language Complexity I added "Who even knows what "\v" (vertical tab) does?" as an off the cuff comment. Re-reading that made me realize something that's blatantly obvious in retrospect, so obvious that I've gone all this time without noticing it:

No one is actually using the vertical tab escape sequence.

And I truly mean "no one." If I could stealthily patch the compiler for any language supporting the "\v" escape so I'd receive mail whenever it occurred in source code, then I could trace actual uses of it. I'm willing to bet that all the mail would come from beginners trying to figure out what the heck "\v" actually does, and then giving up when they realize it doesn't do anything. That's because it doesn't do anything, except with some particular printers and terminal emulators, and in those cases you're better off not relying on it anyway.

And yet this crazy old feature, one that no one understands or uses, one that doesn't even do anything in most cases, not only gets special syntax in modern programming languages, it's consistently given space in the documentation, even in tutorials. It's in the official Lua docs. It's in MIT web course notes about printf. It's in the books Programming in Python 3 and Python Essential Reference. It's in an introduction to Python strings. It's in the standard Erlang documentation, too.

[Insert conspiracy theory involving the Illuminati here.]

Here's my simple plea: stop it. Stop mentioning vertical tabs in tutorials and language references. Drop the "\v" sequence in all future programming languages. Retroactively remove it from recent languages, like Python 3.0. Yes, ASCII character number 11 isn't going away, but there's no reason to draw attention to a relic of computing past.

Surprisingly, the "\v" sequence was removed from one language during the last decade: Perl. And even more surprisngly, there's a 2010 proposal to add escaped character sequences, including vertical tab, to the famously minimal language, Forth.

(If you liked this, you might like Kilobyte Constants, a Simple and Beautiful Idea that Hasn't Caught On.)

Joe's Blog: SurgeCon 2010

Wed, 28 Jul 2010 03:00:34 +0000

If you haven’t heard about Surge, it’s a new web operations conference presented by the smart folks at OmniTI. They have amassed a good list of speakers including guys like John Allspaw and Theo Schlossnagle. I also happen to have been invited to talk about the cloud, Cloudant and all sorts of good stuff.

Damien Katz: CouchCamp is Coming Soon!

Mon, 26 Jul 2010 17:10:07 +0000

CouchCamp, September 8-10

This is the place to be to learn and hack on Apache CouchDB. In honor of the recent 1.0 release, for a limited time it's only $500, with accommodations.

In addition to unconference style discussions, we've got some great speakers: Selena Deckelman, Stuart Langridge, Ted Leung, Josh Berkus, Dion Almaer and me :)

One thing I'm really excited to talk about is our work porting CouchDB to mobile platforms. Android, iOS, RIM, etc. We've got some very cool stuff coming :)

Programming in the 21st Century: One Small Step Toward Reducing Programming Language Complexity

Sat, 24 Jul 2010 06:00:00 +0000

I've taught Python a couple of times. Something that experience made clear to me is just how many concepts and features there are, even in a language designed to be simple. I kept finding myself saying "Oh, and there's one more thing..."

Take something that you'd run into early on, like displaying what's in a dictionary:

for key, value in dictionary.iteritems():
   print key, value

Tuples are a bit odd in Python, so I put off talking about them as long as possible, but that's what iteritems returns, so no more dodging that. There's multiple assignment, too. And what the heck is iteritems anyway? Why not just use the keys method instead? Working out a clean path that avoids constant footnotes takes some effort.

This isn't specific to Python. Pick any language and it likely contains a larger interconnected set of features than it first appears. Languages tend to continually grow, too, so this just gets worse over time. Opportunities to reverse that trend--backward compatibility be damned!--would be most welcome. Let me propose one.

The humble string constant has a few gotchas. How to print a string containing quotes, for example. In Python that's easy, just use single quotes around the string that has double quotes in it. It's a little more awkward in Erlang and other languages. Now open the file "c:\my_project\input.txt" under windows. You need to type "c:\\my_projects\\input.txt", but first you've got to say "Oh, and there's one more thing" and explain about how backslashes work in strings.

Which would be fine...except the backslash notation for string constants is, in the twenty-first century, an anachronism.

Who ever uses "\a" (bell)? Or "\b" (backspace)? Who even knows what "\v" (vertical tab) does? The escape sequence that gets used more than all the others combined is "\n" (newline), but you rarely want to use it directly because end-of-line markers vary between operating systems. It's simpler to have a print function that puts a "return" at the end one that doesn't. Then there's "\t" (tab), but it has it's own set of quirks, and it's almost always better to use spaces instead. The price for supporting a feature that few people use is core confusion about what a string literal is in the first place. "The length of "\n\n" isn't four? What?"

There's an easy solution to all of this. Strings are literal, with no escapes of any kind. Special characters are either predefined constants (e.g., TAB, CR, LF) or created through a few functions (e.g., char(Value), unicode(Name)). Normal string concatenation pastes them all together. In Python:

"Content-type: text/plain" + NL + NL

In Erlang:

"Content-type: text/plain" ++ NL ++ NL

In both cases, the compiler mashes everything together into one string. There's no actual concatenation taking place at runtime.

Note that in Python you can get rid of backslash notation by preceding a string with the "r" character (meaning "raw"), like this:

r"c:\my_projects\input.txt"

But that adds another feature to the language, one to patch up the problems caused by the first.

(If you liked this, you might like In Praise of Non-Alphanumeric Identifiers.)

Erlang Inside: Erlang and REST – an interview with Steve Vinoski

Thu, 22 Jul 2010 12:23:21 +0000

Interview recorded at Erlang Factory, where Steve Vinoski discusses the key concepts of RPC frameworks such as CORBA, and how that compares to REST, and how Erlang fits into both worlds

Joe's Blog: Adding Health Checks to Deckard from Chef.

Mon, 19 Jul 2010 20:52:09 +0000

Recently, we (at Cloudant) open sourced Deckard, a HTTP content check monitoring system based on CouchDB. One of the best bits about using Couch is that it gives you a ReST API and with Deckard it can be used to add new health checks. Doing a simple PUT adds new URLs to monitor. At Cloudant we love Chef and use it for everything. Chef has things called resources and providers. Resources are abstractions that describe the state you want a machine to be in. Providers perform the actions described by a resource. A good example is using the package resource on Centos uses yum while on Ubuntu it uses apt-get. The resource abstracts that away, letting the provider (and node) deal with the specifics on how to install the package. This makes your recipes nice and DRY, use the same code to install packages on all sorts of platforms. There are resources and providers for anything from installing packages to even one I wrote for executing Erlang code via erl_call. One resource that works well with Deckard is the HTTP request resource, using it makes it very easy to add health checks from your cookbooks. We use something like the following code to add checks to new nodes at Cloudant:

This code will add the document describing the check to the monitor_content_check database and then create a file so we can use “not_if” and Chef won’t attempt to add the check twice. Pretty cool stuff and even more reason that everything should have an API. Even cooler than this example would be to use Chef Search to do the same thing but I’ll save that for another blog post.

Trapexit's Erlang Blog Filter: New Column, New Interview

Sat, 17 Jul 2010 18:01:47 +0000

A couple newsworthy items:

The July/August 2010 issue (PDF) of The Functional Web column is available, this time with guest columnist Aaron Bedra writing about using Clojure and the Compojure web framework on the Google App Engine platform. Pretty interesting read, and plenty of code examples.
Sadek Drobi interviewed me about Erlang and REST at Erlang Factory back in March, and the interview is now up at InfoQ.

Programming in the 21st Century: Free Your Technical Aesthetic from the 1970s

Sat, 17 Jul 2010 06:00:00 +0000

In the early 1990s, I used Unix professionally for a few years. It wasn't the official Unix, nor was it Linux, but Sun's variant called SunOS. By "used" I mean I wrote commercial, embedded software entirely a Unix environment. I edited 10,000+ line files in vi. Not vim. The original "one file loaded at a time" vi.

At the time, Unix felt clunky and old. I spent a lot of time in a library room down the hall, going through the shelves of manuals. It took me a long time to discover the umask command for changing the default file permissions and to understand the difference between .bashrc and .bash_profile and how to use tar.

By way of comparison, on my home PC I used a third-party command shell called 4DOS (later 4NT, and it's still available for Windows 7 as TCC LE). It had a wonderful command line history mechanism: type part of a command, then press up-arrow. The bash bang-notation felt like some weird mainframe relic. 4DOS had a built-in, full-screen text file viewer. The Unix equivalent was the minimalist less command. 4DOS help was colorful and pretty and hyperlinked. Documentation paged through as man pages was several steps backward.

The Unix system nailed the core tech that consumer-level computers were way behind on: stability and responsiveness in a networked, multitasking environment. It was ugly, but reliable.

In 2006, I got back into using Unix again (aside from some day-job stuff with Linux ten years ago) in the guise of OS X on a MacBook. The umask command is still there. Ditto for .bashrc and .bash_profile and all the odd command line switches for tar and the clunky bang-notation for history. I'm torn between wonderment that all those same quirks and design choices still live on...and shocked incredulity that all those same quirks and design choices live on.

Enough time has passed since the silly days of crazed Linux advocacy that I'm comfortable pointing out the three reasons Unix makes sense:

1. It works.
2. It's reliable.
3. It stays constant.

But don't--do not--ever, make the mistake of those benefits being a reason to use Unix as a basis for your technical or design aesthetic. Yes, there are some textbook cases where pipelining commands together is impressive, but that's a minor point. Yes, having a small tool for a specific job sometimes works, but it just as often doesn't. ("Those days are dead and gone and the eulogy was delivered by Perl," Rob Pike, 2004.) Use Unix-like systems because of the three benefits above, and simultaneously realize that it's a crusty old system from a bygone era. If you put it up on a pedestal as a thing of beauty, you lose all hope of breaking away from a sadly outdated programmer aesthetic.

(If you liked this, you might like My Road to Erlang.)

Erlang Factory News: Erlang User Conference 2010 Talk Submission Open!

Wed, 14 Jul 2010 19:46:14 +0000

The 2010 Erlang User Conference in Stockholm will be held on Tuesday 16th November 2010. The venue will again be the Old Astoria Cinema in Nybrogatan.

On Monday November 15th there will be a day of tutorials. This will allow delegates to again optimise their visit to Stockholm to take in both these events.

We have opened the submissions page. To submit a proposal for a talk or tutorial, visit the Talk Submission page.

More details will be forthcoming in the near future. Keep a look out or join the Erlang Factory Mailing list!

Programming in the 21st Century: Explaining Functional Programming to Eight-Year-Olds

Fri, 09 Jul 2010 06:00:00 +0000

"Map" and "fold" are two fundamentals of functional programming. One of them is trivially easy to understand and use. The other is not, but that has more to do with trying to fit it into a particular view of functional programming than with it actually being tricky.

There's not much to say about map. Given a list and a function, you create a new list by applying the same function to each element. There's even special syntax for this in some languages which removes any confusion about whether the calling sequence is map(Function, List) or map(List, Function). Here's Erlang code to increment the values in List:

[X + 1 || X <- List]

Fold, well, it's not nearly so simple. Just the description of it sounds decidedly imperative: accumulate a result by iterating through the elements in a list. It takes three parameters: a base value, a list, and a function. The last of these maps a value and the current accumulator to a new accumulator. In Erlang, here's a fold that sums a list:

lists:foldl(fun(X, Sum) -> X + Sum end, 0, List)

It's short, but it's an awkward conciseness. Now we've two places where the parameter order can be botched. I always find myself having to stop and think about the mechanics of how folding works--and the difference between left and right folding, too (lists:foldl is a left fold). I would hardly call this complicated, but that step of having to pause and run through the details in my head keeps it from being mindlessly intuitive.

Compare this to the analog in array languages like APL and J. The "insert" operation inserts a function between all the elements of a list and evaluates it. Going back to the sum example, it would be "+/" in J, or "insert addition." So this:

1 2 3 4 5 6

turns to this:

1 + 2 + 3 + 4 + 5 + 6

giving a result of 21. The mechanics here are so simple that you could explain them to a class of second graders and not worry about them being confused. There's nothing about iterating or accumulating or a direction of traversal or even parameters. It's just...insertion.

Now there are some edge cases to worry about, such as "What does it mean to insert a function between the elements of a list of length 1"? Or an empty list for that matter. The standard array language solution is to associate a base value with operators, like addition, so summing a list containing the single value 27 is treated as 0 + 27. I'm not going to argue that APL's insert is more general than fold, because it certainly isn't. You can do all sorts of things with the accumulator in a traditional fold (for example, computing the maximum and minimum values of a list at the same time).

But in terms of raw simplicity of understanding, insert flat-out beats fold. That begs the question: Is the difficulty many programmers have in grasping functional programming inherent in the basic concept of non-destructively operating on values, or is it in the popular abstractions that have been built-up to describe functional programming?

(If you liked this, you might like Functional Programming Archaeology.)

Erlang Inside: PostgreSQL Erlang client library epgsql supports asynchronous messages from LISTEN/NOTIFY events

Thu, 08 Jul 2010 19:27:05 +0000

If you use PostgreSQL with Erlang, you're probably already familiar with the epgsql client library. Something that slipped my attention was the addition of...

Erlware: A Brief Overview of Concurrency.

noreply@blogger.com (Eric Merritt) — Thu, 08 Jul 2010 16:33:57 +0000

Introduction Over the last few weeks I have had several conversations with people about concurrency, more specifically the ways in which shared information is handled in concurrent languages. I have gotten the impression that there isn't really a good understanding of whats out there in the world of concurrency. That being the case it would be a good idea to just give a quick overview of some of

Process-one Blogs: ProcessOne releases OneCached, a Memcached in erlang

Mon, 05 Jul 2010 16:29:53 +0000

ProcessOne has just released OneCached, a Memcached server and client implementation written in Erlang.

OneCached is a new Memcached server and client implementation written from scratch in Erlang by ProcessOne.

From the Memcached website:

What is Memcached?

Free & open source, high-performance, distributed memory object caching system, generic in nature, but intended for use in speeding up dynamic web applications by alleviating database load.

Memcached is an in-memory key-value store for small chunks of arbitrary data (strings, objects) from results of database calls, API calls, or page rendering.

Memcached is simple yet powerful. Its simple design promotes quick deployment, ease of development, and solves many problems facing large data caches. Its API is available for most popular languages.

OneCached supports the set, add, replace, get, incr, decr, delete, flush_all and quit commands. It doesn't handle expiration time.

You call pull the source code from the public repository at: https://git.process-one.net/onecached

git clone git://git.process-one.net/onecached/mainline.git

To compile, just run make, and to start, just type:

bin/onecachedctl start

OneCached is released under the Erlang Public License (EPL), version 1.1. It is available from ProcessOne Labs.

Erlang Inside: New Erlang job board – totally-erlang.com

Mon, 05 Jul 2010 11:27:25 +0000

The Zotonic guys put together a new Erlang job board at http://totally-erlang.com/

RedHotErlang: Playing with LFE macros

Sat, 03 Jul 2010 06:48:46 +0000

Summertime, it's warm, it's sunny, I'm on vaccation, it's [LFE][1]-time. [Lisp macros][2] are cool. With a Lisp macro you do program transformations where you have the full language available to express these transformations. This means that you *ea...

Programming in the 21st Century: What Do People Like?

Thu, 01 Jul 2010 06:00:00 +0000

I wrote Flickr as a Business Simulator in earnest, but I think it was interpreted more as a theoretical piece. When you build something with the eventual goal of releasing it to the world, the key question is "Will people like this?" And, really, you just won't know until you do it. There's nothing like the actions of tens of thousands of independently acting individuals who have no regard for your watertight theories. What Flickr provides is a way to make lots of quick little "product" releases, and see if your expectations line up with reality. Is this my primary use of Flickr? No! But the educational opportunity is there, regardless. Click on a photo to go to the Flickr page.

The rest of this entry is an annotated list of some photos I've posted to Flickr, with both my conjectures of how they'd be received and what actually happened. In each case the photo comes first with the commentary following.

I sat on this photo for a while after shooting it. I thought it was cliche, something everyone had already seen many times. A real photographer wouldn't bother to recreate such an image. Then I posted it...and it got an immediate string of comments and favorites. It's still one my top ten overall Flickr photos according to the stats system. My invented emphasis on originality didn't matter.

I thought these skid marks in front of a local liquor superstore were photoworthy, but the result didn't grab me. Like the sunset wheat photo, it took on a life of its own on Flickr. Was the hook in the impossibility of those tire tracks? That they look like a signature? Why was I unable to see the appeal before uploading it? It even ended up--with permission--in Scott Berkun's The Myths of Innovation (O'Reilly, 2007).

This one I liked immediately. The red arrow. The odd framing. The blown-out white background that makes the rust pop. The Flickr reaction...well there wasn't one. Is the industrial decay photo niche saturated? Would it have been a hit if I worked at getting hundreds of dedicated followers first? Or maybe I like it because it's better than other photos I've taken recently, but not all that great in absolute terms?

Oh so cleverly titled "I'm Lovin' IT!" I knew this was a novelty. It pulled in some novelty linkage as a ha-ha photo of the day sort of thing. It didn't get anywhere near the exposure of that Yahoo ad next to the 404 distance on a home run fence. The traffic from "I'm Lovin' IT!" was transient, adding points to the view counter, but as they weren't Flickr users they didn't add comments or favorites. In the end it was an empty success.

Process-one Blogs: Hosted.IM gets gateways to legacy IM systems

Wed, 30 Jun 2010 15:08:08 +0000

The XMPP service for your domains has just received a much demanded feature: gateways to legacy IM systems.

Hosted.IM is the cloud service for everything IM, by ProcessOne. This service is free for up to 5 users teams.

We have added gateways to main legacy IM systems in the world:

AOL: aol.hosted.im
ICQ: icq.hosted.im
MSN: msn.hosted.im
Twitter: twitter.hosted.im
Yahoo: yahoo.hosted.im

These gateways are also free for up to 5 users teams.

Erlang Inside: erldocs.com updated with R14A support, mochiweb, and available for your own projects

Tue, 29 Jun 2010 12:53:43 +0000

Dale Harvey just recently updated erldocs.com with R14A support. If you are doing any erlang development, or even looking to just learn a bit about erlang, I highly recommend using erldocs over the official documentation.

Programming in the 21st Century: Tricky When You Least Expect It

Tue, 29 Jun 2010 06:00:00 +0000

Here's a problem: You've got a satellite dish that can be rotated to any absolute angle from 0 to 360 degrees. If you think of the dish as being attached to a pole sticking out of the ground, that's what the dish rotates around. Given a starting angle and a desired angle, how many degrees do you rotate the dish by?

An example should clarify this. If the initial angle is 0 degrees, and the goal is to be at 10 degrees, that's easy. You rotate by 10 degrees. If you're at 10 degrees and you want to end up at 8 degrees, then rotate -2 degrees. It looks at lot like all you have to do is subtract the starting angle from the ending angle, and that's that.

But if the starting angle is 10 and the ending angle is 350...hmmm. 350 - 10 = 340, but that's the long way around. No one would do that. It makes more sense to rotate by -20 degrees. With this in mind and some experimenting, here's a reasonable looking solution (in Erlang, but it could easily be any language):

angle_diff(Begin, End) ->
   D = End - Begin,
   DA = abs(D),
   case DA > 180 of
      true -> -(360 - DA);
      _ -> D
   end.

It seems to cover some quickie test cases, including those listed above. Now try angle_diff(270, 0). The expected answer is 90. But this function returns -90. Oops.

This is starting to sound like the introduction to a book by Dijkstra. He'd have called this problem solving method "guessing," and it's hard to disagree with that assessment. When I run into problems like this that look so simple, and I feel like I'm randomly poking at them to get the right answers, I'm always surprised. So many messy problems are solved as part of the core implementation or standard library in most modern languages, that it's unusual to run into something this subtle.

In Python or Erlang I never worry about sorting, hash functions, heap management, implementing regular expressions, fancy string comparison algorithms such as Boyer-Moore, and so on. Most of the time I write fairly straightforward code that's just basic logic and manipulation of simple data structures. Behind the scenes, that code is leaning heavily on technically difficult underpinnings, but that doesn't change how pleasant things are most of the time. Every once in a while, though, the illusion of all the hard problems being solved for me is shattered, and I run into something that initially seems trivial, yet it takes real effort to work out a correct solution.

Here's a version of the angle_diff function that handles the cases the previous version didn't:

angle_diff(Begin, End) ->
   D = End - Begin,
   DA = abs(D),
   case {DA > 180, D > 0} of
      {true, true} -> DA - 360;
      {true, _}    -> 360 - DA;
      _ -> D
   end.

Don't be surprised if it takes some thought to determine if this indeed handles all cases.

(If you liked this, you might like Let's Take a Trivial Problem and Make it Hard.)

BGH's Blog: Erlang Programming Exercise: 5-2

Mon, 28 Jun 2010 15:19:28 +0000

Exercise 5-2 involves changing the frequency server from earlier in the chapter. Here is the task list:

Restrict the deallocation of a frequency so that only the client that allocated it can deallocate it.
Fix a bug: Deallocating a frequency that isn't allocated crashes the server
Only allow shutdown of the frequency server if there are no allocated frequencies
Limit the number of frequencies a client can allocate to 3

I worked through the tasks and then had a bit of fun with the server. I changed the shutdown sequence so that deallocations work while shutting down but allocations return an error. Once all of the outstanding frequencies have been returned it will complete the shutdown.

As you can see in the code below, I was playing around with typer and dialyzer. Please take a look and let me know if you have any suggestions.

Thanks!
Halzy

[erlang]
-module(frequency).
-export([start/0, stop/0, allocate/0, deallocate/1, deallocate_all/0]).

-export([init/0]).

-define(SERVER, ?MODULE).

-type frequency() :: pos_integer().
-type used_frequency() :: { frequency(), pid() }.

-record(state, {
free = [] :: [frequency()],
allocated = [] :: [used_frequency()],
shutting_down = false :: boolean(),
max_allocations = 3 :: pos_integer()
}).

%% These are the start functions used to create and
%% initialize the server.

start() ->
register(?SERVER, spawn(?MODULE, init, [])).

-spec init() -> ok.
init() ->
State = #state{
free=get_frequencies()
},
loop(State).

% Hard Coded
-spec get_frequencies() -> [frequency()].
get_frequencies() ->
[10, 11, 12, 13, 14, 15].

%% The client Functions

-spec stop() -> ok.
stop() ->
call(stop).

-spec allocate() -> {error, atom()} | pos_integer().
allocate() ->
call(allocate).

-spec deallocate(frequency()) -> ok.
deallocate(Freq) ->
call({deallocate, Freq}).

-spec deallocate_all() -> ok.
deallocate_all() ->
call(deallocate_all).

%% We hide all message passing and the message
%% protocol in a functional interface

call(Message) ->
?SERVER ! {request, self(), Message},
receive
{reply, Reply} ->
Reply
end.

%% The Main Loop

-spec loop(#state{}) -> ok.
%% [bgh] if we are shutting down, and have no outstanding frequencies, end
loop(#state{shutting_down=true, allocated=[]}) ->
ok;
loop(#state{shutting_down=ShuttingDown}=State) ->
receive
{request, Pid, allocate} when false==ShuttingDown ->
{UpdatedState, Reply} = allocate(State, Pid),
reply(Pid, Reply),
loop(UpdatedState);
{request, Pid, stop} when false==ShuttingDown ->
reply(Pid, ok),
loop(State#state{shutting_down=true});
{request, Pid, {deallocate, Freq}} ->
UpdatedState = deallocate(State, Pid, Freq),
reply(Pid, ok),
loop(UpdatedState);
{request, Pid, deallocate_all} ->
UpdatedState = deallocate_all(State, Pid),
reply(Pid, ok),
loop(UpdatedState);
{request, Pid, _} when true == ShuttingDown ->
reply(Pid, {error, shutting_down}),
loop(State)
end.

reply(Pid, Reply) ->
Pid ! {reply, Reply}.

%% The Internal Help Functions used to allocate and
%% deallocate frequencies.

-spec allocate(#state{free::[]}, pid()) ->
{#state{}, {error, no_frequency}};
(#state{free::[frequency(),...]}, pid()) ->
{#state{}, {error, max_allocations}} |
{#state{}, {ok, frequency()}}.
allocate(#state{free=[]}=State, _Pid) ->
{State, {error, no_frequency}};
allocate(#state{free=[Freq|Free], allocated=Allocated}=State, Pid) ->
case can_allocate(Allocated, Pid, State#state.max_allocations) of
false ->
{State, {error, max_allocations}};
true ->
{State#state{free=Free, allocated=[{Freq, Pid}|Allocated]}, {ok, Freq}}
end.

-spec deallocate(#state{}, pid(), frequency()) -> #state{}.
deallocate(#state{free=Free, allocated=Allocated}=State, Pid, Freq) ->
case lists:keytake(Freq, 1, Allocated) of
false ->
State;
{value, {Freq, Pid}, NewAllocated} ->
State#state{free=[Freq|Free], allocated=NewAllocated};
{value, {Freq, _WrongPid}, _NewAllocated} ->
State
end.

-spec pid_match(used_frequency(), pid()) -> boolean().
pid_match({_Freq, Pid}, Pid) -> true;
pid_match({_Freq, _OtherPid}, _Pid) -> false.

-spec deallocate_all(#state{}, pid()) -> #state{}.
deallocate_all(#state{free=Free, allocated=Allocated}=State, Pid) ->
{ToDeallocate, UpdatedAllocated} = lists:partition(fun(Elem) -> pid_match(Elem, Pid) end, Allocated),
{ReleasedFreqs, _Pids} = lists:unzip(ToDeallocate),
UpdatedFree = ReleasedFreqs ++ Free,
State#state{free=UpdatedFree, allocated=UpdatedAllocated}.

-spec can_allocate([used_frequency()], pid(), pos_integer()) -> boolean().
can_allocate(Allocated, Pid, MaxFrequencies) ->
{PidFrequencies, _Other} = lists:partition(fun(Elem) -> pid_match(Elem, Pid) end, Allocated),
length(PidFrequencies) MaxFrequencies.
[/erlang]

Erlang Inside: Spanish Language Erlang List

Fri, 25 Jun 2010 01:52:50 +0000

If you’re looking for Spanish language group to discuss Erlang, Mariano Guerra recently started “ErlAr“, a mailing list for all things Erlang, but in Castellano. Mariano is the author of Efene, a Javascript-syntax language that compiles to Erlang bytecode. I’m planning an interview with Mariano on Efene soon. There is a small but growing group [...]

1011 Ltd Blog: Elegant XML SAX parsing using Erlang's pattern matching

Thu, 24 Jun 2010 17:00:00 +0000

Yesterday I wrote some code for parsing an XML file with Erlang's built-in SAX parser. It turned out that the events generated by the SAX parser, combined with the pattern matching in Erlang yielded a really elegant solution.

Learn You Some Erlang: More On Multiprocessing

Thu, 24 Jun 2010 00:00:00 +0000

This chapter's a bit of an extension on the practical aspects of the Hitchhiker's Guide to Concurrency. New multiprocessing and concurrent aspects of Erlang are seen, including how to hold state in processes, useful abstractions when passing messages, how to handle timeouts and then selective receives for prioritizing messages. I'm publishing this chapter in English on the night of our French-Canadian national holiday, so enjoy!

Process-one Blogs: Case study: Arc International

Wed, 23 Jun 2010 10:22:20 +0000

Arc International has migrated away from a proprietary solution to the open source, and open standards ejabberd and Psi, realising cost-savings and productivity increase.

Arc International is well known for distributing famous tableware brands such as Luminarc®, Arcoroc, Chef&Sommelier, Pyrex and Cristal d’Arques Paris. With 12,000 employees around the world, from Europe to Asia, and the Middle East to North America, they needed to lower the costs of their previous solutions.

They have chosen ejabberd, as an open-source, scalable XMPP platform. In conjunction, with the Psi cllent Arc International has achive their goals of cost-savings and high-quality service.

The cost-savings have benefitted from a lower TCP on IT, as well as reduced telephone bills, while providing a same feature-set to the employees worldwide.

Read our case study on the website, or as a PDF (582 KB).

RedHotErlang: Dizzy thoughts

Tue, 22 Jun 2010 20:52:43 +0000

On the bus home today I was reading the first chapter of [Programming Clojure][1]. The text, which is excellent, discuss the motives behind Clojure. The bus however, was stinking hot and I started to doze off. I was in a strange state of being half a...

Damien Katz: Migrating From MySQL to CouchDB

Tue, 22 Jun 2010 18:08:51 +0000

Here is a detailed white paper from John P. Woods of Interactive Mediums, going into depth about their migration of their mobile marketing archive from MySQL to CouchDB.

http://www.couch.io/migrating-to-couchdb

Damien Katz: CouchCamp, aka BurningCouch!

Tue, 22 Jun 2010 17:12:57 +0000

Registration for CouchCamp is now open. CouchCamp is our conference about CouchDB, September 8th - 10th 2010 at Walker Creek Ranch, north of the Bay area.

This is the event to learn all about CouchDB and it's innards, the community, and how much beer I can drink before hurling. It's going to be fun!

RedHotErlang: Permutations

Sun, 20 Jun 2010 15:29:41 +0000

Permutations ========== Permuting things is fun. Rearranging all the furniture's in a room is one kind of permutation. Generating all combinations of the string "ABC" will give you five more strings. "ACB" "BAC" "BCA" "CAB" "CBA" In general you w...

Erlang Eclipse IDE: [erlide] Regular update site upgraded

vladdu@users.sourceforge.net (Vlad Dumitrescu) — Sat, 19 Jun 2010 20:21:55 +0000

The regular update site at http://erlide.org has been updated to the now not so new p2 update manager format. Only the latest 0.8.3 build is available there.

Older stable releases are to be found at http://erlide.org/update_classic, if needed.

This is so that we can appear on the Eclipse marketplace, which will be integrated in Eclipse in the upcoming 3.6 version.

regards,
Vlad

RedHotErlang: Erlang Factory, London 2010

Sat, 19 Jun 2010 17:22:08 +0000

I went to London recently to attend the Erlang Factory conference. We were a bunch of people coming from [Klarna][1], as you can see below: [1]: http://www.klarna.com/ <img width="50%" src="/blob/ab62b2625d4ec6b6f16b631508b87c48"/> And if you do s...

Damien Katz: How Software Is Built: Apache CouchDB

Fri, 18 Jun 2010 18:31:23 +0000

Here is a detailed interview I recently did for HowSoftwareIsBuilt.com about CouchDB, document databases, cloud and replication:

http://howsoftwareisbuilt.com/2010/06/18/interview-with-damien-katz-apache-couchdb/

1011 Ltd Blog: HOWTO Choose a NoSQL Database

Fri, 18 Jun 2010 13:30:00 +0000

The past year has seen an EXPLOSION in NoSQL databases. It feels like every month there a new contender to consider. The choice is fantastic, but can also be problematic. If there are so many options, how do you choose which one fits your problem the best? The most information I've seen to date focusses on the features and performance of each. Those are important, but...

Erlang Factory News: Erlang User Conference Date Announced

Fri, 18 Jun 2010 10:45:49 +0000

The 2010 Erlang User Conference in Stockholm will be held on Tuesday 16th November 2010. The venue will again be the Old Astoria Cinema in Nybrogatan.

On Monday 15th November there will be a ProTest (Property-based Testing) seminar series held at the Ericsson conference faciilities. This will allow delegates to again optimise their visit to Stockholm to take in both these events.

More details will be forthcoming in the near future. Keep a look out!

Erlang Eclipse IDE: [erlide] Dropped support for R11

vladdu@users.sourceforge.net (Vlad Dumitrescu) — Thu, 17 Jun 2010 12:51:46 +0000

Version 0.8.1.201005250801 is the last to support R11, unless it will be required by enough users (or payed for with enough beers!) This is because R14 can no longer load R11 beam files and we don't have resources to keep two tracks alive.

Version 0.8.3.201006171129 is functionally identical except that the Erlang code is compiled with R12.

regards,
Vlad

Trapexit News Feed: Trapexit News :: tryerlang.org is Live!

Wed, 16 Jun 2010 13:31:28 +0000

Author: admin
Subject: tryerlang.org is Live!
Posted: Wed Jun 16, 2010 1:29 pm (GMT 0)
Topic Replies: 0

tryerlang.org is an interactive hands-on tutorial that allows you to try the power of Erlang directly in the browser. Try the power of the Erlang shell without installing anything to your machine! Visit: http://www.tryerlang.org

Erlware: Build Process Integration

noreply@blogger.com (Eric Merritt) — Wed, 16 Jun 2010 08:52:05 +0000

IntroductionThis post isn't going to be Erlang or Language oriented at all. One of my other hobbies revolves around the build process and build process tools. Over the last few years I have been spending a lot of time thinking about improving them, making the build process more transparent etc. I have a way to do that, I believe. Unfortunately, it would take the cooperation of build too

Damien Katz: Miscellaneous CouchDB News

Tue, 15 Jun 2010 16:58:21 +0000

Awesome New Hires: We've recently hired Volker Mische of GeoCouch, and CouchDB contributor Filipe Manana. These guys are damn good!

CouchDB Case Study: Anologue

"It was difficult to continue programming at times, as I could hardly see through the tears of joy."
- Jon Adams, Chief Architect of Anologue

CouchCamp: September 8th - 10th 2010 Registration will open soon.

1011 Ltd Blog: CV Bling

Mon, 14 Jun 2010 21:55:00 +0000

I love mainting my CV. As much as I love doing the dishes. This time around though, I'm hoping to make things a little bit more exciting and a little bit less painful for the future.

Programming in the 21st Century: A Ramble Through Erlang IO Lists

Sun, 13 Jun 2010 06:00:00 +0000

The IO List is a handy data type in Erlang, but not one that's not often discussed in tutorials. It's any binary. Or any list containing integers between 0 and 255. Or any arbitrarily nested list containing either of those two things. Like this:

[10, 20, "hello", <<"hello",65>>, [<<1,2,3>>, 0, 255]]

The key to IO lists is that you never flatten them. They get passed directly into low-level runtime functions (such as file:write_file), and the flattening happens without eating up any space in your Erlang process. Take advantage of that! Instead of appending values to lists, use nesting instead. For example, here's a function to put a string in quotes:

quote(String) -> $" ++ String ++ $".

If you're working with IO lists, you can avoid the append operations completely (and the second "++" above results in an entirely new version of String being created). This version uses nesting instead:

quote(String) -> [$", String, $"].

This creates three list elements no matter how long the initial string is. The first version creates length(String) + 2 elements. It's also easy to go backward and un-quote the string: just take the second list element. Once you get used to nesting you can avoid most append operations completely.

One thing that that nested list trick is handy for is manipulating filenames. Want to add a directory name and ".png" extension to a filename? Just do this:

[Directory, $/, Filename, ".png"]

Unfortunately, filenames in the file module are not true IO lists. You can pass in deep lists, but they get flattened by an Erlang function (file:file_name/1), not the runtime system. That means you can still dodge appending lists in your own code, but things aren't as efficient behind the scenes as they could be. And "deep lists" in this case means only lists, not binaries. Strangely, these deep lists can also contain atoms, which get expanded via atom_to_list.

Ideally filenames would be IO lists, but for compatibility reasons there's still the need to support atoms in filenames. That brings up an interesting idea: why not allow atoms as part of the general IO list specification? It makes sense, as the runtime system has access to the atom table, and there's a simple correspondence between an atom and how it gets encoded in a binary; 'atom' is treated the same as "atom". I find I'm often calling atom_to_list before sending data to external ports, and that would no longer be necessary.

Erlang at Work: epgsql Moved to GitHub

noreply@blogger.com (Will Glozer) — Mon, 07 Jun 2010 22:43:20 +0000

epgsql development has picked up steam in the past few days with changes to support some of the upcoming features of PostgreSQL 9.0, bug fixes, and support for delivering asynchronous notices and notifications from the LISTEN/NOTIFY mechanism which will be much improved in PostgreSQL 9.0.

I've also moved development to GitHub since git has become my primary version control system. You'll find the new master repository here:

http://github.com/wg/epgsql

The old mercurial repositories will no longer be updated, but I'll leave them up for the time being. If you're a mercurial user please accept my apologies. I'm a big fan of hg but maintaining two repositories would be too much work, and git has a few killer features that convinced me to switch.

Joe's Blog: Just Opensourced: Gaff and Deckard

Fri, 04 Jun 2010 21:18:50 +0000

This post was stolen from my original post on the Cloudant blog.

Today we released two open source projects that have been in use internally at Cloudant for some time now, Gaff and Deckard.

All of our infrastructure is in the cloud and as such we need a way for disperate systems to all request resources, this is where Gaff comes in. Gaff is a pubsub daemon for asynchronously talking to cloud APIs using AMQP. Currently it supports a subset of the Dynect (DNS), Slicehost and EC2 APIs and uses geemus‘ awesome fog Ruby library. The basic workflow for Gaff is to send JSON-RPC formated messages to an AMQP exchange with a routing key corresponding to the API you are talking to, you could be sending these messages from a web application or another service. Each message gets routed to an API specific queue and is picked up by Gaff and turned into the appropriate API call, starting, stopping, modifying your servers on EC2 or elsewhere.

We have a lot of CouchDB instances to keep tabs on to do this we wrote Deckard. Deckard is a HTTP check monitoring system based on CouchDB. Yo dawg! What better than to monitor CouchDB with CouchDB (and some Ruby)? Deckard supports basic HTTP content checks, email alerts, SMS alerts (via email) for on-call rotations, basic maintenance scheduling, replication latency alerts (between two Couches) and even has EC2 Elastic IP support for failover between two EC2 instances. Best of all since it’s based on Couch you get an API for free, just PUT a doc in the HTTP checks database and you get a new HTTP check the next time Deckard runs.

Checkout these and my other projects on GitHub and follow Cloudant and myself on Twitter.

Process-one Blogs: ejabberd 2.1.4 and exmpp 0.9.4 bugfix releases

Fri, 04 Jun 2010 11:16:41 +0000

We are pleased to announce the bugfix releases ejabberd 2.1.4 and exmpp 0.9.4.

Regarding ejabberd 2.1.4:

Brief summary of changes:

Bounce messages when closing c2s session
Bugfixes when handling Service Discovery to contacts
Don't send error stanza as reply to error stanza
Don't store blocked messages in offline queue
Extauth: Optionally cache extauth users in mnesia
Full support for XEP-0115 Entity Capabilities v1.5
HTTP-Bind: Remove 100ms delay, export functions for prebinding methods
LDAP: Inband password change, Extensible match support, and ldap_tls_verify
Localization: Updated most translations
MUC: Refactor code to reduce calls to get_affiliation and get_role
ODBC: Add created_at column also to PostgreSQL schema
PAM: New option pam_userinfotype to provide username or JID
Pubsub: Send node notification. Enforce presence_based_delivery, show_values
Vcard: Automatic vcard avatar addition in presence
WebAdmin: New Access rule webadmin_view for read-only

Check the Release Notes for a more complete list of changes:

http://www.process-one.net/en/ejabberd/release_notes/release_note_ejabberd_2.1.4

If you upgrade from ejabberd 2.0.5 or older, read carefully the release notes of ejabberd 2.1.0 too, because there were several changes in the installation path and the configuration options.

The list of solved tickets since previous version is available on ProcessOne bug tracker:
http://redir.process-one.net/ejabberd-2.1.4

Download

ejabberd 2.1.4 is available as source code package and binary installers for Linux 32 bits, 64 bits, Mac OS X Intel, and Windows:
http://www.process-one.net/en/ejabberd/downloads

Regarding exmpp 0.9.4:

Brief summary of changes:

Add unexpected-request with cancel needed by pubsub
Caps: Add exmpp_caps to the compilation scripts
Caps: Move Caps erlang records to a header file
Handle the case that the payload is incorrectly defined in error stanzas
Preliminary documentation of functions from ejabberd 2 available in exmpp
Remove unexpected-request with cancel as this is pubsub specific
Support for SRV DNS query

exmpp home page:

http://support.process-one.net/doc/display/EXMPP/
or easier to remember: http://exmpp.org/

Download

Download exmpp 0.9.4 source code package from:

http://download.process-one.net/exmpp/

You can also check the ProcessOne Labs page:
http://www.process-one.net/en/labs/

Damien Katz: CouchDB on your TV

Fri, 04 Jun 2010 00:53:54 +0000

After initially getting rejected for sound issues, Google Ads has finally approved our awesome Couchio commercial.

GoogleAds Commercial Version

So we've aired this commercial 11 times so far, 5 times during Robot Chicken, twice duringAqua Teen Hunger Force, once during Tim and Eric's Awesome Show, Great Job! and 3 times on VH1.

It has gone to a total of 321,253 impressions, which means 321,253 people have seen Chris running like a lunatic around the streets of Oakland, singing the CouchDB praises.

This has cost us a total of $709.57!

Just saw a commercial for CouchDB. Seriously. I'm at a loss for words. #couchdb #couchio
@jrgarcia

Someday CouchDB will actually be inside your TV, you can watch CouchDB while watching your CouchDB TV from your couch.Yo dawg.

ejabberd@jabber.ru: ejabberd 2.1.4 - Fourth bugfix release

Wed, 02 Jun 2010 16:29:16 +0000

ejabberd 2.1.4 has been released. It contains many bugfixes and some improvements.

This is a short list of changes:

Bounce messages when closing c2s session
Bugfixes when handling Service Discovery to contacts
Don't send error stanza as reply to error stanza
Don't store blocked messages in offline queue
Extauth: Optionally cache extauth users in mnesia
Full support for XEP-0115 Entity Capabilities v1.5
HTTP-Bind (BOSH): Remove unneeded 100 ms delay, and export functions to facilitate prebinding methods

Process-one Blogs: ProcessOne at Google I/O: slides and photos

Tue, 01 Jun 2010 17:38:28 +0000

ProcessOne has joined the developer Sandbox in Google I/O 2010, in the wave area.

At the Google I/O event, we were sharing the space with innovative small business gadget products (Caseish, Twilio), as well as large companies demoing their use of the Wave protocol (Oracle, Salesforce, SAP, Novell).

ProcessOne set itself apart by demoing a working and federated implementation of the Google Wave protocol. The implementation has been made from scratch and demonstrates that the protocol can federate and work well between two completely different code bases (Google and ProcessOne).

Here are the slides explaining the scenario we were demoing on our pod:

WaveOne server and client by ProcessOne

View more presentations from Mickaël Rémond.

A few pictures form the event.

Moscone Center West:

In the Developers Sandbox:

Zoom to Wave pod:

An finally zoom to ProcessOne's booth:

Erlang Factory News: Only 1 week left!

Tue, 01 Jun 2010 09:46:00 +0000

There is only 1 week left to the Erlang Factory London. The Erlang University courses will start on 7th June and will be followed by the two-day Conference which starts on Thursday 10th.

There are still a few remaining places left on the Erlang University training courses: Erlang Express, Erlang OTP Express and Web Programming with Erlang.

If you haven't registered yet, you can still get a last minute seat - Book Now!

Joe's Blog: Beyond BigData.

Mon, 31 May 2010 16:54:23 +0000

BigData is a big deal. It’s changing how we look at data and analytics, but it isn’t the end. What are the enablers of BigData? First and foremost, cheap computing resources (CPU, disks, memory, bandwidth, etc) all thanks to Moore’s Law. Today even startups have the ability to afford huge amounts of computing power, the likes previously only the big boys could afford. Additionally, this has given rise to commodity hardware and cloud computing, which only furthers the proliferation of large amounts cheap, quickly-provisioned, computing resources. Second, to apply all that power, we have open source data processing systems based on years of distributed systems research, like Hadoop, and many incarnations of NoSQL. The development of open source data processing sytems has allowed proliferation of systems that scale, which only the highly capitalized could afford, until recently. These two things alone have allowed for the democratization of BigData. A guy in a garage can process terabytes of data with little more than a credit card and elbow grease.

With all these tools and recently acquired computing power, where are we going? Of course we can expect datasets to continue to grow, and the computational complexity of our data processing to increase, as well as compute power to continue to rise (GPGPUs, multicore and so on). In addition, I anticipate the emergence of something I’m calling NewData. NewData will build on what we have currently with the BigData, but will include some trends just beginning to take off. First, the development of ubiquitous public APIs (Meatcloud Manifesto). Public APIs have yet to proliferate to all online systems. As a consequence, there is still a lot of screen scraping going on. By having easily query-able and parse-able datasets available through ubiquitous APIs, consuming the internet with machines is easier making the application of BigData more powerful. Netflix is a good example of this. Second and similarly enabling will be the development of standardized public datasets. Current datasets are generally hard to find and use, standardized dataset formats will enable BigData analysis to be more productive and not waste time munging. Data.gov is a start. These two developments are yet to be fully realized in current systems but will allow for the rise of NewData. As these developments begin to roll out we will begin to see changes to how our BigData systems look. NewData systems will be less concerned with how big the data is and what it looks like, but will emphasize derivation of more information from the data. Bradford Cross gets this, and as a result FlightCaster is an early example of what I mean by NewData.

The scale of data and computations is an important issue, but the data age is less about the raw size of your data, and more about the cool stuff you can do with it.

Asking the right questions of the data is important, especially if you’re trying to do cool stuff. The Freakonomics guys proved this a few times over. NewData will be about creating value from data, and asking the right questions is worth as much as the answers. The key enablers of this will be using new found APIs and datasets to combine data from disperate sources in ways that BigData couldn’t. Asking questions that we wouldn’t have thought to ask of BigData. Where BigData was about a handful of datasets at most, NewData will be about dozens of datasets. The mashup is the cornerstone of NewData.

That being said, we will need new systems to process this data and enable us to ask these questions. NewData analysis will need inter-process communication and collaboration. Currently, systems like Hadoop process data by splitting the data up and processing chunks in parallel on hundreds to thousands of machines. Processes are isolated from the other processes. This will continue, but NewData will require more from these systems to ask deeper questions. Complex inter-process communication will be needed to ask these questions. Think of the simplicity of writing Map/Reduce jobs, the robustness of Hadoop, the workflow and dataflow of Cascading and DryadLINQ, respectively, and the power of a message passing system like MPI. These jobs will likely include large in-memory collaborative computations across thousands of machines. Where data locality was key in BigData, both data and memory-locality (NUMA/ccNUMA) will be important in NewData.

It is clear that BigData still has some runway before NewData takes over. However, if the trends in the democratization of compute and processing continue (beyond Hadoop and EC2), and the opening of APIs and datasets proliferate online and off, NewData and it’s new questions, mashups, and systems are inevitable. Where having readily available compute resources and the software to use it defined BigData, NewData will be defined solely by asking the right questions, the algorithms to derive answers, and the systems used to produce them.

Thanks to Mike Miller, Bradford Stephens and my awesome wife Erin for the help on this article.

Follow me on twitter.

RedHotErlang: Rebar template support for gettext

Sat, 29 May 2010 14:11:01 +0000

I have added [gettext][1] support to my [rebar templates][2]. This makes it very easy to internationalize a Nitrogen webapp. To show how this works I'll create a simple example. First, we create the project using rebar: [1]: http://github.com/etnt/g...

Erlware: Why Not To Use Distributed Supervision

noreply@blogger.com (Eric Merritt) — Thu, 27 May 2010 09:52:21 +0000

Let's take the example of distributed supervision. Let's say we have one supervisor on node A that supervises children on node B and node C. What happens if network throughput slows down on the connection from Node A to Node B? This isn't transparent to the Supervisor on Node A. What should the supervisor on Node A do in this case? It has no contact with node B, so it's unsure whether or not the

Damien Katz: High Performance CouchDB

Tue, 25 May 2010 18:47:06 +0000

At Couchio we are working with a company that makes high performance database appliances. These are complete system stacks where all the components, software and interconnects are carefully chosen, modified and optimized. They can deliver performance and scalability that's often an order of magnitude better than what can be accomplished by assembling your own systems with commodity components, and reducing overall hardware and admin costs.

So if you are a user of Apache CouchDB and are interested in high performance CouchDB servers, we'd love to talk with you to help us shape our plans and offerings, and potentially join an early adopters program. Email me at damien@couch.io.

Erlang Factory News: Early-Bird Registration Ends in Just ONE WEEK!

Mon, 24 May 2010 11:30:51 +0000

Early-Bird Registration for the Erlang Factory London 2010 ends on 31st May, so you have only one week to save up to £200 (incl. VAT)!

There are only 2 weeks left to the biggest Erlang gathering in London. List of the speakers, the tracks and talks as well as the programme of the conference are now available on www.erlang-factory.com/conference/London2010

Don't miss out and register today.

Process-one Blogs: WaveOne, a wave server and client by ProcessOne

Fri, 21 May 2010 14:00:41 +0000

WaveOne, the new wave server developped by ProcessOne, has been demoed at Google I/O.

ProcessOne has been invited to join the Wave area in Google Developer Sandbox at Google I/O 2010 in San Francisco.

Mickaël Rémond, the founder of ProcessOne, has been invited by Google in the context of the Google I/O event, to write a blog post to introduce WaveOne, our own wave server implementation.

WaveOne is basically an ejabberd module, so it is written in Erlang. It features an Operationnal Transform engine, as well as a Wave Store. It means that with the help of a client, you can - on your own WaveOne server installation - create, edit, store and share wavelets.

The WaveOne extension to our XMPP client OneTeam enables you to manage your wavelets (and blips), like create, edit, as well as add participants to wavelets, still on your own WaveOne server installation.

With the WaveOne client and server, you can collaborate in real-time internally, as well as externally, thanks to the federation capability. WaveOne supports federation with Google Wave in both directions. You can host the wavelets on your local server and have remote participants or you can do the reverse and participate to wavelets hosted on the Google server. This enables you to add participants, or be added as participant, to wavelets hosted on any wave server. Everything works in real time with character by character support.

Here is a screenshot that shows a wavelet (containing two blips) edited both on Google Wave and ProcessOne's WaveOne:

The result is much like having your own e-mail or XMPP client and server under your own control. This is built on the power of XMPP-based federation.

A handy feature of our WaveOne implementation is the capability to share a textarea of a webpage, for collaborative real-time text editing. This has been demoed at Google I/O, and has received much interest. Here are some sample screenshots.

The user right-clicks in a textarea, and shares it:

He adds participants to the wavelet:

All participants can collaboratively edit the text in real-time:

Learn You Some Erlang: The Hitchhiker's Guide to Concurrency

Fri, 21 May 2010 13:30:00 +0000

I was a bit slow to produce this chapter, but I'll blame that on my laptop dying on me and playoffs Hockey (watching a game as I'm writing this!) Anyway, this is the first chapter to really talk about Erlang's concurrency. Because of this, I'm taking a theoretical approach and visiting the language's history a little bit, explaining the rationale and doing a quick overview of how processes work in Erlang. I also take a look at the concepts of concurrency and parallelism to make sure everyone will be on the same level no matter what their background is. I also show the basic building blocks of concurrent Erlang: spawning processes, sending messages and then receiving them.

Damien Katz: I'm in your phone

Fri, 21 May 2010 00:53:14 +0000

CouchDB on Motorola Droid

And on Nokia n900

Damien Katz: CouchDB Rap

Fri, 21 May 2010 00:44:40 +0000

I Use Couch DB.

Premiered today on The H. Nice.

Scattered Thoughts: about

Wed, 19 May 2010 23:22:58 +0000

Process-one Blogs: TextOne for Android, simple texting for even more smartphones

Wed, 19 May 2010 15:17:53 +0000

TextOne is now available for Android devices, enabling smartphone lovers to text friends and contacts the smart and easy way.

ProcessOne has released an early version of TextOne, the smart text messaging application for smartphones, for the Android platform. As on the iPhone, it features one-to-one chats, and simple groupchats. TextOne also provides reliability mechanisms like visual delivery notification. Of course TextOne for Android and TextOne for iPhone are fully interoperable.

TextOne is better than:

SMS:
- because you can exchange messages freely at no cost
- because you can groupchat
IM/chat:
- because you have reliability mechanisms
- because you don't need a useless presence icon, just send ans receive simply

As an early version, you may experience some bugs and weirdnesses. You can report them on the dedicated TextOne forum.

TextOne for Android works starting from Android 1.5.

Here are some screenshots, so you can have an idea on its look and feel:

The conversation list:

And the conversation screen:

Please feel free to download and play with TextOne for Android in version 0.8.4. It is currently available on the Android Market.

TextOne Android is free during the beta period. A TextOne extended version for Android 2.0 to use the native content management feature is scheduled.

RedHotErlang: New Layout

Tue, 18 May 2010 18:59:30 +0000

RedHotErlang has got a new layout. The old layout had been around for some years now and I wanted to move the code base to use Nitrogen-2.0. So, gone is the desktop style structure with no visible page loads. Now the site is using a more normal page ...

Erlang Solutions
- News: 17 May 2010: Erlang Solutions awarded a Knowledge Transfer Partnership with the Kent Business School

Mon, 17 May 2010 10:17:36 +0000

Erlang Solutions is proud to announce that a third KTP project has been accepted by the Knowledge Partnerships Programme (KTP). This is in addition to the Reusable Components project that recently completed and the E-Learning/E-Certification Project that began in October 2009. This project will be a strategic marketing project together with the University of Kent, who have been our Academic partners in the other two projects and with whom Erlang Solutions has a strong partnership.

The main purpose of the project will be to establish and nurture a marketing orientation within the company and improve current marketing processes from a tactical and strategic perspective.

Erlang Solutions
- News: 26 April 2010: Hans Nilsson joins Erlang Solutions as Senior Consultant

Fri, 14 May 2010 15:16:46 +0000

Erlang Solutions Ltd proudly welcomes one of the world's most experienced and capable Erlang experts into our team.

Hans Nilsson joined the Ericsson Computer Science Lab in 1988, the year after Joe Armstrong. For the first two years, he worked on the development of the highly regarded SICSTUS Prolog. In 1995 together with Claes Wikström, he developed the Mnesia DBMS and Mnemosyne query language, and then went on to study the budding Voice over IP field. He implemented his first Erlang-based SIP stack in 1998, while the standard (RFC2543) was not yet in stable draft. Hans presented his SIP-ISDN Gateway at the Erlang User Conference 1997.

After a couple of years developing a residential Ethernet switch at Ericsson, Hans returned to Voice over IP. He established himself as one of Ericsson's leading SIP experts, and was the company's representative in the GSM Association SIP Technical Expert Group. Meanwhile, he was the technical lead on a large product development project based on his SIP implementation. Before joining Erlang Solutions, he worked in a tiger team doing advanced prototyping with Erlang in close cooperation with the Intel Performance Lab.

Hans is also a key member of the ProTest EU Project, where his work on property-baseddata mining of packet trace logs and QuickCheck verification of SIP parsers have been highly influential. As Erlang Solutions is an active member of that project, his involvement will continue.

With the addition of Hans Nilsson, Erlang Solutions is able to offer world-class expertise in the Voice over IP field.

Erlang Solutions
- News: 10 May 2010: Erlang Solutions Announces Opening of New Office in Stockholm, Sweden

Fri, 14 May 2010 15:16:46 +0000

Erlang Solutions Ltd has opened a new office in central Stockholm. The new office and and staff with extensive knowledge of Erlang will allow the company to better serve its large client-base in Sweden and worldwide. The expansion also provides an expanded training portfolio and facilities. It is envisaged that Erlang community will meet here at regularly organised Erlang User Group Meetings. In addition Erlang Solutions will be able to accommodate more students for internships, training and certification.

Erlang Solutions’ new office is located at Saltmätargatan 5, 113 59 Stockholm, Sweden and can be reached by phone at +46 - (0) 8 - 120 424 00

BGH's Blog: Silence

Thu, 13 May 2010 14:49:19 +0000

The blog has been a bit quiet. I've been rewriting some of our server software at work in Erlang and it's taken up most of my free time. I'm about done with it, so we should see the posts pick up again soon.

Cheers,
Halzy

Programming in the 21st Century: How to Think Like a Pioneer

Thu, 13 May 2010 06:00:00 +0000

Here's an experiment to try at home: do a Google image search for "integrated development environment." Take some time to go through the first several pages of pictures.

Even if you had no idea what an IDE was, the patterns are obvious. There's a big area with text in it, and on the left side of the screen is a pane that looks a lot like Windows Explorer: a collection of folders and files in a tree view, each with icons. Some folders are closed and have little plus signs next to them. Others are expanded and you can see the files contained within them. To be perfectly fair, this project area is sometimes on the right side of the window instead of the left. Variety is the spice of life and all that.

Why have IDEs settled into this pattern of having a project view take up twenty percent or more of the entire left or right side of the window?

The answer is shallower than you may expect. Someone who decides to create an IDE uses the existing programs he or she is familiar with as models. In other words, "because that's how it's supposed to be."

There's no solid reason the project view pane has to be the way it usually is. In fact, there are some good arguments against doing it that way. First, you are typically either looking at the project view or you're editing a file, not doing both at the same time. Yet the project view is always there, taking up screen real estate, sometimes a lot of screen real estate if highly nested folders are expanded. That view is made even wider by having icons to the left of each filename, even though most projects consist of one or two file types and they could be differentiated with color or an outline instead of a contrived icon attempting to evoke "file of Java code."

Second, a long, thin pane containing files and folders doesn't give a particularly deep or even interesting view of a large project. Open a folder and it might fill the whole pane, and all the other folders are now offscreen.

Are there better options? Sure! The first problem, of losing screen space to a persistent view of the project hierarchy, can be alleviated by a hot key that brings up a full-screen overlay. When you want to see the project as a whole, hit a key. Press escape to make it go away (or double-click a file to edit it).

The data presented in this overlay doesn't need to be a tree view. A simple option is to group related files into colored boxes, much like folders, except you can see the contents the whole time. With the narrow, vertical format out of the way, there can be multiple columns of boxes filling the space. Now you can see 100+ files at a time instead of a dozen.

It might make more sense to display modules as shapes, each connected by lines to the modules which are imported. Or provide multiple visualizations of the project, each for a different purpose.

Someone, sometime, and probably not all that long ago, came up with the canonical "project view on the left side of the window" design for IDEs. And you may wonder how that person arrived at that solution. After all, there were no prior IDEs to use for guidance. I think the answer is a basic one: because it's a solution that worked and was better than what came before. No magic. No in-depth comparison of a dozen possibilities. Clearly a way to see all the files in a project is better than a raw window in a text editor where there's no concept of "project" whatsoever. That solution wasn't the best solution that could ever exist in the entire future history of IDEs, but it sure fooled people into thinking it was.

If you want to think like a pioneer, focus on the problem you're trying to solve. The actual problem. Don't jump directly to what everyone else is doing and then rephrase your problem in terms of that solution. In the IDE case, the problem is "How can I present a visual overview of a project," not "How can I write a tree viewer like in all other other IDEs I've ever seen?"

1011 Ltd Blog: Google Wave @ BCS SPA - slides

Mon, 10 May 2010 18:01:12 +0000

Here are the slides from the presentation I gave at BCS SPA on the 5th of May. They're really not that useful without actually hearing the talk, because I don't believe in creating slides that people just read. But you might find them useful if you were there.

Process-one Blogs: TextOne Pink: iPhone messaging with style, for the ladies

Mon, 10 May 2010 15:00:47 +0000

ProcessOne has released a new version of TextOne: TextOne Pink.

TextOne is our new application for simple messaging between smartphones, with groupchat. TextOne has now a sister: TextOne Pink! It is aimed at the ladies worldwide. This is the same strong product designed with extreme simplicity and reliability in mind.

Here are a few sample screenshots...

Splash screen:

Conversation screen:

Conversation list:

Group chat:

Search "TextOne" on the AppStore, you will find both "TextOne" and "TextOne Pink". Simply choose your version and a username, and start conversations!

You can talk about TextOne and share your tips and tricks on the forum.

Erlang Factory News: Countdown to the Erlang Factory London

Mon, 10 May 2010 14:01:11 +0000

There are only 4 weeks left to the Erlang Factory London. If you haven't registered yet, you can still do this by clicking here.

We have new confirmed speakers: Peter Andersson
(Developer at Erlang/OTP),Mariano Guerra (creator of the Efene programming language), Erik Stenman (CTO of Klarna) and Daniel Widgren and Michael Nordström (Erlang hackers at Klarna).

'I'm attending', 'I'm speaking' and 'See you there' banners are now available here. You can add them to your blog, Twitter page or any website. You are also welcome to follow @erlangfactory on Twitter.

Chicago Erlang User Group: CEUG April 21st meeting slides - Switching from Python and Java to Erlang

noreply@blogger.com (Jordan Wilberding) — Thu, 06 May 2010 22:17:00 +0000

Chris and Garrett have been kind enough to share their slides on moving to Erlang from Python and Java, respectively. Video of Chris's talk can be found here, while video of Garrett's talk can be found here. Finally, there was a joint Q&A session which can be found here.Our next meeting is tentatively schedule for June 2nd at Orbitz. The meeting will cover the reasons why to choose OTP for all

Damien Katz: CouchDB Case Studies

Thu, 06 May 2010 21:10:31 +0000

We've just put up our new CouchDB case studies page. So far we have the BBC, Assay Depot and Interactive Mediums, and more in the works. And if you are interested in being profiled for a case study, see this post.

Damien Katz: Announcing New Erlang Native GeoCouch

Wed, 05 May 2010 22:25:58 +0000

GeoCouch: The Future is Now

An idea has become reality. Exactly two years after the blog post with the initial vision, a new version of GeoCouch is finished. It's a huge step forward. The first time the dependencies were narrowed down to CouchDB itself. No Python, no SpatiaLite any longer, it's pure Erlang. GeoCouch is tightly integrated with CouchDB, so you'll get all the nice features you love about CouchDB.

Awesome work Volker!

RedHotErlang: rebar templates

Tue, 04 May 2010 11:52:33 +0000

When I start a new little project of mine, I've had a big ugly shell script that creates the various source files I need. I can now say goodby to that script and instead make use of [rebar][1]'s template functionality. [Rebar][1] templates are locat...

Erlang Factory News: New Speakers and the Very Early-Bird discount!

Tue, 04 May 2010 10:31:46 +0000

We have new amazing speakers for the Erlang Factory: Mariano Guerra (Creator of Efene and Emesene IM), Laura M. Castro from University of A Coruña, Michael Nordström and Daniel Widgren from Klarna, Ulf Norell and John Hughes from QuviQ AB.
To see all Speakers please click here.

Hurry! The Very Early Bird offer for the Erlang Factory London 2010 has been extended to Friday 7th May. Take advantage of this and book soon to save up to £400 off the standard price!

Joe's Blog: Availability, the Cloud and Everything

Sat, 01 May 2010 17:37:42 +0000

Finally posted my presentation at Erlang Factory, WTIA Cloud SIG and Seattle Scalability Meetup here on the blog.

Availability, the Cloud and Everything

View more presentations from logicalstack.

Erlang Examples: Building Erlang B13R04 in CentOS 5.4

Fri, 30 Apr 2010 15:36:34 +0000

Last post was about building Erlang B13R04 in Ubuntu. For CentOS, it’s somehow the same with yum
sudo yum -y install make gcc gcc-c++ kernel-devel m4 ncurses-devel openssl-devel wget http://www.erlang.org/download/otp_src_R13B04.tar.gz tar xfvz otp_src_R13B04.tar.gz cd otp_src_R13B04/ ./configure --with-ssl sudo make install
However, I haven’t found the similar package to xsltproc and fop yet. But it’s only for building the documentation which I don’t really need.

Damien Katz: Create a Custom CouchDB indexer

Fri, 30 Apr 2010 02:43:04 +0000

Recently I worked with Volker Mische to help him create a new R-Tree geo-spacial indexer for CouchDB, the details of which he'll be announcing soon.

And not only that, he took the time to write up a tutorial how to create you own customer indexer. If you wanted to write a new full text indexer in Erlang for CouchDB, this tutorial is the place to start. Awesome work!

http://vmx.cx/couchdb/tutorial/indexer.html

BGH's Blog: Erlang Programming Exercise: 4-2

Wed, 28 Apr 2010 00:32:57 +0000

I've finished with the process ring. I've done this exercise once before when reading "Programming Erlang". Last time I had the processes create each other and set up the connections, this time they were created and linked by the start function. The code is much cleaner this time around.

The basic idea is that you create a number of processes and each process knows the process id of it's neighbor in the ring. When a process receives a message, it should forward it on to it's neighbor. You then send X number of messages into the ring and watch your laptop turn into a skillet.

Please review the code and let me know if you have any suggestions.
[erlang]
-module(four_two).

-export([start/3, test/0]).
-export([process_loop/0, process_loop/1]).

test() ->
FirstPid = start(10,4,"This is a message"),

%% [bgh] after 15 second, kill it automatically
receive
after
15000 ->
stop(FirstPid)
end.

stop(Pid) ->
Pid ! {stop, 0}.

start(M, N, Message) ->
%% [bgh] start N processes
Pids = lists:reverse(lists:foldl(
fun(_Number,PidList) ->
NewPid = spawn(?MODULE, process_loop, []),
[NewPid|PidList]
end,
[],
lists:seq(1, N)
)),

%% [bgh] Shift the one off the front, and put it on the end
NeighborPids = rotate_array(Pids),

%% [bgh] link the N processes together
link_pids(Pids, NeighborPids),

[FirstPid|_OtherPids] = Pids,

%% [bgh] start the message sending by sending M messages to PID
send_messages_to_pid(M, Message, FirstPid),

%% [bgh] start the processes sending messages
FirstPid.

rotate_array([]) ->
[];
rotate_array([First|_]=List) when length(List) =:= 1 ->
[First];
rotate_array([First|Remainder]) ->
io:format("~p ~p~n", [First,Remainder]),
lists:append(Remainder,[First]).

send_messages_to_pid(M, Message, FirstPid) when M > 0 ->
FirstPid ! {message, Message},
send_messages_to_pid(M-1, Message, FirstPid);
send_messages_to_pid(_M, _Message, _FirstPid) ->
ok.

link_pids([], []) ->
ok;
link_pids([Pid|Pids], [NPid|NeighborPids]) ->
Pid ! {link, NPid},
link_pids(Pids, NeighborPids).

process_loop() ->
receive
{link, Pid} ->
process_loop({Pid, 0});
Other ->
io:format("Ignored ~p~n", [Other]),
process_loop()
end.

process_loop({Pid, Count}) ->
receive
{message, Message} ->
Pid ! {message, Message},
process_loop({Pid, Count+1});
{stop, CountSum} ->
Pid ! {stop, Count+CountSum},
io:format("~p is shutting down, saw ~p messages~n", [self(), Count+CountSum]);
Other ->
io:format("Ignored ~p~n", [Other]),
process_loop({Pid, Count})
end.
[/erlang]

Cheers,
Halzy

RedHotErlang: pingis.org

Tue, 27 Apr 2010 17:06:55 +0000

At my [work][1] we are keen Table Tennis players. So we just had to create a score registration system to create some ranking statistics and what not. Well, I and my collegue [Jordi][2] has now setup the first version of [pingis.org][3]. As usual, w...

Yariv's Blog: PicLike

Tue, 27 Apr 2010 16:30:57 +0000

Check out PicLike, the new app I made using the Flickr API, Google App Engine and the Facebook Like button: http://piclike.appspot.com.

Erlang Factory News: New Speakers for the Erlang Factory London 2010

Mon, 26 Apr 2010 10:16:10 +0000

We would like to announce new Speakers for the Erlang Factory London: the designer and co-implementer of F# - Don Syme, Jan Lehnardt - CouchDB committer and evangelist, system engineer and back-end systems architect - Lahav Savir, Alvaro Videla - the lead developer for TheNetCircle.com.

To see all Speakers please click here.

Reminder: The Very Early-Bird Discount for the Erlang Factory London 2010 Expires This Friday! Register now and save up to £400!

Chicago Erlang User Group: CEUG April 21st meeting video - 3 of 3 (Q and A)

martinjlogan@erlware.org (Martin J. Logan) — Sat, 24 Apr 2010 18:05:00 +0000

This is the final video in our series. There was quite a lot of interesting QA as usual and we have it all recorded here.

Chicago Erlang User Group: CEUG April 21st meeting video - 2 of 3 (Garrett on Java to Erlang.)

martinjlogan@erlware.org (Martin J. Logan) — Sat, 24 Apr 2010 18:04:00 +0000

This is the second Erlang OTP video for the Chicago Erlang User Group April 21st meeting. Garrett covers transitioning to Erlang from Python and also does a great job talking about why Erlang in the first place. He humorously covers broad topics in this video from the Erlang standard library, to recursion, to how OTP is like Django! Definitely worth watching.If you are interested in coming to

Chicago Erlang User Group: CEUG April 21st meeting video - 1 of 3 (Chris on Java to Erlang.)

martinjlogan@erlware.org (Martin J. Logan) — Sat, 24 Apr 2010 17:55:00 +0000

We had a great chicago erlang user group meeting this April the 21st. With almost 40 in attendance it was a packed house for sure. We had two great talks. First was Chris Duesing on easing the transition to Erlang from Java and then Garrett Smith did similar but from a Python perspective. Following that we had a long Q & A session. Here is the video of Chris's talk. He covers in the video

Programming in the 21st Century: How Much Processing Power Does it Take to be Fast?

Sat, 24 Apr 2010 06:00:00 +0000

First, watch this.

It's Defender, an arcade game released thirty years ago. I went out of my way to find footage running on the original hardware, not emulated on a modern computer. (There's clearer video from an emulator if you prefer.)

Here's the first point of note: Defender is running on a 1MHz 8-bit processor. That's right ONE megahertz. This was before the days of pipelined, superscalar architectures, so if an instruction took 5 cycles to execute, it always took 5 cycles.

Here's the second: Unlike a lot of games from the early 1980s, there's no hardware-assisted graphics. No honest-to-goodness sprites where the video processor does all the work. No hardware to move blocks of memory around. The screen is just a big bitmap, and all drawing of the enemies, the score, the scrolling mountains, the special effects, is handled by the same processor that's running the rest of the code.

To be fair, the screen is only 320x256 with four bits per pixel. But remember, this was 1980, and home computers released up until mid-1985 didn't have that combination of resolution and color.

Now it's 2010, and there's much amazement at the responsiveness of the iPad. And why shouldn't it be responsive? There's a 32-bit, gigahertz CPU in there that can run multiple instructions at the same time. Images are moved around by a separate processor dedicated entirely to graphics. When you flick your finger across the screen and some images slide around, there's very little computation involved. The CPU is tracking some input and sending some commands to the GPU. The GPU is happy to render what you want, and a couple of 2D images is way below the tens of thousands of texture-mapped polygons that it was designed to handle.

Okay, JPEG decompression takes some effort. Ditto for drawing curve-based, anti-aliased fonts. And of course there's overhead involved in the application framework where messages get passed around to delegates and so on. None of this justifies the assumption that it takes amazing computing power to provide a responsive user experience. We're so used to interfaces being clunky and static, and programs taking long to load, and there being unsettling pauses when highlighting certain menu items, that we expect it.

All the fawning over the speed iPad is a good reminder that it doesn't have to be this way.

(If you liked this, you might like Slow Languages Battle Across Time.)

BGH's Blog: Erlang Programming Exercise: 4-1

Thu, 22 Apr 2010 15:41:17 +0000

I'm glad to be past chapter 3, and that I took the time to go through the exercises. I would highly suggest to anybody learning Erlang to do the same. They helped me learn the syntax of the language and to become much more comfortable in Erlang. I also found the erlang man pages to be very helpful. For example, to get the full documentation for the lists module you type "erl -man lists" in a shell.

Before jumping into the exercises for chapter four I went back and re-read the chapter. It's a nice reminder of how Erlang is different from the languages I use for work. I'm still having trouble trying to grok the activity vs task mentality, it's so different from what I'm used to.

Exercise 4-1 I found to be much easier than 3-10. The goal is to start up a process that prints out messages you send to it, but to have the interaction with that process through a public interface.

Here is the interface you are supposed to maintain:
[erlang]
echo:start() ⇒ ok
echo:print(Term) ⇒ ok
echo:stop() ⇒ ok
[/erlang]

Since I've been naming my modules after the exercise chapter and number I changed 'echo' to four_one. Here is my solution:

[erlang]
-module(four_one).
-export([start/0,print/1,stop/0]).

-export([loop/0]).

start() ->
Pid = spawn(four_one,loop,[]),
register(four_one, Pid),
ok.

print(Term) ->
four_one ! {print, Term},
ok.

stop() ->
four_one ! stop,
ok.

loop() ->
receive
stop -> ok;
{print, Term} ->
io:format("~p~n", [Term]),
loop()
end.
[/erlang]

Cheers,
Halzy

Process-one Blogs: ProcessOne Hosted.IM adds paid plans for XMPP hosting services

Wed, 21 Apr 2010 14:59:13 +0000

ProcessOne has upgraded Hosted.IM with paid services for teams of more than 5 users.

Hosted.IM, the XMPP hosting service launched by ProcessOne in the last summer, has undergone a major change, by accepting paid plans, for work teams of more than 5 users for your own domain name. Hosted.IM will also let you add as many domains as you like, still without the need to manage the burden of administrative tasks.

Hosted.IM still provides XMPP services like federation to Gtalk, Talkr.IM, and other federated XMPP servers and gateways to legacy IM systems like MSN, ICQ, Yahoo, AIM, as well as the microblogging silo Twitter.

With the new Hosted.IM, you can buy credits when you want from the IMStore. This will enable you to add users to your existing plan. At any time you can access you current balance, as well usage reports and recent operations.

Previously, Hosted.IM enabled domains to host up to 10 users at not charge: this has changed to 5 users. We will continue to host existing free domains with up to 10 users. New domains will need to buy credits in order to register more than 5 users.

In order to use Hosted.IM, the first step is to register a username with an existing e-mail account. Then you can configure your DNS, and after some synchronization delay, access your newly created XMPP accounts.

Run your own instant messaging service, without worrying about the administration hassle: join Hosted.IM now.

Kevin Scaldeferri's Weblog: Alpha Male Programmers Are Driving Women Out

Wed, 21 Apr 2010 14:21:40 +0000

Yesterday, DHH made an argument that alpha male programmers aren’t keeping women out of the tech field. I’m of the opinion that he’s wrong and that his argument is flawed, and in a moment I’ll explain why, but let me get a few things out of the way so they don’t distract from the rest of my argument.

First, I don’t think that “alpha males” or the “rockstar” mentality are the only causes of under-representation of women in technology. As far as I can tell, the causes are many, varied, generally difficult to deal with, and in one or two cases may even be valid reasons why we might ultimately accept some degree of imbalance in the field. Second, this is not strictly a gender issue. Some men are also driven away by this behavior, although I think women are more likely to be; and also some “alpha males” happen to be female. Third, this is not a personal attack on DHH or any other individual, although some people might read parts of it in that way. But my goal here is that the range of individuals who find themselves uncomfortably reflected in what I say, but don’t simply reject it all out of hand, might view that discomfort as an opportunity for personal growth. Finally, I am certainly not claiming that I am perfect in this regard. I’ve made mistakes in the past; I will make them again. I simply hope that my friends will be kind enough to point out my mistakes to me, so that I can try to do better.

Okay, now that that’s all out of the way...

I first claim that DHH is wrong. My proof is empirical and anecdotal, but fortunately for me, I’m on the side of this debate that gets to use those techniques. I.e., I’m asserting existence of a phenomenon, rather than non-existence. I know numerous women who have been driven away by alpha male behavior. In some cases, they simply moved to a different team, or a different company. In other cases, they switched to non-programmer roles. And some left the industry entirely. I know this because they told me. They described specific individuals and specific behaviors which drove them away.

With some frequency in these debates, male programmers will claim that they don’t know any women who have left the field for this reason (or who have experienced sexism in the field, or who were offended by the example under discussion, or even just the milder claim that DHH makes, that no one has any idea what to do). I can explain this in only one of two ways: either they don’t know any women in the field to begin with or don’t talk with them beyond the minimal professional requirements, or women are not telling them because they are part of the problem. Perhaps it would be more effective if these women directly confronted the people causing the problem, but the fact of the matter is that most people, men and women, dislike conflict. We’re much more comfortable griping to a sympathetic friend than to the cause of our unhappiness. So consider me something akin to an anonymizing proxy. Without revealing names or too many of the specifics, please trust me when I say that almost every woman in the field experiences and complains about this.

Now I also said that DHH’s argument is flawed, and I will spend the rest of this post pointing out the various flaws I see.

DHH claims alpha males cannot be a problem in programming because the average male programmer is “meek, tame, and introverted” compared to other fields. First off, “alpha males” are by definition not average; they are the most dominant individuals of a group. And, it may even be possible that the general meekness or introversion of programmers makes it easier for a small set of individuals to dominate the interaction, rather than reaching a condition of detente between a group of uniformly assertive individuals. Second, presumably DHH does not interact with these people from other fields in a professional context. A point repeatedly stressed in this recent “pr0n star” controversy is that it’s not an issue of people being anti-sex or anti-porn; it’s about what’s appropriate in the workplace, or in a professional context. Standards for behavior in a social context are different. Third, he speaks in terms of whether these other men are more or less “R-rated”. This is not the point. Women are just as “R-rated” as men. They curse. They talk about sex (often more explicitly than men). The issue is not about whether we say or do adult things, it’s about whether we respect each other as human beings and whether we understand the societal norms of what is and is not appropriate in particular contexts. In fact, in this regard, I’ll defend DHH. Saying “fuck” (in the exclamatory, non-sexual usage) in the course of a technical presentation is not problematic in this day and age within the technology community. I think most of us swear freely in the course of struggling with a nasty bug or production problem. This is a normative expression of frustration within our community, and it does not oppress or disrespect other members of the community. (As far as I know. It’s possible that people just aren’t telling me that it upsets them when I curse at my monitor. If that’s the case, I hope someone will tell me.) Finally, DHH observes that these other fields have a more even mix of men and women. What he misses is that when the distribution is relatively equal it is generally easier and more comfortable for men to be men and women to be women. It is perhaps counterintuitive, but environments which are heavily skewed call for greater sensitivity to gender or other cultural differences simply because it is so easy to unintentionally create an oppressive or exclusionary atmosphere.

In the final paragraphs of his post, DHH suggests that somehow by respecting women we are squashing some other sort of “edge” and diversity in the community. I’m a little puzzled by what he means by this, and I’m sort of afraid that he thinks that being a heterosexual male who likes to look at scantily-clad women (or who openly admits as much) is somehow “edgy”. It’s not. By definition, hetero males like women; and it’s well established that men tend to be visually oriented. Pointing out that you fall in this category does not make you “diverse”, it makes you a completely typical representative of your gender and orientation. No one needs to be reminded of it.

Moreover, it might be true that maximal gains are had by pushing the edges (although I don’t think that one should naively assume that analogy from physics or economics applies to social endeavors), but for this to be work there has to be negative feedback when boundaries are crossed. If the edge-walkers want society to accept their behavior, they must be prepared to apologize, to make reparations, and to correct their course when they go over the line. This is the difference between a trend-setter and a sociopath.

There’s quite a bit more that I could say on this issue, but I fear this may be becoming too long already, and I think it’s probably best to focus only on the arguments presented in this particular post at the moment. To summarize things in a couple of sentences, the phenomenon of women being discouraged by alpha male behavior is real. You merely need to talk, and listen, to women in the field to verify this. (But you might have to earn some trust first.) Comparisons with men in other fields in non-professional settings do not have much relevance to the matter at hand. Claims that respecting the feelings and experiences of a minority group is damaging to the community overall are extraordinary and require extraordinary support. Being a thought leader and being offensive are two very different things.

It’s really quite discouraging that so much of this discussion still seems mired in the question of whether a problem even exists, or whether it is desirable and possible to address the problem. This lack of acceptance leads both to the explicit refusals to acknowledge the validity of the complaints of the offended, as well as the phenomena of false apologies and insincere claims that “I would help if only I knew how (and if it doesn’t require any actual change of behavior on my part)”. Male programmers need to pull their heads out of the sand. The evidence, both hard statistical data and anecdotal, is overwhelming. It also is not hard to find advice about what can be done differently. The hard part is moving from a vague desire for diversity and balance to serious, meaningful, sometimes painful self-examination and commitment to change and improvement. It’s not easy to admit flaws in yourself, to acknowledge when you’ve hurt another person, or to make a true apology. Change doesn’t happen overnight or simply because you say that you want it to. It takes work, but it’s an important part of being a human being and being a member of a community.

Comments

Kevin Scaldeferri's Weblog: Speeding up a Rails request by 150ms by changing 1 line

Wed, 21 Apr 2010 14:21:40 +0000

We’re pretty obsessed with performance at Gilt Groupe. You can get a taste for what we’re dealing with, and how we’re dealing with it, from our recent presentation at RailsConf.

One of the techniques we’re using is to precompute what certain high-volume pages will look like at a given time in the future, and store the result as static HTML that we serve to the actual users at that time. For ease of initial development, and because there’s still a fair bit of business logic involved in determining which version of a particular page to serve, this was done inside our normal controller actions which look for a static file to serve, before falling back to generating it dynamically.

We’re now running on Rails 2.3 and, of course, Rails Metal is the new hotness in 2.3. I spent the last couple days looking into how much improvement in static file serving we would see by moving it into the Metal layer. Based on most of what I’ve read, I expected we might shave off a couple milliseconds. This expectation turned out to be dramatically wrong.

Metal components operate outside the realm of the usual Rails timing and logging components, so you don’t get any internal measurements of page performance. Instead, I fired up ab to measure the serving times externally. What I found for the page I was benchmarking was that the Metal implementation took about 5ms. The old controller action took 170ms. But, wait... the Rails logs were only reporting 8ms for that action. Something was fishy.

I started inserting timers at various places in the Rails stack, trying to figure out where the other 160ms was going. A little bit was routing logic and other miscellaneous overhead, but even setting a timer around the very entry points into the Rails request serving path, I was only seeing 15ms being spent. This was getting really puzzling, because at this point where a Rack response is returned to the web server, I expected things to look identical between Metal and ActionController. However, looking more closely at the response objects I discovered the critical difference. The Metal response returns an [String], while the controller returned an ActionController::Response.

I went into the Rails source and found the each method for ActionController::Response. Here it is:

   def each(&callback)
     if @body.respond_to?(:call)
       @writer = lambda { |x| callback.call(x) }
       @body.call(self, self)
     elsif @body.is_a?(String)
       @body.each_line(&callback)
     else
       @body.each(&callback)
     end

     @writer = callback
     @block.call(self) if @block
   end

The critical line is the case where the body is a String. The code iterates over each line in the response. Each line is written individually to the network socket. In the case of the particular page I was looking at, that was 1300 writes. Ouch.

To confirm this was the problem, I changed that line to

      yield @body

With the whole body being sent in a single write, ab reported 15ms per request, right in line with what I measured inside Rails.

1 line changed. 150ms gained. Not too bad.

This sort of performance pessimization we uncovered is particularly insidious because it’s completely invisible to all the usual Rails monitoring tools. It doesn’t show up in your logged response time; you won’t see it in NewRelic or TuneUp. The only way you’re going to find out about it is by running an external benchmarking tool. Of course, this is always a good idea, but it’s easy to forget to do it, because the tools that work inside the Rails ecosystem are so nice. But the lesson here is, if you’re working on performance optimizations, make sure to always get a second opinion.

Comments

Trapexit News Feed: Trapexit News :: Erlang Open Source crawler!

Wed, 21 Apr 2010 14:21:20 +0000

Author: admin
Subject: Erlang Open Source crawler!
Posted: Thu Nov 19, 2009 4:22 pm (GMT 0)
Topic Replies: 0

Trapexit is proud to announce its own Erlang open source crawler. We crawl the web for you, gathering searchable information on all open source Erlang projects from all the major repositories. You can discuss these projects in the forum, add documentation in the trapexit wiki or rate the various contributions. To view our new project index repository, visit http://projects.trapexit.org.

Trapexit News Feed: Trapexit News :: Navigating The Erlang Source!

Wed, 21 Apr 2010 14:21:20 +0000

Author: francesco
Subject: Navigating The Erlang Source!
Posted: Thu Aug 20, 2009 2:24 pm (GMT 0)
Topic Replies: 0

While trapexit user zghst was looking at the erlang source, there was quite a bit of information about it he felt was missing or hard to find. As a result, he started a wiki page to help new people like him find their way around it: A Guide To The Erlang Source. Why not give him a hand in improving it?

Erlang Factory News: First confirmed speakers for the Erlang Factory London 2010

Wed, 21 Apr 2010 14:20:56 +0000

We are proud to announce the first confirmed speakers for the Erlang Factory London 2010: the inventor of Scala -Martin Odersky, Robert Virding – the inventor of Erlang and Bluetail co-founder, the Father of Erlang - Joe Armstrong, Justin Sheehy and Rusty Klophaus from Basho Technologies, Github co-founder - Tom Preston-Werner, the creator of Erjang - Kresten Krab Thorup, Scott Lystig Fritchie from Gemini Mobile Technologies and Mark Zweifel and William Larson from Yahoo!

Be aware! Each day there are more and more people registering for the Erlang Factory London 2010. Register before it sells out!

Erlang Factory News: Registration for the Erlang Factory London is open!

Wed, 21 Apr 2010 14:20:56 +0000

The Erlang Factory London 2010 will be held on 10th and 11th June in the Old Session House. On 7th, 8th and 9th June there will be also Erlang University courses taking place: Erlang Express, Erlang OTP Express, QuickCheck for Erlang developers and Web Programming with Erlang.

Don't miss out Very Early-Bird discount - register by Friday, 30th April 2010 and save £200!

RiboComments/Erlang: Generating prime numbers with Erlang and Java

Wed, 21 Apr 2010 14:20:54 +0000

During my work with the course-ware of a new Erlang course, I experimented with one of the programming assignments to compare the threading performance of Erlang versus Java. The assignment is one of the classical programs from teaching concurrent programming: How to generate prime numbers using a pipeline of sieve ...

RiboComments/Erlang: The critical section problem in Erlang

Wed, 21 Apr 2010 14:20:54 +0000

The programming language Erlang is based on micro-threads and asynchronous message passing. There is a (naive) belief that critical section problems cannot arise in languages based solely on message passing. The justification for this stand-point is the absence of mutex synchronization primitives, which is absolutely essential in shared-data based concurrent ...

Erlang Announce List: Erlang announce mailing list :: Erlang/OTP now at Github

Wed, 21 Apr 2010 14:19:48 +0000

Author: Anonymous
Subject: Erlang/OTP now at Github
Posted: Wed Nov 25, 2009 2:14 pm (GMT 0)
Topic Replies: 0

The official git repository for Erlang/OTP can now be found at Github:

http://github.com/erlang/otp

Build instructions can be found at:

http://wiki.github.com/erlang/otp

We plan to add more wiki pages with additional information in the
near future.

--
Björn Gustavsson, Erlang/OTP, Ericsson AB

________________________________________________________________
erlang-announce mailing list. See http://www.erlang.org/faq.html
erlang-announce (at) erlang.org

Post received from mailinglist

Erlang Announce List: Erlang announce mailing list :: Erlang/OTP R13B03 has been released

Wed, 21 Apr 2010 14:19:48 +0000

Author: Anonymous
Subject: Erlang/OTP R13B03 has been released
Posted: Wed Nov 25, 2009 1:56 pm (GMT 0)
Topic Replies: 0

Bug fix release : otp_src_R13B03
Build date : 2009-11-23

This is R13B03, the third maintenance release for the R13B major release.

You can find the README file for the release at

http://www.erlang.org/download/otp_src_R13B03.readme

The source distribution and binary distribution for Windows can be
downloaded from

http://www.erlang.org/download/otp_src_R13B03.tar.gz
http://www.erlang.org/download/otp_win32_R13B03.exe

The distribution can also be downloaded using the BitTorrent
protocol. Use the following torrent files to download the source
distribution and binary distribution for Windows:

http://www.erlang.org/download/otp_src_R13B03.tar.gz.torrent
http://www.erlang.org/download/otp_win32_R13B03.exe.torrent

Note: To unpack the TAR archive you need a GNU TAR compatible program.

For installation instructions please read the README file that is part
of the distribution.

The on-line documentation can be found at: http://www.erlang.org/doc/
You can also download the complete HTML documentation or the Unix manual files

http://www.erlang.org/download/otp_doc_html_R13B03.tar.gz
http://www.erlang.org/download/otp_doc_man_R13B03.tar.gz

We also want to thank those that sent us patches, suggestions and bug
reports,

The OTP Team

--
Björn Gustavsson, Erlang/OTP, Ericsson AB

________________________________________________________________
erlang-announce mailing list. See http://www.erlang.org/faq.html
erlang-announce (at) erlang.org

Post received from mailinglist

BGH's Blog: Erlang Programming Exercise: 3-10

Wed, 21 Apr 2010 02:06:14 +0000

Exercise 3-10 has you take unstructured text and make filled text, then later, justified text.

Now, it's trivial to justify the text, you could even do it in a single pass, but I wanted to solve both the filled text and the text justification at the same time. To make development faster, I wrote some test stubs (at the bottom of the file) that would load the text from disk, and call the interface functions.

textProcess and justifyText do basically the same thing, with justifyText trying to figure out how many extra spaces to put in each gap. They start out by creating a list of tuples of {Word, WordLength} and then passing that list into makeWordLines/4 which builds lines. At this point, passing the lines into wordLinesToString/2 will solve the filled text part of the problem. To solve the justified text part, the lines are passed into justifyWordLines/2 which will calculate how many extra spaces per gap are needed and call wordLineToString/5 to turn the line into a string.

My implementation suffers from floating point arithmetic problems. Some lines will not get the last space in the last gap because the gap value is 0.999999999999 instead of 1. This could be solved in a couple of ways, but I'm ready to move into chapter 4.

Looking at the code now, it's very verbose and can probably be done more succinctly.
[erlang]
-module(threeten).
-export([textProcess/2, justifyText/2, testProcess/1, testJustify/1]).

textProcess(Text, Width) ->
TokenText = tokenizeText(Text),
WordLines = makeWordLines(TokenText, Width, Width, []),
wordLinesToString(WordLines).

justifyText(Text, Width) ->
TokenText = tokenizeText(Text),
WordLines = makeWordLines(TokenText, Width, Width, []),
justifyWordLines(WordLines, Width).

justifyWordLines(WordLines, Width) ->
justifyWordLines(WordLines, Width, []).

justifyWordLines([], _Width, JustifiedLines) ->
lists:flatten(lists:reverse(JustifiedLines));
justifyWordLines([[]|WordLines], Width, JustifiedLines) ->
justifyWordLines(WordLines, Width, JustifiedLines);
justifyWordLines([Line|WordLines], Width, JustifiedLines) ->
SpacesPerGap = case length(WordLines) of
0 -> 0; % the last line isn't justified
_Other -> spacesPerGap(Line, Width)
end,
JustifiedString = lists:reverse(wordLineToString(Line, 0, "", SpacesPerGap, 0)),
justifyWordLines(WordLines, Width, [JustifiedString|JustifiedLines]).

spacesPerGap([], _Width) ->
0;
spacesPerGap(Line, Width) ->
Words = length(Line),
WordLength = lists:foldr(fun({_Word, Length}, Accum) -> Length + Accum end, 0, Line),
ExtraSpaces = Width - WordLength - Words + 1,
Gaps = Words-1,
if
Gaps = 0 -> 0;
ExtraSpaces = 0 -> 0;
ExtraSpaces > 0 -> ExtraSpaces / Gaps
end.

wordLinesToString(WordLines) ->
lists:flatten(wordLinesToString(WordLines, [])).

wordLinesToString([], Strings) ->
lists:reverse(Strings);
wordLinesToString([[]|WordLines], String) ->
wordLinesToString(WordLines, String);
wordLinesToString([Line|WordLines], String1) ->
String2 = wordLineToString(Line, 0, String1, 0, 0),
wordLinesToString(WordLines, String2).

wordLineToString([], _WordNumber, String, _SpacesPerGap, _GapLeftover) ->
NewLine = "\n",
[NewLine|String];
wordLineToString([{Word, _Length}|Line], WordNumber, String, SpacesPerGap, _GapLeftover) when WordNumber == 0 ->
wordLineToString(Line, WordNumber+1, [Word|String], SpacesPerGap, SpacesPerGap);
wordLineToString([{Word1, _Length}|Line], WordNumber1, String, SpacesPerGap, GapLeftover1) ->
WordNumber2 = WordNumber1+1, % figure out the current word number
Spaces = erlang:trunc(GapLeftover1) , % drop the decimal places
GapLeftover2 = GapLeftover1 - Spaces + SpacesPerGap, % adjust the remaining leftover
Word2 = [string:copies(" ", Spaces+1)|Word1],
wordLineToString(Line, WordNumber2, [Word2|String], SpacesPerGap, GapLeftover2).

% end case, out of words
makeWordLines([], _Width, _WidthLeft, [LastLine|Lines]) ->
ReversedLastLine = lists:reverse(LastLine),
AllLines = [ReversedLastLine|Lines],
lists:reverse(AllLines);
% if the line is currently empty, and the word length is = than the length of the line
makeWordLines([{_Word, Length}=Token|Tokens], Width, WidthLeft, [[]|Lines]) when Length = Width ->
makeWordLines(Tokens, Width, WidthLeft-Length, [[Token]|Lines]);
% line with words, and the word length is = the length left
makeWordLines([{_Word, Length}=Token|Tokens], Width, WidthLeft, [LastLine|Lines]) when Length WidthLeft ->
makeWordLines(Tokens, Width, WidthLeft-Length-1, [[Token|LastLine]|Lines]);
% if the line is empty, and the word length is > the width of the line
makeWordLines([{_Word, Length}=Token|Tokens], Width, _WidthLeft, [[]|Lines]) when Length > Width ->
makeWordLines(Tokens, Width, 0, [[Token]|Lines]);
% if there is no more space on the line, reverse the tokens on the last line and push a new one on the stack
makeWordLines(Tokens, Width, _WidthLeft, [LastLine|Lines]) ->
ReversedLastLine = lists:reverse(LastLine),
PreviousLines = [ReversedLastLine|Lines],
makeWordLines(Tokens, Width, Width, [[]|PreviousLines]);
% initial case where we have no existing lines on the stack
makeWordLines(Tokens, Width, WidthLeft, []) ->
makeWordLines(Tokens, Width, WidthLeft, [[]]).

tokenizeText(Text) ->
Tokens = string:tokens(Text, " \t\r\n"),
measureTokens([], Tokens).

measureTokens(Measured, []) ->
lists:reverse(Measured);
measureTokens(Measured, [Token|Tokens]) ->
Length = string:len(Token),
measureTokens([{Token, Length}|Measured], Tokens).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Loading Test Stubs %%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

testProcess(Width) ->
{ok, Text} = readFileText('threeten.text'),
io:format("~s~n", [textProcess(Text, Width)]).
testJustify(Width) ->
{ok, Text} = readFileText('threeten.text'),
io:format("~s~n", [justifyText(Text, Width)]).

readFileText(Filename) ->
case file:open(Filename, read) of
{ok, IoDevice} ->
Words = loadRawTextLines([], IoDevice),
file:close(IoDevice),
{ok, Words};
{error, Reason} -> {error, Reason}
end.

loadRawTextLines(Lines, IoDevice) ->
case file:read_line(IoDevice) of
{ok, Line} -> loadRawTextLines([Line|Lines], IoDevice);
eof -> lists:flatten(lists:reverse(Lines))
end.
[/erlang]

Cheers,
Halzy

Damien Katz: Why is this man so damn happy?

Sat, 17 Apr 2010 19:34:46 +0000

CouchDB!

Caoyuan's Blog: NetBeans(6.8) plugin for Scala 2.8.0 RC1

Thu, 15 Apr 2010 05:02:06 +0000

I'm please to announce the NetBeans (6.8) plugin for Scala 2.8.0 RC1 is available now. It's a maintain release to catch up with Scala 2.8.0 RC1.

The packed plugins is downloadable at: http://sourceforge.net/projects/erlybird/files/nb-scala/6.8v1.1.0rc2/

It requires Scala 2.8.0 RC1, which is available at: http://www.scala-lang.org/downloads. For maven project, it's under http://www.scala-tools.org/repo-releases, with version number "2.8.0.RC1"

Please refer to http://wiki.netbeans.org/Scala68v1 for the installation/upgrading information.

Damien Katz: Oaklandish

Wed, 14 Apr 2010 16:26:03 +0000

Go to Tai Chi at 4 pm Tues. & Thurs. at Gold's Gym Oakland. http://www.goldsgym.com/gyms/calendar.php?gymID=0339

LShift on Erlang: SpringSource / VMWare Acquire Rabbit Technologies

Wed, 14 Apr 2010 13:05:28 +0000

SpringSource, a division of VMware, Inc. today announced the acquisition by VMware of Rabbit Technologies, Ltd, a company set up by LShift and partners Monadic and CohesiveFT.

Read the full story

Joe's Blog: Still Alive.

Tue, 13 Apr 2010 23:10:17 +0000

I am still alive and still maintain the blog but haven’t had time to post recently. Lots of cool stuff brewing at Cloudant. Follow me on Twitter for more immediate updates. In the mean time keep following me here and hopefully I’ll have some blog inspiration soon.

Undefined And Most Likely Disastrous: Twitter Killed My Blog

noreply@blogger.com (andy) — Tue, 13 Apr 2010 17:26:00 +0000

In case you haven't noticed, this blog is dead. Find me on Twitter or at The Basho Blog

Erlang Inside: RabbitMQ acquired by SpringSource/VMWare

Tue, 13 Apr 2010 13:40:31 +0000

Erlang-based RabbitMQ was acquired today by SpringSource...

Process-one Blogs: ProcessOne at Google I/O Developer Sandbox 2010

Tue, 13 Apr 2010 08:49:46 +0000

We have been selected to demonstrate our WaveOne server and preview client in Google I/O developer sandbox.

ProcessOne will be presenting many of its new products as a preview technology implementation, among which:

WaveOne server and extension module for ejabberd XMPP server.
Various example client implementations using the Wave protocol from XMPP: OneTeam for Firefox client extension, and Tkabber support.
Jingle and Jingle Nodes XMPP calling with our OneTeam client.
The roadmap for the future of our XMPP and Wave collaborative platform.

We are also preparing various surprises for the people who can attend Google I/O (Did I say Android?).

This is going to be an extraordinary event for us. See you there!

[More...]

Learn You Some Erlang: A Short Visit to Common Data Structures

Tue, 13 Apr 2010 00:00:00 +0000

Chances are you now understand the functional subset of Erlang pretty well and could read many programs without a problem. However, I still feel like there's a few things missing. In this last chapter about the functional subset of Erlang, I cover concepts such as records, key-value stores, sets and other data structures that are part of the standard library.

RedHotErlang: Collective Intelligence

Mon, 12 Apr 2010 17:41:00 +0000

I'm reading a great book named: [Collective Intelligence][1]. I have only read the first three chapters so far. It takes time though, since I'm [re-implementing][2] the examples in Erlang, but it has also been great fun. [1]: http://oreilly.com/cata...

RedHotErlang: Webmachine and multiple IP/Ports

Sat, 10 Apr 2010 15:49:10 +0000

I've been playing around with [Webmachine][1] lately and I like it a lot. In the 1.5 release Host specifications was added to the dispatch.conf file. This makes it possible to support several hosts in the same Webmachine system. It looks something li...

Process-one Blogs: Slides: Real time Web Application with XMPP and Wave

Wed, 07 Apr 2010 16:30:32 +0000

This is the slides of the talk I have given at Erlang Factory 2010 event in San Francisco.

Here are the slides of my presentation on XMPP and our implementation of Wave protocol:

Real time Web Application with XMPP and Wave

View more presentations from Mickaël Rémond.

Next blog post will present a screencast of the federation demonstration between our OneWave server and Google Sandbox.

BGH's Blog: Erlang Programming Exercise: 3-9

Wed, 07 Apr 2010 15:18:58 +0000

In exercise three-nine you are to read some text into a raw document (list of lines) and then into a document (list of words). With this data you generate an index for the words to which lines they were on:

{ "Erlang", [1,1,2,4,5,6,6,98,100,102,102] }

After you have the word to line index, pretty print the index such that the example above would result in:

"Erlang 1-2,4-6,98,100,102"

I decided to start using more of the library functions in order to become more familiar with them. I used the lists/foldr function more than anything else since it lets you visit every element in a list and maintain an accumulator. It was particularly useful in situations where I didn't want to do any pattern matching on the argument, like when I broke the lines into words. It was not useful when I tried to generate the tuples needed for the pretty printed line numbers, this could have been done using a switch statement but I found the code more elegant using the recursive pattern matching.

Instead of copy/pasting a chunk of text into erl every time I wanted to test it, I made the indexer load a file from disk. I also aligned the line numbers, having them all start on the same column made a big difference visually. Here's an example run:

[shell]
1> threenine:index("./threenine.erl").
0 70
1 2, 30, 32, 37, 41, 57, 80
2 64
binary 77
bs 71
case 5, 22, 37
cleannumbers 46, 51-60
close 8, 14
concat 87-88
...
updatedlinenumbers 46-47
updatedwordindex 41-42
updatewordindexlinenumbers 17, 44
when 57
[/shell]

Here is the code:

[erlang]
-module(threenine).
-export([index/1]).

index(Filename) ->
case file:open(Filename, read) of
{ok, IoDevice} ->
indexFile(IoDevice),
file:close(IoDevice);
{error, Reason} -> {error, Reason}
end.

indexFile(IoDevice) ->
RawDocument = loadRawDocument([], IoDevice),
file:close(IoDevice),
Document = loadDocument(RawDocument),
WordIndex1 = indexWords(Document),
WordIndex2 = updateWordIndexLineNumbers(WordIndex1),
prettyPrintWordIndex(WordIndex2),
ok.

loadRawDocument(Lines, IoDevice) ->
case file:read_line(IoDevice) of
{ok, Line} -> loadRawDocument([Line|Lines], IoDevice);
eof -> lists:reverse(Lines)
end.

loadDocument(RawDocument) ->
MakeDoc = fun(Line, {LineNo, Document}) ->
Tokens = string:tokens(Line, "\r\n\t {,}->:;[]().|\\=/~\"'+_"),
{LineNo+1, [{LineNo, Tokens}|Document]}
end,
{_LineNumber, Document} = lists:foldl(MakeDoc, {1, []}, RawDocument),
lists:reverse(Document).

indexWordsFun(Word, {LineNo, WordIndex}) ->
LowerWord = string:to_lower(Word),
LineNumbersList = case lists:keyfind(LowerWord, 1, WordIndex) of
{LowerWord, LineNumbers} -> LineNumbers;
false -> []
end,
UpdatedWordIndex = lists:keystore(LowerWord, 1, WordIndex, {LowerWord, [LineNo|LineNumbersList]}),
{LineNo, UpdatedWordIndex}.

updateWordIndexLineNumbers(WordIndex) ->
Update = fun({Word, LineNumbers}, NewWordIndex) ->
UpdatedLineNumbers = cleanNumbers(LineNumbers, []),
[{Word, UpdatedLineNumbers}|NewWordIndex]
end,
lists:foldr(Update, [], WordIndex).

cleanNumbers([], CleanNumbers) ->
CleanNumbers;
cleanNumbers([Number|LineNumbers], []) ->
cleanNumbers(LineNumbers, [{Number, Number}]);
cleanNumbers([Number|LineNumbers], [{_Start, Number}|_Tail]=NewNumbers) ->
cleanNumbers(LineNumbers, NewNumbers);
cleanNumbers([Number|LineNumbers], [{Start, End}|Tail]) when Number == End+1 ->
cleanNumbers(LineNumbers, [{Start, Number}|Tail]);
cleanNumbers([Number|LineNumbers], NewNumbers) ->
cleanNumbers(LineNumbers, [{Number, Number}|NewNumbers]).

indexWords(Document) ->
IndexWords = fun({LineNo, Words}, WordIndex) ->
{LineNo, WordIndex2} = lists:foldr(fun indexWordsFun/2, {LineNo, WordIndex}, Words),
WordIndex2
end,
lists:foldr(IndexWords, [], Document).

makePrintFormat(WordIndex) ->
MaxLength = lists:foldr(fun({Word,_Lines}, Max) -> erlang:max(string:len(Word), Max) end, 0, WordIndex),
io_lib:format("~~-~Bs ~~s~~n", [MaxLength]).

prettyPrintWordIndex(WordIndex) ->
PrintFormat = makePrintFormat(WordIndex),
PrintWord = fun({Word, LineNumbers}, Format) ->
PrettyLineNumbers = makePrettyLineNumbers(LineNumbers),
io:format(list_to_binary(PrintFormat), [Word, PrettyLineNumbers]),
Format
end,
lists:foldr(PrintWord, PrintFormat, lists:reverse(lists:keysort(1,WordIndex))).

getPrettyLineNumbers(Result, []) ->
Result;
getPrettyLineNumbers(Result, [{Number,Number}|LineNumbers]) ->
getPrettyLineNumbers([integer_to_list(Number)|Result], LineNumbers);
getPrettyLineNumbers(Result, [{Start,End}|LineNumbers]) ->
Range1=string:concat(integer_to_list(Start), "-"),
Range2=string:concat(Range1, integer_to_list(End)),
getPrettyLineNumbers([Range2|Result], LineNumbers).

makePrettyLineNumbers(LineNumbers) ->
RangedLineNumbers = getPrettyLineNumbers([], LineNumbers),
string:join(RangedLineNumbers, ", ").
[/erlang]

Cheers,
-Halzy

Process-one Blogs: New set of iPhone applications: Oneteam for Gtalk and TextOne

Tue, 06 Apr 2010 15:17:17 +0000

We have recently released a new set of applications on Apple AppStore to complete our professionnal XMPP offering on iPhone. Both applications are targeting end users.

OneTeam for Gtalk is a lightweight standalone version of OneTeam for iPhone. It supports user id with either @gmail.com or @googlemail.com domain names. It is as cleaned and streamlined as OneTeam for iPhone and supports push for Gtalk through an XMPP proxy server, which makes it an exclusivity on Apple AppStore. Note that the proxy server is used only when pushed is enabled.

TextOne is a very simple, session-less, presence-less messaging client. It supports exclusive features like:

Message reliability to ensure delivery garantee: you are warned if the message could not reach the end user.
Simple groupchat: You can message a group of friends (in any combination) and reply will go to every one in the original conversation. We used it for a while and yes, this is really a must have and killer feature on mobile.

Here are a few screenshots of OneTeam for Gtalk:

Here is a couple of screenshots for TextOne:

Your feedback is of course welcome on our forum:

Note: both applications cost 0,79 euros.

Erlang Examples: Building Erlang B13R04 in Ubuntu 9.10 Karmic

Mon, 05 Apr 2010 14:03:14 +0000

Frankly speaking, I always use apt-get to install Erlang rather than building from source… lazy huh? Unfortunately, when I apt-get in Ubuntu 9.10 Karmic, only Erlang/OTP R13B01 (5.7.2) is available whereas the latest is R13B04 (5.7.5) which is required to build Riak (actually rebar requires 5.7.4 and above)…

It takes around 10-15 min to build, and these are the required libraries and dependencies

sudo apt-get install build-essential m4 libncurses5-dev libssl-dev xsltproc fop
axel -n 20 http://www.erlang.org/download/otp_src_R13B04.tar.gz
tar xfvz otp_src_R13B04.tar.gz
cd otp_src_R13B04/
./configure --with-ssl
sudo make install

Here i’m using axel for fast download, it’s your choice to use curl or wget.

Ulf Wiger: Erlang.org traffic no longer exponential

Mon, 05 Apr 2010 11:00:07 +0000

Bjarne Däcker, who has been tracking download and web site statistics on erlang.org for years, just produced a new graphic.

Visits to http://www.erlang.org up to March 2010

For years, the erlang.org graph has been nicely exponential. This latest peak seems to break the pattern. It will be interesting to see what follows.

(Update: Looking closer at the graph, it appears to stretch as far as to March 2010. I changed the caption, but left the URL unchanged.)

(Update 2: Closer inspection suggests that this is indeed measurement error. Google analytics, which also takes mirrors into account, reports a steady, but decidedly less dramatic, rise. The number of visitors to erlang.org is now at ca 80,000/month, up from ca 57,000/month in September 2008.)

REALITY.SYS: Nativ implementierte Funktionen in Erlang

Mon, 05 Apr 2010 10:48:27 +0000

Ein interessantes, neues Feature in Erlang sind die NIFs (native implemented functions). Diese Funktionen werden auf die gleiche Art und Weise angewandt wie die reinen Erlang-Funktionen. NIFs ermöglichen, unter anderem, ein über bestimmte Vorgaben abgesichertes Zugreifen auf externen Code. Jedes NIF-Modul muss bestimmte Callbacks implementieren, damit ein ordentliches Verwalten derselben möglich ist. Die Callbacks sind: load, reload, upgrade und unload.

Jeder dieser Funktionen erwarter ein ErlNifEnv* Argument sowie einen void-Pointer auf Modul-spezifische Daten. Und bis auf unload hat jeder Callback noch ein load-Argument vom Typ ERL_NIF_TERM.

Gegeben ist ein Modul namens funcModule.c

 static int load(ErlNifEnv* env, void** priv, ERL_NIF_TERM load_info)
 {
        return 0;
 }

[...andere Funktionen haben dieselbe Signatur...]

Bei unload schaut es aber etwas anders aus:

static void unload(ErlNifEnv* env, void* priv)
{
        return;
}

funcModule.c erhält auch die eigens geschriebene Funktion an und fügt sie in eine Struktur vom Typ ErlNifFunc ein.

static ERL_NIF_TERM func1(ErlNifEnv* env, ERL_NIF_TERM arg)
{
  [... eigener Code ... ]
}

static ErlNifFunc exported_funcs[] =
{
   {"func1", 1, func1}
};

Der Aufbau der Sturuktur ist folgenermaßen: Erlang-Funktionsname, Arity (d.h. die Stelligkeit der Funktion, d.h. wiederum: wieviele Parameter erwartet sie) und der C-Name der Funktion)

Diese Struktur wird über das folgende Makro “bekannt gemacht”:

ERL_NIF_INIT(funcModule, exported_funcs, load, reload, upgrade, unload)

Das Modul wird jetzt kompiliert und anschließend vom Erlang-Code aus angewandt:

-module(func_consumer).
-export([start/0,func1/1]).

start() ->
         erlang:load_nif("funcModule",0).
func1(_Value) ->
         nif_error(?LINE).
nif_error(Line) ->
         exit({nif_not_loaded,module,?MODULE,line,Line}).

Der Aufbau ist denkbar einfach: zuerst wird das externe C-Modul mittels der Funktion “start” geladen. Danach versucht die exportierte func1 ausgeführt zu werden. Wenn mit dem C-Modul alles ordentlich verlaufen ist, wird die zuvor in C definierte Funktion ausgeführt, ansonsten gibt es einen Erlang-Fehler inklusive der Angaben, wo dieser passierte und in welchem Modul.

Somit ist die Ausführung ausfallsicher, denn im Falle eines Problems auf der C-Seite gibt es immer zumindest eine lesbare Erlang-Fehlermeldung.

Mehr Details zu diesem nützlichen Erlang-Feature gibt es hier zu lesen (die Beispiel-Codes in diesem Beitrag basieren auf diesem Tutorial): http://www.davispj.com/2009/11/23/erlang-nif-test.html

Technische Details zu NIFs gibt es hier: http://www.erlang.org/doc/man/erl_nif.html

REALITY.SYS: Erlang Concurrency

Mon, 05 Apr 2010 09:36:43 +0000

Erlang’s concurrency model has been used in commercial systems for well over 15 years, but what differentiates it from other technologies …

http://fora.tv/2008/11/19/Erlang_Concurrency_Whats_the_Fuss

Programming in the 21st Century: Rethinking Programming Language Tutorials

Sat, 03 Apr 2010 06:00:00 +0000

Imagine you've never programmed before, and the first language you're learning is Lua. Why not start with the official book about Lua? Not too far in you run across this paragraph:

The table type implements associative arrays. An associative array is an array that can be indexed not only with numbers, but also with strings or any other value of the language, except nil. Moreover, tables have no fixed size; you can add as many elements as you want to a table dynamically. Tables are the main (in fact, the only) data structuring mechanism in Lua, and a powerful one. We use tables to represent ordinary arrays, symbol tables, sets, records, queues, and other data structures, in a simple, uniform, and efficient way. Lua uses tables to represent packages as well. When we write io.read, we mean "the read entry from the io package". For Lua, that means "index the table io using the string "read" as the key".

All right, where to start with this? "Associative arrays"? The topic at hand is tables, and they're defined as being synonymous with an odd term that's almost certainly unfamiliar. Ah, okay, "associative array" is defined in the next sentence, but it goes off track quickly. "Indexed" gets casually used; there's the assumption that the reader understands about arrays and indexing. Then there's the curious addendum of "except nil." All this talk of arrays and association and indexing, and the novice's head is surely swimming, and then the author throws in that little clarification, "except nil," as if that's the question sure to be on the mind of someone who has just learned of the existence of something called a table.

I've only dissected two sentences of that paragraph so far.

Really, I should stop, but I can't resist the declaration "Lua uses tables to represent packages as well." Who is that sentence written for exactly? It has no bearing on what a table is or how to use one; it's a five mile high view showing that a beautifully invisible language feature--packages--is really not so invisible and instead relies on this table idea which hasn't been explained yet.

I don't mean to single out Lua here. I can easily find tutorials for other languages that have the same problems. Every Haskell tutorial trots out laziness and folding and type systems far too early and abstractly. Why? Because those are the concerns of people who write Haskell tutorials.

To really learn to program, you have to go around in circles and absorb a lot of information. You need to get immersed in the terminology. You'll be exposed to the foibles and obsessions of language communities. You'll absorb beliefs that were previously absorbed by people who went on to write programming tutorials. It's hard to come out of the process without being transformed. Not only will you have learned to program, but all that nonsense that you struggled with ("We use tables to represent ordinary arrays...") no longer matters, because you get it. After that point it's difficult to see the madness, but it's still there.

Programming language tutorials shouldn't be about leaning languages. They should be about something interesting, and you learn the language in the process.

If you want to learn to play guitar, the wrong approach is to pick up a book about music theory and a chart showing where all the notes are on the fretboard. There's a huge gap between knowing all that stuff and actually playing songs. That's why good music lessons involve playing recognizable songs throughout the process. But what do we get in programming tutorials? Hello World. Fibonacci sequences. Much important manipulation of "foo."

Not all tutorials are this way. Paradigms of Artificial Intelligence Programming is a survey of classic AI programs mixed together with enough details about Lisp to understand them. I've mentioned others in Five Memorable Books About Programming. But I still want to see more. "Image Processing in Lua." "Massively Multiplayer Games in Erlang." "Exploring Music Theory (using Python)."

I'll give a real example of how "Image Processing in Lua" could work. You can convert the RGB values of a pixel to a monochrome intensity value by multiplying Red, Green, and Blue by 0.3, 0.6, and 0.1 respectively, and summing the results. That's an easily understandable Lua function:

function intensity(r, g, b)
   return r*0.3 + g*0.6 + b*0.1
end

If each color value ranges from 0 to 255, then a full white pixel should return the maximum intensity:

intensity(255, 255, 255)

and it does: 255. This tiny program opens the door for showing how the R, G, and B values can be grouped together into a single thing...and that turns out to be a table! There's also the opportunity to show that each color element can be named, instead of remembering a fixed order:

{green=255, blue=255, red=255}

Rewriting the "intensity" function first using tables and then using tables with named elements should hammer home what a table is and how it gets used. There was no need to mention any techy tangentials, like "tables have no fixed size." (That can go in a terse reference doc.)

After all, the reason to learn a programming language is to do something useful with it, not simply to know the language.

(If you liked this, you might like The World's Most Mind-Bending Language Has the Best Development Environment.)

BGH's Blog: Erlang Programming Exercise: 3-8-4 & 3-8-5

Fri, 02 Apr 2010 14:33:43 +0000

I enjoyed coding up 3-8-4 and 3-8-5. It took just a couple hours to finish the pair. In the first one you implement a compiler for a stack machine, in the second you implement the stack machine. There is a lot to think about. How does a stack machine work? What will you be generating? How do the instructions for (3+4)+5 differ from 3+(4+5)? How will the stack machine differ from the evaluator in 3-8-2?

Starting out I looked up stack machine on Wikipedia and found a link to "0-operand" instruction sets that had enough information for me to get going. I decided to keep all of my instructions one token long for simplicity. I have 'add' and 'sub' which use the first two arguments off of the stack, 'umin' (unary minus) only uses the the first item off of the stack. I don't have a need for a 'pop' instruction and decided that 'push' was the default. As an example, adding 1+2 would look like: [1, 2, add]. The numbers would get pushed onto the stack, and then add would take the first two items off of the stack, add them together and place the results back onto the stack.

I may at a later time go back and change the instruction set to have proper push and pop instructions, but for now, this worked.

[erlang]
-module(threeeightyfour).
-export([compile/1]).

translateInstruction(unary_minus) -> umin;
translateInstruction(minus) -> sub;
translateInstruction(plus) -> add.

compileExpression(Instructions, []) ->
Instructions;

compileExpression(Instructions, [{num, Value}|Expressions]) ->
compileExpression([Value|Instructions], Expressions);

compileExpression(Instructions, [{Operator, Value}|Expressions]) ->
Op = translateInstruction(Operator),
OpInstructions = [Op|Instructions],
ValueExp = [Value|Expressions],
compileExpression(OpInstructions, ValueExp);

compileExpression(Instructions, [{Operator, LHS, RHS}|Expressions]) ->
Op = translateInstruction(Operator),
OpInstructions = [Op|Instructions],
RightExp = [RHS|Expressions],
LeftExp = [LHS|RightExp],
compileExpression(OpInstructions, LeftExp).

compileExpression(Expression) ->
compileExpression([], [Expression]).

compile(Results, []) ->
lists:reverse(Results);
compile(Results, [CurrentExpression|Expressions]) ->
Result = compileExpression(CurrentExpression),
compile([Result|Results], Expressions).

compile(Expressions) ->
compile([], Expressions).
[/erlang]

And the stack simulator:
[erlang]
-module(threeeightyfive).
-export([simulate/1]).

simulator(Instructions) ->
simulator([], Instructions).

simulate(Results, []) ->
lists:reverse(Results);
simulate(Results, [Instructions|ArraysOfInstructions]) ->
Result = simulator(Instructions),
simulate([Result|Results], ArraysOfInstructions).

simulate(ArraysOfInstructions) ->
simulate([], ArraysOfInstructions).
[/erlang]

Cheers,
-Halzy

Process-one Blogs: New Strategic Guide released: from Real-time to Interpersonal Web

Thu, 01 Apr 2010 13:21:02 +0000

ProcessOne has just released a new strategic guide explaining the underlying trends of the web evolution and how this will lead to the interpersonal web, the core business of ProcessOne.

Instant messaging has grown so rapidly in popularity and usage that it is shaping the next era in the evolution of the Internet. This Strategic Guide explains how demand for more real-time communication and personalized content is leading to the emergence of the Interpersonal Web.

The reference document is published on IMtrends: Strategic Guide: The Interpersonal Web.

Further articles with explain how to build this Interpersonal web thanks to ProcessOne technologies.

Your comments are welcome.

Erlware: SF Erlang Factory Talks and Slides

martinjlogan@erlware.org (Martin J. Logan) — Thu, 01 Apr 2010 13:03:39 +0000

For those of you who would like to view the presentation slides from the speakers, these are now available here: http://www.erlang-factory.com/conference/SFBay2010/talks (please click on the icon underneath the individual talk description). Erlang Solutions have posted most of the photos from the conference on Flickr: http://www.flickr.com/photos/erlang-consulting/collections/72157623733690054/

Erlware: Erlang Factory: Steve Vinoski: Using Erlang in a Carrier Grade Media Distribution Switch

martinjlogan@erlware.org (Martin J. Logan) — Wed, 31 Mar 2010 14:55:42 +0000

Steve spent his first 6 years as a hardware test engineer. Spent 17 years doing enterprise middlware with, horrors, corba. Left that world and discovered Erlang - became depressed when he saw how much easier the previous 17 years could have been. Part of the reason that he left and joined Verivue, the media delivery startup he is currently with, was because of Erlang. Verivue runs a managed

Process-one Blogs: Strategic Guide: The Interpersonal Web

Tue, 30 Mar 2010 17:59:34 +0000

Instant messaging has grown so rapidly in popularity and usage that it is shaping the next era in the evolution of the Internet. This Strategic Guide explains how demand for more real-time communication and personalised content is leading to the emergence of the Interpersonal Web.

Download the document:

English version: Strategic Guide: The Interpersonal Web (PDF).

Process-one News: Strategic Guide: The Interpersonal Web

Tue, 30 Mar 2010 17:59:34 +0000

Download the document:

English version: Strategic Guide: The Interpersonal Web (PDF).

Trapexit's Erlang Blog Filter: “Erlang the Movie” Poster

Mon, 29 Mar 2010 16:47:19 +0000

They handed out this poster at Erlang Factory. Brilliant!

LShift on Erlang: On the limits of concurrency: Worker Pools in Erlang

Mon, 29 Mar 2010 09:35:18 +0000

A worker pool is a very common pattern, and they exist in the standard libraries for many languages. The idea is simple: submit some sort of closure to a service which commits to running the closure in the future in some thread. Normally the work is shared out among many different threads and in the absence of anything fancier, one assumes a first-come-first-served queue of closures.

Erlang, with its light-weight process model is not a language which you would expect would require such an approach: processes are dirt cheap, and the scheduler maps processes onto threads when they are ready to be run — in many ways, the ErlangVM is a glorified implementation of a worker pool, only one that does pre-emption and other fancy features, in a very similar way to an OS kernel. However, we recently found in RabbitMQ a need for a worker pool.

At various points in RabbitMQ, we use mnesia transactions to ensure that state that is held by mnesia (for example, the existence or otherwise of a queue) is updated safely. A client recently informed us that he was creating 10,000 connections, each connection was creating a queue, with exclusive set (which means the queue must be deleted automatically when the connection disappears), and then dropping all the connections at the same time. RabbitMQ would become very unresponsive, for a very very long time. A small amount of head scratching and some quick testing led to the conclusion that this was creating 10,000 transactions, all on the same table, all of which were continuously colliding with each other and thus having to be restarted. Here, the realisation is that there is frequently no good reason to allow more mnesia transactions to go on at the same time than you have cores available — the probability of a collision will rise exponentially with the number of concurrently in flight transactions.

The solution here is to submit all of these transactions to a worker pool which has the same number of workers as there are CPU cores in the system. As a result, the probability of a collision is greatly reduced, and things progress much much faster. In many ways, this is a good example of where hinting to the underlying VM as to how it should schedule different jobs would result in massively improved performance.

One interesting gotcha with this solution is the issue of nested transactions. Mnesia handles these very well indeed, but if we wrap every transaction in a submission to the worker pool, we stop mnesia from knowing that these transactions are nested (which means we lose the unrolling of the inner ones if the outer one subsequently fails), and furthermore, we risk deadlock if every worker in the pool is waiting on another nested transaction to complete. To solve this problem, on submission of a closure, we detect whether or not we are already in a worker pool process, and if we are, we just run the closure in the current process without submission at all. This means that nested transactions are correctly run in the same process as their parent, and we don’t reach deadlock.

The code is already QA’d and merged into our default branch and is in the three modules worker_pool_sup (which is the module you just need to start up, it’ll then start everything else), worker_pool_worker (the actual workers who do the, erm, work), and worker_pool (which is the module to which you submit your jobs). Note that the submission is synchronous, thus you will be returned the result of your closures. Furthermore, your closures are responsible for catching any errors that might occur and returning them to you as values. Finally, note that you’ll also need our gen_server2 module as the worker_pool and worker_pool_worker modules both use this.

Trapexit's Erlang Blog Filter: Erlang Factory: You Should’ve Been There

Mon, 29 Mar 2010 02:19:26 +0000

The Erlang Factory SF Bay Area 2010 conference just wrapped up last Friday, and it was fantastic. The talks were of high quality and the conference organization was excellent. The slides for all the talks should be on the Erlang Factory site soon.

If you missed this one, I strongly encourage you to attend the London Erlang Factory coming up in June if you can.

Erlware: Erlang Factory: Martin Logan, Eric Merritt, Richard Carlson: Writing a Technical Book

noreply@blogger.com (Jordan Wilberding) — Fri, 26 Mar 2010 14:59:12 +0000

Where to start Writing a technical book is at least as hard as you think it is, porbably even more. The main prerequisite is believing you have something important and worth saying. After that the next thing to do is to choose a medium. In this case a publisher. They chose manning. The first step is writing

Process-one Blogs: OneTeam Media Server by ProcessOne

Fri, 26 Mar 2010 14:00:35 +0000

ProcessOne has just released OneTeam Media Server, a Flash server written in erlang.

OneTeam Media Server, or OMS for short, is a new Flash server implementation, written in erlang, by ProcessOne. This will enable your users to broadcast voice and/or video streams to multiple subscribers.

OneTeam Media Server, although being at an early stage, behaves already quite well, since it is more scalable than red5. It might not be a fair comparison though, since it OMS is not as featurefull as red5.

Key features:

Support for streaming live/recorded content
Support for recording live content
Support for ActionScript3.0 Shared Objects
Clustering support
Ability to write application modules in Erlang/OTP

It still does not include RTMPT for HTTP tunneling. The license chosen for OneTeam Media Server is the Erlang Public License version 1.1. OMS needs Erlang/OTP R11B-0 or higher.

The source code is available here: https://git.process-one.net/oms

To pull the source code form git, please type:

git clone git://git.process-one.net/oms/mainline.git

The usual procedure is required (./configure, make, sudo make install). To start OMS, just type:

omsctl start

Please check the documentation in:

doc/doc.html

Erlware: Erlang Factory: Michael Truog The Cloud as an Interface

noreply@blogger.com (Tristan Sloughter) — Fri, 26 Mar 2010 12:35:07 +0000

A Cloud as an Interface - http://cloudi.org/Cloudi - not for webapps or data cloud, but for processing. For managing processes and making sure they are fault tolerant.Cloudi is a flexible framework for private cloud computing. Its dynamically loud balanced and scheduled. Distributed execution of C/C++ work.Cloudi is an alternative to paying for a blackbox commercial cloud.Erlang coordinates all

Erlware: Riak Search

noreply@blogger.com (Tristan Sloughter) — Fri, 26 Mar 2010 12:19:00 +0000

Riak SearchPresented by John Muellerteile from Basho.Fulltext and general indexing methods.Agenda* Intro* A search Tale* Riak search"I used to make stuff" (but now I'm a database hacker)Got sick of having to roll own indexes.Act 1: I love luceneLife is good, fast and predictable.Act 2: Cluster LuckA few shards, good performance.Act 3: SANFULots of shards. Operational nightmare. Diminishing

Erlware: Git Basics

noreply@blogger.com (Tristan Sloughter) — Fri, 26 Mar 2010 12:18:46 +0000

Mastering Git BasicsGiven by @mojombo the cofounder and cto of github.Initial Config:git config --global user.name [NAME]git config --global user.email [EMAIL]git config --global color.ui trueLast one gives nice colors for diffs and such.Creating and CommittingMake a dir for your project:$ cd patch/to/repos$ mkdir hello$ cd hellogit init$ git init # converts empty directory into a git repo.

Erlware: Erlang Factory: Jack Moffit: Erlang Is Our Superpower

noreply@blogger.com (Jordan Wilberding) — Fri, 26 Mar 2010 12:09:25 +0000

Introduction to Erlang Started as a game, chess park. Play chess online. Were python guys, so wrote it in python. Decided to use XMPP for all the wonderful features it has. Started using jabbberd. Weren't happy with it. Decided to look at ejabberd, which led them to Erlang. New Product Wanted to have a

Erlware: Erlang Factory: Tony Garnock-Jones: What is messaging and why should we care?

noreply@blogger.com (Jordan Wilberding) — Fri, 26 Mar 2010 10:51:24 +0000

Why messaging? Scaling, load balancing Delayed jobs, task queues Multicast and broadcast Trusted store-and-forward Management monitoring Decoupling of components What is messaging? Messaging involves relaying, filtering, buffering, queueing, and transfer of responsibility. Where is messaging? See it in

Erlware: Erlang Factory: Yogish Baliga, Mark Zweifel: Deploying Erlang at Yahoo - A Case Study

noreply@blogger.com (Eric) — Fri, 26 Mar 2010 10:51:15 +0000

We are going to do this collaboratively. We have worked together for over a year, we talk a lot together and thats what we are going to do here. When you try to bring in a new language to a new company you don't want to be tagged as someone who chose something to be clever. So we did something in three stages. We will give you the back ground as well as what we did. The critical thing here is to

Erlware: Erlang Factory: Joe Armstrong: Keynote - What are the Important Ideas in Erlang?

noreply@blogger.com (Jordan Wilberding) — Fri, 26 Mar 2010 10:00:15 +0000

Plan -History -3 things missing -1 big mistake -2 good ideas -3 great ideas Erlang crawled along starting from 1986. Picked up in 1996-1998, then died out for a bit, and now is becoming popular once again. 1986-89 were productive years. 1989-96 was at war with the world. 1996-98 peace broke out. 1998-2000

Erlware: Erlang Factory: Mats Cronqvist :The nine nines and how to get there

martinjlogan@erlware.org (Martin J. Logan) — Thu, 25 Mar 2010 17:28:04 +0000

Rumination, a calm and lengthy intent consideration. Mats will rumnate on 9 9s of uptime. We will cover debugging the axd switch and generally on debugging Erlang itself.Mats is going to pick on Joe Armstrong because he does not care... all these internet sites talk about 9 9s of uptime. It is based on an internal Ericsson slide that you can't find on the internet. This slide had to do with some

Erlware: Erlang Factory: Kenji Rikitake: Erlang Secure RPC and the SSH module

noreply@blogger.com (Eric) — Thu, 25 Mar 2010 17:24:46 +0000

My Erlang ActivitiesDiscovered erlang in 2008, via Joe's book. Patches accepted, TAI leap second, SSH aes123-cbc, backporting freebsd patches, there for quite a long time. First I am going to talk about the security weakness in erlang in general and then why ssh is needing and finally an ssh protocol review, four how erlang supports ssh, six prototype implementation and support. Lets talk about

Erlware: Erlang Factory: Todd Lipcon: Thrift Avro/Erlang bindings

martinjlogan@erlware.org (Martin J. Logan) — Thu, 25 Mar 2010 16:44:19 +0000

Thrift and avro bindings with Erlang. Previously Todd built many websites in the standard languages for doing such things. He worked for Amie Street and Songza which is where he had the chance to work with Erlang. This talk is really not for those doing hobby websites. This talk is for those doing enterprize level websites. This is for websites with multi functional teams. Popular Web

Erlware: Erlang Factory: Kresten Thorup: Erjang

noreply@blogger.com (Eric) — Thu, 25 Mar 2010 16:32:34 +0000

This is my project to learn Erlang. There are a lot of questions in the community about wether this is possible at all. This ignited me, so I had to go prove that it is possible. I have a software company of around a 100 people and we are mostly doing java. We are the goto guys for java in denmark. We where a very early adapter of java. We have been very successful with that. Recently I have been

Erlware: Erlang Factory: Chad DePue: Lua Integration with Erlang

noreply@blogger.com (Eric) — Thu, 25 Mar 2010 16:17:05 +0000

Problems we start having with it is when you start running multiple servers (monit). A couple of cool things about monit and god, nice because its turing complete, monitor with distributed monitoring like with m/monit. Problem with it is that its running in ruby. Erlang, monitoring code is in erlang, configuration in lua. connected nodes share the same configuration. How does that interact with

Erlware: Erlang Factory: Patrick Nyblom: Erlang SMP Support - Behind the Scenes

noreply@blogger.com (Eric) — Thu, 25 Mar 2010 15:21:02 +0000

Erlang Multicore SupportIf you went to EUC this year, this is a good time to take a nap. This talk will be very similar to that one. The erlang multicore support has been in the product for a couple of releases. we started five or six years ago with the single cpu virtual machine. Its still there, if you start on a single core machine you get the single threaded virtual machine. Now we have

Erlware: Erlang Factory: Sean Cribbs: Achieving Parsing Sanity with Neotoma

martinjlogan@erlware.org (Martin J. Logan) — Thu, 25 Mar 2010 14:52:16 +0000

CucumberSean worked on a testing framework for doing acceptance testing called cucumber. Cucumber let you write agile stories that were executable. Sean had a thought, why not write cucumber in Erlang? Gherkin uses TreetopA simple language for expressing tests. Why not use leex and yecc to do the parser generation for handling Gherkin/Treetop. The problem with using leex and yecc was that the

Erlware: Erlang Factory: Cliff Moon: Fast Enough

noreply@blogger.com (Eric) — Thu, 25 Mar 2010 13:24:04 +0000

I had a bunch of slow erlang that I ported to C and now I have two problems. So we are going to talk about how to be fast enough.Performance Tuning, Profiling all the things you need to do before this point. Through put, Online transaction processing, 99.9% latency. These are the things that typically matter. How do we go about profiling.Identify bottle necks. Optimize algorithmsPort critical

Erlware: Erlang Factory: Andy Gross: Distributed Erlang Systems In Operation: Patterns and Pitfalls

martinjlogan@erlware.org (Martin J. Logan) — Thu, 25 Mar 2010 12:56:56 +0000

Andy is the VP of engineering and social media liability at Basho Technologies. He has been doing work on distributed systems ever since he worked at akami for 7 years. He really wished he knew about Erlang back then. After moving to apple he wrote distributed systems in objective c and so on. After getting sick of that he went to work at mochi media and fell in love with Erlang. Now at basho

Erlware: Erlang Factory: Bjarne Däcker: discussion of basic vs. applied research in the software domain and the creation of Erlang

noreply@blogger.com (Eric) — Thu, 25 Mar 2010 11:13:46 +0000

CSLab and all that ...How many at Erlang factory in london last summer (few), not exactly the same talk as then. (microphone issues). Reason for this talk is to explain the background to Erlang. It wasn't just something that fell out of the sky. There was a lot of thinking behind it. At a big company like Ericsson there are research activities that are structured into laboratories. We went to

Erlware: Erlang Factory: Welcome - Francesco Cesarini

noreply@blogger.com (Eric) — Thu, 25 Mar 2010 09:23:39 +0000

Growth in the Erlang Comunity. His first consulting gig in the US was in 2002 in chicago. At that point not more then 10 companies using Erlang in the US. One of those companies was Cellpoint, which eventually brought Erlang to South Africa, where it has grown tremendously. Other non-Ericsson companies using Erlang Telia (sweden) Bluetail (sweden) Cellpoint (sweden, Uk, US) One 2 On (UK) IdealX (

Erlware: Erlang Factory - San Francisco 2010 Live Blogging

noreply@blogger.com (Eric) — Thu, 25 Mar 2010 09:18:37 +0000

Your Erlware Devs are attending the Erlang Factory 2010 in San Francisco. Both Eric and Martin are Track Hosts and speakers for this event. We are going to do our best to live blog the various talks and events starting this morning. We will have live updates of the talks on the Erlware blog.Update - that is 2010 not 2009 as the original title indicated - obviously

Damien Katz: Replication

Tue, 23 Mar 2010 21:57:07 +0000

Some cool Apache CouchDB replication related links:

LShift on Erlang: The fine art of holding a file descriptor

Tue, 23 Mar 2010 17:26:56 +0000

People tend to like certain software packages to be scalable. This can have a number of different meanings but mostly it means that as you throw more work at the program, it may require some more resources, in terms of memory or CPU, but it nevertheless just keeps on working. Strangely enough, it’s fairly difficult to achieve this with finite resources. With things like memory, the classical hierarchy applies: as you use up more and more faster memory, you start to spill to slower memory — i.e. spilling to disk. The assumption tends to be that one always has enough disk space.

Other resources are even more limited, and are harder to manage. One of these is file descriptors. This is especially difficult to manage in a VM such as Erlang’s where lots of other systems are potentially using file descriptors and you have no control over them. In the released versions of Rabbit, Rabbit’s persister used only one or two file descriptors, and the queues themselves used none. This would be an obvious scalability issue in that it would restrict to a single process access to messages stored on disk, were it not for the fact that released versions of Rabbit hold all messages in memory all the time, thus negating that problem (at the expense of a larger scalability issue). However the upside is that as more queues appear, you don’t need more file descriptors, so almost all file descriptors could be set aside for network sockets. If you need to allow more network connections to Rabbit than your OS provides, then just raise the ulimit (and often the default Erlang process limit too) and away you go.

With the new persister, each queue requires at least two file descriptors each, and can use a number of file descriptors bounded only by the number of messages stored on disk. Whilst this has removed all sorts of bottlenecks, it has also made the probability of running out of file descriptors rather higher. Introducing a central file descriptor allocator would reintroduce a bottleneck that we have sought to avoid, and so we have developed an alternative scheme for managing file descriptors. This scheme can go wrong: it is really only probabilistic that it works. But, given the way in which Rabbit works, it seems to be working very successfully.

Firstly, there is a central process. However, this is never asked for a file descriptor, instead all processes who open files asynchronously tell the central process that they’ve opened a file. They also tell the central process when they close a file descriptor. With both of these messages, processes include another piece of information which is the time at which the least recently used file descriptor that the process has open was used. Thus the processes maintain a mapping from file descriptor to the timestamp at which they were last used. The smallest value in this mapping is the value which is included with these messages to the central process. Whenever a process uses a file descriptor, it takes a new timestamp and updates this mapping. No communication is made to the central process on use of a file descriptor.

The central process detects the ulimit imposed by the OS on the number of file descriptors that can be opened. It imposes an artificial limit, 100 less than the real limit. This gives both buffer space, and allows the rest of the Erlang VM some file descriptors beyond our own control. When we reach this artificial lower limit, the central process does the following calculation: for every process that has some open files, it finds the difference between the current timestamp and the most recently reported least recently used file descriptor timestamp. It sums and averages these ages to give the average time since the least recently used file descriptors were used. It then asynchronously sends messages to all the processes with open files, telling them to close any file descriptor that has not been used for more than this average time.

The first time the processes receive this message, they may very well find that they don’t have any file descriptors that have not been used for this long. This is because the central process is only informed or processes’ least recently used file descriptor timestamps when the process opens or closes a file descriptor. As such, if the process then uses the file descriptor then the central process will immediately have out of date information. Thus all processes, when they receive a request to close files descriptors older than the calculated average, they always inform the central process of the timestamp of their current least recently used file descriptor. Thus at this point, the central process is brought up to date, and if it finds that it’s still at or over the limit of open file descriptors, it recalculates the average age (which will now be less than before) and asks all the processes again to close file descriptors older than the new, smaller average age.

What this means is that processes are never blocked from opening files, even when Rabbit’s over the limit of file descriptors. However, immediately after opening a file, when it goes to receive its next message, a process may find a request from the central process, asking it to close the file it’s just opened. Thus the limit is enforced softly, in a way which does as little as possible to impact performance. This is the reason why we have the lower artificial limit: to try and guard against the possibility of lots of processes opening files at the same time, pushing us over the limit before they or any other process receive the close request from the central process. However it can still go wrong: if a process is hell bent on opening as many files as possible then it can do so, and still hit the hard OS limit, crashing the VM. Cooperation from the processes is obviously vital: for example if a process can never open more than one file descriptor before checking its mailbox again, then you’re very likely to be safe in this scheme.

All of this is implemented in a module called file_handle_cache.erl which is available in the new persister branch of RabbitMQ. This module also wraps many of the functions of Erlang’s file module, providing many more optimisations (at the cost of, for example, only ever being able to append to files). These optimisations aim to reduce to an absolute minimum the number of OS calls. So, much better control of write buffers is provided, and seeks which would position the file handle at the same location as it currently is are optimised out. Further calls are provided, e.g. to throw away the write buffer contents without writing them out to disk.

When the request to close a file comes in, the file_handle_cache module works out which file descriptors to close. If it finds a file handle to close, it flushes any outstanding writes, closes the file, but keeps track of the last state that it was in. Thus the next time the process decides to use that file descriptor, the module can silently reopen the file and seek to the last location. As a result, when writing to this module, you never need to find out whether or not the central process has asked the module to close files and what, if anything, the result of that request was. The result is a system which dynamically closes old and unused file descriptors but without imposing arduous constraints on the client: the module manages all the state of the file descriptors.

Finally, there are some file descriptors which we have decided, after careful consideration, not to arbitrarily close. These are network sockets to AMQP clients. For these, it is indeed right to have a central process controlling whether further sockets can be created. This is simply implemented as a pair of synchronous calls (acquire and release) to the central process which lowers and raises, respectively, the artificial limit on the number of allowed file descriptors.

Programming in the 21st Century: Living Inside Your Own Black Box

Tue, 23 Mar 2010 06:00:00 +0000

Every so often I run across a lament that programmers no longer understand the systems they work on, that programming has turned into searches through massive quantities of documentation, that large applications are built by stacking together loosely defined libraries. Most recently it was Mike Taylor's Whatever happened to programming?, and it's worth the time to read.

To me, it's not that the act of programming has gotten more difficult. I'd even say that programming has gotten much easier. Most of the Apple Pascal assignments I had in high school would be a fraction of the bulk if written in Ruby or Python. Arrays don't have fixed lengths. Strings are easy. Dictionaries have subsumed other data structures. Generic sort routines are painless to use. Functions can be tested interactively. Times are good!

That's not to say all problems can be solved effortlessly. Far from it. But it's a tight feedback loop: think, experiment, write some code, reconsider, repeat. This works as long as you can live inside an isolated world, where the basic facilities of your programming language are the tools you have to work with. But at some point that doesn't work, and you have to deal with outside realities.

Here's the simplest example I can think of: Write a program to draw a line on the screen. Any line, any color, doesn't matter. No ASCII art.

In Python the first question is "What UI toolkit?" There are bindings for SDL, Cocoa, wxWindows, and others. Selecting one of those still doesn't mean that you can simply call a function and see your line. SDL requires some up front effort to learn how to create a window and choose the right resolution and color depth and so on. And then you still can't draw a line unless you use OpenGL or get an add-on package like SDL_gfx. If you decide to take the Cocoa route, then you need to understand its whole messaging / windowing / drawing model, and you also need to understand how Python interfaces with it. Maybe there's a beautifully simple package out there that lets you draw lines, and then the question becomes "Can I access that library from the language I'm using?" An even more basic question: "Is the library written using a paradigm that's a good match for my language?" (Think of a library based on subclassing mutable objects and try to use it from Haskell.)

There's a clear separation between programming languages and the capabilities of modern operating systems. Any popular OS is obviously designed for creating windows and drawing and getting user input, but those are not fundamental features of modern languages. At one time regular expressions weren't standard in programming languages either, but they're part of Perl and Ruby, and they're a library that's part of the official Python distribution.

A handful of language designers have tried to make GUI programming as easy as traditional programming. The Tk library for TCL, which is still the foundation for Python's out-of-the-box IDE, allows basic UI creation with simple, declarative statements. REBOL is a more recent incarnation of the same idea, that sample code involving windows and user input and graphics should be a handful of lines, not multiple pages of wxWindows fussing. I wish more people were working on such things.

A completely different approach is to go back to the isolationist view of only using the natural capabilities of a programming language, but in a more extreme way. I can draw a line in Python with this tuple:

("line",0,0,639,479)

or I can do the same thing in Erlang with two fewer characters:

{line,0,0,639,479}

I know it works, because I can see it right there. The line starts at coordinates 0,0 and ends at 639,479. It works on any computer with any video card, including systems I haven't used yet, like the iPad. I can use the same technique to play sounds and build elaborate UIs.

That the results are entirely in my head is of no matter.

It may sound like I'm being facetious, but I'm not. In most applications, interactions between code and the outside world can be narrowed down to couple of critical moments. Even in something as complex as a game, you really just need a few bytes representing user input at the start of a frame, then much later you have a list of things to draw and a list of sounds to start, and those get handed off to a thin, external driver of sorts, the small part of the application that does the messy hardware interfacing.

The rest of the code can live in isolation, doing arbitrarily complex tasks like laying out web pages and mixing guitar tracks. It takes some practice to build applications this way, without scattering calls to external libraries throughout the rest of the code, but there are big wins to be had. Fewer dependencies on platform specifics. Fewer worries about getting overly reliant on library X. And most importantly, it's a way to declutter and get back to basics, to focus on writing the important code, and to delve into those thousands of pages of API documentation as little as possible.

RedHotErlang: Mercurial, DVCS and Agile methods

Mon, 22 Mar 2010 19:39:45 +0000

I've been reading the Mercurial book recently and liked it a lot. Although I've been using git and github for quite a while, I couldn't help myself from being impressed by the clean and simple approach of Mercurial. A simple base set of commands wi...

Erlang Inside: Simple Chart Of Embeddable Scripting Options In Erlang

Mon, 22 Mar 2010 01:51:34 +0000

In preparation for my upcoming talk this week at Erlang Factory San Francisco, focused on Lua integration in Erlang, I'm reviewing Lua, Javascript, and Reia, and I came up with this very simple decision tree. Thoughts on the PDF download would be welcome.

Programming in the 21st Century: A Short Story About Verbosity

Wed, 17 Mar 2010 06:00:00 +0000

In the early 2000s I was writing a book. I don't mean in the vague sense of sitting in a coffeeshop with my laptop and pretending to be a writer; I had a contract with a tech book publisher.

I'm in full agreement with the musician's saying of "never turn down a gig," so when the opportunity arose, I said yes. I did that even though there was one big, crazy caveat:

"In order for a book to sell," said my publisher, "it's got to be thick. 600 pages thick." "In the worst case we could go as low as 500 pages, but 600+ should be your target."

Wow, 600 pages. If I wrote two pages a day, that's almost a full year of writing, and I had less than a year. But still, never turn down a gig, and so I took a serious attempt at it.

I can't prove or refute the claim that a 600 page tech book sells better than thinner ones, but it explains a lot of the bloated tomes out there. Mix sections of code with the text, then reprint the whole program at the end of the chapter. That can eat four or eight pages. Add a large appendix that reiterates a language's standard library, even though all that info is already in the help system and online. Add some fluff survey chapters that everyone is going to skip.

I try not to wax nostalgic about how the olden days of computing were better. While I might have some fond memories of designing games for 8-bit home computers, there has been a lot of incredibly useful progress since then. But I do find myself wishing that the art of the 250 page technical book hadn't gone completely out of style.

Eventually I did give up on the 600 page monster I was writing. It was a combination of me not having enough time and my publisher taking weeks to give feedback about submitted chapters. In the end I think I had written the introduction and maybe eight full chapters. Do I wish I had finished it? Yes. Even with the 600 page requirement, there was still some clout that went along with writing a book at the time. These days it's much less so, and I think those padded-out-to 600 pages volumes had a lot to do with it.

(If you liked this, you might like Two Stories of Simplicity.)

Learn You Some Erlang: Functionally Solving Problems in Erlang

Tue, 16 Mar 2010 00:30:00 +0000

A new chapter arrives. This one is about putting to practice what was seen in Learn You Some Erlang until now. The problems are borrowed from Learn You A Haskell and are about implementing a Reverse Polish Notation calculator with pattern matching and finding the shortest path from Heathrow to London. Hopefully this chapter will help those having trouble thinking in a functional manner to solve problems.

Caoyuan's Blog: How the Functional Ability of Scala Comparing to Haskell - an Example

Mon, 15 Mar 2010 21:06:29 +0000

About one and half year ago, it was my first time to consider Scala seriously, I wrote a blog about the syntax example of Scala, Erlang and Haskell .

With more experience of Scala, I'd like to know how about the functional ability of Scala comparing to Haskell. I picked up Paul R. Brown's perpubplat blog engine again, which is a Haskell implementation heavily in functional style. I tried to port more code from Haskell to Scala keeping in similar expressions. Here's the code example of Entry.scala in Scala comparing to Brown's original Entry.hs:

Original Haskell code piece

-- | Data structures for an item (post or comment) and the
-- overall structure in terms of parents and children.
module Blog.Model.Entry where
import qualified Blog.FrontEnd.Urls as U
import Utilities
import qualified Blog.Constants as C
import Maybe
import List ( sortBy, isPrefixOf, intersperse)
import qualified Data.Map as M
import Data.Map ( (!) )
type ISO8601DatetimeString = String
type XhtmlString = String
-- | Overall data model for the runtime.  
data Model = Model { -- | 
                     by_permatitle :: M.Map String Item,
                     by_int_id :: M.Map Int Item,
                     child_map :: M.Map Int [Int],
                     all_items :: [Item],
                     next_id :: Int }
empty :: Model
empty = Model M.empty M.empty M.empty [] 0
data Kind = Post | Comment | Trackback
            deriving (Show, Read, Eq)
build_model :: [Item] -> Model
build_model [] = empty
build_model items = Model (map_by permatitle sorted_items)
                    bid
                    (build_child_map sorted_items)
                    (sorted_items)
                    (n+1)
    where
      sorted_items = sort_by_created_reverse items
      bid = (map_by internal_id sorted_items)
      n = fst . M.findMax $ bid
build_child_map :: [Item] -> M.Map Int [Int]
build_child_map i = build_child_map_ (M.fromList $ (map (\x -> (internal_id x,[])) i)) i
-- Constructed to take advantage of the input being in sorted order.
build_child_map_ :: M.Map Int [Int] -> [Item] -> M.Map Int [Int]
build_child_map_ m [] = m
build_child_map_ m (i:is) = if (parent i == Nothing) then
                                build_child_map_ m is
                            else
                                build_child_map_ (M.insertWith (++) (unwrap $ parent i) [internal_id i] m) is
-- | Insert an item, presuming that all of its data other than
-- internal identifier have been correctly set.
insert :: Model -> Item -> (Item,Model)
insert m i = (i', m { by_permatitle = M.insert (permatitle i') i' $ by_permatitle m
                    , by_int_id = M.insert n i' $ by_int_id m
                    , child_map = M.insert (internal_id i') [] $
                                  case parent i of
                                    Nothing ->
                                        child_map m
                                    (Just p_id) ->
                                        M.insert p_id (insert_comment_ m (item_by_id m p_id) i') $ child_map m
                    , all_items = insert_ after (all_items m) i'
                    , next_id = n + 1 } )
    where
      n = next_id m
      i' = i { internal_id = n }
insert_comment_ :: Model -> Item -> Item -> [Int]
insert_comment_ m p c = map internal_id (insert_ before (children m p) c)
insert_ :: (Item -> Item -> Bool) -> [Item] -> Item -> [Item]
insert_ _ [] y = [y]
insert_ o s@(x:xs) y = if (x `o` y) then
                           (x:(insert_ o xs y))
                       else
                           (y:s)
after :: Item -> Item -> Bool
after a b = (created a) > (created b)
before :: Item -> Item -> Bool
before a b = (created a) < (created b)
-- | Apply a structure-preserving function, i.e., one that does not
-- change parent/child relationships or ids, to a specific item.
alter :: (Item -> Item) -> Model -> Item -> IO Model
alter f m i = do { ts <- now
                 ; let i' = (f i) { updated = ts }
                 ; return $ m { by_permatitle = M.insert (permatitle i') i' $ by_permatitle m
                              , by_int_id = M.insert (internal_id i') i' $ by_int_id m
                              , child_map = if (parent i == Nothing) then
                                                child_map m
                                            else
                                                M.insert p_id resort_siblings $ child_map m
                              , all_items = insert_ after all_but i' } }
    where
      not_i = \item -> (internal_id item) /= (internal_id i)
      all_but = filter not_i $ all_items m
      p_id = unwrap $ parent i
      p = item_by_id m p_id
      resort_siblings = map internal_id (insert_ before (filter not_i $ children m p) i)
cloak :: Model -> Item -> IO Model
cloak = alter (\i -> i { visible = False })
uncloak :: Model -> Item -> IO Model
uncloak = alter (\i -> i { visible = True })
permatitle_exists :: Model -> String -> Bool
permatitle_exists = (flip M.member) . by_permatitle
max_id :: Model -> Int
max_id = fst . M.findMax . by_int_id
post_by_permatitle :: Model -> String -> Item
post_by_permatitle = (!) . by_permatitle
maybe_post_by_permatitle :: Model -> String -> Maybe Item
maybe_post_by_permatitle = (flip M.lookup) . by_permatitle
item_by_id :: Model -> Int -> Item
item_by_id = (!) . by_int_id
children :: Model -> Item -> [Item]
children m i = map (item_by_id m) ((child_map m) ! (internal_id i))
unwrap :: Maybe a -> a
unwrap (Just x) = x
unwrap Nothing = error "Can't unwrap nothing!"
data Author = Author { name :: String,
                       uri :: Maybe String,
                       email :: Maybe String,
                       show_email :: Bool
                     }
              deriving ( Show,Read,Eq )
-- | General purpose runtime data structure for holding a post or
-- comment.  For a comment, a number of the fields will be ignored
-- (e.g., comments and tags) until/if the presentation and syndication
-- system gets fancier.
data Item = Item { -- | an internal unique number for this post
                   internal_id :: Int,
                   -- | the kind of item that this represents
                   kind :: Kind,
                   -- | the title of the post, as it should be rendered on
                   -- the web or inserted in an Atom feed; this should be a
                   -- valid XHTML fragment.
                   title :: XhtmlString,
                   -- | the summary of the post, as it should be rendered on
                   -- the web or intersted into an Atom feed; this should be
                   -- a valid XHTML fragment.
                   summary :: Maybe XhtmlString,
                   -- | the body of the post as an XHTML fragment.  This
                   -- will be wrapped in an XHTML @<div>@ when rendered on
                   -- the web or in a feed.
                   body :: XhtmlString,
                   -- | tags for the post, if any, expected to be in
                   -- alphabetical order and consisting of letters, digits,
                   -- dashes, and/or underscores.
                   tags :: [String],
                   -- | a generated UID for the post; this is expected to be
                   -- suitable for use as an Atom GUID.  The expectation is
                   -- that it will be supplied by the implementation when
                   -- the post is ingested.
                   uid :: String,
                   -- | a permanent title for the item, consisting of only
                   -- lowercase letters, digits, and dashes.
                   permatitle :: String,
                   -- | the timestamp, as an ISO8601 datetime, when the post
                   -- came into being.  This is never blank and would be
                   -- supplied by the implementation when the post is
                   -- ingested.
                   created :: ISO8601DatetimeString,
                   -- | the timestamp, as an ISO8601 datetime, when the post
                   -- was updated.  Initially, this is equal to the value of
                   -- the 'created' field.
                   updated :: ISO8601DatetimeString,
                   -- | the author of the post, expected to be hardwired to
                   -- the author of the blog
                   author :: Author,
                   -- | whether or not the item is to be displayed.
                   visible :: Bool,
                   -- | this item's parent, if any.
                   parent :: Maybe Int
                 }
            deriving ( Show, Read, Eq )
-- | Compute a permalink for the item relative to the supplied base URL.
permalink :: Model
          -> Item -- ^ the item
          -> String
permalink m i = U.post (relative_url m i)
relative_url :: Model -> Item -> String
relative_url m = _form_permalink . (ancestors m)
_form_permalink :: [Item] -> String
_form_permalink [] = ""
_form_permalink [i] =  let s = permatitle i in
                       if (kind i == Post) then
                           "/" ++ s
                       else
                           "#" ++ s
_form_permalink (i:is) = if (kind i == Post) then
                            ("/" ++ permatitle i) ++ (_form_permalink is)
                        else
                            (_form_permalink is)
ancestor_path :: Model -> Item -> String
ancestor_path m i = concat . (intersperse "/") . (map permatitle) $ ancestors m i
ancestors :: Model -> Item -> [Item]
ancestors m i = ancestors_ m [] (Just $ internal_id i)
ancestors_ :: Model -> [Item] -> Maybe Int -> [Item]
ancestors_ _ is Nothing = is
ancestors_ m is (Just i) = ancestors_ m (i':is) (parent i')
    where
      i' = item_by_id m i
lastUpdated :: [Item] -> ISO8601DatetimeString
lastUpdated ps = maximum (map updated ps)
drop_invisible :: [Item] -> [Item]
drop_invisible = filter visible
sort_by_created :: [Item] -> [Item]
sort_by_created = sortBy created_sort
created_sort :: Item -> Item -> Ordering
created_sort a b = compare (created a) (created b)
sort_by_created_reverse :: [Item] -> [Item]
sort_by_created_reverse = sortBy created_sort_reverse
created_sort_reverse :: Item -> Item -> Ordering
created_sort_reverse a b = compare (created b) (created a)
-- | Filter a list of items according to a date fragment
date_fragment_filter_ :: ISO8601DatetimeString -> [Item] -> [Item]
date_fragment_filter_ s = filter ((s `isPrefixOf`) . created)
-- | Filter a list of posts for those made in a specific year.
year_filter :: Int -- ^ year
            -> [Item] -> [Item]
year_filter y = date_fragment_filter_ $ show y
-- | Filter a list of posts for those made in a specific month.              
month_filter :: Int -- ^ year
             -> Int -- ^ month
             -> [Item] -> [Item]
month_filter y m | (0 < m) && (m < 13) = date_fragment_filter_ ((show y) ++ (pad_ m))
                 | otherwise = const []
-- | Filter a list of posts for those made on a specific day
day_filter :: Int -- ^ year
           -> Int -- ^ month
           -> Int -- ^ day
           -> [Item] -> [Item]
day_filter y m d = date_fragment_filter_ ((show y) ++ (pad_ m) ++ (pad_ d))
-- | Utility function to zero pad months and days in date expressions.
pad_ :: Int -> String
pad_ i | i < 10 = "-0" ++ (show i)
       | otherwise = ('-':(show i))
-- to do: make this faster using the sortedness.
tags_filter :: [String] -> [Item] -> [Item]
tags_filter t p = foldl (flip ($)) p (map tag_filter t)
tag_filter :: String -> [Item] -> [Item]
tag_filter t = filter ((t `elem`) . tags)
plink_filterf :: String -> Item -> Bool
plink_filterf = flip $ (==) . permatitle
plink_filter :: String -> [Item] -> [Item]
plink_filter = filter . plink_filterf
ymd_plink_finder :: Int -> Int -> Int -> String -> [Item] -> [Item]
ymd_plink_finder y m d t = (plink_filter t) . (day_filter y m d)
all_posts :: Model -> [Item]
all_posts = (filter (\x -> Post == kind x)) . all_items
all_comments :: Model -> [Item]
all_comments = (filter (\x -> Comment == kind x)) . all_items
flatten :: Model -> [Item] -> [Item]
flatten m = flatten_ (children m)
flatten_ :: (a -> [a]) -> [a] -> [a]
flatten_ _ [] = []
flatten_ f (i:is) = (i:(flatten_ f (f i))) ++ (flatten_ f is)
concat_comments :: Model -> [Item] -> [Item]
concat_comments m = (foldr (++) []) . (map $ children m)
(</>) :: String -> String -> String
s </> t = s ++ ('/':t)
to_string :: Item -> String
to_string i = concat [metadata i, "\n", body_block i, "\n", summary_block i]
metadata :: Item -> String
metadata i = unlines $ apply i [ ("internal_id",show . internal_id),
                                 ("parent", show . parent),
                                 ("title",title),
                                 ("tags",show_no_quotes . tags),
                                 ("permatitle",permatitle),
                                 ("kind",show . kind),
                                 ("uid",uid),
                                 ("created",created),
                                 ("updated",updated),
                                 ("author",show . author),
                                 ("visible",show . visible) ]
show_no_quotes :: [String] -> String
show_no_quotes = concat . (intersperse ", ")
apply :: Item -> [(String,(Item -> String))] -> [String]
apply _ [] = []
apply i (x:xs) = ((concat [fst x, ": ", (snd x) i]) : (apply i xs))
body_block :: Item -> String
body_block i = concat ["--- START BODY ---\n",
                       (body i),
                       "\n--- END BODY ---\n"]
summary_block :: Item -> String
summary_block i | summary i == Nothing = ""
                | otherwise = concat ["--- START SUMMARY ---\n",
                                      (unwrap $ summary i),
                                      "\n--- END SUMMARY ---\n"]
default_author :: Author
default_author = Author C.author_name C.author_uri C.author_email True

In Scala:

Formatted and highlighted by NetBeans Scala Plugin, exported via [File] -> [Print to HTML ...]

package org.aiotrade.blog.model
import java.util.Calendar
import org.aiotrade.blog.{Constants => C}
object Entry {
  type XhtmlString = String
  class Model (
    var by_permatitle: Map[String, Item],
    var by_int_id: Map[Int, Item],
    var child_map: Map[Int, List[Int]],
    var all_items: List[Item],
    var next_id: Int
  ) {
    // call by name
    def apply(block: => Unit) = {block; this}
  }
  abstract class Kind //deriving (Show, Read, Eq)
  case object Post extends Kind
  case object Comment extends Kind
  case object Trackback extends Kind
  case class Author (
    var name: String,
    var uri : Option[String] = None,
    var email: Option[String] = None,
    var show_email: Boolean = false
  )
  /** General purpose runtime data structure for holding a post or
   * comment.  For a comment, a number of the fields will be ignored
   * (e.g., comments and tags) until/if the presentation and syndication
   * system gets fancier.
   */
  case class Item (
    // an internal unique number for this post
    var internalId: Int,
    // the kind of item that this represents
    var kind: Kind,
    // the title of the post, as it should be rendered on
    // the web or inserted in an Atom feed; this should be a
    // valid XHTML fragment.
    var title: XhtmlString,
    // the summary of the post, as it should be rendered on
    // the web or intersted into an Atom feed; this should be
    // a valid XHTML fragment.
    var summary: Option[XhtmlString],
    // the body of the post as an XHTML fragment.  This
    // will be wrapped in an XHTML @<div>@ when rendered on
    // the web or in a feed.
    var body: XhtmlString,
    // tags for the post, if any, expected to be in
    // alphabetical order and consisting of letters, digits,
    // dashes, and/or underscores.
    var tags: List[String],
    // a generated UID for the post; this is expected to be
    // suitable for use as an Atom GUID.  The expectation is
    // that it will be supplied by the implementation when
    // the post is ingested.
    var uid: String,
    // a permanent title for the item, consisting of only
    // lowercase letters, digits, and dashes.
    var permatitle: String,
    // the timestamp, as an ISO8601 datetime, when the post
    // came into being.  This is never blank and would be
    // supplied by the implementation when the post is
    // ingested.
    var created: Long,
    // the timestamp, as an ISO8601 datetime, when the post
    // was updated.  Initially, this is equal to the value of
    // the 'created' field.
    var updated: Long,
    //the author of the post, expected to be hardwired to
    // the author of the blog
    var author: Author,
    //whether or not the item is to be displayed.
    var visible: Boolean,
    //this item's parent, if any.
    var parent: Option[Int]
  ) {
    def apply(block: Item => Unit) = {block(this); this}
  }
  def empty = new Model(Map(), Map(), Map(), Nil, 0)
  def build_model(is: List[Item]) =
    is match {
      case Nil => empty
      case _ =>
        val sortedIs = sort_by_created_reverse(is)
        val bid = Map() ++ sortedIs.map{x => (x.internalId -> x)}
        val n = bid.keySet.max
        new Model(Map() ++ sortedIs.map{x => (x.permatitle -> x)},
                  bid,
                  buildChildMap(sortedIs),
                  sortedIs,
                  n + 1)
    }
  def buildChildMap(is: List[Item]) =
    buildChildMap_(Map() ++ is.map(_.internalId -> Nil), is)
  def buildChildMap_(map: Map[Int, List[Int]], is: List[Item]) =
    map ++ {
      for (i <- is if i.parent.isDefined) yield {
        // pid, cids definitions go into body // it's more efficient.
        val pid = i.parent.get
        val cids = map.getOrElse(pid, Nil)
        pid -> (i.internalId :: cids)
      }
    }
  /** Insert an item, presuming that all of its data other than
   internal identifier have been correctly set.
   */
  def insert(m: Model, i: Item): (Item, Model) = {
    val n = m.next_id
    i.internalId = n
    (i, m {
        m.by_permatitle += (i.permatitle -> i)
        m.by_int_id += (n -> i)
        m.child_map = (i.parent match {
            case None => m.child_map
            case Some(p_id) => m.child_map + (p_id -> (insert_comment_(m, item_by_id(m)(p_id), i)))
          })
        m.all_items = insert_(after, m.all_items, i)
        m.next_id = n + 1 }
    )
  }
  def insert_comment_(m: Model, p: Item, c: Item): List[Int] =
    insert_(before, children(m)(p), c) map (_.internalId)
  def insert_(o: (Item, Item) => Boolean, is: List[Item], y: Item): List[Item] =
    is match {
      case Nil => List(y)
      case x :: xs => if (o(x, y)) x :: insert_(o, xs, y) else (y :: is)
    }
  def after (a: Item, b: Item): Boolean =
    a.created > b.created
  def before(a: Item, b: Item): Boolean =
    a.created < b.created
  /**
   * Apply a structure-preserving function, i.e., one that does not
   * change parent/child relationships or ids, to a specific item.
   */
  def alter(f: (Item => Item), m: Model, i: Item): Model = {// -> IO Model
    val not_i = (item: Item) => item.internalId != i.internalId
    val all_but = m.all_items filter not_i
    val p_id = unwrap (i.parent)
    val p = item_by_id(m)(p_id)
    val resort_siblings = insert_(before, children(m)(p) filter not_i, i) map (_.internalId)
    val ts = System.currentTimeMillis
    val i1 = f(i) {_.updated = ts}
    m {
      m.by_permatitle += (i1.permatitle -> i1)
      m.by_int_id += (i1.internalId -> i1)
      m.child_map = i.parent match {
        case None => m.child_map
        case _ => m.child_map + (p_id -> resort_siblings)
      }
      m.all_items = insert_(after, all_but, i1)
    }
  }
  def cloak(m: Model, i: Item): Model = // -> IO Model
    alter (i => i {_.visible = false}, m, i)
  def uncloak(m: Model, i: Item): Model = // -> IO Model
    alter (i => i {_.visible = true}, m, i)
  def permatitle_exists(m: Model, p: String): Boolean =
    m.by_permatitle.contains(p)
  def max_id(m: Model): Int =
    m.by_int_id.keySet.max
  def post_by_permatitle(m: Model, p: String): Item =
    m.by_permatitle(p)
  def maybe_post_by_permatitle(m: Model, p: String): Option[Item] =
    m.by_permatitle.get(p)
  def item_by_id(m: Model)(id: Int): Item =
    m.by_int_id(id)
  def children(m: Model)(i: Item): List[Item] =
    m.child_map(i.internalId) map (item_by_id(m))
  def unwrap[T](a: Option[T]): T =
    a match {
      case Some(x) => x
      case None => error("Can't unwrap none!")
    }
  def relative_url(m: Model, i: Item): String =
    _form_permalink(ancestors(m, i))
  def _form_permalink(is: List[Item]): String =
    is match {
      case Nil => ""
      case i :: Nil =>
        val s = i.permatitle
        if (i.kind == Post)
          "/" + s
        else
          "#" + s
      case i :: is =>
        if (i.kind == Post)
          ("/" + i.permatitle) + _form_permalink(is)
        else
          _form_permalink(is)
    }
  def ancestors(m: Model, i: Item): List[Item] =
    ancestors_(m, Nil, Some(i.internalId))
  def ancestors_(m: Model, is: List[Item], i_? : Option[Int]): List[Item] =
    i_? match {
      case None => is
      case Some(i) =>
        val i1 = item_by_id(m)(i)
        ancestors_(m, i1 :: is, i1.parent)
    }
  def lastUpdated(ps: List[Item]): Long =
    ps map (_.updated) max
  def drop_invisible(is: List[Item]): List[Item] =
    is filter (_.visible)
  def sort_by_created(is: List[Item]): List[Item] =
    is sortWith created_sort _
  def created_sort(a: Item, b: Item) =
    a.created < b.created
  def sort_by_created_reverse(is: List[Item]): List[Item] =
    is sortWith created_sort_reverse _
  def created_sort_reverse(a: Item, b: Item) =
    b.created < a.created
  def date_fragment_filter_(is: List[Item], ts: Int*) = {
    val cal = Calendar.getInstance
    ts match {
      case Seq(y, m, d) => is filter {i => pad_(cal, i.created) match {
            case (`y`, `m`, `d`) => true
            case _ => false
          }
        }
      case Seq(y, m) => is filter {i => pad_(cal, i.created) match {
            case (`y`, `m`, _) => true
            case _ => false
          }
        }
      case Seq(y) => is filter {i => pad_(cal, i.created) match {
            case (`y`, _, _) => true
            case _ => false
          }
        }
    }
  }
  def year_filter(y: Int)(is: List[Item]): List[Item] =
    date_fragment_filter_(is, y)
  def month_filter(y: Int, m: Int)(is: List[Item]): List[Item] =
    date_fragment_filter_(is, y, m)
  def day_filter(y: Int, m: Int, d: Int)(is: List[Item]): List[Item] =
    date_fragment_filter_(is, y, m, d)
  def pad_(cal: Calendar, t: Long): (Int, Int, Int) = {
    cal.setTimeInMillis(t)
    import Calendar._
    (cal.get(YEAR), cal.get(MONTH) + 1, cal.get(DAY_OF_MONTH))
  }
  def tags_filter(ts: List[String])(is: List[Item]): List[Item] =
    is filter (i => (false /: ts) {_ || i.tags.contains(_)})
  def tag_filter(t: String)(is: List[Item]): List[Item] =
    is filter (_.tags.contains(t))
  def plink_filterf(p: String)(i: Item): Boolean =
    i.permatitle == p
  def plink_filter(p: String)(is: List[Item]): List[Item] =
    is filter plink_filterf(p)
  def ymd_plink_finder(y: Int, m: Int, d: Int, p: String)(is: List[Item]): List[Item] =
    plink_filter(p) (day_filter(y, m, d) (is))
  def </> (s: String, t: String): String =
    s + '/' + t
  def all_posts(m: Model): List[Item] =
    m.all_items filter (_.kind == Post)
  def all_comments(m: Model): List[Item] =
    m.all_items filter (_.kind == Comment)
  def flatten(m: Model, is: List[Item]): List[Item] =
    flatten_(children(m), is)
  def flatten_[T](f: T => List[T], is: List[T]): List[T] =
    is match {
      case Nil => Nil
      case i :: is => i :: flatten_(f, f(i)) ::: flatten_(f, is)
    }
  def concat_comments(m: Model, is: List[Item]): List[Item] =
    ((is map children(m)) :\ List[Item]())(_ ::: _)
  def metadata(i: Item): String =
    apply(i, List(("internal_id", show(_.internalId)),
                  ("parent",      show(_.parent)),
                  ("title",       _.title),
                  ("tags",        show_no_quotes(_.tags)),
                  ("permatitle",  _.permatitle),
                  ("kind",        show(_.kind)),
                  ("uid",         _.uid),
                  ("created",     show(_.created)),
                  ("updated",     show(_.updated)),
                  ("author",      show(_.author)),
                  ("visible",     show(_.visible)))
    ) mkString "\n"
  // curring
  def show(f: Item => Any)(i: Item): String =
    f(i) toString
  def show_no_quotes(f: Item => List[String])(i: Item): String =
    f(i) mkString ", "
  def apply(i: Item, xs: List[(String, Item => String)]): List[String] =
    xs match {
      case Nil => Nil
      case x :: xs => (x._1 + ": " + x._2(i)) :: apply(i, xs)
    }
  def body_block(i: Item): String =
    "--- START BODY ---\n" + i.body + "\n--- END BODY ---\n"
  def summary_block(i: Item): String =
    i.summary match {
      case None => ""
      case Some(x) => "--- START SUMMARY ---\n" + x + "\n--- END SUMMARY ---\n"
    }
  val default_author = Author(C.author_name, C.author_uri, C.author_email, true)
}

Damien Katz: O'Reilly's CouchDB: The Definitive Guide for $9.99 Today Only!

Mon, 15 Mar 2010 19:00:39 +0000

CouchDB: The Definitive Guide

Use this discount code: DDCDB

ejabberd@jabber.ru: ejabberd 2.1.3 - Third bugfix release

Fri, 12 Mar 2010 16:28:03 +0000

ejabberd 2.1.3 has been released. It contains many bugfixes and some improvements.

This is a short list of changes:

New ejabberd_c2s option: max_fsm_queue
ejabberdctl: Support concurrent connections with bound connection names
Cross-domain HTTP-Bind support (EJAB-1168)
Hibernate http-bind process after handling a request

Process-one Blogs: OneTeam XMPP client entering private alpha

Thu, 11 Mar 2010 14:00:21 +0000

Our OneTeam XMPP client for Linux, Mac OS X, and Windows is entering a private alpha period.

OneTeam is a multiplatform XMPP client for Linux, Mac OS X, and Windows. We have slowly worked on it during long months (and even years, it is being developed since 2006) but never had enough time and resources to release it properly.

The time to launch OneTeam in the wild and interoperable internet is soon arriving. We believe we have achieved our goal to deliver some real enterprise-class user experience. As a proof, we are using it inhouse on a daily basis as a productivity tool, without any major glitch.

For the record, OneTeam works as a Firefox extension, as well as a standalone application, on the three major platforms, thanks to the XUL technology. OneTeam has a nice dashboard-based interface, and handy user interactions improvements everywhere. This XMPP client supports a wide range of features, including chat and presence of course, but also Multi-User Chat (groupchat), message threading, history browsing, etc. It also features Jingle voice calls, as well as the exclusive Jingle Nodes feature demoed at FOSDEM, that works much like Skype. On the more technical side, there is the XML console, as well as a very interesting remote debugging console.

So, we are now releasing OneTeam, but in alpha quality for now, to the curious ones, and those willing to help and test. Please feel free to contact us, if you want to join the alpha testing, and report issues. Please e-mail nverite at process-one.net for a OneTeam ride.

Damien Katz: Win a Nexus One from Couchio

Thu, 11 Mar 2010 01:58:29 +0000

Port CouchDB to an Android app and get our phone! Details.

Damien Katz: CouchDB Case Study: Assay Depot

Sat, 06 Mar 2010 23:40:35 +0000

Apache CouchDB Case Study: Assay Depot

...replication give this ability that would have been much more difficult to accomplish in MySQL. We could have done this in a relational manner but it would have been very challenging, very custom. CouchDB give a lot of the benefits for free.

CouchDB has changed the way I think about developing web applications

Process-one Blogs: Talkr.IM XMPP/Jabber server gets Apple Push notifications

Wed, 03 Mar 2010 21:00:16 +0000

The free public XMPP/Jabber server Talkr.IM gets Apple Push notifications for iPhone.

The ProcessOne's free, open, public XMPP/Jabber server Talkr.IM is gaining a new feature: Apple Push notifications. This well enable users to get notified of offline messages when they arrive, as well as simulate a continued XMPP session on iPhone devices that still do not implement multitasking.

For the latter feature, since the iPhone still does not accept to run applications in the background, if you want to use another application, you will have to shutdown your XMPP client and thus disconnect from Talkr.IM. With the Push feature enabled on your XMPP client (if this one supports Apple Push notifications), you can tell your contacts you are still online when you are using other applications. You will then automatically receive notifications of new messages. And when you re-open your XMPP client, you will receive these messages.

OneTeam for iPhone has the Apple Push feature enabled: you will be able to use it on you Talkr.IM account. Just use you Jabber ID, like username@talkr.im, and for a simple configuration, go to the "Settings" tab, then "Push settings".

The Talkr.IM XMPP server will stop at 10:00am CET. This means:

01:00am Los Angeles
04:00am New York
12:00 Moscow
18:00 Tokyo

UPDATE: the Apple Push module is installed on Talkr.IM, and working fine. You can use it on OneTeam for iPhone. You can run a APNS module on your own ejabberd server with IMpush.

Erlware: Erlware on R13B04

martinjlogan@erlware.org (Martin J. Logan) — Wed, 03 Mar 2010 18:15:13 +0000

Erlware tools are now running on R13B04 for Mac OSX Leopard (Intel and PowerMac)Mac OSX Snow LeopardLinux i686Linux x86_64To install the 'erl' shell and start playing use 'faxien install-release erl'Note* escript still needs an update - contributions welcome.

Process-one Blogs: ejabberd tip: simple health check

Wed, 03 Mar 2010 16:30:28 +0000

An ejabberd health check mechanism might be useful in your deployments, but using the HTTP file server might be overkill...

Some people want to do regular health checks on ejabberd, which is always a good idea. Doing a health check over XMPP might not be the solution, here is at least two reasons:

with a pure ad-hoc solution like a cron script, you might need an XMPP library you might not want to install on your servers
monitoring systems might not talk XMPP at all...

So people first think of the internal ejabberd HTTP file server, which then they have to configure through a specific listener and the right module... possibly with logs, they would have to manage (rotate, parse, clean, etc.).

Sometimes people just don't think there is already an HTTP listener on their internal BOSH Connection Manager. You would argue that BOSH uses the HTTP POST method. But the ejabberd BOSH Connection Manager replies to simple GET:

wget http://myserver.net/http-bind

And ejabberd will answer:

ejabberd mod_http_bind v1.2

An implementation of XMPP over BOSH (XEP-0206)

This web page is only informative. To use HTTP-Bind you need a Jabber/XMPP client that supports it.

RedHotErlang: Returning a file with Nitrogen

Tue, 02 Mar 2010 19:41:01 +0000

Let's say I want to create a file download link in my Nitrogen application. First I create a _src/pages/web_file.erl_ file, and fill it with some code: -module(web_file). -export([main/0, title/0, body/0, event/1]). -include_lib ("nitrog...

Damien Katz: BBC and CouchDB

Mon, 01 Mar 2010 22:11:06 +0000

Vaguely interesting KV/#couchdb stat from the BBC - 3.3 billion requests handled since last summer, running at about 150-170 million per day

http://twitter.com/endafarrell/status/9820160677

Planet Trapexit - Erlang/OTP News

Erlang Solutions - Jobs: Subcontractors, Stockholm Sweden

Process-one Blogs: TextOne for iPhone, with photo sharing!

Damien Katz: What's New in CouchDB 1.0 Security 'n Stuff

Programming in the 21st Century: Common Sense, Part 1

Erlang Inside: Russia’s numerous contributions to the Erlang community – Dmitrii Dimandt, creator of erlanger.ru

Chicago Erlang User Group: 6/2/2010 OTP Plus

Nicolas Charpentier's blog: Next language to learn: Haskell

Programming in the 21st Century: Personal Programming

Damien Katz: Why Large Hadron Collider Scientists are Using CouchDB

Erlang Solutions - Jobs: Junior Systems Engineer at Erlang Solutions, London, Stockholm or Krakow (travel to client locations may be required)

Erlang Solutions - Jobs: Senior Systems Engineer at Erlang Solutions , Location: London, Stockholm or Krakow (travel to client locations may be required)

Erlang Solutions - Jobs: Open Source Support Engineers at Erlang Solutions, London, Stockholm or Krakow (occasional travel may be required)

Erlang Solutions - News: 25 August 2010: Erlang User Conference Registration Open with a Very-Early Bird Rate!

Erlang Factory News: Erlang User Conference Registration Open with a Very-Early Bird Rate!

Damien Katz: The Little Comedian

Process-one Blogs: Tsung 1.3.3 has been released

Erlang Solutions - News: 19 August 2010: Ulf Wiger CTO of Erlang Solutions will be presenting at Cracow Grid Workshop ‘10.

Erlang Solutions - News: 17 August 2010: Ulf Wiger of Erlang Solutions will be presenting at Yow! Australia 2010 in Brisbane and Melbourne

Erlware: ErlangCamp - Erlang and OTP Workshop in Chicago Oct 23 and 24

Damien Katz: WARNING: CouchDB 1.0.0 Data Loss bug

Erlang Solutions - News: 12 August 2010: Hans Nilsson of Erlang Solutions will be presenting at Java Zone 2010

Jordan Wilberding: ErlangCamp Chicago 2010

Chicago Erlang User Group: ErlangCamp Chicago 2010 Registration Open

EazyErl!: erlang: Simple Debug macro

ejabberd@jabber.ru: ejabberd 3.0.0-alpha-1 - for alpha-testing only

Erlang Inside: ErlangCamp Chicago 2010 – Oct 23rd/24th

1011 Ltd Blog: Why Google Wave "failed"

Damien Katz: CouchDB Diplom Thesis

Erlang Solutions - News: 05 August 2010: Announcing the call for submissions for the Erlang User Conference 2010 in Stockholm.

Damien Katz: We are hiring open source contributors!

ejabberd@jabber.ru: ejabberd 2.1.5 - Fifth bugfix release

Process-one Blogs: ejabberd 2.1.5 and exmpp 0.9.5 bugfix releases

Regarding ejabberd 2.1.5:

Release Notes

Links

Regarding exmpp 0.9.5:

Links

Damien Katz: Getting Your Open Source Project to 1.0

Hypothetical Labs: Part 1: Introducing riak_core

What is riak_core?

Node Liveness & Membership

Partitioning & Distributing Work

Cluster State

What’s the plan?

Learn You Some Erlang: Errors and Processes

Programming in the 21st Century: Stop the Vertical Tab Madness

Joe's Blog: SurgeCon 2010

Damien Katz: CouchCamp is Coming Soon!

Programming in the 21st Century: One Small Step Toward Reducing Programming Language Complexity

Erlang Inside: Erlang and REST – an interview with Steve Vinoski

Joe's Blog: Adding Health Checks to Deckard from Chef.

Trapexit's Erlang Blog Filter: New Column, New Interview

Programming in the 21st Century: Free Your Technical Aesthetic from the 1970s

Erlang Factory News: Erlang User Conference 2010 Talk Submission Open!

Programming in the 21st Century: Explaining Functional Programming to Eight-Year-Olds

Erlang Inside: PostgreSQL Erlang client library epgsql supports asynchronous messages from LISTEN/NOTIFY events

Erlware: A Brief Overview of Concurrency.

Process-one Blogs: ProcessOne releases OneCached, a Memcached in erlang

Erlang Inside: New Erlang job board – totally-erlang.com

RedHotErlang: Playing with LFE macros

Programming in the 21st Century: What Do People Like?

Process-one Blogs: Hosted.IM gets gateways to legacy IM systems

Erlang Inside: erldocs.com updated with R14A support, mochiweb, and available for your own projects

Programming in the 21st Century: Tricky When You Least Expect It

BGH's Blog: Erlang Programming Exercise: 5-2

Erlang Inside: Spanish Language Erlang List

1011 Ltd Blog: Elegant XML SAX parsing using Erlang's pattern matching

Learn You Some Erlang: More On Multiprocessing

Process-one Blogs: Case study: Arc International

RedHotErlang: Dizzy thoughts

Damien Katz: Migrating From MySQL to CouchDB

Damien Katz: CouchCamp, aka BurningCouch!

RedHotErlang: Permutations

Erlang Eclipse IDE: [erlide] Regular update site upgraded

RedHotErlang: Erlang Factory, London 2010

Damien Katz: How Software Is Built: Apache CouchDB

1011 Ltd Blog: HOWTO Choose a NoSQL Database

Erlang Factory News: Erlang User Conference Date Announced

Erlang Eclipse IDE: [erlide] Dropped support for R11

Erlang Solutions
- Jobs: Subcontractors, Stockholm Sweden

Erlang Solutions
- Jobs: Junior Systems Engineer at Erlang Solutions, London, Stockholm or Krakow (travel to client locations may be required)

Erlang Solutions
- Jobs: Senior Systems Engineer at Erlang Solutions , Location: London, Stockholm or Krakow (travel to client locations may be required)

Erlang Solutions
- Jobs: Open Source Support Engineers at Erlang Solutions, London, Stockholm or Krakow (occasional travel may be required)

Erlang Solutions
- News: 25 August 2010: Erlang User Conference Registration Open with a Very-Early Bird Rate!

Erlang Solutions
- News: 19 August 2010: Ulf Wiger CTO of Erlang Solutions will be presenting at Cracow Grid Workshop ‘10.

Erlang Solutions
- News: 17 August 2010: Ulf Wiger of Erlang Solutions will be presenting at Yow! Australia 2010 in Brisbane and Melbourne

Erlang Solutions
- News: 12 August 2010: Hans Nilsson of Erlang Solutions will be presenting at Java Zone 2010

Erlang Solutions
- News: 05 August 2010: Announcing the call for submissions for the Erlang User Conference 2010 in Stockholm.

Erlang Solutions
- News: 17 May 2010: Erlang Solutions awarded a Knowledge Transfer Partnership with the Kent Business School

Erlang Solutions
- News: 26 April 2010: Hans Nilsson joins Erlang Solutions as Senior Consultant

Erlang Solutions
- News: 10 May 2010: Erlang Solutions Announces Opening of New Office in Stockholm, Sweden