BeeBuzz

PURE Is Working With The JavaScript Framework Prototype

Mic — Thu, 13 Nov 2008 06:59:02 +0000

Thanks to the contribution of Carlos Saltos and Borja Vazquez our JavaScript Template Engine PURE is now working with the JavaScript Framework Prototype

The code is not in the master repository yet, but you can get it in the branch of PURE created by Carlos.

They are also working on the MooTools support.

With the announcement of the DOMAssistant support a few weeks ago, and jQuery initially, it is now three JavaScript libraries that are supported.

Stay tuned

Ruby Like Notation #{ … } To Mix Strings And Variables

Mic — Thu, 06 Nov 2008 06:56:52 +0000

New feature for our JavaScript template engine PURE

From revision 1.7 on, there is a new shortcut available to concatenate strings.

We’ll take a similar HTML as our basic Hello World example:



    Hello World

Now we remove the “Hello ” string:



    World

Here is the JSON we’ll use to render this HTML:

var json = { "name": "Mary" }

And now the directive that will link them both:

var dir = { "span": "Hello #{name}"}

Direct assignation continues to work.

For more information and examples, visit the dedicated Wiki page

Stay tuned

BeeLit Becomes BeeBole

Yves — Sun, 02 Nov 2008 10:46:58 +0000

In an attempt to simplify the environment we plan to create around our first solution (including time tracking, expense management, invoicing and the related reporting tools), we decided to regroup everything we are producing now and will produce in the future under our company name BeeBole.

The main changes are the following:

The name BeeLit will disappear.

The website beelit.com has been moved to the URL http://beebole.com. If you are trying to access beelit.com, you will automatically be redirected to beebole.com. Be sure to update your bookmark!

The mailing list that helps you keeping track of the coming beta has been renamed into BeeBole Newsletter. There are no impacts for those who are already following us (Click here to subscribe, it takes 10 seconds).

Stay tuned

Tips Section For Our JavaScript Template Engine

Yves — Mon, 27 Oct 2008 06:51:34 +0000

We have just created a tips section on the PURE Wiki. The given information should help you in your day-to-day use of PURE

All your own tips are more than welcome. Just send us an email with what you’ve got.

And to end this post on really good news, Douglas Crockford, the man behind JSON, just added PURE on JSON.org main page.

Stay Tuned

Video Tutorial To Start Developing Web Applications on Erlang

Hughes — Mon, 20 Oct 2008 09:01:28 +0000

Please find hereunder a video tutorial highlighting the key points of developing a JSON based web application with Erlang and Mochiweb.

Note that, for best performances (HD Definition), you have to directly go to the Vimeo website where the video is stored and watch it in full screen mode.

You may want to download the video. In that case, you will have to follow the instructions at the bottom of the video page on the Vimeo website.

Click on the image below to go the the video page.

The purpose of all this, aside from arousing your curiosity, is to provide you with a getting started pack and allow you to go a step further in the Erlang web application sphere.

I invite you to download the example application (as illustrated in the video stickyNotes.zip) in order for you to understand all the pieces of the puzzle and to venture behind the scene.

Just keep in mind that stickyNotes is a one shot application that I’ve developed from scratch with the unique aim of illustrating the video example.

Having said that, any comment or suggestion is always welcome, especially about ’struct.erl’, a module that I’ve created when I was learning the language in order to play with the tree structure resulting from the mochijson2 decode function.

We are using it in our mainstream development and I’m still wondering if I might have missed something important with regard to the Erlang distro or Mochiweb itself.

In order to install this stuff on your system and assuming that Erlang is properly setup on your box, just follow these steps:

1) Download stickyNotes and extract the archive in your home directory:

stickyNotes.zip

2) cd to stickyNotes dir and compile the code :

make clean && make

3) Start the application and initialize the db from the Erlang console (only once)

./start-dev.sh
stickydb:reset().

4) Browse the following address 127.0.0.1:8000

Super easy isn’t ?

Enjoy

London Calling - FOWA 2008

Yves — Wed, 08 Oct 2008 07:33:29 +0000

Early tomorrow, we will be leaving Brussels to attend the Future of Web Apps event in London.

