Recent Content
9th European Lisp Symposium in Kraków
posted on 2016-05-11 10:37
The 9th European Lisp Symposium in Kraków has ended. It was my second ELS (first time I've attended it just a year before in London). It is really cool to spend some time and talk with so knowledgeable people. The European Lisp Symposium is a unique event because it gathers people from all around the world who are passionate about what they're doing. The mixture was astonishing – the university professors, professional programmers, individual hackers, visionaries, students.
I'm glad that I have met in person many people with whom I had only the contact over the internet. I've heard about various exciting projects and ideas either during the sessions and the breaks. I have even an autograph from miss Kathleen Callaway on my Lisp in Small Pieces book. I'm also very excited that this year there was a Clojure talk, which is a modern incarnation of the Lisp idea.
During the event I had a chance to stand in front of this "angry crowd" (actually crowd of a very nice people – I still was very stressed though) during my lightning talk. I was talking about my opinions on how the contributing to the Common Lisp ecosystem should look like, how people can get involved in a productive and efficient way.
Yesterday we were on a banquet which officially closed the symposium. The food was delicious and the company was great. The only thing is that it could last a little longer. In fact many of the attendees moved to some other place to continue the meeting. I've heard they've ended late in the night (or early in the morning). I was too sleepy, so I've left to my kind host's flat.
I want to thank all the organizers and speakers for the effort they've put to make the symposium happen. Michał Psota did a tremendous job as a local chair – he managed all the local stuff and it was all perfect, Irène Durand and Didier Verna were managing things very well – everything went very smooth and only a few people got shot during the lightning talks by Didier for exceeding the time frame. I hope that I'll be able to attend the next ELS which will probably take place in Brussels.
Kraklisp and hackerspace in Kraków
posted on 2016-05-03
During the last weekend I've been in Kraków to visit some friends. Since I know that there is a lisp group kraklisp on the Jagiellonian University and I know a few people in there (mainly from IRC channel #lisp-pl @ freenode), I've arrived in Kraków a bit earlier than I have originally planned to give a talk about the reader macros in Common Lisp. You may find it here (it's in polish):
Michał "phoe" Herda has met us on the bus station near the university buildings and lead us to the destination. Jagiellonian University has very beautiful buildings reminding these on Morasko in Poznań. When we've arrived at the destination we have entered KSI students association room, waited a few moments and started the workshops.
I was surprised that so many people arrived. Eleven people is a lot given that Common Lisp is considered a niche language. kraklisp brings together not only students but also lisp enthusiasts who work with Scala, Java, NetBSD and many other technologies outside the university. That's great to know, that we have an active group of lisp hackers here in Poland!
My talk took about an hour and from the feedback I infer it was just fine but the pace was a little too fast. People were actively listening and asking questions. That was fun. After me Jacek "TeMPOraL" Złydach lead a workshop about the web scrapping in Common Lisp. He has shown very nicely how to build programs interactively in the bottom-up manner. The video is available here (also in polish):
After the meeting the group has split and we have headed to the Hackerspace Kraków headquarters. Amazing place – group of people who tinker with the hardware and software in their free time. A lot of electronic devices, soldering irons, computers and boxes with an unknown content. We've chatted a little and we've learned about some nice projects they have developed – like a device mounted on your chest to locate objects in front of you. It has been created to help blind people to get around the room. Theirs location was in a little bustle, because they are currently moving to the new location. Hackerspace in Kraków is definitely worth seeing, and if feasible – cooperating with.
Finally we've moved to our stay due to the late hour (hackerspace is open 24h!). Kraków seems to be a great place to engage in a CS hobbies like programming and electronics or just to hang around with a smart people in general. I'm glad I'll arrive there again soon to attend the European Lisp Symposium.
Creating a project homepage with the SCLP
posted on 2016-04-22
Introduction
In this short tutorial I'll describe how to bootstrap easily a project website. In fact that's what I did today with the Embeddable Common-Lisp website in order to provide the RSS feed and make putting there the news easier.
Additionally I'm showing here, how to create a standalone executable
for coleslaw with clon after providing quicklisp independant
bundle of systems.
Quick start
First clone the repository:
$ cd /home/p/ecl
$ git clone https://gitlab.common-lisp.net/dkochmanski/sclp.git website
$ cd websiteNow you should adjust the appropriate files. Edit .coleslawrc (file
is self-explanatory), static pages and posts.
Each file with the extension *.page is a static
page. pages/main.page is an example template with a static page –
don't forget to link it in the .coleslawrc's sitenav
section. Exact URL of the page is declared in the file's header.
Files named *.post represent blog/news posts which appear in the RSS
feed. They are indexed and accessible from the root URL. Supported
file formats are markdown, html and cl-who (if enabled).
When you're done, you could just load coleslaw with your favorite CL
implementation, using Quicklisp load coleslaw and call the function
main on the website directory:
(ql:quickload 'coleslaw)
(coleslaw:main "/home/p/ecl/website/")We will take more ambitious road – we'll create a standalone executable with a proper command line arguments built from a clean bundle produced by Zach Beane's Quicklisp. CLI arguments will be handled by Clon – the Command-Line Options Nuker, an excellent deployment solution created by Didier Verna.
Creating the bundle
Bundle is a self-containing tree of systems packed with their
dependencies. It doesn't require internet access or Quicklisp and is
a preferred solution for the application deployment.
Some dependencies aren't correctly detected – Quicklisp can't
possibly know, that our plugin will depend on the cl-who system, and
it can't detect cl-unicode's requirement during the build phase –
flexi-streams (this is probably a bug). We have to mention these
systems explicitly.
Clon is added to enable the clonification (keep reading).
(ql:bundle-systems '(coleslaw flexi-streams
cl-who cl-fad
net.didierverna.clon)
:to #P"/tmp/clw")Clonifying the application
(in-package :cl-user)
(require "asdf")
(load "bundle")
(asdf:load-system :net.didierverna.clon)
(asdf:load-system :coleslaw)
(asdf:load-system :cl-fad)
(use-package :net.didierverna.clon)
(defsynopsis (:postfix "DIR*")
(text :contents "Application builds websites from provided directories.")
(flag :short-name "h" :long-name "help"
:description "Print this help and exit."))
(defun main ()
"Entry point for our standalone application."
(make-context)
(when (getopt :short-name "h")
(help)
(exit))
(print (remainder))
(handler-case (mapcar
#'(lambda (p)
(coleslaw:main
(cl-fad:pathname-as-directory p)))
(remainder))
(error (c) (format t "Generating website failed:~%~A" c)))
(terpri)
(exit))
(dump "coleslaw" main)You may generate the executable with sbcl and ccl (ecl has some
problems with the coleslaw dependency - esrap, I'm working on
it). I have used ccl, because it doesn't "derp" on the symbol exit
and produces slighly smaller executable than sbcl.
Issue the following in the bundle directory (/tmp/clw):
ccl -n -l clonify.lispThis command should create native executable named coleslaw in the
same directory. On my host ccl produces binary with the approximate
size 50M.
Executable usage
This is a very simple executable definition. You may extend it with new arguments, more elaborate help messages, even colors.
To generate a websites with sources in directories /tmp/a and
/tmp/b you call it as follows:
./coleslaw /tmp/a /tmp/bThat's all. Deployment destination is set in the .coleslawrc file in
each website directory.
Adding GIT hooks
You may configure a post-receive hook for your GIT repository, so your
website will be automatically regenerated on each commit. Let's
assume, that you have put the coleslaw standalone executable in
place accessible with the PATH environment variable. Enter your bare
git repository and create the file hooks/post-receive:
cd website.git
cat > hooks/post-receive <<EOF
########## CONFIGURATION VALUES ##########
TMP_GIT_CLONE=$HOME/tmp-my-website/
########## DON'T EDIT ANYTHING BELOW THIS LINE ##########
if cd `dirname "$0"`/..; then
GIT_REPO=`pwd`
cd $OLDPWD || exit 1
else
exit 1
fi
git clone $GIT_REPO $TMP_GIT_CLONE || exit 1
while read oldrev newrev refname; do
if [ $refname = "refs/heads/master" ]; then
echo -e "\n Master updated. Running coleslaw...\n"
coleslaw $TMP_GIT_CLONE
fi
done
rm -rf $TMP_GIT_CLONE
exit
EOFThat's all. Now, when you push to the master branch your website will
be regenerated. By default .gitignore file lists directory
static/files as ignored to avoid keeping binary files in the
repository. If you copy something to the static directory you will
have to run coleslaw by hand.
Conclusion
Coleslaw is a very nice project simplifying managing project website
with easy bootstrapping the site without any need to maintain working
lisp process on the server (this is static content which may be served
with nginx or apache) and allowing easy blogging (write a post in
markdown and push to the repository).
Sample Common-Lisp Project is a pre-configured website definition
with a theme inspired by the common-lisp.net projects themes with
some nice features, like RSS feed and blog engine (thanks to
coleslaw).
We have described the process of creating a simple website, creating a standalone executable (which may be shared by various users) and chaining it with git hooks.