An interesting recent review article (Wooster et al., "Animal cognition and culture mediate predator–prey interactions", Trends in Ecology & Evolution 2024) argues for bridging the academic silos of "predator-prey ecology" and "animal cognition and culture": Abstract: Predator–prey ecology and the study of animal cognition and culture have emerged as independent disciplines. Research combining these disciplines […]

A colleague, who has sometimes posted here as Bystander N, has sent me the following, asking me to put it on the blog. It is gratifying, and I hope that it is true.

• Tomorrow is a particularly sad day for my bench. I know Bystander and he had no idea I was going to

  write this short piece. Tomorrow he will be officially “past it”, though of course in reality nothing like

  past it and he is as sharp as they come.

  Both here on this blog and in our retiring rooms we will miss his kindness, warmth, immense

  knowledge, sense of fair play, sense of humour and seemingly endless stream of amusing court

  anecdotes.

  I have not always agreed with him on bail and sentence decisions but that’s the way the system

  works. I have learned a great deal from him and I am really sorry he will not be amongst us any

  longer. I have heard him say that he thinks he saw the best of the bench many years ago. He may

  be right but I’m still sure, even if he will not miss all of it, he will miss most of it.

I have just had a letter on lovely thick straw-coloured letterhead from the Royal Courts of Justice in which a Rt.Hon.Lord Justice thanks me for my 31 years' service on the bench. 

That's nice, and I shall pass it on to my granddaughters in due course. Both of their parents are solicitors. My impending third grandchild will have two journalists as parents, so that's nice too.

Prisons are in the news again, following recent outbreaks of disorder. This is an excellent piece from the Telegraph

I have been to Hollesley Bay a couple of times; it had a completely different culture from closed prisons such as the Scrubs, with a target of getting inmates ready for work on release.

British number one Zoe Gillings finishes sixth at the penultimate round of the boarder-cross World Cup in Valmalenco.

Well, it's been a busy summer writing-wise.  I'm letting a draft of a middle grade sci-fi adventure cure for a bit and also completed a work-for-hire project, and two-and-a-half nonfiction projects. (The half is still in-progress :-)).

Circa 1995.  No hills :-).

After the Cap Tex Tri weather debacle, I reconsidered my original plan to try the Austin Half-Ironman (or Ironman 70.3 as they're calling the things these days).   I'd wanted to do a couple Olympic distance races this summer (the other would've been the Tri Rock Austin Triathlon over Labor Day weekend) to get the kinks out before going for the longer distance.

Unfortunately, the schedule didn't quite work out (and I'm going to be doing some school and bookstore visits in October, prime training time :-)).  Also, this allows me to delay buying a new bike -- my current one is a 1989 Trek that is fine, but riding 50+ miles around the Hill Country, I can see where handlebar shifters would be useful :-).

So I decided to dive back in to the Austin Distance Challenge and take up the Austin Runners Club on the marathon training (which would also help with next year's triathlons).  My goal is a personal best or possibly Boston Marathon qualifying. (With the age-group corrections, BM qualifying has finally caught up with my PB :-)).

The ARC program is based on the Runner's World "Run Less, Run Faster" program, which has you run three days a week and do other cardio work two days a week.  One of the days is a track workout, one is a tempo run and the third is a long run, with pace times based on a one mile time trial we did a couple weeks ago. I have no idea if it will work, but I like it because I want to keep up the biking and running as well.

After the long run

I just completed the first week of the program and didn't actually hit any of my goal times, but I've never actually tried running for time, so at least the effort is interesting.  I ran a trial mile of 7:10, slightly slower than my 6:50 from last spring and a lot slower than my PB of 5:55 (granted, twenty years ago :-)).

From this, the track workout was supposed to be 4x1000 m at 4:09; my times were 4:20; 4:14; 4:15; and 4:22, so not terrible.  The tempo workout was supposed to be 4 miles at a 7:38 pace and my actual pace was 7:46. I figured it would be a challenge to hit those marks but was glad to have been close.  

