• Part 1: Thinking Functionally with Haskell- Introduction to Haskell
• Part 2: Thinking Functionally with Haskell – Type system
• Part 3: Thinking Functionally with Haskell – A kata to apply what is taught so far
• Part 4: Thinking Functionally with Haskell – Plumbing with monads

The biggest problem I find when using ocaml is the build system. There are a lot of tools to simplify the build process. There’s ocamlbuild and ocamlfind. But I find that the documentations aren’t very helpful. For example, I can’t find any documentations about writing META files for ocamlfind. Neither can I find any guides about writing _tag files for ocamlbuild. I guess the best way around this is for the users of these tools to post their own guides and document their issues. Sp I’m going to write this post so that I can save another user the headaches that I’ve went through.

For my final year project, I’m working with Jeremy Yallop’s deriving library. The library uses camlp4 (original syntax). To install the library to your system, install opam and execute this command:

$> opam install deriving-ocsigen

Opam is a package manager for OCaml libraries. After installing, make sure you have findlib installed. Then test your installation:

$> ocaml
        OCaml version 4.00.1
# #use "topfind";;

You should see a menu with some commands to get you started with findlib. Next execute these commands in your ocaml toploop:

# #camlp4o;;
# #require "deriving-ocsigen.syntax";;

You should see some output showing that the library’s path is added to ocaml’s search path. Next, let’s try to evaluate some code that use the deriving library.

type point = { mutable x : int; mutable y : int }
     deriving (Eq, Show);;

If the above code is successfully evaluated, then you should have the deriving library installed on your system. To compile code that uses the deriving library, you have to use ocamlfind telling it to use the camlp4o (original syntax) and to use the deriving-ocsigen.syntax package.

ocamlfind ocamlc -package deriving-ocsigen.syntax -syntax camlp4o -c point_seq.ml -o point

That’s it. Hope I’ve saved you some headaches when using ocamlfind with libraries that use camlp4. I believe the above commands should work with other libraries that use camlp4 (sexplib) too.

Therefore in python, it’s possible to do things like this:

def raise_to_base(n):
  def my_pow(x):
    return x**n
  return my_pow

>>> pow_base_5 = raise_to_base(5)
>>> pow_base_5(2) # => 32

(above code is taken from Python Closures Explained)

I have created a function that returns another function. And the inner function is known as a closure. A “closure” is an expression (typically a function) that can have free variables together with an environment that binds those variables (that “closes” the expression). With closures, we can do other neat things like this:

def outer():
  y = 0
  def inner():
    nonlocal y
    y+=1
    return y
  return inner


>>> f = outer()

>>> f()
1
>>> f()
2
>>> f()
3

The inner function now becomes something like a method in OOP. It controls the way the variable y is accessed from the outside. But there’s a problem when we want to do this in Python 2.7. The above code works only in Python 3.x. The nonlocal keyword does not exist in Python 2.7. To solve this problem, we can use dictionaries (or we can also create another object) to store the y variable in a namespace that the inner function can access.

def outer():
  d = {'y' : 0}
  def inner():
    d['y'] += 1
    return d['y']
  return inner

Though IMO, it’s kinda weird that we can’t access the non local variable but we can access the dictionary.


First, you have to get the netcfg and the wpa_supplicant packages.

sudo pacman -S netcfg wpa_supplicant

netcfg allows you to configure your wifi according to profiles and manages the profiles for you. wpa_supplicant is used for configuring the authentication.
Next, copy /etc/network.d/examples/wireless-wpa-config to /etc/network.d/nus. In this example, I shall name it as nus.

sudo cp /etc/network.d/examples/wireless-wpa-config /etc/network.d/nus

Then, make sure your /etc/wpa_supplicant.conf looks like this:

ctrl_interface=/var/run/wpa_supplicant

network={
ssid="NUS"
key_mgmt=WPA-EAP
eap=PEAP
group=CCMP
pairwise=CCMP
identity="NUSSTU\"
password=""
priority=1
ca_path="/etc/ssl/certs"
phase2="auth=MSCHAPV2"
}


Lastly, start the netcfg profile. The profile name should correspond to the file name of the profile configuration file in /etc/network.d/.

sudo netcfg nus


Rhino is an open-source implementation of JavaScript written entirely in Java. It is typically embedded into Java applications to provide scripting to end users. It is embedded in J2SE 6 as the default Java scripting engine.

The best thing about rhino is that it has a javascript shell. (IMO, that’s the best thing about it. It comes with other cool things like a debugger by the way.)

Setting Up Rhino (On the OSX)