The event is one of the major event in the apps industry in Europe.

Well known names are joining the party: Mark Zuckerberg from Facebook, Kevin Rose from Digg and many others.

Just leave a comment if you plan to attend the event and we might try to meet each other.

Are Online Ads The Easy Way To Donate ?

Yves — Tue, 07 Oct 2008 09:17:08 +0000

When we redesigned the PURE website, we’ve had intense debates about adding ads or not on the main page.

I was against it mainly because when you give something Open Source, you give it for free and shouldn’t expect any financial returns.

However, I had nothing against donations.

Using ads as an easy way to donate got me convinced.

When you click on the ads, you don’t need to take your credit card out of your wallet but money goes to the provider.

Still, the reality is different. 35000 visits later, the amount of money raised thanks to the ads reaches 15$.

Are we the only one doing this for projects we like ?

At least, Seth Godin, a well-known marketer, thinks the same way

But in the long term, it can only corrupt the ads system.

And, as Google prevents you to encourage clicks, it is maybe something for Donation Sites like Pledgie to look into, a one click support badge.

Our JavaScript Template (PURE) Becomes Cross-Library

Yves — Thu, 02 Oct 2008 07:04:36 +0000

We started the development of PURE with the clear goal of developing a cross-library JavaScript template engine.

Since we are using jQuery as our main JS library in the development of our BeeLit solution, it was obvious to start with this one.

Today, we are happy to announce that PURE has moved another step closer to our initial goal as it now also works with DOMAssistant.

I must say, we haven’t really played a big role here. Everything started with a simple message on the DOMAssistant discussion group

Lim Cheng Hong (one of the three developers behind the library) took the challenge in his hands and made the 6 examples of our Getting Started page working with DOMAssistant in just two days.

You can discover those 6 examples with the DOMAssistant library here

So thank you Lim Cheng Hong and thanks to the DOMAssistant team.

We will soon update our wiki and the PURE website with those new examples.

The next steps will be to port PURE on Prototype, MooTools and Dojo.

If you are ready to get your hands dirty with those adaptations, your help will be more than welcome.

Stay tuned

Web Application on Erlang: Configure Nginx with Mochiweb

Hughes — Tue, 30 Sep 2008 10:13:44 +0000

My previous post, the first of our series dedicated to the Erlang world, was definitively getting too long, so here is the second chapter of this marvelous article.

I’ll assume that you have successfully installed Erlang and Mochiweb and deployed your first small tiny app.

When it comes to deliver static content at lightning speed and do reverse proxy job, there is one name : Nginx, the Igor Sysoev high-performance HTTP server.

It plays well with ssl and in the last dev version you can even find an interesting module for uploading files, nothing less … we will probably tell you more about that in the series.

Nginx is really turning itself into a real handy swiss knife.

Step 0 - SSL packages check

So let’s start by ensuring that the ssl packages are already installed on your box :

foo@bar:~$ sudo apt-get install openssl libssl-dev

Step 1 - Install Nginx

Now, we are ready to download, compile and install Nginx.

Here, we want to install the last stable version (0.6.32).

foo@bar:~$ sudo apt-get build-dep nginx

foo@bar:~$ wget http://sysoev.ru/nginx/nginx-0.6.32.tar.gz

foo@bar:~$ tar -zxvf nginx-0.6.32.tar.gz

foo@bar:~$ cd nginx-0.6.32

foo@bar:~/nginx-0.6.32$ ./configure –with-http_ssl_module

foo@bar:~/nginx-0.6.32$ make && sudo make install

Done.

Step 2 - Nginx configuration

We do have now to tell Nginx what to proxy, in our case http://my_server_name:8000 (in the previous post, remember?)

You can find the Nginx configuration file, nginx.conf, under /usr/local/nginx/conf/.

Here is a working example one :

Discover the code in Friendpaste

user www-data;

worker_processes  4;
...