The long run was supposed to be 11 miles at 8:57, which I though I could do, no problem, since I'd done my half marathons last year at around 8:24.  But with the humidity and heat (in August, hydration tends to be my biggest problem) and having only three hours of sleep (due to small feline mammals), I only did seven miles at a 9:07 pace.

Based on limited data, I like the program because it's not just about racking up mileage, which was getting a bit old. Also, the track workouts are not far from where I live :-). 

Anyway, I'm looking forward to the challenge of a new marathon best time, at the 2017 Austin Marathon!

Setting my PB on a wintry spring day

    



 

I'm a bit late this year, but here is a preliminary listing of books written and illustrated by Austinites with releases in 2017!  Note that publication dates may change and/or slip...

For books from earlier years, go here.

Picture Books

BOOK OR BELL, by Chris Barton, ill. by Ashley Spires (Bloomsbury 2017).

MIGHTY TRUCK: MUDDY MANIA, by Chris Barton, ill. by Troy Cummings (HarperCollins 2017).

DAZZLE SHIPS: WORLD WAR I AND THE ART OF CONFUSION,  by Chris Barton, ill. by Victo Ngai (Millbrook 2017).

 WHY AM I ME?, by Paige Britt, ill. by Sean Qualls & Selina Alko (Scholastic Press, Sept. 2017).
 
WHOBERT WHOVER, OWL DETECTIVE, by Jason Gallaher (@DraftingJason), ill. by Jess Pauwels (Margaret McElderry Books/Simon & Schuster, July 2017).
 
 CINNAMON, by Neil Gaiman, ill. by Divya Srinivasan (HarperCollins, May 2017).

THE YOUNGEST MARCHER; THE STORY OF AUDREY MAY HENDRICKS, A YOUNG CIVIL RIGHTS ACTIVIST, by Cynthia Levinson (Atheneum/Simon & Schuster 2017)

BOB, NOT BOB, by Liz Garton Scanlon, ill. by Audrey Vernick (Disney Hyperion, Winter 2017)

ANOTHER WAY TO CLIMB A TREE, by Liz Garton Scanlon, ill. by Hadley Hooper (Neal Porter Books/Roaring Brook Press, Aug. 2017).

STRONG AS SANDOW: HOW EUGEN SANDOW BECAME THE STRONGEST MAN ON EARTH, by Don Tate (Charlesbridge, Aug. 2017).

WHAT THIS STORY NEEDS IS A BANG AND A CLANG, by Emma Virjan (HarperCollins 2017).

Middle Grade/Tween

THE GREAT HIBERNATION, by Tara Dairman (Wendy Lamb Books/Random House, September 2017).

GNOMEAGEDDON, by K.A. Holt (McElderry Book/S&S, Fall 2017)

TUT: MY EPIC BATTLE TO SAVE THE WORLD, by P.J. Hoover (Tor 2017).

FAULT LINES IN THE CONSTITUTION: THE FRAMERS, THEIR FIGHTS, AND THE FLAWS THAT AFFECT US TODAY, by Cynthia Levinson and Sanford Levinson (Peachtree 2017).

IF THE SHOE FITS, by Mari Mancusi (Aladdin/Simon & Schuster, Fall 2017).

IN A DARK LAND, by Christina Soontornvat (Sourcebooks 2017).

REVENGE OF THE HAPPY CAMPERS, by Jennifer Ziegler (Scholastic 2017).


Young Adult

THIS IS NOT THE END, by Chandler Baker (Disney-Hyperion, Aug. 2017).

WITCHTOWN, by Cory Putnam Oakes (Houghton Mifflin Harcourt, Oct. 2017).

THE SANDCASTLE EMPIRE, by Kayla Olson (HarperTeen 2017).

AVENGED, by Amy Tintera (HarperTeen May 2017).

Never actually saw anyone on a horse

So after having completed my first triathlon in 20 years, I decided to sign up for the Austin Ironman 70.3 on October 29! It's a "half Ironman" distance race, meaning it's a 1.2 mile swim, a 56 mile bike, and a 13.1 mile run. I figured the swim's only a little longer than an Olympic distance tri and the bike and the run are only about twice the distance, so why not?

