Posts on Joe k Bullard

Blackjack with Clojure - Part 2

Wed, 23 Jul 2025 21:44:28 +0100

This is the second of two posts using Clojure to make a simple blackjack program, in the previous post we made a hand, deck and a way to get the face value of the card. We will build on this to include scoring and the actual game logic.

Building on where we finished last time, getting the value of individual cards, we will make a function to get the score of multiple cards. The easiest way to do this is to use our get-value function with map and then reduce to get the combined total:

Blackjack with Clojure - Part 1

Sun, 20 Jul 2025 21:10:11 +0100

One of the first small projects I like to do when learning a new language is to model a deck of cards. It’s a good way to familiarise yourself with the basics of language, such as data structures and flow control, once you have a functioning card deck you can take it a step further and model a game like poker or blackjack. As part of my Clojure learning, I have been playing around a bit and thought it would be fun to model the card game blackjack.

TIL about threading in Clojure

Tue, 10 Jun 2025 21:23:28 +0100

Clojure has an incredble range of functions and macros in its core library - just look at them all! While I don’t expect to ever learn them all by heart, there are some that I’ve figured are important for shaping how you breakdown a problem with Clojure. I’ve particularly enjoyed improving my understanding of the threading macros -> and ->> (There are others, such as some->, but I’m yet to use them myself).

TIL how to use Java spatial libraries in Clojure

Mon, 09 Jun 2025 21:39:16 +0100

Being able to utilise Java libraries through interop is a really powerful Clojure feature. One such example that I’ve been using recently is Geotools, a geospatial library - specifically, I have been usign it to create and write to a GeoPackage.. This post will quickly run through the basics of accessing Java libraries through Clojure - this will be followed by another post showing how to use this library to create a GeoPackage.

TIL how to destructure with clojure

Sun, 08 Jun 2025 21:17:51 +0100

This isn’t strictly a “TIL” but it seemed like a good place to start as I’ve recently started learning Clojure for a work project. Compared to a language like Python the syntax is radically different, most code written in Clojure comes in what is known as a form - a statement contained within parentheses, for example:

(+ 2 (* 2 2)) 
;; 6

One aspect I’ve found particularly challenging is the syntax around destructuring of maps and vectors within a let form. let is what is known as a special form and is used to bind a data structure to a symbol that is usable within the scope of the let form. For example:

Day 16 - Oceania

Wed, 15 Nov 2023 22:31:46 +0000

It is often said that Perth is one of the most isolated cities on the planet, indeed Wikipedia mentions the following:

With more than two million residents, Perth is one of the most isolated major cities in the world. The nearest city with a population of more than 100,000 is Adelaide, over 2,100 km (1,305 mi) away. Perth is geographically closer to both East Timor (2,800 km or 1,700 mi), and Jakarta, Indonesia (3,000 km or 1,900 mi), than to Sydney (3,300 km or 2,100 mi).

Day 11 - Retro

Sat, 11 Nov 2023 10:58:41 +0000

This one makes use of the brilliant prettymaps library by Marcelo Prates. This library makes it incredibly simple to create aesthetically pleasing maps using Open Street Map data.

import prettymaps
from matplotlib.font_manager import FontProperties
import matplotlib.pyplot as plt

plot = prettymaps.plot(
    'Cabot Tower, Bristol, United Kingdom', 
    preset='macao',
    credit={
        'text':"data © OpenStreetMap contributors",
        'y': 0
    }
)

plot.fig.patch.set_facecolor('#F2F4CB')
# Add title
plot.ax.set_title(
    'Bristol',
    fontproperties = FontProperties(
        fname = 'BrightFont.otf',
        size = 70
    )
)

plt.show()

Day 10 - North America

Fri, 10 Nov 2023 09:47:30 +0000

Pretty simple one for today, NBN occurence records of one of the most notorious of US imports, the Eastern Grey Squirrel. As is often the case with biological records, the data is heavily skewed by survey effort. This is the first time I’ve used the Datashader library, it’s a useful visualisation tool when working with large datasets that would be impractical to plot as vectors. It works with plotly as below but seems easier to use with GeoViews/HoloViews and Bokeh. A key thing to consider when working with Plotly mapbox plots is that the coordinates must be in 4326, but you need to reproject to avoid projection distotion, hence why the script below chops between 3857 and 4326.

Day 4 - A bad map

Sun, 05 Nov 2023 22:43:36 +0000

