# Older blog entries for aleix (starting at number 68)

add1, sub1 and + recursive process

In The Little Schemer you are asked to write the function + using the functions zero?, add1 and sub1, such as the result of (+ 46 12) is 58.

```(define add1
(lambda (n) (+ n 1)))

(define sub1
(lambda (n) (- n 1)))
```

The solution given is:

```(define o+
(lambda (n m)
(cond
((zero? m) n)
(else (add1 (o+ n (sub1 m)))))))
```

which is correct but has a little problem.

If you are like me (hopefully not), you might have read twenty times the first chapters of SICP (and haven't gone any further). Remember about recursive and iterative processes and recursive procedures? In our o+ case we have a recursive procedure that generates a recursive process, as the process generates a chain of deferred add1 operations.

With a recursive process we can easily blow our stack:

```scheme@(guile-user)> (o+ 10 100000)
While executing meta-command:
ERROR: Throw to key `vm-error' with args `(vm-run "VM: Stack overflow" ())'.
```

This is because this will generate:

```(add1 (add1 (add1 (add1 ...... n))))
```

with as many add1 as m.

So, how to improve this? With a recursive procedure that generates an iterative process:

```(define o+
(lambda (n m)
(cond
((zero? m) n)
(else (o+ (add1 n) (sub1 m))))))
```

which will generate:

```(o+ 11 99999)
(o+ 12 99998)
...
(o+ 100010 0)
```

and doesn't overflow the stack.

scheme@(guile-user)> (o+ 10 100000)
\$1 = 100010

Yes, this is a tail-recursive function.

Syndicated 2013-04-13 14:56:15 from aleix's blog

The Law of Car

In The Little Schemer, The Law of Car is defined as:

The primitive car is defined only for non-empty lists.

In the implementation given for (firsts l), it seems to me that the law is broken:

```(define firsts
(lambda (l)
(cond
((null? l) '())
(else (cons (car (car l))
(firsts (cdr l)))))))
```

As (firsts '()) is '(). So, this would actually fail (in guile):

```\$ (firsts '((a b) () (e f)))
In procedure firsts:
In procedure car: Wrong type argument in position 1 (expecting pair): ()
```

I think a correct implementation would be:

```(define (firsts l)
(cond
((null? l) '())
(else (cond
((null? (car l)) (firsts (cdr l)))
(else
(cons (car (car l))
(firsts (cdr l))))))))
```

in which we take care of the non-empty list before getting the first typical element (car (car l)). This would result in:

```\$ (firsts '((a b) () (e f)))
(a e)
```

Syndicated 2013-04-10 06:18:09 from aleix's blog

Install Emacs packages from command line

Lately, I have found myself playing with packages and my .emacs too much. Sometimes I had to comment the use of a package (e.g. smex) because it was not installed.

So, at the end, I wrote this basic elisp to install a package from the command line.

```\$ emacs --batch --expr "(define pkg-to-install 'smex)" -l emacs-pkg-install.el
```

The elisp script looks like this:

```;;
;; Install package from command line. Example:
;;
;;   \$ emacs --batch --expr "(define pkg-to-install 'smex)" -l emacs-pkg-install.el
;;

(require 'package)

'("melpa" . "http://melpa.milkbox.net/packages/") t)

;; Fix HTTP1/1.1 problems
(setq url-http-attempt-keepalives nil)

(package-refresh-contents)

(package-install pkg-to-install)
```

For convenience, you can wrap it in a shell script and simply type:

```\$ ./emacs-pkg-install.sh smex
```

The shell script:

```#!/bin/sh

if [ \$# -ne 1 ]
then
echo "Usage: `basename \$0` <package>"
exit 1
fi

emacs --batch --eval "(defconst pkg-to-install '\$1)" -l emacs-pkg-install.el
```

Syndicated 2013-01-08 15:33:36 from aleix's blog

Install Emacs packages from command line

Lately, I have found myself playing with packages and my .emacs too much. Sometimes I had to comment the use of a package (e.g. smex) because it was not installed.

So, at the end, I wrote this basic Emacs lisp to install a package from the command line. Just type:

```\$ emacs --batch --expr "(define pkg-to-install 'smex)" -l emacs-pkg-install.el
```

The script looks like this:

```;;
;; Install package from command line. Example:
;;
;;   \$ emacs --batch --expr "(define pkg-to-install 'smex)" -l emacs-pkg-install.el
;;

(require 'package)

'("melpa" . "http://melpa.milkbox.net/packages/") t)

;; Fix HTTP1/1.1 problems
(setq url-http-attempt-keepalives nil)

(package-refresh-contents)

(package-install pkg-to-install)
```

For convenience, you can wrap it in a shell script and simply type:

```\$ ./emacs-pkg-install.sh smex
```

The shell script:

```#!/bin/sh

if [ \$# -ne 1 ]
then
echo "Usage: `basename \$0` <package>"
exit 1
fi

emacs --batch --eval "(defconst pkg-to-install '\$1)" -l emacs-pkg-install.el
```

Syndicated 2013-01-08 10:20:12 from aleix's blog

git-cherry-base

If you use git, you might find yourself wanting to merge a huge list of commits into a branch, but you might not want all of them. git-rebase already helps with this task but it becomes less convenient when you have lots of commits as you may not remember all of them and also because it doesn't show you the contents of each commit

git-cherry-base is an interactive script (written in Guile) that lets you choose which commits you'd like to merge and even which parts of the commit you want. Given a list of revisions (obtained from git-rev-list) it will show the contents for each commit and will let you choose if you want to merge the commit, skip it or merge only parts of it.

```Usage: git-cherry-base rev-file
```

I wrote it some months ago as I couldn't find any other command line tool to do this and, well, it was just a good excuse to hack something in Scheme.

Syndicated 2012-11-15 00:43:55 from aleix's blog

Packing and unpacking bit structures in Python

Last week, I released the first version of the BitPacket Python module which allows you to pack and unpack data like the struct and array modules, but in an object-oriented way. At work I needed an easy way to create network packets and at that time I did not know the existence of the struct and array modules, so I googled a bit and I found out the BitVector class for a memory-efficient packed representation of bit arrays, which I decided to use for my purpose.

I implemented three classes, BitField, BitStructure and BitVariableStructure (the lastest two are derived from BitField). A network packet would be represented by the BitStructure class, which at creation does not contain any field, and the idea is that any BitField subclass might be added to it.

I'll will show you the most basic example. Suppose, you need a simple network packet like the one below:

```+---------------+-------------------+
|  id (1 byte)  |  address (4 byte) |
+---------------+-------------------+
```

You could easily create a network packet using BitStructure, like this:

```>>> bs = BitStructure('mypacket')
>>> bs.append(BitField('id', BYTE_SIZE, 0x54))
```

and print its contents:

```>>> print bs
>>> (mypacket =
>>>   (id = 0x54)
```

In order to unpack an incoming packet, we could use the variable created above or a new one without default values:

```>>> bs = BitStructure('mypacket')
>>> bs.append(BitField('id', BYTE_SIZE))
```

In order to unpack an incoming array of bytes, we would do the following:

```>>> data = array.array('B', [0x38, 0x87, 0x34, 0x21, 0x40])
>>> bs.set_stream(data)
```

```>>> print '0x%X' % bs['id']
0x38
0x87342140
```

There are a lot more possibilities to pack and unpack bit field structures by using BitStructure and BitVariableStructure. You can see all of them in the module's online documentation.

Syndicated 2011-08-15 14:40:39 from aleix's blog

Emacs 23.3 for RHEL 6

Emacs version in RHEL 6.1 is very outdated, 23.1 (which was released on July 2009). I needed a newer version to run Geiser at work, so after searching for the package in the typical places (rpmfind.net and rpm.pbone.net) and Google I decided to build my own one. For it, I just followed these instructions on how to build Source RPM packages and did some minor updates on the RPM spec file.

This will only create an rpmbuild directory in your home:

```\$ rpm -i emacs-23.3-1.el6.src.rpm
```

Install rpm-build if you don't have it, and build the Emacs RPMs:

```\$ cd \$HOME/rpmbuild/SPECS
\$ rpmbuild -ba emacs.spec
```

```\$ cd \$HOME/rpmbuild/RPMS
\$ sudo rpm -U emacs-23.3-1.el6.x86_64.rpm emacs-common-23.3-1.el6.x86_64.rpm
```

Syndicated 2011-06-28 13:12:12 from aleix's blog

more tekuti hacks

I have had less time lately, but I still found some minutes to hack on tekuti. The most important new feature is performance. tekuti is now one or two order of magnitudes faster than before. No more delays when accessing posts or listing tags or archives posts. Basically, accesses to git have been reduced to the minimumn. So, these are the new features since last post:

• Fixes: search works again.

• Performance: reduction of git accesses (and adding Look-Up-Tables) has improved speed dramatically.

• New widgets: blank and page-rank.

• Page navigation: the new links at the bottom (go to the end of the page) allow navigation through all blog history.

• Cosmetics: post lists (in tags or archives) show the post date besides the title...

You can check out all these new features from gitorious:

```git clone git://gitorious.org/~aleix/tekuti/acf-tekuti.git
```

Happy hacking!

Syndicated 2011-03-01 15:58:43 from aleix's blog

tekuti hacks

Lately, I've been hacking new features for tekuti, the blogging software that's running this site. tekuti is written in Scheme , so I had no more excuses to start hacking on it.

Blah, blah, blah... but what have you done? Nothing really impressive, indeed, but quite useful for my needs:

• Support for deleting posts. As tekuti is based on git, it's easy to recover them for free. And you don't need to spell any git command, tekuti admin interface can help you here.

• Support for deleting post comments. This is useful if undesired spam gets in your site.

• Support for custom user templates. Before, there was only one template. Now, it is possible to add multiple templates and choose your desired one from the configuration file (via the *template-module* variable).

• Configure widgets on the sidebar. You can now configure the widgets you want to appear in your blog sidebar. Mine, looks like this:

```(set! *main-sidebar-widgets* `(subscribe search tag-list))
(set! *post-sidebar-widgets* `(subscribe related))
```

Available widgets are: subscribe, search, related, tag-cloud, tag-list.

• Support Movable Type API. This means it is now possible to use your favorite blog editor and post or edit your tekuti articles. You need to configure tekuti as a Movable Type blog. The XMLRPC endpoint is http://yoursite.com/path-to-blog/xmlrpc.In fact, some MetaWeblog and Blogger methods have been also implemented. This is the list of supported methods:

• metaWeblog.newPost

• metaWeblog.getPost

• metaWeblog.editPost

• metaWeblog.getRecentPosts

• metaWeblog.getCategories

• mt.setPostCategories

• mt.getPostCategories

• mt.getCategoryList

• blogger.getUsersBlogs

• blogger.deletePost

For this to work, I have created a reusable XMLRPC library for guile. More on this in next post.

These hacks are not yet available in tekuti's master, so you can get them from my branch:

```git clone git://gitorious.org/~aleix/tekuti/acf-tekuti.git
```

Happy new year and happy hacking!

Syndicated 2011-01-10 00:24:11 from aleix's blog

new year, new blog: spreading the word with tekuti

This will be my last post in wordpress.com after using the service since 2006. At the time of this writing the blog has received 27122 visits which is not very much, but at least it means someone is reading (…may be the crawlers?).

WordPress is provided with statistics, anti spam filters, themes and much more (that I do not really use)… So, why am I leaving? Simply, because I want to learn new things (I’ve been feeling quite stuck lately). But, shouldn’t I be worried with the “what” instead of the “how”? Like solving the problem instead of worrying about the language I use? Well, I guess so, but I like to learn new languages even I don’t solve any problem (at the end this is not true, but I don’t want to get recursive here).

My new blog (http://hacks-galore.org/aleix/blog) is based on tekuti, a weblog software written in Scheme, using Git as its persistent store. All axelio’s posts have been imported to the new blog, so don’t panic!

Happy hacking!

Syndicated 2010-12-23 00:22:55 from axelio

59 older entries...