Even better, the race was just outside Austin, so I wouldn't have to travel. The swim was in Decker Lake (Walter E. Long Lake), the bike was a 56 mile loop almost out to Elgin, and the run would be in the park by the lake and up to the Travis County Convention Center.  I was a little concerned about the hills (having run the Decker Challenge Half Marathon more than once) but decided that that was what training was for.

That started in June, not long after the Capital of Texas Triathlon. Yes, training would be through the height of a Texas summer.  And every time I went out, I would remember Noel Coward's line that "[m]ad dogs and Englishmen go out in the mid-day sun..."

My training program was based Triathlete Magazine's Week by Week Training Guide and involved nine workouts a week. I didn't completely adhere to all of the mileage suggestions (some weeks doing more, some less), but mostly kept to the program of two a days.  

By early August, the mileage was starting to pile up but it didn't seem particularly efficient (and also was getting a little tedious), so I decided to join the triathlon training/masters swim group at Pure Austin Gym and, really, it was the best decision I made in the entire process.  The awesome Coach Peri Kowal leads two swim workouts a week, mostly in a pool but also including two a month in the Quarry Lake, so participants can get used to open water swimming. (Also, during the summer, the gym does a Splash N Dash (Swim 750k, then run 2k) once a month; it's good practice for the whole "group of people in the water, don't get kicked in the face" thing).

Quarry Lake

Somewhat to my surprise, the group was a mix from beginning triathletes to multiple Ironman (and Kona) finishers.  Everyone was enthusiastic and supportive, even when insufficiently caffeinated during the Thursday morning (6 AM) workouts.

Insufficiently caffeinated

Best of all, there were a number of folks for whom the Austin Ironman 70.3 was to be their first half Ironman, as well, so we fell into an ad hoc training group of the equally blissfully ignorant, typically doing our long bike rides and BRicks together on weekend mornings. It was great having a mutual support group and not just when we got flat tires...(Incidentally, if you get a flat in Texas, watch out for fire ants).

Anyway, here are some pics of the process:

Training happens even when you're away on business

Igloo coolers are our friends!

Monkey Road really needs to be resurfaced

Don't drive off with your cell phone on the roof of your car

The gang poses after a long BRick

Starting the run after a 40 mile bike ride...

Kevin and Alec hamming it up...

My first shoes to come with an instruction manual

Celebrating Coach Peri's birthday!

Sights you see along Town Lake

More sights...

About to test out a wetsuit

Went through a lot of these...

Feeling punchy three days before the race...

On the whole, training took a lot of time and work and there were moments in early October when I was really ready for race day to arrive. OTOH, I'm also happy I had that extra three weeks of training....

In the end, I was really glad to have been able to do race-distance open-water swims in the Quarry Lake and to bike the race route. I think we ended up riding the route about 5-7 times altogether and it was helpful not just for putting in mileage but in learning where the potholes and seams were. Also, the BRick workouts were really helpful -- when I had done triathlons in the 90s, the bike to run transition was always terrible. This time, not so much...but that's for another post :-).

I finished training feeling cautiously optimistic -- I'd put in the time and the mileage and the BRicks and the intensity and worked out my nutrition and hydration requirements and figured out how to change a flat tire without getting bit by fire ants in under ten minutes.  We had generally accounted for every possible variable and had kept in mind the mantra, "Don't try anything new on race day."

Except that having trained through blistering heat and humidity of Texas in the summer and fall, the weather was forecast to be 39 degrees at race start... 
















So, how did that go? Well, I'll do Race Day Weekend in another post...

How the inclusion of Katie Taylor v Amanda Serrano on the bill legitimises the carnival of Mike Tyson v Jake Paul in Texas

 I couldn't believe my luck at the Other Partizan show last Sunday, I actually got to meet Kevin Calder, the creator of the Bonnie Blue Flag rules.

I first saw the Iron Brigade banner and followed it down to reveal an actual BBF game being played. I recognised Kevin instantly and shook his hand. I gushed about his rules and told him how much I like them. I also explained about play testing it a month ago and he said he had seen the post, which was nice. It was only a quick hello as I had to race back to my own game.

