justinhj's coding blog

Making a emacs lisp expression expand itself to XML

2011-12-26T10:32:00.001-08:00

My response to the blog article An Emacs Programming Challenge

The goal is to make the emacs lisp record below execute itself and produce XML. My lisp has gotten rusty so it took me a couple of hours to get this working, but I think I got there...

You can see it properly formatted and coloured here

It's fairly straightforward. The only complexity is the use of lexical-let. emacs lisp is dynamically scoped, so in the function I create for each keyword, where it prints the symbol name is a free variable at runtime. So if sym-name is not defined you'll get an error, otherwise you'll get whatever it is defined as instead of the value you wanted.

By using lexical-let any variables are bound lexically, that is stored in an environment that stays with the function we create when it is executed (a closure).

(require 'cl) ;; uses lexical-let

(defun make-xml-izer(name)
 "Given a symbol NAME this makes a function that outputs an xml string for that
symbol and using fset binds it to the same symbol so it becomes executable.
This pollutes the global function namespace so be careful with which names you
pass in"
 (lexical-let ((sym-name name))
   (fset (intern name)
   (lambda(&rest input)
     "returns a string representing the xml encoding of the input sexp"
     (let ((res (format "<%s>" sym-name)))
       (dolist (item input)
  (if (listp item)
      (setf res (concat res (eval item)))
    (setf res (format "%s%s" res item))))
       (setf res (format "%s" res sym-name))
       res)))))

;; executing this makes all the symbols in the list below executable 
(mapcar (lambda(s)
   (make-xml-izer
    (symbol-name s)))
 '(record date millis sequence logger level class method thread emessage exception frame line))

;; the sample record
(record
 (date "2005-02-21T18:57:39")
 (millis 1109041059800)
 (sequence 1)
 (logger nil)
 (level 'SEVERE)
 (class "java.util.logging.LogManager$RootLogger")
 (method 'log)
 (thread 10)
 (emessage "A very very bad thing has happened!")
 (exception
   (emessage "java.lang.Exception")
   (frame
     (class "logtest")
     (method 'main)
     (line 30))))

eredis update

2011-07-30T00:03:00.001-07:00

I've been busy on my emacs redis client eredis and it now supports the entire API. It still needs a bit more polish but it should be a workable Redis client now, and I will continue to play with the org-mode table integration which I think has a lot of potential uses: for example making a gui to edit server parameters in just a few seconds.

Also made a new video showing some of the new org table creating commands and the monitor mode that shows the Redis commands as they are run on the server:

eredis: a Redis client in emacs lisp

2011-07-25T01:06:00.000-07:00

I set up a google code project today for eredis. A Redis client in emacs lisp.

The program consists of a single emacs lisp file eredis.el

emacs lisp includes facilities for writing network applications. In my code I use `make-network-process' to open a connection to a specified redis server. Then the Redis api is exposed.

One nice feature of emacs I have used is org-table-mode. This lets you edit and manage the data in a Redis server in an org table. For example, you can grab all keys matching a pattern and create an org table from the key value pairs, then edit that table. You can then send it back to Redis with interactive commands that send either the whole table, or just the current row back to Redis using mset or set.

This work flow is not safe when working with multiple users, if you care about overwriting each others data. For example, I could store the last values you got from Redis in addition to your edited values. When you go to set a new value I first grab it from Redis, check if it has changed since you got it, and if so warn you (showing you the new value). For many work flows this would work well. For example the use case of a group of users editing a shared DB of configuration data.

Emacs progress indication

2011-06-14T15:12:00.000-07:00

When programming in emacs lisp, there is an easy way to show progress feedback to the user when a task will take some time. Here's a block of code from the elisp manual showing how to do it.

(let ((progress-reporter

(make-progress-reporter "Collecting mana for Emacs..."

0 500)))

(dotimes (k 500)

(sit-for 0.01)

(progress-reporter-update progress-reporter k))

(progress-reporter-done progress-reporter))

I've incorporated this into my duplicate files code, linked below...

http://code.google.com/p/justinhj-emacs-utils/source/browse/trunk/duplicates.el

More on duplicate file handling in emacs dired

2011-06-05T20:41:00.000-07:00

I had some good feedback on my last post, that it would be useful to be leave just the superfluous duplicate files marked in the dired buffer. After doing that you can then copy them to another folder, or delete them.

I've added a function to do this `dired-mark-duplicate-files', and updated the google code site with the changes.

To copy to another folder use R and select a folder to move the dupes to. In order to delete them hit D.

Finding duplicate files in a dired buffer

2011-06-01T21:31:00.000-07:00

picture by Donald MacLeod

This is a an example of programming emacs in emacs-lisp just to give an idea of what you can put together in an hour or two. I was looking at a dired buffer with a bunch of photos in, and some were the same photo that I'd downloaded twice. So I started thinking about writing a utility in emacs to automatically find and remove the duplicate files. In this post I'll just show the code for finding the files and display their filenames in a buffer.

I've put the source on google code.

After downloading you can load the source into emacs and call `eval-buffer', then open up a dired buffer to try it out. For this to be useful you need some duplicated files, so make some if you need to.

Mark the files you want to check for duplicates. For example to mark all jpg files you would type %m to mark files matching a regexp and type .*\.jpg

Now execute the command `dired-show-marked-duplicate-files' and after a short delay (in my test 80 jpg photos took about 5 seconds) you'll see a buffer called 'Duplicated files' which contains a list of the files which have the same contents.

Next steps for this little project will be to give you an interactive way to delete the duplicated files. I haven't decided quite how I'd like that to work, drop me an email if you have an idea. I've been thinking about perhaps resetting which files are marked so that only the duplicates are marked. At that point you can then hit R to move them to another spot, or delete them with x.

Now some comments about the code involved...

Most of the work is done in the function dired-show-marked-duplicate-files. First line " (interactive)" makes it an interactive function, meaning the user of emacs can invoke it.

"(if (eq major-mode 'dired-mode)" will check that we're in the right kind of buffer, because it makes no sense to run this in another mode.

In order to find the duplicate files I just need to walk the list of marked files, generate the md5 value of the contents of each one and add it to hash table. The keys in the hash table will be the md5, and the values will be a list of files with that md5. Once we've done that, finding duplicates is a simple matter of walking the hash table keys and displaying any where the value has multiple entries.

"(let ((md5-map (make-hash-table :test 'equal :size 40)))" Creates the hash table, making sure we use 'equal to match our filenames.

"(let ((filenames (dired-get-marked-files)))" this gets the marked files as a list of filenames

The next little bit of code is just to store the item in the hash table after getting the md5. There's no function in emacs to get the md5 of a file, but you can get the md5 of a string, so I wrote a helper function for getting the contents of a file into a temporary buffer first.

(defun md5-file(filename)

"Open FILENAME, load it into a buffer and generate the md5 of its contents"

(interactive "f")

(with-temp-buffer

(insert-file-contents filename)

(md5 (current-buffer))))

Finally I want to display the results, so I create a buffer and then use maphash (walks the keys of a hash table executing a function on each) with a helper function `show-duplicate' which simply writes the values of the hash table entry into that buffer.

Programmer tips for Mac OSX

2011-04-26T15:12:00.000-07:00

Some tips for programmers on the Mac.

emacs: the best place to get emacs for Mac seems to be here http://emacsformacosx.com/ which is also the most no nonsense website design ever

Not really a Mac tip, but I stick my .emacs configuration file in a Dropbox folder, along with any emacs libraries and emacs lisp code I write. Then where-ever I install emacs I make a simple .emacs that points to the one in the Dropbox folder. This also forces me to make sure any platform specific emacs stuff is properly handled.

Clipboard: copy and paste between the terminal and other apps can be done with pbcopy and pbpaste. For example a long complicated command line you want to email to yourself, just do:

echo "long complicated bash command line you don't want to retype" | pbcopy

And then you can Command-V that into your email window. Going the other way is just as simple; Command-C the text you want and pop it into the terminal window with pbpaste.

Open: If you want open an application from the command line you can do it like this:

open -a SomeApp /Users/yourname/SomeFile.hai

You can open a folder in finder

open /Folder/

open /Folder/SomeFile.hai

to open that file with it's default application.

Check out the help 'man open', to see other stuff like how you pipe stdout into an application.

Finally check out this guys OpenTerminalHere script. This pops an icon in finder that lets you open a terminal window in the highlighted folder.

http://www.entropy.ch/software/applescript/

MovieRatings

2011-04-26T15:00:00.000-07:00

A little side project I did when learning about Clojure was to grab movie ratings from Rotten Tomatoes, which I did a post about here:

http://justinsboringpage.blogspot.com/2011/01/grabbing-rotten-tomatoes-movie-ratings.html

This is just an update that I've posted the whole leiningen project onto github

https://github.com/justinhj/movieratings

Talking to mysql from Python on Mac OS X 10.6

2011-04-25T17:40:00.000-07:00

image by Sam Pullara

Here's a problem I couldn't solve with Google, although it seems to be a moving target so YMMV.

I wanted to do some work driving a MySQL database with Python. On Windows and Linux I've used MySQLdb so I decided to do the same on Mac.

For reference I got mysql (client and server) through mac ports.

mysql5 --version

mysql5 Ver 14.14 Distrib 5.1.45, for apple-darwin10.4.0 (i386) using readline 6.1

and Python is the stock version:

Python 2.6.1 (r261:67515, Jun 24 2010, 21:47:49)

[GCC 4.2.1 (Apple Inc. build 5646)] on darwin

First download from here http://sourceforge.net/projects/mysql-python/ and extract the file somewhere...

mkdir ~/pythondb

cd ~/pythondb

tar -vxf ~/Downloads/MySQL-python-1.2.3.tar.gz

Then you need open up the site.cfg file and make a change as below. Your mysql_config5 maybe in a different spot. You can find out with the command 'which mysql_config5'.

# The path to mysql_config.
# Only use this if mysql_config is not on your PATH, or you have some weird
# setup that requires it.
mysql_config = /opt/local/bin/mysql_config5

Now execute the following:

python setup.py build

python setup.py install

If everything works you can now import MySQLdb in your python program and start interacting with mysql.

Grabbing Rotten Tomatoes movie ratings with Clojure

2011-01-15T10:22:00.001-08:00

flikr pic by Gammelmark

Currently I'm teaching myself Clojure from Stuart Halloway's excellent book Programming Clojure. Here's my first program that does something; a simple web page scraper to get the critics and audience ratings for movies off Rotten Tomatoes. Here's how it looks at the REPL:

rottentomatoes.core> (pmap-get-movie-ratings "lord of the rings")
movie url: http://www.rottentomatoes.com/m/lord_of_the_rings_the_return_of_the_king/
Audience 83
Critics 94
movie url: http://www.rottentomatoes.com/m/lord_of_the_rings_the_fellowship_of_the_ring/
Audience 92
Critics 92
movie url: http://www.rottentomatoes.com/m/lord_of_the_rings_the_two_towers/
Audience 92
Critics 96
movie url: http://www.rottentomatoes.com/m/lord_of_the_rings/
Audience 74
Critics 50
movie url: http://www.rottentomatoes.com/m/master_of_the_rings_the_unauthorized_story_behind_jrr_tolkiens_the_lord_of_the_rings/
Audience 34
Critics null
movie url: http://www.rottentomatoes.com/m/jrr-tolkien-and-the-birth-of-the-lord-of-the-rings/
Audience 93
Critics null
movie url: http://www.rottentomatoes.com/m/jrr_tolkien_and_the_birth_of_the_lord_of_the_rings/
Audience 32
Critics null
movie url: http://www.rottentomatoes.com/m/more_at_imdbpro_creating_the_lord_of_the_rings_symphony_a_composers_journey_through_middle_earth/
Audience 100
Critics null
nil

I use leiningen to develop with Clojure (it's like Maven for Java), so if you want to build the project here's my project configuration that includes the dependencies used. I'm using swank-clojure which enables the REPL to function with emacs slime. http.async.client is a clojure API that builds on Netty and I use that for the GET requests to the Rotten Tomatoes server.


(defproject rottentomatoes "1.0.0-SNAPSHOT"
:description "Clojure code to grab movie ratings from Rotten Tomatoes"
:dependencies [
     [org.clojure/clojure "1.2.0"]
             [org.clojure/clojure-contrib "1.2.0"]
     [http.async.client "0.2.1"]
     ]
:main rottentomatoes.core
:dev-dependencies [
         [swank-clojure "1.2.1"]
          ]
)

And here's the code:


(ns rottentomatoes.core
(:gen-class)
(:require
[clojure.contrib.str-utils2 :as s]
[http.async.client :as c]))

(import [java.net URLEncoder]
 [java.lang.Character])

(def *base-url* "http://www.rottentomatoes.com")
(def *search-end-point* "/search/full_search.php?search=")

(defn first-match-after [re1 re2 seq]
"Splits the sequence SEQ using RE1 then searches after the first match and before the next match for the first occurence of RE2"
(let [[_ _ after] (s/partition seq re1)]
 (re-find re2 after)))

(defn response-status-code [resp]
(:code (c/status resp)))

(defn scoop-url [url]
"Use the http client to do a GET on the url"
(let [resp (c/GET url)]
   (c/await resp)
   [(response-status-code resp) (c/string resp)]))

;; Get movie urls
;; Does a search of Rotten Tomatoes for the search text, then scrapes the results
;; for the page for each movie. Returns a collection of the movie urls

(defn get-movie-urls [search-text]
(let [encoded-search-text (URLEncoder/encode search-text)
 [code body] (scoop-url (str *base-url* *search-end-point* encoded-search-text))
 ]
 (when (= code 200)
   (let [[_ _ after] (s/partition body #"<span>Title</span>")]
 (let [[_ & results] (s/partition after #"\"(/m/.*/)\"")]
   (map #(str *base-url* (second %)) (take-nth 2 results)))))))

;; Given a movie url GET the page then scrape it for the citic and audience rating

(defn get-movie-rating [movie-url]
(let [[code body] (scoop-url movie-url)]
 (if (= code 200)
   {:critics (second
     (first-match-after #"class=\"critic_side_container" #">([0-9]+)<" body))
    :audience (second
       (first-match-after #"class=\"fan_side" #">([0-9]+)<" body))})))   

;; Finds the ratings for all Rotten Tomatoes movies that match the search string and prints them out

(defn get-movie-ratings [search-str]
(let [urls (get-movie-urls search-str)]
 (when (> (count urls) 0)
   (doseq [url urls]
 (let [ratings (get-movie-rating url)]
   (printf "movie url: %s\n\tAudience %s\n\tCritics %s\n" url (:audience ratings) (:critics ratings)))))))

;; Slight variant on above that uses pmap so that the requests are done in parallel

(defn pmap-get-movie-ratings [search-str]
(let [urls (get-movie-urls search-str)]
 (when (> (count urls) 0)
   (let [ratings (pmap #(get-movie-rating %) urls)
     url-and-ratings (map vector urls ratings)]
 (doseq [[url ratings] url-and-ratings]
   (printf "movie url: %s\n\tAudience %s\n\tCritics %s\n" url (:audience ratings) (:critics ratings)))))))

I'm using the str-utils2 module for it's regex function partition, which will split a sequence up by regex matches. This made it easy to write the function `first-match-after', which finds a regex then finds the first occurrence of some text after that regex.

It was so easy to parallelize the requests. My first attempt at get-movie-ratings retrieved each movie page synchronously. By using pmap I was able to make it do the requests via thread pools, and thus return in a few seconds for many movie matches.

The code is much shorter than it would have been in Common Lisp, at least the way I program. I love the destructuring syntax, and that maps, vectors and lists can be returned from functions and manipulated without much effort.

I'm still new to Clojure so if you feel you can improve the code or have any feedback please let me know.

View Data from the Clojure REPL

2011-01-11T11:09:00.000-08:00

Here's a nice debugging feature in Clojure. The inspect module lets you look at variables in a popup JFrame. The two examples below show how you quickly view data in a table or tree format. This is really handy to quickly view data from the REPL.

(require 'clojure.inspector)

(clojure.inspector/inspect-tree '(1 (a b) 2 (c d) 3 (e f )))

(clojure.inspector/inspect-table '((1 2 3) (a b c) (e f g)))

F# vs C#

2010-12-15T10:26:00.000-08:00

Nice article comparing directly some code written in C# vs one in F#

http://sharp-gamedev.blogspot.com/2010/12/on-performance-of-f-on-xbox-360.html

What's interesting is that now that VM's are starting to become the new platforms, we are starting to be less restricted by language choice. When it's native code with hand crafted memory management you want, it has to be C++.

But when you start to look at the JDK and the .Net VM's, the language choice has far less impact on performance... after all you're using the same garbage collector, same base libraries and so on.

This is great news for those of us with more peculiar tastes in language (I like Clojure and Common Lisp for example).

Although I think it will be a few years until AAA console games run on VM's, if ever, due to the nature of that business. Memory is always at a premium, and the goal is to choke every last hz of CPU performance.

Just browsing

2010-11-02T11:04:00.000-07:00

It's handy in emacs to be able to go straight to your browser to view a page, and you can do fancy stuff with `webjump' as I mentioned in a previous post.

Another handy function is `browse-url' which will prompt for the url but default to whatever your point is at.

If you're in a html file and you'd like to open that with your browser then `browse-url-of-file' will open it up.

Finally, and I just found this today, if you have some html code in a buffer that isn't even a file, you can open that in your browser to using `browse-url-of-buffer' and emacs will write it to a temporary file and open that in the browser for you.

rgrep on windows 7 for emacs

2010-10-19T16:14:00.000-07:00

I lost an hour configuring this, so seems worthy of a blog post.

A fresh install of emacs for windows will have functionality that does not work because it depends on unix style utilities.

One very useful example is the command rgrep, which searches files recursively through subfolders looking for a regular expression in those files.

Under the hood it uses the unix command line tools find, and egrep. Unfortunately the windows version of find takes entirely different parameters and will not function. In fact you will get an error that looks like this:

FIND: Wrong parameter format

Using the set of native ports of Unix command line tools UnxUtils you can easily fix this:

Download the zip file and extract it to c:\unxutils
Add the following path to the very front of your path by editing your system environment variables C:\unxutils\usr\local\wbin\;

That's it. You can run rgrep now and hopefully you're up and running.

If not make sure you have restarted emacs so it picks up the new setting of PATH. Open a shell in emacs and type 'find --version'. You should see something like this if your path is configured correctly:

c:\find --version

find --version

GNU find version 4.1

and if not you will see:

C:\Windows\system32>find --help

FIND: Parameter format not correct

Couple of mysql tips

2010-07-30T14:55:00.000-07:00

Wondering what the heck is going on on your mysql DB?

show processlist ;

Shows you all the active threads, which is very handy indeed. It shows what each thread is doing, and how long it has been doing it for.

Thread safe record insertion

When doing a record insert, another thread could be trying to insert a record that would violate any DB contraints, and if it gets there before you, then your insert will fail.

There may be cases where you want don't want to have it fail and try again; you may want to take a different action if the record already exists. For example lets say you have some data like this, where the Name is a unique key...

Name, Number of products purchase

Bob, 1,

Ben, 2,

Now if two threads try to insert a user 'Roger' who has just bought an item, then the one that arrives at the server last will fail.

INSERT INTO purchase (Name, PurchaseCount) VALUES ('Roger', '1') ON DUPLICATE KEY UPDATE PurchaseCount=PurchaseCount+1;

This will handle the key collision and execute the update clause instead, in the event that somebody beat you to it. This makes it much easier to write thread safe code that adds records.

Adjusting server logging level at runtime

2010-06-08T14:12:00.000-07:00

log4j is an awesome logging library for Java. One thing I found out today is that you can change the logging level (debug, warn, info) at runtime, with a few lines of code.

static
{
       // This monitors the log4j for changes over a specified period of milliseconds
       PropertyConfigurator.configureAndWatch("./resources/log4j.properties", 60000);
}

What this function does is to tell log4j to check the configuration file every minute (60000 ms) for changes. So you can deploy a production server with only warn and error logging, but if something goes wrong you can enable debug and info logging (for example) simply by editing the configuration file and waiting a minute.

(source code formatted by this handy website http://formatmysourcecode.blogspot.com)

Growling Mac

2010-05-16T18:28:00.000-07:00

(pic from flickr)

Last year I wrote a blog post about how to make growl notifications (little pop ups driven by the application Growl) appear from emacs in windows. Since then I've become a total Mac-head. Here's an update on how you get that working from emacs on a mac...

Everything is the same except you need to install Growl for Mac (obv) and also make sure you copy the folder called Extras somewhere.

Open up a terminal and then cd to where you put the Extras directory. Find a sub-directory called growlnotify. Enter that and run 'sudo ./install.sh' which will prompt you for your admin password, and then go ahead and install growlnotify.

You can now run growlnotify from a terminal window. Try it out, if it doesn't work you won't be able to growl from emacs.

Now follow the instructions in my blog post above but ignore all the windows parts. You'll need to customize the growl command (M-x customize group, todochiku) and replace the full path I used for windows with just 'growlnotify'.

If everything is cool you can now do M-x todochiku-in and type a message, a time in minutes (zero for now), and pop, you should have a notification.

Using tar and gzip

2010-04-17T10:01:00.000-07:00

Picture from flickr by Windwirral

Here are the basic steps to use tar and gzip to package up some files in a compressed archive, so that you can move them to another computer or back them up.

First you want to create and add files to the archive. Go to the target directory and enter individual filenames and directories you want to have included.

tar -vzcf mystuff.tar.gz file1.txt file2.doc mypictures/

Now you can test if that worked by listing the files in the archive.

tar -tvf mystuff.tar.gz

When you want to extract the files, go to the folder where you want to extract them, in this case 'targetfolder'.

cd targetfolder

tar -vxf mystuff.tar.gz

Nice Code

2010-01-23T22:18:00.000-08:00

Just wanted to point out a couple of very nice pieces of source code I came across recently.

ipin.py

Firstly check out this Python code ipin.py, by Axel E. Brzostowski, which converts png files from an iphone application into a format that you can read on any computer.

The python code is clean, easy to read, almost like literate programming. Very useful if you want to write a similar application that processes every file in a directory.

transmission

Another really nice program, is really a website. When you run transmission-daemon (linux bittorrent program), you can connect to it with a command line app called transmission-remote. In addition you can connect via a built in web server, which is a really excellently designed application. The html and javascript is so well documented and tidy it's as beautiful as the actual web page. Check it out here.

http://trac.transmissionbt.com/browser/trunk/web

Securing an ssh server with fail2ban

2010-01-01T19:26:00.000-08:00

There are all kinds of ways to secure an ssh server, with varying degrees of increasing security and decreasing flexibility. For example by limiting your server to only accept connections from certain known IP's, you are secure from random hackers on the internet, but you lose the ability to connect to your machine from anywhere you want to. Perhaps while travelling, for example.

Port knocking and listening on a high numbered non-standard port. make it harder for an attacker to even start trying to hack your connection. But this also requires you connect with a machine that you have the knock program installed on. Again, less convenient, more secure.

However, once an attacker does find your port there's nothing to stop brute force password hacking. If you look in your log file, you should see people connecting to your ssh port quite frequently and trying password attacks.

cat /var/log/auth.log

If you have a secure password then it would require days of brute force hacking to gain access to your ssh account, but even so, if you don't watch your logs then it's perfectly possible somebody will gain access eventually.

Brute force attacks can be limited using fail2ban. There's a great article on setting it up here. This program will scan your auth.log for you, using a regular expression to find failed password attempts. On a specified number of failures from a given IP, it will then modify the iptables on your machine (the firewall), to lock that IP out for a specified time.

Now instead of watching your auth.log fill up with reams of failed passwords, you'll see a greatly reduced amount of brute force attacks, and you can watch your fail2ban log file fill up with the IP addresses of hackers.

Using screen

2010-01-01T18:49:00.000-08:00

When running a linux app, perhaps on a remote box, you don't want it to terminate when you close the terminal window. You can run some applications as daemons, or run them with the nohup command (no hang up).

For example:

nohup ./myapp > output.txt

will run the program myapp and send the output to output.txt.

You can then follow the output.txt with a command

tail -f output.txt

but if you hit Ctrl-C or close the terminal (or have a power cut), the application will still be running on the remote machine.

A more powerful solution is the Gnu screen application. This lets you run multiple shell sessions and switch between them. Using screen you can be logged into a server in your office, then detach from the screen session, go home and reattach to it there (assuming you have network access to the computer).

Here's a cheat sheet for using screen.

Running it:

screen

Learning to use it:

Ctrl-a help

Important commands:

Ctrl-a c (open a new window)

Ctrl-a p (prev window)

Ctrl-a n (next window)

exit or C-a q to exit

How to reattach to the screen session:

screen -ls

That shows screen sessions on the machine your logged on to, and then you reattach using:

screen -r name

That's all folks!

Transparent emacs on windows

2009-10-12T21:35:00.000-07:00

Here's a handy function which lets you choose a transparent level (0 is fully transparent and 100 is opaque), for the main emacs frame in both focused and unfocused state.

(defun transparent(alpha-level no-focus-alpha-level)
 "Let's you make the window transparent"
 (interactive "nAlpha level (0-100): \nnNo focus alpha level (0-100): ")
 (set-frame-parameter (selected-frame) 'alpha (list alpha-level no-focus-alpha-level))
 (add-to-list 'default-frame-alist `(alpha ,alpha-level)))

To run M-x transparent.

Enter the values you want for when the window has focus and when it does not. In the background you can see system status information on the desktop, which is another excellent utility from sysinternals called BgInfo. It let's you display useful info about your system right on your desktop, similar to tools you may find on linux.

MSDOS iterating filenames in a file

2009-10-09T12:18:00.000-07:00

In an earlier post I covered finding the writable files in a directory, which is something you often need to do when messing around with source control. For example, if there's a writable file in your source folder that isn't checked out, then you know you need to add it before checking in. In fact I have a tool that compares my changelist with the list of writable files, and lets me know if I'm about to break the build when I check in.

Anyway I digress. Once you have found the writable files using:

dir source_folder /a-r-d /s /b > files.txt

then you may want to run some operation on them; for example make them read only.

Here's how to do that with the windows for command (see here for documentation)

for /F %i in (files.txt) do attrib -R %i

The for command with the /F option can iterate through a file full of filenames, which is what we generated with the first command, and run the operation after the do instruction.

It's actually quite powerful; you can specify comment markers, delimiters, and choose which of a number of columns you want to make into variables.

Windows command window title

2009-09-23T16:18:00.000-07:00

Did you know you could change the title in the window of a command prompt using the title command? Example:

title Poop ha ha

Now that's only really useful for making windows with rude words in their title bars right? Well actually, I've found a great use for it. If you have a bunch of command prompt windows open then you have no idea which one is which on the Windows taskbar, once they are stacked. So naming them is a really useful habit since once named you can see which window is which.

English quote in Common Lisp

2009-09-21T09:55:00.000-07:00

(defun today() (cadr days-of-your-life))

Making emacs growl

2009-09-10T07:13:00.000-07:00

I've always wished emacs could notify me of it's doings. For example the message function just pops up text in the minibuffer and is easy to miss, and impossible to see when the window is not in focus. So I was pleased when looking through the twit.el code to find out about todochiku, and emacs interface to Growl.

Download Growl for windows and set it up. Send yourself a test growl at the command prompt like this:

"C:/Progra~1/Growlf~1/growlnotify.exe" /T:"title" "message"

Once that's working you can send notifications from emacs. todochiku is an emacs package for sending notifications to growl, snarl or whatever you have. In our case we have growl. Unfortunately the windows default is to use snarl, and there's no support for growl. I've made a few modifications to the original to get that working and uploaded the new file here. (Ideally I should make it so it searches both for windows and for growl or snarl being installed but for now the choice is made manually)

heyes-jones.com/todochiku.el

Download the elisp file into a directory in your emacs load-path (or add it) and add the (require 'todochiku) command to your .emacs file. Reload emacs, or just hit C-x e after the (require command in your .emacs)

You will need (require 'cl) somewhere before this is loaded (.emacs perhaps)

Customize the variables for the program using M-x customize-group todochiku

You'll need to set the `todochiku command' to something like this:

C:/Progra~1/Growlf~1/growlnotify.exe

Use "Dir /x *" in a folder to find out what the 8 character name is.

If you want icons that come with todochiku then download them from the todochiku wiki page and point to them with the variable `todochiku icons directory'. For example mine is set to:

~/localemacs/todochiku-icons

Finally you can do a growl... try this

(growl "Emacs" "Hello")

There's also `todochiku-message' which let's you specify an icon. This can be an image filename, and url, or an icon symbol from the built in list of icons you can find by the variable `todochiku-icons'.

(todochiku-message "Emacs" "You're growlingnow" 'social)

(todochiku-message "Emacs" "You're growlingnow" "http://www.growlforwindows.com/gfw/images/downloadlatest.gif")

(todochiku-message "Emacs" "You're growlingnow"
"c:/cygwin/home/Justin/localemacs/todochiku-icons/binary.png")

There's a command `todochiku-in' which will send you a notification from emacs in a set number of minutes.

(todochiku-in "hello" 3)

If you use twit.el you should find that todochiku automatically notifying you of tweets if you have called `show-recent-tweets'.

It's very simple to use todochiku and growl so you should find all kinds of applications for this. Have fun!

Directional window movement in emacs

2009-09-08T14:12:00.001-07:00

One thing I sometimes miss about the text editor Brief, which I stopped using a decade ago, is being able to move between windows easily by pressing a function key and then an arrow key to switch to a window in that direction.

In emacs I only knew how to move between windows using `other-window', mapped to C-x o and that only cycles around the windows, and if you have a few windows open and possibly you're also editing the mini-buffer, that's quite a round trip.

I just learned about `M-x windmove-default-keybindings', which binds a set of commands that do exactly the kind of directional movement I'm talking about (`windmove-right', `windmove-up' and so on) to the cursor keys (with shift key held).

Handful of emacs tips

2009-09-01T14:37:00.000-07:00

keep-lines
flush-lines

These handy functions prompt you for a regular expression and will either remove every line that does not contain that expression (keep) or remove the ones that do (flush).

finder-list-keywords

This function shows all the keywords used in the packages within emacs. In other words you can find a lot of stuff in emacs that you never knew was there.

Simple budget forecasts in emacs

2009-08-26T23:36:00.000-07:00

When I first moved from England to North America one of the things I found hard to get used to was getting paid every two weeks instead of monthly. This means that some of your bills are monthly, some are biweekly, and occasionally I had more or less money than I expected as they got out of sync.

I've been using a simple elisp program I wrote to let you manage your upcoming bills, weekly budget items like groceries, and your regular income. It runs through a period of dates you supply, and a list of incomes and expenses, and produces a csv file and a buffer that contains the output of the forecast. It shows the highest and lowest balance of the period too, so you can spot if you will go over drawn, and also see peaks when it's a good time to move money to savings.

The code is hosted on google code as emacs-easy-budget and is also released as GPL v3. Hope somebody finds it useful.

1337 on StackOverflow

2009-06-17T11:41:00.000-07:00

I noticed today that my StackOverflow reputation is 1337. What an incredibly geeky way to begin Wednesday!

Linux: Looking at files changed recently

2009-05-27T10:35:00.000-07:00

This is really handy (on Linux and Cygwin) when you're working on a project that may not be in source control and you want to see what you changed recently.

I made this blog post, when it seems a trivial use of find, because I don't think the man page covers it well.

This command finds all files modified in the last 60 minutes:

find . -type f -cmin -60

Linking MingW32 with psapi

2009-05-14T16:48:00.000-07:00

Here's something I came across that didn't have a good answer when I googled. If you get link errors with MingW32 like:

undefined reference to `GetProcessMemoryInfo@12' or
c:/justinhj/mem.cpp:55: undefined reference to `EnumProcesses@12'

Then you are not linking with the library psapi, and you need it.

To do this just add -lpsapi to your command line. It needs to be last in the list of libraries too!

Writing quick C++ programs in emacs without a makefile

2009-05-14T16:36:00.000-07:00

Cheetah by Storm Crypt

Often when programming in C++ (or many other languages) it's desirable to write a quick program, usually a console application, to test something quickly. Working in developer studio, it takes an amount of fiddling and clicking large enough that you may not want to bother.

Working in emacs and MingW32 (or Microsoft's CL.exe) I can quickly create a CPP file, and then compile it. To compile a program though you need to either write a makefile, or build up a complex g++ command line.

Rather than do either of those I make a helloworld.cpp file which can be built like this:

g++ helloworld.cpp -g -o helloworld.exe

So I hit

M-x compile

then type in the above to compile and link it.

However there's a better way. You can add the compile command as the first line of the file as a file local variable.

// -*- compile-command:"g++ helloworld.cpp -g -o helloworld.exe"; -*-

Now I can hit the compile and it works right away, between sessions. No makefile or project settings in sight, and now there are minimal barriers involved in creating a simple test program beyond copy and pasting the file.

Converting flac to mp3

2009-05-12T21:59:00.000-07:00

This is just a link to a great description of converting flac to mp3 files. There's a tonne of commercial and useless sites that try to answer this question

So I thought I'd add another link to this one that actually works, and uses free software.

http://www.afterdawn.com/guides/archive/how_to_convert_flac_files_to_mp3.cfm

emacs: Renaming multiple files at once with a regular expression

2009-05-08T08:33:00.000-07:00

M-x dired
(navigate to the folder)
M-x wdired-change-to-wdired-mode
M-x replace-regexp
(enter search and replace expressions)
C-c C-c

Which writes out the changes to the directory.

emacs: Searching programming API's with webjump

2009-05-07T09:08:00.000-07:00

Image by MarkyBon

In a previous post I outlined how to use webjump, a built in feature of emacs to quickly launch web pages in a browser, after querying the user for search phrases and so on.

This describes how to simply setup webjump to search the API documentation for whatever framework you are using. The example will be Java's Platform documentation.

Find the base url you want to search. We will use google to only find things that begin with this. In the case of Javas documentation I'm going to search at http://java.sun.com/javase/6/docs/api/
Set up the web jump code as below. The three arguments in square brackets are [ base url, normal search url prefix, search url post fix ]. You just need to replace the JAVA API part of my URL with the URL you are interested in.
M-x webjump
Type your query and hit enter
Browser opens with search results


(require 'webjump)
(global-set-key [f2] 'webjump)
(setq webjump-sites
(append '(
("Java API" .
[simple-query "www.google.com" "http://www.google.ca/search?hl=en&as_sitesearch=http://java.sun.com/javase/6/docs/api/&q=" ""])
)
      webjump-sample-sites))

Running an elisp function on each marked file in a dired buffer

2009-04-15T10:49:00.001-07:00

Chain Tool by Florian

If you have some function, say some custom refactoring operation, you can call it from a dired buffer, and have it run on each marked file, using the code below.

Go into a dired buffer, mark some files, and then do M-x and run your command. In this case it would be test-for-each-dired-marked-file


;;; iterating over files in dired

;;; usage example - for-each-dired-marked-file returns a filename and path
;;; for each marked file, so this is what a function using it looks like
(defun view-stuff(filename)
"opens up the file and gets the length of it, then messages the result"
(let (fpath fname mybuffer len)
  (setq fpath filename)
  (setq fname (file-name-nondirectory fpath))
  (setq mybuffer (find-file fpath))
  (setq len (buffer-size))
  (kill-buffer mybuffer)
  (message "Buffer length %d %s" len (buffer-file-name mybuffer))))

; Usage example
(defun test-for-each-dired-marked-file()
(interactive)
(for-each-dired-marked-file 'view-stuff))

(defun for-each-dired-marked-file(fn)
"Do stuff for each marked file, only works in dired window"
(interactive)
(if (eq major-mode 'dired-mode)
   (let ((filenames (dired-get-marked-files)))
     (mapcar fn filenames))
 (error (format "Not a Dired buffer \(%s\)" major-mode))))

Securely copying files to another machine

2009-04-02T11:51:00.000-07:00

Fast post about copying files between computers over a secure connection.

Linux and Cygwin comes with scp, a secure version of cp.

Usage... in this case I'm copying a file from my cygwin (putty) terminal to a remote machine.

scp /cygdrive/c/Documents and Settings/myname/My Documents/interestingfile.txt usernameonmachine@1.2.3.3:/home/usernameonmachine/

You should get a password prompt and see the transfer complete as follows.

interestingfile.txt 100% 34KB 34.3KB/s 00:00

Vancouver game companies

2009-03-18T08:46:00.000-07:00

I've copied this excellent list of Vancouver game companies from :

http://csciun1.mala.bc.ca:8080/~wesselsd/gamedev/index.html

Please not that the number of jobs for each one is constantly changing, and so will be only (roughly) correct at the time I posted this.

Acronym Games (7 jobs)

Action Pants Inc (always recruiting multiple positions)

AirG (2 jobs)

Atomic Robot Games (always recruiting)

Backbone Entertainment/Foundation 9/Digital Eclipse (2 jobs)

Bardel Entertainment Inc. (3+ jobs)

BigSandwich Games (4+ jobs)

Blue Castle Games (14 jobs + 3 co-op jobs)

Credo Interactive

Deep Fried Entertainment (8+ jobs)

Electronic Arts Canada (21 jobs)

Gekido Design Group (3+ jobs)

Hot Dog Day

HotHead Games (2 jobs)

InLight Entertainment (Victoria) (5+ jobs)

InterScape Creations

IronClad Games

IUGO (2 jobs)

Jarhead Games (always recruiting)

JetBlack Games (1 job)

Just Leap In (4+ jobs)

KoolHaus Games (10 jobs)

LavaMind

The Lunny Group

Magellan Interactive (3 jobs)

Magnetar Games

Nerd Corps Entertainment (7+ jobs)

Next Level Games (4 jobs)

Nintendo of Canada

Orangeview Games

Piranha Games Inc. (always recruiting)

Propaganda Games (5 jobs)

Radical Entertainment (16 jobs)

Rainmaker (30+ jobs)

Relic Entertainment (12 jobs)

Rockstar Vancouver (5 jobs)

Singular Inversions

Slant Six Games (6 jobs)

Smoking Gun Interactive (5 jobs)

Threewave (8 jobs)

TrueView Rendering and Animation

United Front Games (3 jobs)

Yamisoft Entertainment Inc.

Yummy Interactive (1 job)

Using tags in emacs on windows

2009-03-09T10:06:00.000-07:00

This requires you install the Gunwin32 tools or Cygwin, and describes how to build a tags table for the project you're working on, when using emacs to edit the source.

First you want to generate a file containing all the source files you want to have tagged. Go to the root folder of your project.

find . -regex ".*\(h$\|cpp$\)" > files.txt

Next pass this to etags to generate the tags table.

etags.exe - < files.txt 

Then when you're in emacs you need to visit the tags table, which will have been saved as TAGS.  M-x visit-tags-table  then browse to the folder where you made the TAGS file.  Now when you have the curser on some function you can type...  M-.  to go to a tag and  C-u M-.  to go to the next tag.  Once you're done, you can return to where you started with  M-*  Another useful function is  tags-apropos  Which will list all the tags matching a regex in a buffer.

Sending mail with emacs in Windows

2009-02-20T10:31:00.000-08:00

Thanks to a commenter in my earlier blog post for pointing me to this way of sending mail that actually does work:

http://www.emacswiki.org/emacs/GnusMSMTP

You need to download msstp from sourceforge and install the exe in your path.

http://sourceforge.net/projects/msmtp/

There is one change I needed to make to get this working. In the config file:

msmtprc.txt

You need to add a line

from your.email@address.here

Without that I was getting an error number and no email. If you run into a problem like that you can make sure MSSTP is running by trying it from the command line:

msmtp -a yourname some@recipient.com

Type some mail and hit Ctrl-Z and it should send correctly.

Once that is working you can enter gnus within emacs, and send a mail using:

M-x message-mail

Fill out the fields and type C-c C-c and it should send correctly.

A security issue with this is that it doesn't seem to work if you leave your password empty in the configuration file. From the command line it simply prompts you for your password and away you go, but from emacs it just hangs. So if you use this method you're taking the huge risk of having your password in a readable file on the hard drive. I'll be trying to find a way around that before using this permanently.

Who uses the A* code

2009-02-16T17:12:00.000-08:00

I often wonder who uses the A* code. Sometimes people write to me to tell me they've used the code in their University assignments or just for fun, but has anyone used this in a project that I don't know about?

My A* algorithm on google code

During my time at Activision I worked on a code base that included some code from their game Gun, and was happy to find my code, verbatim included there too!

Also, today, I downloaded a 2d game prototyping engine called Angel, from some EA guys. When I looked at how their path finding worked, I was surprised to see my code in there too!

http://code.google.com/p/angel-engine/

It's cool that people are using this code. If you do use it in some commercial or interesting project, please let me know. A credit or thank you in your product would be nice too!

A* algorithm bug fixes

2009-02-16T17:04:00.000-08:00

It's been a while since I checked the issues page on my A* algorithm google code project. So it turns out there's a possible memory leak and the Manhattan distance calculation in the findpath.cpp is wrong. I've investigated both of these and uploaded a fixed version.

In the case of the memory leak, there is some code in my "fast simple allocator" which allocates some memory, assigns it to a temporary pointer, then converts it and stores it in a member variable. Apparently, this shows up in memory tracking software as a leak, even though the memory is released in the destructor, so I've changed the code so that the allocation and free is done with the same variable.

The Manhattan distance refers to a simple heuristic for finding a path when you can only move horizontally and vertically through a grid. Like calculating how far you would have to walk in a city on a grid system, like NY, you simple count how many blocks along and how many blocks up you need to walk. Well I implemented this carelessly and forgot to make sure that I take the absolute value when calculating the difference between 'streets'. That's done now.

You can download the latest version of the A* algorithm here...

http://code.google.com/p/a-star-algorithm-implementation/downloads/list

Setting up lispworks personal

2009-02-13T22:42:00.000-08:00

I've always used this excellent pair of blog posts by Bill Clementson to get lispworks personal working with emacs/slime on windows.

Configuring SLIME for 3 Win32 CL Implementations
Using LispWorks Personal with Emacs/SLIME on Windows

Having had the joy of a hard drive failure last week I had to reinstall everything, and I've found that with the latest CVS version of slime you need to change your ".slime.lisp" file to look like this:


(load "/YOURPATHTOSLIME/slime/swank-loader.lisp")
(swank-loader:init)
(swank::create-server :port 4005)

So if your slime/lispworks personal setup stops working when you upgrade slime, hopefully you found your way here.

Searching Reddit, Flickr, and Google from emacs = Rad

2009-02-13T22:07:00.000-08:00

I came across another brilliantly useful corner of emacs today.

webjump by Neil Van Dyke is part of emacs and Xemacs, and gives you a way to assign memorable names to web site urls, and to build simple search queries. It then opens the website using emacs' built in browse-url function.

Set up is easy. All you need to add something like this to .emacs:


(require 'webjump)
(global-set-key [f2] 'webjump)
(setq webjump-sites
      (append '(
  ("Reddit Search" .
   [simple-query "www.reddit.com" "http://www.reddit.com/search?q=" ""])
  ("Google Image Search" .
   [simple-query "images.google.com" "images.google.com/images?hl=en&q=" ""])
  ("Flickr Search" .
   [simple-query "www.flickr.com" "flickr.com/search/?q=" ""])
  )
       webjump-sample-sites))

The first line just makes sure the feature is loaded, and then I bind the webjump function to F2 in the second line.

To use webjump, just press F2, and press TAB to expand the sample sites that are built in, and the ones we just added above. Type Flickr Search for example, and then you get a prompt for the search string. Once you enter that your browser should open with flickr showing the search.

I've added Reddit, Flickr, and Google image search above, but it's easy to add your own as follows:

Each entry in the jump list takes the form (name . url|builtin), where the simplest shortcut is just a name, url pair like this:


("astar algorithm" . "http://www.heyes-jones.com/astar")

There are some builtin functions that you can use. For example simple-query lets you enter some text that will be inserted between two strings. The format is:


("Reddit Search" .
 [simple-query "www.reddit.com" "http://www.reddit.com/search?q=" ""])

When doing something more clever than an url you pass in a vector (hence the []'s), where the first argument is the function, the second is the default url (if the user doesn't enter anything, and the third and forth arguments are the prefix and the postfix wrapped around the users input to make the search work. In this case the last argument is the empty string.

You can provide your own functions to do something really fancy if you need to.

Fun with RSS

2009-02-07T22:51:00.000-08:00

Today I've been playing around with emacs, and one of the things I've wanted to write is something to grab a web page, do some manipluations to it and dump that to a buffer.

So what I've got going is two things that are not quite joined up yet. Firstly grabbing some URL and sticking it in a buffer...


(defun url-to-buffer(url)
  (interactive "sEnter site url : ")
  (let ((buffer (get-buffer-create "*url-to-buffer*")))
    (shell-command (format "c:/coreutils/bin/wget.exe -q -O - %s" url) buffer)))

As you can see I'm using windows here, but as long as you have a path to wget this should work. I'm simply running wget and capturing the output to a buffer.

So running that on BBC's news RSS feed, I then saved it to a file called bbc.xml.

Since this is an XML file I can parse it without any effort using xml.el. Here is some code that walks through the items in the RSS file and prints them out in human readable format (ie: not XML) into a buffer.

There is some helpful info about xml.el here

http://www.emacswiki.org/emacs/XmlParserExamples

which was neccesary to figure to figure out the syntax to grab the text from a tag. I wrote helper function to go from a node to the text for that node, since the syntax is quite verbose:


(defun get-item(tag node)
  (let ((child-node (car (xml-get-children node tag))))
    (car (xml-node-children child-node))))

This lets you go from a tag name (eg title) and a node that you parsed from the xml file, to the item.


(defun parse-rss(filename)
  (interactive "fRss file :")
  (let ((parsed-xml 
  (xml-parse-file filename))
 (buffer
  (get-buffer-create (format "%s-parsed.txt" filename))))
    (goto-line 1 buffer)
    (erase-buffer)
    (let* ((rss (car parsed-xml))
    (channel (xml-get-children rss 'channel))
    (items (xml-get-children (car channel) 'item)))
      (dolist (item items)
 (let ((title (get-item 'title item))
       (description (get-item 'description item))
       (date (get-item 'pubDate item)))
   (insert (format "*%s*\n%s\n%s\n\n" title description date)))))))

xml-parse-file is our one shot call to parse the xml file, which returns a nested lisp structure representing the xml document. I grab the channel, then grab any items within the channel and print out three items that I've grabbed from them, the title, description and date.

So each item output looks like this:

*Obama defends economic stimulus*
The US president defends his economic stimulus plan as "absolutely necessary", and urges Congress to approve it quickly.
Sat, 07 Feb 2009 22:23:20 GMT

Note that if you want to read RSS feeds in emacs, look up the builtin function newsticker. All this information I'm writing about is really useful if you want to code up something custom though.

Sending email via gmail in emacs

2009-02-07T13:33:00.000-08:00

I got this working in linux, and it's fairly easy. I'm still trying to get it working on my win32 machines, and I'll post about that later if I get it working.

This post has most of the details I needed:

http://obfuscatedcode.wordpress.com/2007/04/26/configuring-emacs-for-gmails-smtp/

So I put the following in my .emacs


; install starttls from here (no need for patch)
; http://josefsson.org/emacs-smtp-starttls.html

(setq send-mail-function 'smtpmail-send-it
   message-send-mail-function 'smtpmail-send-it
   smtpmail-starttls-credentials
   '(("smtp.gmail.com" 587 nil nil))
   smtpmail-auth-credentials
   (expand-file-name "~/.authinfo")
   smtpmail-default-smtp-server "smtp.gmail.com"
   smtpmail-smtp-server "smtp.gmail.com"
   smtpmail-smtp-service 587
   smtpmail-debug-info t
   starttls-extra-arguments nil
   smtpmail-warn-about-unknown-extensions t
   starttls-use-gnutls nil)

And followed the instructions to make the .authinfo file containing:

machine smtp.gmail.com login [your name]@gmail.com password [your password]

And finally download, unzip, make and install startttls:

http://josefsson.org/emacs-smtp-starttls.html

You don't need to apply the patch there, it works without as far as I can tell.

Finally you can create and send mail.

Simple perforce checkout in emacs using elisp

2009-01-23T14:23:00.000-08:00

I know there are all kinds of clever perforce modes, but I prefer to have a few common perforce actions that I write myself and can easily extend and customise as needed.

For example this is all you need to checkout a file you are visiting.


(defun p4-checkout-buffer()
 "Check out the current buffer from perforce using a shell command line"
 (interactive)
 (shell-command (format "p4.exe edit %s" (buffer-file-name)))
 (toggle-read-only -1))

Finding writable files in a directory in a windows command line

2009-01-12T07:45:00.000-08:00

Simple thing, but if you want to find which files in a directory are writable, use this dos command ...

dir /a-r-d /s /b

/a is to search for attributes. In this case r is read only and d is directory. The minus signs negate those attributes. So we're looking for writable files only.

/s means recurse subdirectories

/b means bare format. Path and filename only.

Who changed the line your working on last?

2009-01-08T12:48:00.000-08:00

My team use Perforce for version control, and I recently wrote an implementation of 'blame', also known as 'praise'. When editing a file that is in Perforce, I can run p4-blame, and it will figure out the last change list that this file, and the line that point is on, was changed. It then opens a buffer containing that change list. This is often useful while working, and is so fast when accessed from the editor, it makes it trivial to do.

First, I wanted it to open two buffers, one with the annotated file (the file you're working on with the change list number at the start of each line), and another with the changelist you're interested in. When running the command multiple times I want these buffers to be deleted. So I added a helper function that creates a named buffer, and if it exists already, makes sure it is empty.


(defun get-buffer-create-and-clear(name)
  (interactive "sName: ")
  (let ((buffer (get-buffer-create name)))
    (goto-line 1 buffer)
    (erase-buffer)
    buffer))

Ok now for the blame code. As you can see, mostly what it's doing is called the P4 command line and passing the output to buffers. Firstly I call annotate to get the change list numbered lines. Then I go to that file and go to the same line that point was at. (number-at-point) returns that number. Finally I call p4 describe to get the changelist information.


(defun p4-blame()
  "blame the current line of code... it seeks out the change list of the last person
to change this line. The arguments to annotate, which dumps the source file with the 
change list number it was last altered in, are q (no header) i (follow branches) and
c for change numbers rather than revision numbers."
  (interactive)
  (let* ((line (line-number-at-pos))
  (source-file (buffer-file-name))
  (annotate-buffer (get-buffer-create-and-clear "*p4-annotate*")))
    (shell-command (format "p4.exe annotate -q -i -c %s" source-file) annotate-buffer)
    (goto-line line annotate-buffer)
    (let ((change-number (number-at-point)))
      (if change-number
   (let ((blame-buffer (get-buffer-create-and-clear "*p4-blame*")))
     (shell-command (format "p4.exe describe %d" change-number) blame-buffer))
 (message "error: could not get change list number for line %d" line)))))

The error detection is a bit sloppy here. I don't know how to figure out if the shell-command failed. But it's not a big deal because if you do this in a file that is not in P4 then it will simply print a message saying could not get change list.

Ideally I could send the error output to a buffer, and then parse it to see if it's empty.

How to copy an SVN repository from sourceforge to google code

2008-11-21T11:43:00.000-08:00

Subversion has a tool called SVNSYNC to make it easy to sync from one repository to another. This is great when moving to a different web based server. In this example I'm copying a project I work on from Sourceforge to Google Code. Once done, the google code repository will be an exact mirror, including the complete change history.

You also need to set the revision number of the repository to zero. Google code, predictably, makes this easy, by having a button on the source page to do it for you.

You need to have your username and password for google code to do this. For the repository you're copying you don't. First you use the initial command to set things up for the copy, then use the sync command to do the actual copy. It does this one revision at a time and takes a while...


svnsync init https://lispbuilder.googlecode.com/svn https://lispbuilder.svn.sourceforge.net/svnroot/lispbuilderProject
svnsync --username YOURNAME --password YOURPASSWORD sync https://lispbuilder.googlecode.com/svn https://lispbuilder.svn.sourceforge.net/svnroot/lispbuilder

Grabbing info from web pages

2008-11-08T22:03:00.001-08:00

This is how you use wget to grab a web page to stdout ...

wget -O - http://newsrss.bbc.co.uk/rss/newsonline_world_edition/front_page/rss.xml

Where -O species the output file, and the - specifies use stdout instead of a filename.

Using find and printf

2008-05-27T17:25:00.000-07:00

This is basic stuff but I wanted to post it so I can find it when I search for it...

How to find a file and print the name, path and date and time it was last accessed...

Change filename to be the file you want, with optional wildcards. (Use -iname for case insensitive search).


find . -name  -printf "%p %AD %AH:%AM\n"

Batch file tip ... %~dp0

2008-05-13T11:45:00.000-07:00

Here's a nice blog post on this...

Silly batch file tricks, redirecting stdout into an evironment variable and %~dp0

But just for my own reference the cryptic looking character sequence resolves to the path to the batchfile you are running.

So if you put the following in a batch file, no matter what directory you are in when you run it, it will print the directory the batch file is in, and do a directory listing.


echo Batch file path is %~dp0
dir %~dp0

Copying characters from the line above in emacs

2008-05-01T11:38:00.000-07:00

The BBC microcomputer had a button called COPY, which when you pressed it would copy the character on the line above the cursor. This was quite handy, and I recently was waiting for a large amount of code to link, and thought I'd have a go at implementing it.

There's not a lot to it in fact. This function just remembers the cursor position (using save-excursion) and then goes to the previous line, gets the character after the point, and finally after the save-excursion block I just insert the character.


(defun copy-char-above()
 "copy the character above point into the buffer"
 (interactive)
 (let (c)
   (save-excursion
     (previous-line)
     (setq c (char-after)))
   (insert (char-to-string c))))

Here I just assign the function to a key...


(global-set-key [f6] 'copy-char-above)

Is it a leap year

2008-02-29T18:24:00.000-08:00

Here's a bit of elisp code to find out...


(defun is-century-year(year)
  (if (= (mod year 100) 0)
      t
    nil))

(defun is-leap-year(year)
  "leap year is century years divisible by 400, 
not other century years, otherwise anything evenly 
divisble by 4"
  (if (is-century-year year) 
      (if (= 0 (mod year 400))
   t
 nil)
    (if (= 0 (mod year 4))
 t
      nil)))

emacs - a simple search and replace function

2008-01-29T14:42:00.000-08:00

This function is for emacs; it searchs for any sequence composed of spaces and tabs and replaces it with a single tab


(defun space-and-tabs-to-tab()
  (interactive)
  (while (re-search-forward "[\t ]+" nil t)
    (replace-match "\t" nil nil)))

emacs: how-many

2007-12-08T15:18:00.000-08:00

Discovered another emacs command yesterday:

how-many

Returns the count of a regex following the point (cursor position).

For example

M-x how-many
\b\w

returns a word count from point to the end of the buffer.

Nice.

C: Passing on variadic function arguments to another function

2007-12-07T13:04:00.000-08:00

I needed to do this today, and it took me a while to google it, so here is complete sample showing how it's done:


// How to pass a variadic argument list to another function
// Justin

#include "iostream"
#include "stdarg.h"

using namespace std;

void debugMessageHelper(char *buffer, const char* format, va_list arglist)
{
 vsprintf(buffer, format, arglist);
} 

void debugMessage(char *buffer, const char* format, ...)
{
 va_list arg;
 va_start(arg, format);

 debugMessageHelper(buffer, format, arg);

 va_end(arg);
} 

int main(int argc, char *argv[])
{
 char testBuffer[128];
 
 debugMessage(testBuffer, "hello %s %u %-04.2f", "world", 21 33.122f);

 cout << "\'" << testBuffer << "\'" << endl;

}

Ubuntu 7.10

2007-10-24T09:50:00.001-07:00

With a new version of Ubuntu out (7.10) I decided to repeat the painful experience I put myself through every couple of years to see if I want to use it as a windows replacement on the desktop.

I've been pleasantly surprised this time. The install process was a bit of a monumental fuck up, but it turned out that my PC has been overheating for a while due to a dirty fan. Windows didn't seem to care. Linux kept shutting down, and I eventually found the system log that told me why it was shutting down, and the exact temperature that caused it. Nice.

At least when linux fails it is usually able to tell you exactly whats going on.
Installing the Nvidia drivers turned out to be a pain in the ass too. The simple procedure they give you to do it from the desktop just didn't work. I then tried Nvidia's simple shell script, which didn't work. And a day or so later I found something called Envy, which did work.

Overall I had to be familiar with linux commands, logging in as root, and editing configuration scripts to get it to do what I needed. It's still a computer experts OS as far as I can tell. Although you can pay for phone support, I don't think they're anywhere near capturing the typical Best Buy PC owner.

So far I can do nearly everything I need to in XP, but the user interface is both flashier, faster, and has the benefit of being linux.

It's still likely I won't be able to fully ditch XP though. I can't chat with my webcam yet. The webcam works but the chat software doesn't support it.

I don't like the fonts, but I'm hoping I can configure that, I haven't spent time twiddling with it yet.

Ubuntu is definitely getting there.

C and C++ function pointers

2007-10-24T09:00:00.000-07:00

I came across a great page for C and C++ function pointers. It includes the syntax for how you do most things you would ever do with them. An ideal reference because I can never remember the syntax...

http://www.newty.de/fpt/fpt.html

Avoiding Ten Common Game AI Mistakes

2007-10-09T10:44:00.000-07:00

1) Moonwalking into walls or objects

Often this is a symptom of the interface between the AI and the game world being too complex, and therefore hard to debug. Sometimes it can simply mean that you have no path finding in the game at all, but we will ignore that for now.

Look for differences in the way that the animation moves and the way it queries the collision system. For example, the AI may do a ray cast to see if there is an object in front of it, but the character control system may move a larger object such as a cylinder, which then collides with the world unexpectedly.

Other problems may be that the general movement code does not handle the collision when it is detected resulting in continuous attempts to move when the physics and collision system will not allow it. Sometimes the movement code fails, switches to an idle state, which then immediately attempts to move again, see item 4 below.

2) Turning "the long way around" to face a target

For some reason this bug often survives until late in a project; sometimes it even ships! It seems like a simple thing to calculate... should I turn left or right to face a target.

Typically people start out getting the X and Z distance to the target and figuring out that as an angle using atan2. Then they take the X and Z components of the facing vector to get that angle via the same route. Finally you just take the difference between those angles.

What usually happens is that if you're not careful when manipulating these angles there are mistakes made when converting between radians of degrees, or when figuring out whether to turn left or right, or when wrapping angles around at 360 degrees.

Let's look at a solution that avoids having to convert and do arithmetic with angles, which is where most of the bugs I see come from.

Firstly take a dot product of the vector to your target and the characters facing direction (just the X and Z components). This gives you the cosine of the angle between the two vectors. Take an acos of that to get the angle in radians. What's nice about that compared to the atan2 route is that it immediately gives you the angle you want, the angle between the facing direction and the target position. You don't have to do anything more to make sure it's the shortest way around.

Then we want to know whether to turn left or right. Again looking only at the X and Z vectors, we can simply figure out whether the target is to our left or right. First we need to get the 2d cross product of our facing direction. If the facing vector is (x,y,z), a vector at right angles to this in 2d is just (-z, x).

If you then take the dot product of this and the vector to the target, the sign of that is whether you should turn left or right! Simple.

3) All the enemies on screen doing the same idle animation in perfect synchronization

This is a very common when a bunch of enemies get spawned at the same time, with the same behaviour and their animations end up perfectly synchronised. Also it happens when the AI's are all hit by some weapon at the same time.

It looks lame, and there's a couple of ways to help this along with making a major impact on your engine. You can play animations at irregular speeds. Play the idle animations at variances of just a few percent, and they won't look wrong, and they will be out of sync with each other. Use sets of random animations as often as you can, especially looping ones. At a higher level you can also make sets of states behave differently. If you have a state machine which has random elements for choosing the next state, then use that to vary the AI's.

4) Enemy behaving unpredictably

However you set up your AI system it will always end up complicated. At it's worst AI code is a mass of "if X then do Y" type statements, and unless you manage it correctly you won't be able to understand what is going on.

Firstly you need to abstract the state actions and state decisions as much as you can. Seperate concepts such as "doing an action" from "perceiving the world" and "deciding to do something". As much as you can allow the AI to be set up in the game data, not in the game code.

Doing so also makes concurrency easier, since if you encapsulate all of your queries about the world, you can execute them in parallel with other game systems, then in a later stage of execution you get the deferred results of those queries and act on them.

But the ultimate solution to unpredictability is debugging tools. You want to be able to store the last few states the AI was in, what transitions got him into that state, and what states it is considering transitioning to. If you can show this stuff on screen, at will, while the game is running, then you're golden. Spend lots of time on this kind of stuff, because I guarantee there will be a time near the end project when someone will come and stand behind you and ask you why something on the screen is doing X instead of Y. If you have no idea, then you're not doing job as an AI programmer.

5) Enemy is vibrating, flipping rapidly between two animations

This happens often in state machines. If you get a state A which transitions to state B, and then on the next update, state B transitions back to A again. Assuming, as often people do, the AI states also trigger animations, then you have the horrible flickering between the two first frames of each.

Ulimately the AI designers can avoid state cycles by not making them, but there are bound to be some that slip through. At which point it, it would be nice to have some mechanism to avoid them. You could flag an error or warning when a state immediately returns to the previous state, or you could have a time within which you cannot return to the previous state.

One nice way to handle this is to make the data about how long you should stay in a state explicit. For example, if an enemy is rolling along the floor then it makes sense that you cannot interrupt that action once it starts, so we have the concept of an interrupt time, before which you cannot break to a different state. Tying states to animations achieves this too, but I don't recommend a one-to-one match of animations to state for reasons that I will cover later.

Having interrupt times that are at least 1/2 a second is a simple way to avoid state thrashing, but you still have to solve the problem at the design level.

6) Irratic running on the spot and sudden direction changes.

Have you ever seen AI's running to a point in the world, then when they get there they overshoot? Or maybe they just keep stopping and running again. Or maybe they spin on the spot.

The problem here is nearly always to do with managing movement and distances to points. There are many ways to get this wrong. For example, if you use a bone or root node on a model as the absolute position of the character, then his distance from a point may vary over time as he animates. Meaning that you keep moving too far from the target point, triggering a new movement state.

Another issue is how close do you have to be to the point to stop trying to move there? If it is 1cm then how accurate is your character movement system? can you move someone with an accuracy of 1cm? If not then you need to enlarge your arrival distance until it is large enough that you can guarantee accurate arrival.

If you couple movement to animation you need to spend a lot of time thinking about where the character is, and a good way is to use a root node that is carefully animated to be well behaved. Then I recommend that you store the displacement of animations, so that you know exactly how far they will move the root node when played.

For ultra slick AI's that walk or run to a point then do a smooth stop animation and end up exactly on the target, you just need to play your walk animation until you get to the point when the transition to stop animation would get you exactly to the target. The you need to play that animation at the right point. You also need to consider where the foot steps are. You can then determine whether to transition to a left or right footed stop.

Finally, it's nice if you can manipulate your animations so that you can vary the distance covered by your walk cycle, just enough so that the transition to stop can be executed at a perfect boundary.

If animation is just something you play in the background and doesn't affect your movement, then things are easier. It comes down to fixing the issues above as best you can, but you don't have to fix them, you will just get sliding and popping now and then. But you won't get the kind of animation driven movement problems that cause you to overshoot.

One final issue is turning. Make sure your characters have a turn speed, that varies with running speed. You can turn on the spot when you're stationary, for example. When running your turning circle is limited.

7) Enemy doing nothing at all

This is pretty much a design level issue, but it's common enough to mention. Sometimes AI's are just dead. They have no idea what to do next and this looks pretty stupid.

Usually this occurs when AI have no valid transition from an idle state. So have your designers think about things the AI should do if everything they typically think he should be able to do cannot be done.

One possiblity is that the path finder is failing. Perhaps the AI spawned in an unreachable area by mistake, or was pushed there, or fell there. If your AI's can get into a situation where they cannot move, then perhaps have them animate now and then so they look puzzled, or are looking around wondering what to do.

Look though transitions from idle and make sure that there is something interested there that can be transitioned to if everything else fails.

This also comes down to good AI system debugging tools. If you can immediately bring up a display showing which transitions the dead entity is considering, you will be able to figure out what to do.

8) Movement deadlocks (doors, bridges)

Choke points happen in AI. Narrow corridors, doors, bridges, tunnels. Sometimes we are even clever enough to come up with a system for handling them. AI's that want to enter the choke point take a queue number, and they go through one by one for example.

Whether you do something like that, or do nothing at all, there needs to be some way to avoid deadlock. One way to do that is by giving your AI's different priorities for movement, so that they can move AI's out of the way. Often a player is able to move AI's about, sometimes simply because he moves first.

If you have a physics based engine for character movement this is easy, just set the mass to be greater on characters that you want to have the highest priority. Otherwise you'll probably have some kind of collision resolution system, and you need to feed in the priority from the AI into that.

9) Using A* for everything

I run a web site which teaches A*, and yet when I come to write a pathfinding or other search program I don't always use A*, and when I do I never do A* on a fine mesh or grid. Why? Because it uses a lot of memory and processing power that is totally unneccesary.

Firstly if you're searching only small data sets, like an AI state graph, or a dozen or so path nodes in a room, you can use Dijkstra's algorithm, which is particularly effective when all the AI's in the room will path find to the same node, since the algorithm will fill out data for the whole network rather than just the start and end nodes. Sometimes even a breadthfirst search is enough.

In general you want the path finding data to be as high level as possible whilst still allowing movement to all possible gameplay areas.

One approach is hierarchical path finding, which really needs to work at engine level. If you divide your game world up into regions, buildings, floors and rooms, for example, an AI can path find at all those levels before finally pathfinding on a grid or mesh level inside the current room it is in.

10) Being too clever

Good AI is often based on quite simple systems. It almost always is built up using good tools and good design, rather than clever algorithms.

Things to watch out for are learning algorithms, unless they are directly related to gameplay, which tend to make it hard to get the behaviour you want. I don't want to sound like I'm stifling innovation, but don't use a back propagating neural network when a simple table would do the job.

At all times make the systems workings clear via debugging tools, and as best you can allow rapid iteration of AI changes, ideally allow real time changes while the game is running.

11 Visual Studio tricks in Emacs

2007-09-27T14:46:00.000-07:00

Recently I read the blog post "11 Visual Studio 2005 IDE Tips and Tricks to Make You a More Productive Developer" which has some neat tips indeed. I thought I would investigate which of the tips can be replicated in emacs, which are easier or more powerful in emacs and vice versa.

I've been using Visual Studio for over 10 years though I'm certainly not a power user, and recently I only use it for building and occasional code editing. I do more editing in emacs. I'm not writing this post to prove that one is better than the other, it is more for the learning experience for myself, and hopefully somebody will find something interesting here.

(1) Express Yourself with Regular Expressions

The example is to convert

, last_name
, ssn
, employee_id

into

+ "last_name"
+ "ssn"
+ "employee_id"

using a regex. Well, I'd probably record a keyboard macro to do that, but let's do the regex replace instead.

The syntax of the regex is a little different in emacs, but the basic sequence looks like this:

Alt-x replace-regexp
$, $$.*$$
, "\2"

Notice you need slashes for the brackets to make the groups.

Verdict: Visual Studio lets you use Regex's in script, and emacs lets you do it in elisp code... and they both have the functionality needed for the tip. Draw.

(2) Take (Keyboard) Shortcuts

This tip is to simply use keyboard shortcuts. Well in fact you won't get anywhere with emacs without using them. So this is kind of a mute point.

But I'll list some random keyboard short cuts for completeness...

Alt z runs zap-to-char, kills everything up until the character you enter.

Alt . runs find-tag. Finds the next occurence of current tag in the tags table, for finding function and variable declarations for example.

Ctrl U Alt . finds previous tag

Ctrl < goes to the start of a buffer

Ctrl > goes to the end

Ctrl H m describes the current mode, which is handy if you just downloaded a new editing mode and you want to see what the keys are and so on

Alt t runs transpose. You can flip two words around.

Verdict: Another draw.

(3) Make New Shortcuts

This is straight forward in emacs...

(global-set-key [M-f2] 'zap-to-char)

... sets Alt-F2 to do zap-to-char

You can override keys globally like that, or you can do local-set-key to change that key only for the current editing mode.

Verdict: emacs and Visual Studio both allow remapping anything they can do to a key, and they both allow you to redefine a key differently for different modes. Another draw!

(4) Use Code Snippets

I wasn't aware of this feature for Visual Studio so I checked it out briefly. So it lets you dump out text, such as automatically creating empty for loops or adding set and get fields given a field name.

Well in emacs there are abbreviations. So for example let's say I want for( to automatically expand to for(int i; ithen I can make an abreviation, by going into the mode I want this to be active, and typing

Alt-x abbrev-mode (turn the mode on)
Alt-X define-mode-abbrev (interactively add a new abbreviation for this mode)
for
for(int i; i
and now when I type for and space, it will expand automatically.

If you don't want it to expand then you type Ctrl-Q before you complete the abbreviation.

But snippets let you do more advanced stuff like take a field name and create the get, set fields. Well I would write elisp code for that kind of thing, or again use a keyboard macro.

Abbreviations are nice and easy to use, but they don't have the power of snippets.

Verdict: Visual Studio code snippets don't seem to map directly to emacs. In emacs you can use the more basic abbreviations, or roll your own solution for wrapping text in more dynamic ways.

(5) State Your Preferences

Not a lot to say here. emacs is fully configurable through the startup file .emacs, so you can do configure everything as you want it to be.

Verdict: Draw.

(6) "Attach to Process" to Start Debugging ASP.NET

Emacs doesn't support windows debugging, of course, but you can use gdb to debug processes. So the same functionality would be :

Alt-x gdb
attach [process ID]

Verdict: Draw.

7) Stop Conditionally (Conditional Breakpoints)

Again, this is a windows only thing... you can run gdb and type

break [LOCATION]

and

condition [COND]

to set up a conditional breakpoint.

Verdict: Draw. You can't debug windows processes from emacs, and you can't debug linux processes from Windows, but both offer debugging from within the IDE.

(8) Employ Task List Tokens

This is an odd feature. By typing // TODO in C++ code, for example, you can view the TODO's in a task list window for that file.

Emacs lets you do this with say the 'occur' function.

Alt-X occur
TODO

Will give a list of lines containing TODO.

You could make an elisp function to wrap this up into a task list function:

(defun task-list()
(interactive)
(occur "TODO"))

Verdict: Not much of a feature really, but yeah, another draw.

(9) Go Directly to Any File with the Find Combo Box

I couldn't get this tip to work, but Alt-Shift O seems to be the one he is talking about. A very nice list of files, and you can quickly open a file by typing part of the filename.

emacs doesn't include the files in your current project, so we don't have a direct comparison, but let's assume you have a root directory containing your source and you want to find files matching a regex:

Alt-x find-dired
d:\YourSourceFiles\
-regex ".*SEARCHTEXT.*"

This will open a dired window (like a file manager dialog box but lets you do lots more things to the files) containing the matching files.

Verdict: emacs is a bit better than studio in that you can search using all the power of the unix find command, but it's more fiddly to use, and there's no equivalent to Studio managing all the files in each project. (That I know of).

(10) Type Ahead (Incremental Search) in Lists

So for example in Studio, do Ctrl-O and you get a file dialog. Typing letters gradually filters the available files until you get the one you want.

Emacs has exactly the same thing.

Ctrl-X Ctrl-F to visit a file for example (although this works with anything that asks you for a file.)

Firstly you can use the buffer history to find files you opened and closed earlier, and also you can edit this, so if you just opened a .cpp file, you can change it to .h and load that easily.

Secondly hitting tab will cycle through possible files based on what you typed so far, but also open a buffer with the current valid files, so you can switch and select from there.

Finally, if you open the wrong file by mistake you can run 'find-alternate-file' and load a different file into the buffer you opened.

Verdict: emacs wins by a nose. More flexibility.

(11) Automate with Macros and Visual Studio Automation

emacs also has very cool macro recording...

Ctrl-X ( starts recording

do your thing

Ctrl-X ) ends recording

Ctrl-X e runs the macro

If you make a useful macro that runs on one line, you can then run it multiple times:

Ctrl-U 10 Ctrl-X e

runs the macro 10 times for example.

You can also edit the macro with edit-last-kbd-macro, which brings up an editor.

Well that's it, I'm sure I've missed out a lot of emacs features, I've been using it for about 4 years and I know there is still a lot of stuff in there I haven't discovered!

Word numbers programming puzzle

2007-09-22T09:44:00.000-07:00

Reading Reddit last week I came across an interesting programming puzzle.

http://www.itasoftware.com/careers/puzzles07.html

I've written a straightforward Common Lisp solution which is pasted below. What is interesting about this problem, and what would make it a good interview question, is that coding up the basic solution as I have here only poses more problems.

None of the Lisp environments I've tried have enough heap space to complete this problem, even though in terms of time complexity it is O(n). Judging by how long it takes to run on a few hundred thousand numbers, and then several million, it would take about 20 hours on my 2Ghz PC to solve for 1 billion numbers.

Even if I used the file system to hold the numbers, assuming each number fits in 50 chars of text, 4 bytes for the value and a further 4 to hold the length of the string, that is still in the order of 50Gb. You would then need to sort that file a bit at a time in memory, using a merge sort, and finally do a linear run through the file until you get the 51,000,000,000nth number.

Some clever folk have presented a more intelligent solution here...

http://conway.rutgers.edu/~ccshan/wiki/blog/posts/WordNumbers1/

Here is my solution so far:


#|
 Word Numbers

This is a partial solution to the problem found at http://www.itasoftware.com/careers/puzzles07.html
by Justin Heyes-Jones

I say partial because it does actually work, and if you had a lisp environment with enough memory, it would finish 
in about a day. But the real solution seems to be either to spot patterns so you don't have to generate and sort 
all 1 billion numbers, or to use the file system to cope with what your computer memory cannot. 

 "If the integers from 1 to 999,999,999 are written as words, sorted alphabetically, and concatenated, what is the 51 billionth letter?"

To be precise: if the integers from 1 to 999,999,999 are expressed in words
(omitting spaces, 'and', and punctuation[1]), and sorted alphabetically so that the first six integers are

    * eight
    * eighteen
    * eighteenmillion
    * eighteenmillioneight
    * eighteenmillioneighteen
    * eighteenmillioneighteenthousand

and the last is

    * twothousandtwohundredtwo

then reading top to bottom, left to right, the 28th letter completes the spelling of the integer "eighteenmillion".

The 51 billionth letter also completes the spelling of an integer. Which one, and what is the sum of all the integers to that point?

[1] For example, 911,610,034 is written "ninehundredelevenmillionsixhundredtenthousandthirtyfour"; 500,000,000 is written "fivehundredmillion"; 1,709 is written "onethousandsevenhundrednine".

|#

; (load (compile-file "wordnumbers.lisp"))
; (solve 999999999 51000000000) ; unlikely to finish unless you have a massive memory heap 
; (solve 10 26) ; will work, but may not get you the job ;-)

;;;; Utilities

(defmacro with-string-words((str word) &body body)
  "Utility macro to iterate over a string and return each word (anything between spaces)"
  `(do* ((start 0 (if end (1+ end) nil))
         (end
          (position #\Space ,str :start 0)
          (if end (position #\Space ,str :start (1+ end)) nil))
         (,word (subseq ,str start end) (if start (subseq ,str start end) nil)))
       ((null start))
     ,@body))

;;;; Numbers are stores as the number in words, the length of this string and finally the numeric value

(defun get-words(lst)
  (first lst))

(defun get-length(lst)
  (second lst))

(defun get-value(lst)
  (third lst))

(defun remove-and(str)
  "remove occurences of 'and' from a string"
  (let ((new-str (make-array 0 :element-type 'character :fill-pointer 0 :adjustable t)))
    (with-string-words (str word)
                (if (string/= "and" word)
                    (and
                     (setf new-str (concatenate 'string new-str word))
                     (setf new-str (concatenate 'string new-str " ")))))
    new-str))

(defun char-space-or-hyphen-p(c)
  (if (or (char= #\Space c) (char= #\- c))
      t
      nil))
  
(defun remove-spaces-and-hyphens(str)
  "remove spaces and hyphens from a string"
  (remove-if #'char-space-or-hyphen-p str))

(defun get-number-as-words(n)
  "Use common lisps built in English text number output"
  (format nil "~r" n))

(defun get-numbers-as-word-list(n)
  "get the numbers from 1 to n and return as a list of strings and the lengths"
  "of each string as a list of three items, words, length of word string and" 
  "actual numeric value"
  (loop for n from 1 to n collect
        (let* ((str (get-number-as-words n)) (len (length str)))
          (list (convert-text str) len n))))

(defun compare-word-and-len(a b)
  "given a string, length pair compare on alphabetical order"
  (string< (get-words a) (get-words b)))

(defun sort-number-word-list-alphabetically(lst)
  (sort lst #'compare-word-and-len))

(defun convert-text(str)
  (remove-spaces-and-hyphens (remove-and str)))

(defun get-number-from-letter-index(lst target-index)
  (do
   ((number 0 (1+ number))
    (index 0 (+ index (get-length (nth number lst)))))
   ((> number (1- (length lst))))
    (if (<= target-index (+ index (get-length (nth number lst))))
        (return-from get-number-from-letter-index number)))
  nil)

(defun sum-to-n(lst n)
  (if (>= n 0)
      (+ (get-value (car lst))
         (sum-to-n (cdr lst) (1- n)))
      0))

(defun solve(num n)
  "Solve the problem for 'num' numbers, finding character position n"
  (let ((lst
         (sort-number-word-list-alphabetically
          (get-numbers-as-word-list num))))
    (format t "Made list~%")
    (let ((number
           (get-number-from-letter-index lst n)))
      (format t "Found number~%")
      (let ((value (get-value (nth number lst))))
        (format t "Done.~%Number at character pos ~a is ~a. Sum to that number is ~a~%" n value (sum-to-n lst number))))))

Commenting out a block of C++ in emacs

2007-09-12T13:30:00.000-07:00

Here are couple more simple functions, used for commenting out a block of C++ code.

c++-comment-line below simple inserts "//" at the start of a line

c++-comment region will take the current region and run the c++comment-line on each line.


(defun c++-comment-region()
 "Comment a region out"
 (interactive)
 (save-excursion
   (save-restriction
     (narrow-to-region (point) (mark))
     (goto-char (point-min))
     (while (> (point-max) (point))
 (c++-comment-line)
 (forward-line)))))

(defun c++-comment-line()
 "Comment a line of C++ out"
 (beginning-of-line)
 (insert "//"))

Adding C++ class names to a function name

2007-09-11T08:44:00.000-07:00

I use this elisp code to add a C++ class name to a line such as:


void getNameRawString(char *string);

automatically becomes ...

void SomeClassName::getNameRawString(char *string);

This is useful as you can copy a bunch of class method definitions from a header file you've just created and then run this on each line to add the class names.

First I wrote a utility function that finds the function name, which is presumed to be letters and underscores, following space and ended with a bracket. The function name includes the word probably because it might not work depending on your formatting, but you can twiddle the regex to get what you want.

So as you can see this finds the match for the regex, which will place the point at the end of the search. Then I search backwards for a space which puts the point where we want to insert the class name and double colons...


(defun find-function-start-probably()
  (interactive)
  (re-search-forward " [*&_a-zA-Z]+(")
  (re-search-backward " ")
  (forward-char)
  (if (or
       (char-equal (char-after) ?*)
       (char-equal (char-after) ?&))
      (forward-char)))

Finally the function below calls find-function-start-probably. It prompts for the class name, finds the function and inserts the text. The program automatically aborts if there is no match. You can override that behavior by passing arguments to re-search-forward.


(defun classname-add(classname)                                                                   
    (interactive "sEnter class name: ")                                                           
    (find-function-start-probably)                                                                
    (insert classname)                                                                            
    (insert "::")                                                                                 
    (beginning-of-line)                                                                           
    (forward-line))

Improvements on the way:

Multi-line version: do this over multiple lines

Improvements unlikely but would be nice:

Parse the header file more intelligently and create all the class function definitions with empty function bodies in a specified buffer

Fixing up windows pathnames to use in cygwin

2007-09-07T16:46:00.000-07:00

I use emacs within Cygwin, and often I want to paste a pathname from an explorer window into emacs and use it there. Unfortunately you have to edit it by hand before it will work.

So for example a path like:

c:\code\haskell\cats\monkeys

Needs to be converted to:

/cygdrive/c/code/haskell/cats/monkeys

The following interactive elisp function does that with the currently selected text:


(defun win32-to-cygwin-path()
  "Converts a win32 path into a cygwin happy one"
  (interactive)
  (save-excursion
    (save-restriction
      (narrow-to-region (point) (mark))
      (goto-char (point-min))
      (insert "/cygdrive/")
      (goto-char (point-min))
      (while (search-forward ":" nil t)
        (replace-match "" nil t))
      (while (search-forward "\\" nil t)
        (replace-match "/" nil t)))))

Nothing much clever going on here, just two search and replaces for the slashes and to removed the colon, and I insert the cygdrive prefix.