A collection of coding snippets, tips, hints and random thoughts.
Developing clojure with Emacs Cider is great. To be able to view summaries for clojure functions and special forms, type this in you Cider REPL:
(use 'clojure.repl)
Afterwards, you can do stuff like this:
my.repl> (doc conj)
-------------------------
clojure.core/conj
([coll x] [coll x & xs])
conj[oin]. Returns a new collection with the xs
'added'. (conj nil item) returns (item). The 'addition' may
happen at different 'places' depending on the concrete type.
nil
Emacs has a great mode for using Clojure called Cider. Cider comes with an interactive REPL. The REPL allows you to test your code, start web apps, if you are using Luminus, and all in all accelerates development. One annoying thing though is that you have to refresh Cider every time you saved your sources. The good thing is that you can do this automatically. Just add the following to your init.el. I took the function from a blog post by Kris Jenkins:
(add-hook 'cider-mode-hook
'(lambda () (add-hook 'after-save-hook
'(lambda ()
(if (and (boundp 'cider-mode) cider-mode)
(cider-namespace-refresh)
)))))
(defun cider-namespace-refresh ()
(interactive)
(cider-interactive-eval
"(require 'clojure.tools.namespace.repl)
(clojure.tools.namespace.repl/refresh)"))
(define-key clojure-mode-map (kbd "C-c C-r") 'cider-namespace-refresh)
Additionally, you can now run the refresh command manually, by hitting C-c C-r.
Update: I changed the after-save-hook to only trigger if we are in a buffer that has cider-mode enabled. Otherwise every save command in Emacs would have triggered the refresh!
My goal here was to forward emails from my GMX freemail account to my iCloud account. Up until now, I used GMX’s own forwarding capability, which is a bit hidden in the filters settings. However, iCloud cranked up its spam filtering, and is now using spamhaus blacklists, which very often label the GMX forwarding servers as bad.
Hence I would only get bounce mails instead of the actual mails. Since this is no good, I set up fetchmail and msmtp on my root server to do the forwarding for me. First, fetchmail will get all mail on GMX via POP3 and pass it on to msmtp, which will in turn pass it on to the iCloud mx server.
At first I tried to deliver it via authenticated SMTP, but iCloud refuses mails sent this way, if the header from field does not contain any of your own iCloud aliases. This will most of the time be a problem, since we are trying to forward emails that were sent to you, not sent from you.
So first let’s see the ~/.fetchmailrc (make sure to chmod 0600 it):
poll pop.gmx.net
with proto POP3
user "user@gmx.net"
there with password "secretpassword"
mda "/usr/bin/msmtp -- someuser@icloud.com"
options
no keep
ssl
sslcertck
sslcertpath /etc/ssl/certs
set daemon 300
This will poll GMX every 300 seconds and pass the received mails to msmtp for delivery to someuser@icloud.com.
The corresponding ~/.msmtprc looks like this:
account default
host mx6.mail.icloud.com
port 25
auto_from off
from "user@localdomain"
tls on
tls_starttls on
tls_trust_file /etc/ssl/certs/ca-certificates.crt
logfile ~/.msmtp.log
domain mx.of.localdomain
You can find out the valid mx entries for iCloud by running nslookup -type=mx icloud.com.
The settings above are assuming Debian stable. Other distributions or operating systems may have the SSL certs at different places in the file system.
If you are implementing REST APIs, and are thinking about using application/json as your content type, please consider application/hal+json. It allows you to represent link relations and embedded resources in a standardized manner.
The content type offers three things:
As an example, you might have a programmable power strip with three sockets. The strip itself can be modeled as a resource. It will have three optionally embedded resources with the link relation sockets. These resources themselves will have a link relation called toggle. Doing e.g. a POST on this resource will allow you to toggle it. The lovely thing here is that the API will give you the correct URL to turn on or off the socket. An example request and response:
GET http://foo.com/powerstrip/1
Accept: application/hal+json
{
"_links" : {
"self" : { "href" : "http://somedomain/powerstrip/1" },
"sockets" : [
{ "href" : "http://somedomain/powerstrip/1/sockets/1", "name" : "Socket 1" },
{ "href" : "http://somedomain/powerstrip/1/sockets/1", "name" : "Socket 2" },
{ "href" : "http://somedomain/powerstrip/1/sockets/1", "name" : "Socket 3" }
]
},
"_embedded" : {
"sockets" : [
{
"_links" : {
"self" : { "href" : "http://somedomain/powerstrip/1/sockets/1" },
"toggle" : { "href" : "http://somedomain/powerstrip/1/sockets/1/off" }
}
"state" : "on"
},
{
"_links" : {
"self" : { "href" : "http://somedomain/powerstrip/1/sockets/2" },
"toggle" : { "href" : "http://somedomain/powerstrip/1/sockets/2/on" }
}
"state" : "off"
},
{
"_links" : {
"self" : { "href" : "http://somedomain/powerstrip/1/sockets/3" },
"toggle" : { "href" : "http://somedomain/powerstrip/1/sockets/3/on" }
}
"state" : "off"
}
]
},
"numberOfSockets" : 3,
"voltage" : 230
}
The content type is described in an RFC draft, and is well on its way to become a standard. Make sure to also read the associated web linking RFC.
Amazon is already using this content type in its AppStream API.
The strength of using link relations and a content type such as HAL is that you can actually document your link relations, which are a fundamental part of your API. You should actively design the link relations and make them meaningful.
For resources, I recommend that you document the following aspects:
For link relations you should document these aspects:
Given a CSV file with the following format:
;;firstname.lastname@somehost.com
The task is to extract the names from the email addresses. We assume that the names are seperated by periods (.) and that all the names are supposed to be capitalized and printed with strings:
#!/usr/bin/env python
import sys
if len( sys.argv ) < 2:
print "Usage: %s filename" % sys.argv[ 0 ]
sys.exit( 1 )
textFileName = sys.argv[ 1 ]
textFile = open( textFileName, "r" )
for line in textFile:
fields = line.strip().split( ';' )
email = fields[ 2 ].split( "@" )
emailName = email[ 0 ].split( '.' )
capitalizedName = [ x[:1].upper() + x[1:].lower() for x in emailName ]
print '%s;%s;%s' % ( capitalizedName[ 0 ], ' '.join( capitalizedName[ 1: ] ), fields[ 2 ] )
In the following I will explain on how you can backup your Pi’s SD-card, so that whenever it breaks down, you can simply restore the backup image to a fresh SD-Card. This may also help with tinkering, when you totally screwed up your Pi’s Linux-installation. I will explain the first step specifically for Mac OS X, but you can do this similarly on other UNIXes and Linux, by using the mount and umount commands.
So, shut down your Pi using the command sudo shutdown -h now and remove the SD-card after the Pi has done so. Take the card and insert it into your Mac’s SD-card slot.
First of all, we need to find out which disk device has been assigned to the card. We can do this with diskutil list:
Then unmount the card using diskutil unmountDisk:
Next we will use dd to produce an image, which we can compress using bzip2, or pbzip2 for more performance. You can use MacPorts to install pbzip2.
Restoring the image is also easy:
If your are using the excellent Emacs for Mac OS X distribution, you may have noticed that it does not use the environment you may have defined in your ~/.bashrc. This can be a problem if you are using MacPorts, for example to install clojure and Leiningen. You will get an error message like this, when trying to run inferior-lisp in clojure-mode:
apply: Searching for program: No such file or directory, lein
(when (memq window-system '(mac ns))
(exec-path-from-shell-initialize))
I use rsync a lot. And I use find a lot. You can use them both together, by using the magnificent xargs command. Two problems are there to solve: xargs usually just pastes the arguments from find at the end of the specified command. No way to specify the destination directory. Second, file names with spaces are a problem.
The solutions are:
So let’s put it together:
Thanks to redeyeblind for the insightful blog post.
A while back I pointed out a blog post by someone else, which described how to get C-left and C-right working in tmux and OS X. Now I noticed that I cannot resize windows in tmux. This is because tmux seems to expect xterm keys for C-arrow. The xterm keycodes for the arrow keys are:
I can now configure OS X terminal to send those key codes, and tmux works fine. However, other apps running in tmux will break, because they don’t expect to get xterm key codes. I found a workaround in the ArchWiki, which suggests to create your own terminfo entry. I will try that and report back here.
Update 3: And a very last update… It seems that tmux does not support bce (background color erase), which xterm does. This is a problem for progams like htop, vim, or mc. You will see rendering errors, if you do not fix this.
So you need to make your own terminfo file and own terminal type, called xterm-256color-nobce. You can do this on the command line:
This will create a new terminfo source file, which does not advertise the bce feature. You can install this with the following command:
This makes the terminal type xterm-256color-nobce available. After this, change your ~/.tmux.conf once again, to use the new terminal type per default:
Update 4: To make the Ctrl+Arrow keys also work in regular OS X Terminal, you need to edit or create ~/.inputrc to contain this:
The “1;” variant is otherwise not recognized by GNU readline on OS X.
There you should see your LAN device. Edit it to have an appropriate IP address from your local subnet. Most often your network will be 192.168.0.0 and your existing router will have the IP 192.168.1.1. But your mileage may vary…
Lets put in a static IP address, so we can find our router in case something goes wrong. Also make sure to set the netmask (in this case 255.255.255.0), gateway and DNS server (both probably should point to your router, 192.168.1.1).