I would have liked to have talked for longer and ask him lots of nerdy questions, like how to adapt them for AWI etc. still, I'm sure I'll bump into him again.

 Here are the unit sizes in Muskets and Tomahawks that are good to see as a guide. All just early days still just throwing ideas around to see if something sticks.

Drilled Vs irregular base.I decided to go with 60x60mm bases to give a more spread out look. Also these Galloping Major figures are quite large for 28mm so it suits them better.

 

I'm a sucker for sage advice much as anyone else, and Kernighan is certainly right on money in the epigraph. Alas there comes a time in programmer's career when you just end up there despite the warning. It could be that you were indeed too clever for your own good, or maybe the code isn't quite yours anymore after each of your colleague's take on it over the years. Or just sometimes, the problem is indeed so hard that it strains your capacity as a coder.

It would usually start with a reasonable idea made into first iteration code. The solution looks fundamentally sound but then as you explore the problem space further it begins to seep nuance, either as manifestation of some real world complexity or your lack of foresight. When I run into this my first instinct is to instrument the code. If the problem is formidable you got to respect it: flailing around blindly modifying things or ugh, doing a rewrite at this stage is almost guaranteed to be a waste of time. It helps to find a promising spot, chisel it, gain a foothold in the problem, and repeat until you crack it. Comfortable debugging tools here can really help to erode the original Kernighan coefficient from 2 to maybe 1.6 or 1.4 where you can still have a chance.

Lisp users are fortunate with the options of interactive debugging, and one facility I reach often for is the plain BREAK. It's easy enough to wrap it into a conditional for particular matches you want to debug. However sometimes you want it to trigger after a particular sequence of events across different positions in code has taken place. While still doable it quickly becomes cumbersome and this state machine starts to occupy too much mental space which is already scarce. So one day, partly as a displacement activity from being intimidated by a Really Hard Problem I wrote down my debugging patterns as a handful of macros.

Enter BRAKE. Its features reflect my personal preferences so are not necessarily your cup of tea but it could be a starting point to explore in this direction. Things it can do:

• act as a simple BREAK with no arguments (duh)
• wrap an s-expression, passing through its values upon continuing
• trigger sequentially based on the specified position for a common tag
• allow for marks that don't trigger the break but mark the position as reached
• provide conditional versions for the expressions above
• print traces of tagged breakpoints/marks

If you compile functions with debug on you hopefully should be able to see the wrapped sexpr's result values.

(use-package '(brake))

(defun fizzbuzz ()
  (loop for n from 100 downto 0
	for fizz = (zerop (mod n 3))
	for buzz = (zerop (mod n 5)) do
	(format t "~a "
		(if (not (or fizz buzz))
		    (format nil "~d" n)
		  (brake-when (= n 0)
			      (concatenate 'string
					   (if fizz "Fizz" "")
					   (if buzz "Buzz" "")))))))

These macros try to detect common cases for tagged sequences being either aborted via break or completed to the last step, resetting them after to the initial state. However it is possible for a sequence to end up "abandoned", which can be cleaned up by a manual command.

Say in the example below we want to break when the two first branches were triggered in a specific order. The sequence of 1, 3, 4 will reinitialize once the state 4 is reached, allowing to trigger continuously. At the same time if we blow our stack it should reset to initial when aborting.

(defun ack (m n)
  (cond ((zerop m) (mark :ack 3 (1+ n)))
        ((zerop n) (mark :ack 1 (ack (1- m) 1)))
        (t (brake :ack 4 (ack (1- m) (ack m (1- n)))))))

In addition there are a few utility functions to report on the state of brakepoints, enable or disable brakes based on tags and turn tracing on or off. Tracing isn't meant to replace the semantics of TRACE but to provide a souped up version of debug by print statements everyone loves.

CL-USER> (report-brakes)
Tag :M is DISABLED, traced, with 3 defined steps, current state is initial
Tag :F is DISABLED with 2 defined steps, current state is 0
Tag :ACK is ENABLED with 3 defined steps, current state is initial

Disabling breakpoints without recompilation is really handy and something I find using all the time. The ability to wrap a sexpr was often sorely missed when using BREAK in constructs without implicit body.

Sequencing across threads is sketchy as the code isn't guarded but in many cases it can work, and the appeal of it in debugging races is clear. One of those days I hope to make it more robust while avoiding potential deadlocks but it isn't there yet. Where it already shines tho is in debugging complex iterations, mutually recursive functions and state machines.

Earlier this year, I started working through the online book Ray Tracing In One Weekend (Book 1). I have been following along with it in Common Lisp, and I have been extending it all from 3-dimensional to n-dimensional.

I reproduced 4-dimensional versions of all of the book images which you can see on my weekend-raytracer github page.

Here is the final image. This is a 250-samples-per-pixel, 640x360x10 image plane of three large hyperspheres (one mirrored, one diffuse, one glass) atop a very large, diffuse hypersphere. Also atop this very large hypersphere are a bunch of smaller hyperspheres of varying colors and materials. The image is rendered with some defocus-blur.

Final image of 4-dimensional scene

Caveat: This depends on a patched version of the policy-cond library that is not in the current Quicklisp distribution but should be in the next.

Last week I finished a new service written in Common Lisp. It now runs in production© every mornings, and it expands the set of services I offer to clients.

It’s the 4th service of this kind that I developed: - they are not big - but have to be done nonetheless, and the quicker the better (they each amount to 1k to 2k lines of Lisp code), - they are not part of a super advanced domain that requires Common Lisp superpowers - I am the one who benefits from CL during development, - I could have written them in Python - and conversely nothing prevented me from writing them in Common Lisp.

So here lies the goal of this post: illustrate that you don’t need to need a super difficult problem to use Common Lisp. This has been asked many times, directly to me or on social media :)

