David Vázquez

The surprising JSCL rising

2013-05-01T00:00:00-07:00

I am just back from a few days of holidays and have seen how active JSCL is! It is really exciting.

This rising is due to abeaumont probably. I stopped working, but he came up with an idea I liked. It is, why don't integrate JSCL into Conkeror? We would end up with a Lisp programmable browser… that's a practical reason! We did some tests locally and it seemed to work, but now it is time for improving JSCL itself.

It is not the only platform where JSCL could run on. I plan to add support for Node JS. Indeed, it will let us use the REPL and tests in the terminal in addition to the browser, which is a much more convenient way to program.

In the meantime, I would like to improve the compiler a little bit.

Suggestion and patches are very welcome if you want to join us.

https://github.com/davazp/jscl

Back in action

2013-04-11T00:00:00-07:00

Hello everyone. I have been away some days from the computer, but I am back now! I have spent two weeks in New York visiting such a great city. I had the opportunity to attend to a LispNYC meetup and enjoy the great atmosphere there. I hope to come back soon.

I have also a new laptop. Finally, I have to say, as I inherited the last one from my brother and I have been using it for 6 years. Most of the time it was good enough but it is becoming very annoying. For example, I could not compile SBCL because it was restarted due to overheating..

I feel like doing things now so I wish I could tell you new adventures soon.

Forth model illustration

2013-03-06T00:00:00-08:00

I like old systems which expose a good part of their internals, specially when they are so simple. I created this animation using ditaa to illustrate how execution is done in Forth:

Of course, it only makes sense if you already know Forth. But I guess you do not know many languages where such thing is possible.

Special arguments

2013-01-24T00:00:00-08:00

I have learnt a new trick these days. Did you know that you can declare an argument as a special variable? Quoting Hyperspec:

Each required parameter is specified by a parameter variable var. var is bound as a lexical variable unless it is declared special.

It seems to work also for optional and keyword arguments, but Hyperspec does not mention it explicitly. For example, yo can do:

(defvar *variable*)
(defun foo () *variable*)
(defun foobar (&optional *variable*)
  (foo))

Lisp to Javascript compiler

2013-01-04T00:00:00-08:00

Raimon Grau and I have been working on a simple Lisp to Javascript compiler, in order to better understand how to bootstrap it. Now we got it. It compiles itself and the resulting code can be used from the browser. It can even call its own internals, which is quite nice.

It is not very helpful, you can try it. Now I have to think if it could be useful for something… maybe a live Lisp tutorial, or make it suitable for Android. Any suggestions?

The repository with the whole history is at:

http://github.com/davazp/ecmalisp/

Emphasizing text in ERC

2012-12-13T00:00:00-08:00

I have realized ERC supports control characters to emphasize text as bold, underline… However, I prefer *foo*, /bar/ and _foobar_ syntax, just like org-mode and Gnus. So I have added the following code to my .emacs to do the job:

(defun erc-emphasize ()
  (when (eq erc-interpret-controls-p t)
    (goto-char (point-min))
    (while (re-search-forward "\\(?:^\\|\\s-\\)\\(\\*\\([^*]+\\)\\*\\)\\(:?$\\|\\s-\\)" nil t)
      (replace-match "\C-b\\2\C-o" nil nil nil 1))
    (goto-char (point-min))
    (while (re-search-forward "\\(?:^\\|\\s-\\)\\(_\\([^_]+\\)_\\)\\(?:$\\|\\s-\\)" nil t)
      (replace-match "\C-_\\2\C-O" nil nil nil 1))
    (goto-char (point-min))
    (while (re-search-forward "\\(?:^\\|\\s-\\)\\(/\\([^/]+\\)/\\)\\(?:$\\|\\s-\\)" nil t)
      (replace-match "\C-V\\2\C-O" nil nil nil 1))))

(add-hook 'erc-send-pre-hook
          (lambda (string)
            (with-temp-buffer
              (insert string)
              (erc-emphasize)
              (setq str (buffer-substring (point-min) (point-max))))))

(add-hook 'erc-insert-modify-hook 'erc-emphasize)