http {
    include       mime.types;
    ...

    upstream mochiweb {
        server my_server_name:8000;
    }

    server {
        listen       80;
        server_name  my_server_name;

        ...

        location / {
            root   path_to_myapp/myapp/priv/www;
            index  index.html index.htm;
            ...

            if (!-f $request_filename) {
                proxy_pass http://mochiweb;
                break;
            }

        }

    }

}

Step 3 - Start, Stop Nginx

Finally, we are going to tell Ubuntu how to start and stop the server.

Just create a new file named ‘nginx’ in /etc/init.d and paste the content of this link:

Discover the code in Friendpaste

foo@bar:~/nginx-0.6.32$ cd /etc/init.d

foo@bar:~/etc/init.d$ sudo vi nginx

Above, for those of you who are not in love with vi, you can use nano instead: sudo nano nginx

foo@bar:~/etc/init.d$ sudo chmod +x nginx

foo@bar:~/etc/init.d$ sudo update-rc.d nginx defaults

foo@bar:~/etc/init.d$ sudo ./nginx start

Cool, you have now a working reverse proxy.

foo@bar:~/etc/init.d$ cd ~/myapp

foo@bar:~/myapp$ ./start-dev.sh

Browse this link http://my_server_name

Peace!

As a reminder, the next points we will discuss are:

The basic configuration of Postfix (mail)
The use of Imagemagick to create dynamically a captcha for your application
The configuration of Bind9 in order to play with the url CNAME

So, stay tuned

How To Quickly Set Up Ubuntu 8.04 loaded with Erlang, Mochiweb and Nginx

Hughes — Thu, 25 Sep 2008 09:54:50 +0000

Let’s say you want to give a try to Erlang (Discover our post about Why Erlang?) for your next web development project and you want to be up and running as quickly as possible… you just landed smoothly in the right place.

This post is the starting point of a series of posts in which I’m going to provide you with all the commands you’ll need to set up an Ubuntu 8.04 server loaded with Erlang, Mochiweb proxied by Nginx.

In the same series, I’ll also cover:

The basic configuration of Postfix (mail)

The use of Imagemagick to create dynamically a captcha for your application

The configuration of Bind9 in order to play with the url CNAME

The goal here is not to set up an hardened production server with all the optimizations and security niceties in head (I definitively want to avoid a ‘Why not Gentoo, or Slackware, or Debian, or FreeBSD, …?’, I love them all).

No, it’s all about being able to quickly set up a test server and/or your dev machine in order to dive directly in the development typhoon. And, I must say, Ubuntu(*) is a king at this task.

(*) from a dev point of view, having your dev machine installed with the same OS that your test server is running is definitively a big plus.

You’ve just rent a cheap box from your web host provider, done a fresh Ubuntu 8.04 server installation and you are currently ssh logged in as root … yes, yes, you have done all those things. (In the case you are setting up your desktop machine you can go directly to point 3)

So let’s start!

Step 0 - Upgrade

We ensure with this step that our package sources and our installation is up to date.

root@bar:~$ apt-get update

root@bar:~$ apt-get clean

root@bar:~$ apt-get upgrade

Step 1 - Denyhosts

We install Denyhosts, a Python script used to prevent brute force hacking of our SSH server.

Also, we set RESET_ON_SUCCESS = yes in order to avoid being blocked because we reached the max attempt value.

root@bar:~$ apt-get install denyhosts

root@bar:~$ vi /etc/denyhosts.conf

/RESET_ON_SUCCESS [enter] i

RESET_ON_SUCCESS = yes

[esc] :wq

Step 2 - A new sudoer + reboot

We add a new user and grant him the ability to use the sudo command.

A first and unique reboot (we don’t need to do that … but I’m used to reboot my system at least once in order to check that everything is properly set up after a clean install).

root@bar:~$ adduser foo

root@bar:~$ apt-get install sudo root@bar:~$ visudo

foo ALL=(ALL) ALL

root@bar:~$ reboot

We log in with the user we have just created:

ssh foo@bar

Step 3 - Some useful packages

Installation of the GNU C and C++ compiler, the ‘make’ utility, svn and Git.

foo@bar:~$ sudo apt-get install build-essential subversion git-core

Step 4 - Erlang

Building the last Erlang release from source.