At the same time, I want to encourage you to write a little something about how you use Common Lisp in the real world. Sharing creates emulation. Do it! If you don’t have a blog you can simply write in a new GitHub repository or in a Gist and come share on /r/lisp. We don’t care. Thanks <3

We’ll briefly see what my scripts do, what libraries I use, how I deploy them, what I did along the way.

Needless to say that I dogfooded my CIEL (beta) meta-library and scripting tool for all those projects.

Table of Contents

• Scripts n°4 and 2 - shaping and sending data - when you can write Lisp on the side
  • SFTP
  • Deploying
  • Script n°2 and simple FTP
• Scripts n°3 and 1 - complementary web apps
• Lasting words
• Links

Scripts n°4 and 2 - shaping and sending data - when you can write Lisp on the side

My latest script needs to read data from a DB, format what’s necessary according to specifications, and send the result by SFTP.

In this case I read a DB that I own, created by a software that I develop and host. So I could have developed this script in the software itself, right? I could have, but I would have been tied to the main project’s versioning scheme, quirks, and deployment. I rather had to write this script on the side. And since it can be done on the side, it can be done in Common Lisp.

I have to extract products and their data (price, VAT...), aggregate the numbers for each day, write this to a file, according to a specification.

To read the DB, I used cl-dbi. I didn’t format the SQL with SxQL this time like in my web apps (where I use the Mito light ORM), but I wrote SQL directly. I’m spoiled by the Django ORM (which has its idiosyncrasies and shortcomings), so I double checked the different kinds of JOINs and all went well.

I had to group rows by some properties, so it was a great time to use serapeum:assort. I left you an example here: https://dev.to/vindarel/common-lisps-group-by-is-serapeumassort-32ma

Dates have to be handled in different formats. I used local-time of course, and I still greatly appreciate its lispy formatter syntax:

(defun date-yymmddhhnnss (&optional date stream)
  (local-time:format-timestring stream
                                (or date (local-time:now))
                                :format
                                '((:year 4)
                                  (:month 2)
                                  (:day 2)
                                  (:hour 2)
                                  (:min 2)
                                  (:sec 2)
                                  )))

the 2 in (:month 2) is to ensure the month is written with 2 digits.

Once the file is written, I have to send it to a SFTP server, with the client’s codes.

I wrote a profile class to encapsulate the client’s data as well as some functions to read the credentials from either environment variables, the file system, or a lisp variable. I had a top-level profile object for ease of testing, but I made sure that my functions formatting or sending data required a profile parameter.