The code transforms the text before sending it, so it will work without changes in the IRC client of the other person, supposed control characters is supported of course. If you want to send/receive text literally, just disable control characters interpretation with C-c C-c in the ERC buffer.

I wrote a Forth implementation for x86

2012-12-08T00:00:00-08:00

Yes, I did it, and I have to say that it was one of the most exciting hack experiences that I have had. But let us start in the beginning, four years ago. At that time, a friend and I was writing some toys related to operating systems. He was a C programmer, but knowing that nobody even will try our system, I wanted to have some extra fun! I convinced him to embed a Forth in the kernel. I did not know anything about Forth, but it promised to be interesting. I picked up an old specification of the Forth language and implement it in assembler for x86. It became a retro-software project. However, he moved to other projects and the project stopped.

A couple of years later, I found the code again. I have not any other thing to work in, so I chose to give it a try. I ported my original implementation to 32 bits and I integrated the Forth implementation with the C kernel. Once that I could write programs on it, I replaced C and grew the language with many words. I wrote output routines, a serial driver, keyboard and a video driver, memory management, exceptions, timer… It was so fun that I could not stop there and I wrote a speaker driver, an assembler and disassembler, trace/untrace utilities, a Sokoban game taken from GForth, emacs keybindings and autocompletion in the terminal like in readline, and a simple Lisp interpreter! Did I say how great growing the system from scratch was?

Try Eulex

The first thing you have to do is make sure you have a recent Qemu installation. It has to be enough recent to support multiboot kernels. Just installing the version of your distribution should work. Now, get the source code from the repository

git clone https://github.com/davazp/eulex.git

Move to the directory where it was cloned and type make to compile. In order to launch QEmu with the Eulex image, run the script ./run-eulex.sh. If you pass any argument to this script, they are passed to QEmu. It can be useful to enable sound, for example.

At this point, the system should boot as below. You can type Forth code right there and it will be evaluated. Indeed, you can type TAB key to autocomplete words, or use some emacs-like keybindings, e.g: C-a, C-e, M-b, M-f, C-l…

By default, the context provides standard Forth words, but if you want to hack the internals you will need access to the internal vocabulary. Use the word eulex to do that. You can try to type words to list all the words in a context. In the internal vocabulary, there are about a thousand words.

It is possible to disassemble words, e.g: see edit-line. Note that the disassembler uses the current context to look call addresses back into word names. If many addresses are not showing, try moving to the eulex vocabulary.

There is not persistent storage, after halting QEmu, or rebooting with the command reboot, changes will be lost. Therefore, you could want to write code in the file eulexrc.fs, which is loaded automatically when the system starts.

In closing, I would like to include a couple of nice pictures. The first one is an incomplete screen block editor,

The second one is a little Lisp interpreter, written in Forth.

I hope you liked it. If you fancy hacking this and enjoy it as I did, do not hesitate to write to me, I will help you with pleasure. There many minor details, if you would like to try it but no to spend so much time. If you feel adventurous, then the points to work are:

Bootstrapping

Rewriting forth.S as a crosscompiler to run on GForth, the 100% of the code would be Forth. The system could compile itself eventually. The assembler I wrote can be used to this task, as it executes both in Eulex as in GForth.

Improving the compiler

It is as native as described in this document. Code is very inefficient. We could optimize it, but we do not want if the compiler is written in assembler. So bootstraping should come first.

Hard disk driver and FAT implementation.

Actually, files are stored built-in with the same Eulex image, so they are read-only.

Dumping and restoring the world

When the floppy driver or a file system implementation is working, dumping the dictionary to the disk would have the nice effect ot saving the whole state of the system.

First post

2012-12-01T00:00:00-08:00

Hello everybody. Here it is, a new github-hosted blog. You can know something about me now, but what will this blog be about? Unsurprisingly, I will tell different things I hack, as the main reason to open this blog is because I do not know many people to talk about this kind of things face-to-face. You will find some Lisp and Emacs-related posts probably, as well as some light math, but I will post anything I find interesting.

The blog is quite simple. I do not provide tags yet, but I have enabled comments on the posts, so you can give some feedback.

Finally, I hope to share some nice things, and somebody likes it. Also, English is not my mother tongue, so writing it requires some extra effort, but I will do my best.

Welcome to my blog.