How to switch from one version of Erlang to another one in a simple way?

There are no magics behind what I’m going to say in this post. Actually, this post will sound quite trivial to most of you. I simply wanted to share what I currently do with the ones of you who might have the same need. I’m using Snow Leopard, but all of the above should apply to any UNIX-like system. Also, I assume you’re fine with installing Erlang from source.

Assume you have two separate Erlang installations in your home directory:

~/erlang13b04

~/erlang14a

Notice that you can specify the installation path of Erlang by selecting, at installation time:

./configure –prefix=YOUR_INSTALLATION_PATH

First of all, let’s edit our ~/.bashrc, by adding the following line:

PATH=$PATH:$HOME/bin

Then, let’s create the bin folder under the home directory:

mkdir $HOME/bin

Let’s now create some scripts in the directory we’ve just created. We will need one script for each installation we want to use.

Let’s create a file called “13″ (no extension). Inside the file, we write:

#!/bin/bash
env PATH=/User/[USERNAME]/erlang13b04/bin:$PATH "$@"

Let’s then do the same for R14. Create a file named “14″ and write the following into it:

#!/bin/bash
env PATH=/User/[USERNAME]/erlang14a/bin:$PATH "$@"

Make the two script executable:

cd ~/bin

chmod +x 13 14

Let’s “source” the ~/.bashrc (or simply open a new shell):

source ~/.bashrc

That’s it. If you want to run a command using R13, just:

13 erl

Erlang R13B04 (erts-5.7.5)

Eshell V5.7.5  (abort with ^G)

1>

Or:

14 erl

Erlang R14A (erts-5.8)

Eshell V5.8  (abort with ^G)

1>

Assuming you have a project you want to compile with R13:

13 make

Or, if you prefer R14:

14 make

Well, you should have got the idea at this point…

Notice that you can still specify the path of your favourite (default) Erlang installation in your ~/.bashrc file, so you wan’t need to prepend “14″ to your commands every time you want to use the latest Erlang version.

As I’ve already said, there’s nothing special here. Just a bit of playing with paths that might turn useful from time to time.

Suddenly, with no apparent reason, every non native application crashes immediately after the launch. A reboot in this case doesn’t help. The native applications (mail, safari, settings, etc) simply work fine.

I’ve just realized that an update of ANY existing application or the installation of ANY new application via the Apple store brings the device back into a normal state and all applications behave normally again.

Obviously this is just an ugly workaround, but it seems to work very effectively. See if it helps.

The bad thing about access keys is that they’re often hidden, by default, in the web pages. This doesn’t make sense to me.

Take the Twitter home page. How many of you knew that, during a search, you could press CTRL+ALT+n to display the “N new tweets since you started searching” or that you could press CTRL+ALT+s to visit your “settings” page? As a different example, let’s consider Wikipedia. Did you know that CTRL+ALT+e lead you to the “edit” mode? Probably not.

Resuming, “accesskey” shortcuts can be very useful. So why they are not displayed by default on the web pages? How should we know about them? And how could we ever remember all of them?

Long time ago, I found this post on how to display the “accesskey” keyboard shortcuts in Firefox and I used it for a while. But I’ve recently fallen in love with Google Chrome and I was wondering if the same feature was already available.

At first, I googled for a quick solution and I couldn’t find anything really useful. Then, I asked on Superuser if what I wanted was somehow possible. After a couple of hours, someone answered my question, claiming he created a new Chrome extension just for that. I must admit I was more impressed by the rapidity of the answer than by the answer itself. If this guy could read my specification and implement a solution in such a short time, there was only one possible consequence: “Creating extension for Google Chrome is easy”.

So, I tried by myself.

First of all, I had a look to the “Getting Started” section of the Chrome extensions documentation. As expected, everything was extremely simple. To implement the “accesskey” shortcuts, it took me no more than five minutes. Literally. And now my Twitter page looks like:

Can you see the pink characters close to the links? They are all available “accesskey” shortcuts, a piece of information that was already embedded in the web page but that has just been hidden. Let’s see how can we make it visible again via a brand new Google Chrome Extension.

First of all, create a new folder somewhere in your hard drive and call it “shortcuts”.

Every Chrome extension is characterized by a “manifest” file, written in json, reporting the “properties” of the extension itself. Inside the “shortcuts” folder, create a new file, named “manifest.json”:

{

  "name": "Shortcuts",

  "version": "1.0",

  "description": "Display the accesskey shortcuts.",

  "content_scripts": [{

    "matches": ["http://*/*", "https://*/*"],

    "css": ["style.css"]

  }]

}

Apart from the name, the version number and the description of the extension, you can notice a “content_scripts” property. This is used to “inject” some code automatically every time a web page is displayed. In our case, we simply want to apply some specific CSS properties to the pages. The “matches” section tells Chrome to apply the transformation to every page using the http or the https protocol.

Now, we just need to create a style.css file (inside the same “shortcuts” folder) containing the needed stylistic information:

a[accesskey]:after,

button[accesskey]:after,