(defun send-stock (profile &key date) ...)
(defun write-stock (profile filename) ...)

Still nothing surprising, but it’s tempting to only use global parameters for a one-off script. Except the program grows and you pay the mess later.

SFTP

To send the result through SFTP, I had to make a choice. The SFTP command line doesn’t make it possible to give a password as argument (or via an environment variable, etc). So I use lftp (in Debian repositories) that allows to do that. In the end, we format a command like this:

lftp sftp://user:****@host  -e "CD I/; put local-file.name; bye"

You can format the command string and run it with uiop:run-program: no problem, but I took the opportunity to release another utility:

• https://github.com/vindarel/lftp-wrapper

First, you create a profile object. This one-liner reads the credentials from a lispy file:

(defvar profile (make-profile-from-plist (uiop:read-file-form "CREDS.lisp-expr"))

then you define the commands you’ll want to run:

(defvar command (put :cd "I/" :local-filename "data.csv"))
;; #<PUT cd: "I/", filename: "data.csv" {1007153883}>

and finally you call the run method on a profile and a command. Tada.

Deploying

Build a binary the classic way (it’s all on the Cookbook), send it to your server, run it.

(during a testing phase I have deployed “as a script”, from sources, which is a bit quicker to pull changes and try again on the server)

Set up a CRON job.

No Python virtual env to activate in the CRON environment...

Add command line arguments the easy way or with the library of your choice (I like Clingon).

Script n°2 and simple FTP

My script #2 at the time was similar and simpler. I extract the same products but only take their quantities, and I assemble lines like

EXTRACTION STOCK DU 11/04/2008
....978202019116600010000001387
....978270730656200040000000991

For this service, we have to send the file to a simple FTP server.

We have a pure Lisp library for FTP (and not SFTP) which works very well, cl-ftp.

It’s a typical example of an old library that didn’t receive any update in years and so that looks abandoned, that has seldom documentation but whose usage is easy to infer, and that does its job as requested.

For example we do this to send a file:

(ftp:with-ftp-connection (conn :hostname hostname
                                   :username username
                                   :password password
                                   :passive-ftp-p t)
      (ftp:store-file conn local-filename filename))

I left you notes about cl-ftp and my SFTP wrapper here:

• https://dev.to/vindarel/ftp-and-sftp-clients-for-common-lisp-1c3b

Scripts n°3 and n°1 - specialized web apps

A recent web app that I’m testing with a couple clients extends an existing stock management system.

This one also was done in order to avoid a Python monolith. I still needed additions in the Python main software, but this little app can be independent and grow on its own. The app maintains its state and communicates it with a REST API.

 

It gives a web interface to their clients (so my clients’ clients, but not all of them, only the institutional) so that they can:

• search for products
• add them in shopping carts
• validate the cart, which sends the data to the main software and notifies the owner, who will work on them.

The peculiarities of this app are that:

• there is no user login, we use unique URLs with UUIDs in the form: http://command.client.com/admin-E9DFOO82-R2D2-007/list?id=1
• I need a bit of file persistence but I didn’t want the rigidity of a database so I am using the clache library. Here also, not a great activity, but it works©. I persist lists and hash-tables. Now that the needs grow and the original scope doesn’t cut it any more, I wonder how long I’ll survive without a DB. Only for its short SQL queries VS lisp code to filter data.

I deploy a self-contained binary: code + html templates in the same binary (+ the implementation, the web server, the debugger...), with Systemd.

I wrote more on how to ship a standalone binary with templates and static assets with Djula templates here:

• https://lisp-journey.gitlab.io/blog/lisp-for-the-web-build-standalone-binaries-foreign-libraries-templates-static-assets/

I can connect to the running app with a Swank server to check and set parameters, which is super helpful and harmless.

It is possible to reload the whole app from within itself and I did it with no hiccups for a couple years, but it isn’t necessary the most reliable, easiest to set up and fastest method. You can do it, but nobody forces you to do this because you are running CL in production. You can use the industry’s boring and best practices too. Common Lisp doesn’t inforce a “big ball of mud” approach. Develop locally, use Git, use a CI, deploy a binary...

Every thing that I learned I documented it along the way in the Cookbook ;)