foo@bar:~$ sudo apt-get build-dep erlang
foo@bar:~$ sudo apt-get install java-gcj-compat java-gcj-compat-dev

foo@bar:~$ wget http://www.erlang.org/download/otp_src_R12B-4.tar.gz

foo@bar:~$ tar zxvf otp_src_R12B-4.tar.gz
foo@bar:~$ cd otp_src_R12B-4
foo@bar:~/otp_src_R12B-4$ ./configure
foo@bar:~/otp_src_R12B-4$ make && sudo make install

foo@bar:~/otp_src_R12B-4$ erl

Eshell V5.6.4 (abort with ^G) 1>init:stop().

Step 5 - Mochiweb

UPDATE, Octobre 20th 2008: Read and view more about installing Mochiweb and creating a first Erlang Web application on our video

Here, we install Mochiweb and we create our first app skeleton … Tataaaan

foo@bar:~$ svn checkout http://mochiweb.googlecode.com/svn/trunk/ mochiweb

foo@bar:~$ cd mochiweb
foo@bar:~/mochiweb$ make
foo@bar:~/mochiweb$ chmod +x scripts/new_mochiweb.erl
foo@bar:~/mochiweb$ ./scripts/new_mochiweb.erl myapp ../.
foo@bar:~/mochiweb$ cd ../myapp
foo@bar:~/myapp$ make
foo@bar:~/myapp$ ./start-dev.sh

Launch your favorite browser and check this address : http://bar:8000, where bar is the ip adress or the name of your server/desktop.

You should see:

MochiWeb running.

Well Done, you have an ultra fast ligthweight webapp server up and running !

Step 6 - Some getting started hints

Where do I start coding ?

foo@bar:~/myapp/src$ vi myapp_web.erl

In the main loop you will find a case testing the GET and the POST method.

Just add the ‘congrat’ part.

loop(Req, DocRoot) ->
"/" ++ Path = Req:get(path),
case Req:get(method) of
Method when Method =:= 'GET'; Method =:= 'HEAD' ->
case Path of

"congrat" ->
Req:ok({"text/html", [],["

`Congratulation`

"]});

    _ ->
     Req:serve_file(Path, DocRoot)
    end;
  'POST' ->
   case Path of
    _ ->
     Req:not_found()
   end;
  _ ->
    Req:respond({501, [], []})
end.

foo@bar:~/myapp/src$ cd ..
foo@bar:~/myapp$ make
foo@bar:~/myapp$ ./start-dev.sh

Launch the browser you want to live with and travel to this url: http://bar:8000/congrat, where bar is the ip adress or the name of your server/desktop.

In this module, I’m used to limit the code to the functions related to Req, the mochiweb_request module;

Here are a few more:

Req:get_cookie_value(”myCookie”)
Req:parse_qs() (parse the query string)
Req:parse_post() (parse the posted data)

How do I start Mnesia with my app?

foo@bar:~/myapp/src$ vi myapp.erl

%% @spec start() -> ok
%% @doc Start the myapp server.
start() ->
myapp_deps:ensure(),

ensure_started(crypto),
ensure_started(mnesia),
application:start(myapp).

%% @spec stop() -> ok
%% @doc Stop the myapp server.
stop() ->
Res = application:stop(myapp),
application:stop(mnesia),
application:stop(crypto),
Res.

Edit your start script in order to specify the db location

foo@bar:~/myapp$ vi start-dev.sh

exec erl ... -mnesia dir '"/path_to_your_db/myapp_dev"' ...

How do I start my app silently in background ?

Launch Erlang with the -detached flag (start erl without a controlling terminal)

foo@bar:~/myapp$ vi start-dev.sh

exec erl ... $1

You can now pass the -detached argument to your start script like this:

foo@bar:~/myapp$ ./start-dev.sh -detached

Mochiweb is coming with a handy set of modules

Have a look at the source of mochiweb_request, mochiweb_cookies, mochinum, mochijson2, mochihex, …

In the next post, I’ll finish this basic install with the configuration of Nginx and I’ll provide you with a small JSON app example.

NOTE : The post has been updated on the 08/10/2008 to match the new Erlang release number