input[accesskey]:after,

label[accesskey]:after,

legend[accesskey]:after,

textarea[accesskey]:after {

  margin-left: 0.3em;

  color: Plum;

  content: "[" attr(accesskey) "]";

}

That’s all folks. We’re done. We can just install our brand new Google Chrome Extensions by visiting the URL:

and clicking on the “Load Unpacked Extension” button.

Using the same strategy, it is obviously possible to apply different CSS transformations. Imagine for a second that you would like to hide all the images from a web page. A CSS like the following would do the job:

img {

  display: none;

}

Hope this help.

We’re going from:

first

second

third

To:

1. first

2. second

3. third

Obviously, there are many ways to achieve this, but one is to use the Emacs Keyboard Macro Counter.

In this period, I’m working a bit with PHP and I’ve immediately thought that enabling flymake for Emacs was indeed a good idea.

Well, someone has apparently already thought about it, so everything you need to know about it is explained here.

I tried it on my machine and it worked like a charm. Combined with some PHP documentation integrated in Emacs, I’m now starting to have a complete and powerful development environment for PHP.

I’m now wondering if there’s any way to get this a step forward. First of all, I’m trying to identify errors different from the parsing ones. What I would really love, for example, is to have Emacs showing me all the unused variables in a PHP file. If you have any idea on how to achieve this, don’t be shy and share your thoughts with me, as a post comment or, if you prefer, as a private e-mail or through twitter.

Are you already using the full power of Gmail?

First of all, I edited my configuration.php file to contain the following settings:

	var $mailer = 'SMTP Server';
	var $mailfrom = 'MY_GMAIL_ADDRESS';
	var $smtpauth = '1';
	var $smtpuser = 'MY_GMAIL_ADDRESS';
	var $smtppass = 'MY_GMAIL_PASSWORD';
	var $smtphost = 'ssl://smtp.gmail.com:465';

Then, I patched the libraries/phpmailer/phpmailer.php file by editing the SmtpConnect function. In the specific I changed the lines:

if(strstr($hosts[$index], ":"))
        list($host, $port) = explode(":", $hosts[$index]);

into:

if (preg_match('#(([a-z]+://)?[^:]+):(\d+)#i', $hosts[$index], $match))
{
        $host = $match[1];
        $port = $match[3];
}

Please note that I’m using Joomla version 1.5.6. This trick is based on the following discussion.

Sometimes you need to recursively set a specific UNIX permission for a whole set of files and/or directories. And you want to have a different permission for your files and for your directories.

For example, when installing a CMS like Joomla (or Moodle), you might want to recursively set the UNIX permissions to 700 for all the directories contained in your web root (say, your htdocs). And you want to do the same for all the files, but this time to 600.

This can easily be achieved by entering your htdocs and by using the find command:

find . -type d -exec chmod 700 {} +
find . -type f -exec chmod 600 {} +

The commands should be read as follows:

“Read everything in the current directory, recursively. For every single item that is of type directory (file) change permissions to 700 (600).”

The {} + option (refer to the find man page) runs the specified command on the selected files, but the command line is built by appending each selected file name at the end.

More information about UNIX permissions here.

It is possible to execute a php command directly from the command line by doing the following:

php -r 'COMMAND'

For example:

php -r 'echo substr("hello world", 6);'

Enjoy!

Also Known As
ETS Driven Testing

Intent
When writing Quickcheck unit tests for an Erlang application, it usually happens that you require to stub some external application, since you’re not interested in System Tests, but you want to test your application as a mere black box.

Motivation
You want complete control on the results provided by your stubs, so that you can successfully check the properties you need for your application.

Sample Code

In your quickcheck module, just define in your state the results you need, together with their default value:

-record(state, {stub_result = true}).

Define the initial state as follows:

initial_state() ->
    init.

initial_state_data() ->
    #state{}.

In your property, create an ETS table containing the results (don’t forget to delete it after running the tests) and call the run_commands function by passing an extra parameter:

prop_commands() ->
    ?FORALL({Cmds, State}, custom_commands(),
            ?TRAPEXIT(begin
                          results = ets:new(results, [named_table, set, public]),
                          ets:insert(results, {stub_result, State#state.stub_result}),
                          {H,S,Res} = eqc_fsm:run_commands(?MODULE, Cmds, [{var, stub_result}]),
                          true = ets:delete(results),
                          ...

The custom_commands function is the place where you set the list of available results:

custom_commands() ->
    ?LET(State,
         #state{stub_result = oneof([true, false])},
         {more_commands(100, eqc_fsm:commands(?MODULE, {init, State})), State}).

You can check the result in your postconditions, as follows:

postcondition(_From, _To, S, {call, _, _, _}, R) ->
    S#state.stub_result == R.

Obviously, your stubs need to contain something like:

stubbed_function() ->
    ets:lookup_element(results, stub_result, 2).

Consequences
Your tests will be able to cover a bigger number of code lines (lemmings).

Thanks
Thanks to Master Magnus Henoch for his help.