First, download Rhino. Extract it. Then, create the ~/Library/java/Extensions directory if it’s not created yet. Lastly, copy js.jar from the rhino folder to ~/Library/java/Extensions. Or you can copy and paste the following commands to your Terminal.

mkdir -p ~/Library/java/Extensions
cp ~/Downloads/rhino1_7R3/js.jar ~/Library/java/Extensions

To test it, execute this in the Terminal:

java org.mozilla.javascript.tools.shell.Main

You should see this in your Terminal:

Rhino 1.7 release 3 2011 05 09
js>

And..you’re done. Oh a quick tip, instead of typing that long command to your terminal, you can alias it. You can do so by putting this in your ~/.bash_profile:

alias js="java org.mozilla.javascript.tools.shell.Main"

Enjoy!

Note: If you want to have readline capabilities like line editing, history, etc, you might want to put this in the ~/.bash_profile instead:

alias js="rlwrap java org.mozilla.javascript.tools.shell.Main"


• mozilla-central
• comm-central
• rust-lang
• pdf.js

In case you don’t know, memoization is the use of caches to retrieve previously computed values to reduce the time complexity of algorithms.

For example, this is the code for to compute the nth fibonacci number:

def fib(n):
    if n == 1: return 1
    return fib(n-1) + fib(n-2)

The running time for this piece of code is exponential. The memoized version of the function goes like this:

f = [-1]*n
def pre_fib(n):
    f[0] = 1
    f[1] = 1
    fib(n)
def fib(n):
    if f[n] != -1: return f[n]
    return f[n-1] + f[n-2]

This version of the fibonacci function is polynomial. The key lies in the use of the array to retrieve previously computed values instead of computing it again.

Decorate Your Python

In Python, we can transform functions using decorators. It is a design pattern that allows the programmer to add behavior to existing objects. To decorate our fibonacci function, we need to first define what behavior we want to add to the function. This is how we define the decorator:

from functools import wraps

def memo(func):
    cache = {}
    @wraps(func)
    def wrap(*args):
        if args not in cache:
            cache[args] = func(*args)
        return cache[args]
    return wrap

This piece of code simply wraps the function that we want to memoize and calls it if the value we are looking for is not in the cache. If it is in the cache, it simply returns the value from the cache. Here comes the beauty of using decorators to memoize the fibonacci function. IMO, it’s really elegant. See it for yourself:

@memo
def fib(n):
    if n<2: return 1
    return fib(n-1) + fib(n-2)

That’s it! It’s really easy. Now simply call the fib function to see it in action!

Write a Exponentiation Modulo 10 table for 0 to 9. That is x = 0 to 9, y = 0 to 9 and the table values are x^y mod 10.

After computing the first few values, I got tired and fired up my python shell to get the computer to compute for me. This was my code:


>>> for x in range(10):
... print [x**y % 10 for y in range(10)]


This is the output:


[1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 2, 4, 8, 6, 2, 4, 8, 6, 2]
[1, 3, 9, 7, 1, 3, 9, 7, 1, 3]
[1, 4, 6, 4, 6, 4, 6, 4, 6, 4]
[1, 5, 5, 5, 5, 5, 5, 5, 5, 5]
[1, 6, 6, 6, 6, 6, 6, 6, 6, 6]
[1, 7, 9, 3, 1, 7, 9, 3, 1, 7]
[1, 8, 4, 2, 6, 8, 4, 2, 6, 8]
[1, 9, 1, 9, 1, 9, 1, 9, 1, 9]


Not bad huh. I am pretty impressed that python can do it in just two lines of code.

The Matlab Alternative

I’m really excited about contributing to Sage. It’s a open source alternative to popular proprietary products such as Matlab and Mathematica. What’s really cool about it is that it’s in my favorite language, python! I will be working on improving the SageNB usability. See my a draft of my proposal here.

Automate, automate, automate

As for Thunderbird, I am going to work on their automated email ISP configuration manager. Specifically, I’m gonna work on the database. They call it the ISPDB. It’s a database that the ISP configuration manager queries for server configurations of email domains. The user simply have to supply their email address and the manager will query for the configuration (server address, port, protocol, etc) of the email domain. Currently, there’s no way for users to submit configurations to ISPDB directly, so that’s what I’m going to implement for this summer. Another feature that I’m gonna implement is to allow users to edit (or propose changes) to the configurations.

Things are kinda hazy now but I think things will get clearer soon as I talk to the mentors. Hope my proposals get approved.

Update: The url for the svn code repo is at http://svn.mozilla.org/mozillamessaging.com/sites/ispdb.mozillamessaging.com/trunk/ispdb/