Erlang/OTP architectures: Cowboy

I guess you can either see it as how much faster Cowboy is or how much more useful Rails is. It's nice if you have a lot of Erlang code already, but if you're making a web application from scratch, performance is pretty far down the list and I would stick to the half dozen stacks that are proven. Erlang can make sense sometimes, but it's probably not(!) comparable to Rails in those cases.

Edit: Eh, I forgot a "not" in the last sentence, which is now added.

I'd be interested to see the comparative performance for a "hello world" Phoenix app.

But in reality we need a better benchmark than "hello world". Something like TodoMVC, but for server-side development.

eg.

  GET /todos
  * authenticated
  * 100 todos
  * + threaded comments

implement the same in Rails, Phoenix, Express, and use that as a benchmark.

(edited for formatting)

It might be worth looking at how Phoenix[0] does it (or, you know, just consider using Elixir/Phoenix). Phoenix runs on cowboy out of the box and makes setting up a web app a snap:

    $ mix phoenix.new my_app

which then sets up the directory structure for you to just run

    $ mix phoenix.server

and have cowboy serving your webapp. The guides then tell you which files to add new routes, controllers, models, etc (in a way similar to Django or Rails). All that said, it's in Elixir at that point, but maybe you could still infer how the applications and gen servers and whatnot are structured from it.

It may be worth asking josevalim and chrismccord in #elixir-lang for tips on setting it up, since they obviously must know how to set up cowboy pretty well to build a system on top of it.

I think Erlang and things like cowboy and OTP are absolutely amazing for the web, but Elixir has made things 100x easier to get up and running with them.

[0] https://github.com/phoenixframework/phoenix

Here's the cowboy user guide: http://ninenines.eu/docs/en/cowboy/1.0/guide/

You can also clone the repo and checkout the examples:

Make sure you have erlang installed

    $ cd examples/hello_world
    $ make

    $ ./_rel/hello_world_example/bin/hello_world_example start
    OR
    $ ./_rel/hello_world_example/bin/hello_world_example console

then visit localhost:8080

cowboy's documentation is pretty poor and there's no good 'getting started with cowboy' thing i can point you at, but this is pretty good for erlang in general:

http://howistart.org/posts/erlang/1

Yes, I had the the same experience. I started to learn Erlang for growing my personal skills, and because I love functional programming. There are a lot of books about Erlang itself, but when I started to try some http service I found a lack of documentations and step by step tutorial

My first attempt at making a simple Cowboy application was less than successful. I found the documentation spotty, inconsistent, and very difficult to understand. After about 45 minutes of really frustrated dicking around, I figured out how to make a simple HTTP server that allowed me to handle simple HTTP requests. I had to write code to switch on the passed-in HTTP verb, but everything worked, more or less. I could serve HTTP requests, but my code crashed after every request. (This was -of course- not fatal, but a bit of a performance killer.) Pipelined requests didn't work due to server connection resets. (Again, not fatal, just perf-diminishing.) I was utterly unable to get cowboy_rest to work.

Several months later, with a lot of additional Erlang experience under my belt, I come back to the documentation, and it's -somehow- 60->70% comprehensible. I figured out what was wrong with my simple HTTP server. (I was calling my request handler in init, rather than returning {ok, Req, []}, and letting Cowboy call my request handler later.) I still can't get cowboy_rest to work, but (OTOH) I haven't spent more than five minutes trying to get it to work since my first attempt way back when.

I don't know how much experience you have with Erlang, so I'll give you some basic advice that might be entirely unhelpful. Feel free to ask additional questions. Also feel free to ask questions on the erlang-questions mailing list. [0] Everyone who regularly posts there is very helpful. Many (most?) of them use Erlang professionally.

Anyway. Advice:

Projects/frameworks like OTP and Cowboy provide a callback API that application code is expected to conform to. Cowboy's documentation for this API is kind of all over the place, [1] but OTP's is well organized. [2]

Because Erlang tries to eschew global state as much as it can, OTP has a convention that one of the values in the tuple returned from an callback is the state for that particular instance of your application code. This State variable seems to always be the last element in the returned tuple, and the last argument to your callback function. State can be any Erlang term; it only has meaning to your application code. If your callbacks don't care about state, then you can pass anything as state. Many other frameworks have adopted this convention; it's a pretty good one.

Cowboy appears to be a pretty good HTTP/SPDY server. The beginner's documentation needs a LOT of love. (Even now, I had difficulty trying to piece together that walk through the docs in the footnote.) Given that it's a one-man shop, it's surprising that the docs are in as good a shape as they are; documentation isn't easy. :) But, still...

Anyway, questions? Comments? Ask away either here, or on the erlang-questions mailing list. :)

[0] http://erlang.org/mailman/listinfo/erlang-questions

[1] First you have to read the examples shipped with the source code https://github.com/ninenines/cowboy/blob/1.0.x/examples/hell... https://github.com/ninenines/cowboy/blob/1.0.x/examples/hell... to kind of get the impression that you need to use the cowboy_http_handler API (kinda introduced here http://ninenines.eu/docs/en/cowboy/1.0/guide/http_handlers/ and documented here http://ninenines.eu/docs/en/cowboy/1.0/manual/cowboy_http_ha... ) in order to handle plain HTTP requests. If there's a better way to arrive at this conclusion, I overlooked it. :(

[2] For example, the docs for OTP's application API: http://www.erlang.org/doc/man/application.html or the gen_server API: http://www.erlang.org/doc/man/gen_server.html The parts before the "CALLBACK FUNCTIONS" section are functions you use to manipulate an application or gen_server. The bits after are functions you implement in your module that the application or gen_server machinery will call.

Glad to see another person attempting it. There are a few (including a commercial product, a Kickstarter project, and me) but most have been abandoned, AFAIK.