Another app that I’ll mention but about which I also wrote earlier is my first web app. This one is open-source. It still runs :)

 

In this project I had my friend and colleague contribute five lines of Lisp code to add a theme switcher in the backend that would help him do the frontend. He had never written a line of Lisp before. Of course, he did so by looking at my existing code to learn the existing functions at hand, and he could do it because the project was easy to install and run.

(defun get-template(template &optional (theme *theme*))
  "Loads template from the base templates directory or from the given theme templates directory if it exists."
  (if (and (str:non-blank-string-p theme)
           (probe-file (asdf:system-relative-pathname "abstock" (str:concat "src/templates/themes/" theme "/" template))))
      ;; then
      (str:concat "themes/" theme "/" template)
      ;; else :D
      template))

He had to annotate the if branches :] This passed the code review.

Lasting words

The 5th script/app is already on the way, and the next ones are awaiting that I open their .docx specification files. This one was a bit harder but the Lisp side was done sucessfully with the efficient collaboration of another freelance lisper (Kevin to not name him).

All those tasks (read a DB, transform data...) are very mundane.

They are everywhere. They don’t always need supercharged web framework or integrations.

You have plenty of opportunities to make yourself a favor, and use Common Lisp in the wild. Not counting the super-advanced domains where Lisp excels at ;)

---

Links

• https://lispcookbook.github.io/cl-cookbook/
• awesome-cl
• companies using Common Lisp in production (at least the ones we know)
• Common Lisp course in videos – it helps me, and you ;) I added 9 videos about CLOS last month, and more are coming. It’s 86 minutes of an efficient code-first approach, out of 7+ hours of total content in the course. After this chapter you know enough to read the sources of the Hunchentoot web server or of the Kandria game.

I have done some preliminary Common Lisp exploration prior to this course but had a lot of questions regarding practical use and development workflows. This course was amazing for this! I learned a lot of useful techniques for actually writing the code in Emacs, as well as conversational explanations of concepts that had previously confused me in text-heavy resources. Please keep up the good work and continue with this line of topics, it is well worth the price! [Preston, October of 2024]

.

 

 

CONTINUED TOMORROW.

 

Above: Every Autumn, I write a Halloween story, write it out on leaves (one word per leaf), photograph the leaves, and then leave them where.I found them. The story is then serialized, starting on October 1 and concluding on the 31st--All Souls Day.

 

 .

 

 

 

CONTINUED TOMORROW.

 

Above: Every Autumn, I write a Halloween story, write it out on leaves (one word per leaf), photograph the leaves, and then leave them where.I found them. The story is then serialized, starting on October 1 and concluding on the 31st--All Souls Day.

 

.

 

 

CONTINUED TOMORROW.

 

Above: Every Autumn, I write a Halloween story, write it out on leaves (one word per leaf), photograph the leaves, and then leave them where.I found them. The story is then serialized, starting on October 1 and concluding on the 31st--All Souls Day.

 

 

.

 

 

CONTINUED TOMORROW.

 

Above: Every Autumn, I write a Halloween story, write it out on leaves (one word per leaf), photograph the leaves, and then leave them where.I found them. The story is then serialized, starting on October 1 and concluding on the 31st--All Souls Day.

 

 

 

.

 

 

CONTINUED TOMORROW.

 

Above: Every Autumn, I write a Halloween story, write it out on leaves (one word per leaf), photograph the leaves, and then leave them where.I found them. The story is then serialized, starting on October 1 and concluding on the 31st--All Souls Day.

 

 

 

.

 

 

CONTINUED TOMORROW.

 

Above: Every Autumn, I write a Halloween story, write it out on leaves (one word per leaf), photograph the leaves, and then leave them where.I found them. The story is then serialized, starting on October 1 and concluding on the 31st--All Souls Day.

 

 

.

  

 

 

 

CONTINUED TOMORROW.

 

Above: Every Autumn, I write a Halloween story, write it out on leaves (one word per leaf), photograph the leaves, and then leave them where.I found them. The story is then serialized, starting on October 1 and concluding on the 31st--All Souls Day.