Not the finest of creations, but I guess that’s the point. Pretty simple really, this map shows the location of all villages/towns/cities that are named “Bad”. For a reason I can’t quite figure out, Switzerland seems to be the baddest of them all.

import geopandas as gpd
import plotly.express as px
import requests
from shapely.geometry import Point

overpass_url = "http://overpass-api.de/api/interpreter"
overpass_query = """
[out:json];
(
  node["place"="city"]["name"~"^Bad$"];
  node["place"="town"]["name"~"^Bad$"];
  node["place"="village"]["name"~"^Bad$"];
  node["place"="hamlet"]["name"~"^Bad$"];
  node["place"="isolated_dwelling"]["name"~"^Bad$"];
);
out center;
"""
response = requests.get(overpass_url, 
                        params={'data': overpass_query})
data = response.json()

# Collect coords into list
d = {"name": [], "type": [], "geometry": []}
for element in data["elements"]:
    if element["type"] == "node":
        lon = element["lon"]
        lat = element["lat"]
        name = element["tags"]["name"]
        settlement_type = element["tags"]["place"]

    elif "center" in element:
        lon = element["center"]["lon"]
        lat = element["center"]["lat"]

    d["name"].append(name)
    d["type"].append(settlement_type)
    d["geometry"].append(Point(lon, lat))


gdf = gpd.GeoDataFrame(d, crs="EPSG:4326")
  
lat = float(gdf.dissolve().centroid.y.iloc[0])
lon = float(gdf.dissolve().centroid.x.iloc[0])

fig = px.scatter_mapbox(
    gdf,
    lat=gdf.geometry.y,
    lon=gdf.geometry.x,
    center=dict(lat=lat, lon=lon),
    zoom=2,
    opacity=0.6,
    hover_data=["name", "type"],
    mapbox_style="carto-darkmatter",
    width=600,
    height=400,
)

fig.update_layout(
    margin={"r": 0, "t": 0, "l": 0, "b": 0},
)

fig.show()

Using docker with Gdal

Sun, 23 Jul 2023 22:32:05 +0100

Note - this assumes you have docker installed and are broadly familiar with using it from the command line.

Anyone who works with GIS will be familiar with the Geospatial Data Abstraction Library, or GDAL as it’s more commonly know. It’s the swiss army knife of GIS tools - allowing users to read, write and convert between numerous raster and vector formats. For those who aren’t familiar there are plenty of resources around that give an introduction, a good place to start is the official GDAL tutorial page.

An Intro to Geopackage

Thu, 23 Mar 2023 08:32:20 +0000

Geopackage is a format that will be familiar to many who work with spatial data, particularly those that use QGIS. In the majority of use cases it will be treated as little more than a shapefile replacement - i.e. a means to manage and share vector data. But what if I told you that by using a geopackage you could have access to a whole range of additional features and functionality more typically associated with a relational database management system (RDMS) like PostgreSQL/PostGIS? In this three part series we will go on a deep dive into some of the finer details of geopackage - but first lets start with the fundemental question - what is a GeoPackage?

Docker Geoserver Part 1

Mon, 21 Nov 2022 01:22:15 +0000

This is the first in a small series that will go through the process of compiling an open source spatial stack to store, serve and visualise spatial data. Given we will be working with a number of containers it is beneficial to work with docker-compose.

Note: While it is possible to use Postgres in a docker container, this is not recommended for production purposes. A managed service such as AWS RDS is a better option in these instances.

Subdivide and Conquer

Mon, 21 Nov 2022 01:12:57 +0000

Dealing with large and complex geometries in postgis can be computationally expensive, even with a spatial index. To understand why this is we need to have some understanding of how a spatial index works. In simple terms, a spatial index is a bounding box that encapsulates the extent of a geometry, using a spatial index can rapidly speed up spatial processing by first checking which bounding boxes intersect - a comparatively quick process - as opposed to which raw geometries intersect - potentially a lot slower - and more so as the size of your dataset increases. If you want to learn a little then the postgis documentation does a good job of explaining it further.

Manipulating NBN species data with Geopandas

Mon, 21 Nov 2022 01:07:07 +0000

Geopandas has established itself a great python library for working with spatial data, building on the much loved pandas library and adding the ability to perform spatial operations. In this post I’ll run through some of the capabilities of the library. I’m using some data from the NBN Atlas - a great resource for species records. This particular dataset contains all mammal records recorded in the locality of Bristol, UK. The code can be found on my github.