Time series models normally require the designing of specific features to capture something about the underlying patterns:

• Fourier terms, Radial Basis functions etc in old blog post about linear models
• holiday events
• Calendar features (hour, day of week, weekend)

However, with the recent success of modelling lanugages with enormous amounts of data and processing power, a team at AWS asked

what are the fundamental differences between a language model that predicts the next token, and a time series forecasting model that predicts the next values? … Both endeavors fundamentally aim to model the sequential structure of the data to predict future patterns. Shouldn’t good language models “just work” on time series?

Previous attempts at applying LLMs to timeseries forecasting have consisted of clever fine-tuning of existing models (GPT4TS, Time-LLM) or just asking the LLM nicely (Promptcast). As with all the best ideas, it seems obvious in hindsight that a model trained on language is clearly not going to beat a LLM-type model trained on timeseries data. While it sounds easy on paper, the two major challenges are:

• there is much much more structured text data to learn from when compared to timeseries
• how do we define a “vocabulary” for our timeseries?

The first problem can be solved by taking the clean timeseries data that already exists, like the M competition, and applying a bit of mathematical pick-n-mix to create a wide corpus of training data

As for vocabulary, the authors scaled and quantized the data into 4096 buckets that represent the tokens.

That’s it.

Now all we have to do is borrow the transformer architecture that worked so well for modelling language and applying to the newly generated dataset of timeseries.

The results are frankly ridiculous for zero-shot forecasting with no special timeseries features.

How does it work?

Sparse autoencoders

Just as we have borrowed the architecture used to train LLMs, we can also apply the same “mechanistic interpretability” techniques used to understand how the model learns “concepts”. These papers are a bit dense, but I understood it much more clearly after reading Illustrated guide to AI. You can see the video version of the chapter here

One of the main take aways is that these neural networks represent more features than they have dimensions for encoding them, known as superposition hypothesis. For any given model, we can train another “sparse autoencoder” to map the neuron outputs at any given layer to concepts. Once we know which combinations of neurons lead to a certain concept, we can find examples in the training text that maximise these neuron patterns. Some legend set up Neuronpedia to easily visualise the findings of 400 different sparse autoencoders on the Gemini models.

While these techniques are now commonplace for language models, they are fairly new for the timeseries equivalents. In March 2026, Mishra 2026 dissected Chronos and discovered that different layers of the network focussed on different classes of features (seasonality, level shifts, change-detection). The jury is still out however, as another paper claims the model predictions did not change much when they purposefully set high neuron activations to zero. They think this could still explain why linear models continue to perform well.

Occlusion

Another way to peek inside the model’s brain is to purposefully occlude data from the input and measure how much worse this makes the forecast. Since Chronos gives us a probability of each token, we can use “Continuous Ranked Probability Score” (CRPS), like they do in Mishra 2026, to estimate the accuracy and precision of the forecast. We can then interpret this, with a pinch of salt, as where the model is “looking” when it makes its predictions.

I knocked up this quick demo to demonstrate the above for a few example datasets, which turn out to be fascinating! (Warning: this is not meant to be scientific, just a bit curious)

For a seasonal pattern, you can see that Chronos is “looking” at the peaks of the pattern at several points in the past:

It’s even more interesting when we add a linear trend term. I interpret the red dots as Chronos trying to find the amplitude for its future predictions

Whereas for a linear trend, no single point is relied on. There is no real change is we occlude a single point (hence all blue)

As Mishra 2026 claimed, Chronos clearly ignores the data before the regime change and also focusses more on recent data

Chronos2

Turns out I’m quite late to the party, as the AWS team has already released a huge improvement with Chronos2 that adds the ability to use exogenous variables through a “group attention” mechanism. I’ll leave that for another time after I have tried these models on my own data at work.

The old workflow required several convoluted steps:

1. A Python script to move only the relevant notes to a new folder and strip out some private content
2. Open the new folder with Obsidian and use the Webpage HTML Export plugin to export HTML files to yet another folder
3. Push the final folder to Github as a repo named “cooking”, so that it will appear at the right url when published with GitHub pages

The main problem is buggy rendering of dataview plugin, which underpins the functionality of the vault. This workflow also needed a GUI to complete and was extremely slow for my 1000+ pages.

The new architecture

I knew the exported website wasn’t up to scratch for a while but had no idea how to get around the dataview issue, apart from waiting for the plugin authors to update their code. I laid out this predicament for Claude who then diligently prepared a new pipeline based on Python and Quartz v5.

Claude was able to write a full Python interpreter for the dataview queries, like:

table length, healthy, course
from "100 Recipes"
where icontains(cuisine, "french")
sort course,length asc

It’s not the most complex query, but I was very pleasantly surprised that this worked straight away. I think the biggest improvement in AI is the fact that it writes tests at each stage of the development. After the Python code has converted the dataview queries to Markdown lists and tables, Quartz v5 then builds a fully functional static website with backlinks, interactive graph etc all thanks to greater Obsidan compatability.

The final result is that I can now just run make deploy to build the website from scratch and push to GitHub.

The naive approach (and why I didn’t use it)

The simplest option is to call the Unsplash API from JavaScript on the client side:

fetch('https://api.unsplash.com/users/rlaker/photos', {
  headers: { 'Authorization': 'Client-ID YOUR_ACCESS_KEY' }
})

This works, but it has two problems:

1. Your API key is visible in the page source. Unsplash’s demo keys are read-only and rate-limited, so it’s not catastrophic, but it’s not great either.
2. Rate limiting. The demo tier allows 50 requests per hour. Each page view is one request that collects the metadata of all my images on unsplash (the photos themselves are served from Unsplash’s CDN and don’t count as requests).

The build-time approach

Instead, with the help of Claude, I fetch the photos at build time using a GitHub Actions workflow. The workflow runs weekly (and can be triggered manually), calls the Unsplash API, and saves the results to _data/unsplash.json. Jekyll reads this file as site.data.unsplash during the build, so the photos are baked into the HTML meaning no API calls when someone views the page.

The GitHub Action

name: Fetch Unsplash photos

on:
  schedule:
    - cron: "0 6 * * 1"  # every Monday at 6am
  workflow_dispatch:       # manual trigger

jobs:
  fetch:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Fetch photos from Unsplash
        env:
          UNSPLASH_ACCESS_KEY: ${{ secrets.UNSPLASH_ACCESS_KEY }}
        run: |
          # fetch all photos, paginating through results
          # save to _data/unsplash.json

      - name: Commit if changed
        run: |
          git add _data/unsplash.json
          git diff --cached --quiet && exit 0
          git commit -m "update Unsplash photo data"
          git push

The API key lives in a GitHub secret and never touches the repo or the client.

The template

The photos page loops over the data file using Liquid:

{% for photo in site.data.unsplash %}
  <a href="{{ photo.url }}">
    <img src="{{ photo.src }}" alt="{{ photo.alt }}" loading="lazy">
  </a>
{% endfor %}

I show the first 12 photos and hide the rest behind a “Load more” button that just removes display:none — no JavaScript fetch needed.

The data file

Each entry in unsplash.json looks like:

{
  "url": "https://unsplash.com/photos/...",
  "src": "https://images.unsplash.com/...?w=400",
  "alt": "photo description",
  "description": "longer description"
}

The src field uses Unsplash’s small size (400px wide), which is plenty for a thumbnail grid and keeps the page fast.

Setup steps

1. Create an app on unsplash.com/developers and grab the Access Key
2. Add it as a GitHub secret called UNSPLASH_ACCESS_KEY (repo Settings > Secrets and variables > Actions)
3. Run the workflow manually once to generate the initial _data/unsplash.json
4. After that, the workflow refreshes it weekly

The result

My photos page now shows my latest Unsplash uploads at the top, automatically refreshed every week, with no API key exposed and no client-side rate limiting to worry about.

While doing research for a consulting project that sadly went nowhere (classifying rock type by core samples if you’re asking), I discovered Hidden Markov Models (HMMs).

Weather example

Imagine we want to classify the state of weather, as us British are wont to do, based on the Temperature (C) and Humidity (%).

We might design a naive model that could classify the three different states (Sunny, Cloudy and Rainy) based on thresholds in the temperature and humidity variables. The scatter points in the plot below represent the observed temperature and humidity measurements for 60 time steps, which clearly have some noise as they have a good amount of overlap. The dotted black lines show the decision boundaries of the Naive classifier, which does an OK job of classifying states, but noisy data could lead to the predicted state flipping back and forth in an un-natural way.

We can avoid this with the genius of a Hidden Markov Model that allows us to define both:

• How likely the transition between states is
• What is the probability of seeing parameters T and H, given a state $s$?

In technical lingo, the HMM allows us to encode our special British knowledge into the “transition matrix” and “emission probabilities”.

Transition matrix

TRANSITION = np.array([
    # Sunny  Cloudy  Rainy
    [0.75,   0.20,   0.05],   # from Sunny
    [0.25,   0.55,   0.20],   # from Cloudy
    [0.05,   0.35,   0.60],   # from Rainy
])

The transition probabilities can be see above. As an example how to read the matrix, we are saying if it is currently Sunny there is a 75% chance it will remain Sunny, 20% it will become cloudy and only 5% it will transition straight to rainy.

This is a really elegant design, since we could even update our knowledge. Maybe we think the chance of transitioning from state Sunny -> Rainy is more probable in April over August.

Emission probabilities

The emission probabilities capture how likely a certain measurement is, given we are in the titular “hidden markov state”.

EMISSION_MEANS = np.array([
    [24.0, 45.0],   # Sunny
    [19.0, 65.0],   # Cloudy
    [14.0, 80.0],   # Rainy
])

EMISSION_COVS = np.array([
    [[4.5**2, 0.0   ], [0.0, 14.0**2]],   # Sunny
    [[4.5**2, 0.0   ], [0.0, 14.0**2]],   # Cloudy
    [[4.0**2, 0.0   ], [0.0, 12.0**2]],   # Rainy
])

In the example above, the probability of observing a temperature T when it is Sunny follows a Gaussian with $\mu = 24C$ and a $\sigma = 4.5C$

Note: I am just using Gaussian probabilities because it makes things easy here. The model can work with any distribution

This can be visualised by plotting the same scatter points as above, but this time with the shaded regions showing the 65% confidence interval of each state

Viterbi algorithm

So how do we find the most probable path through all of these states? There are a few options, but the most ingenious is the Viterbi algorithm which goes a little something like this…

At the first time step, we see the emission, $o_1$. Therefore, we can represent the probability of the first state $s_1$ with the following product:

where $\pi_s$ is the starting probabilities of each state and $f$ is our Gaussian function from earlier.

Using the Markov property that “each state is only depends on the one before it”, we can create a recursive equation for the score of the best path ending in state $s$ at each step (i.e. the joint probability of that path having produced all observations $o_1,\ldots,o_t$).

• $D_{t-1}(s’)$ is the “probability of the best path ending in state $s’$ at the previous step, having explained $o_1, \ldots, o_{t-1}$.” This is the running joint probability of one specific path through the states.
• $\times \; A_{s’ \to s}$ represents the transition from $s’$ to $s$. Given the Markov property, we just read this from the transition matrix
• $\max_{s’}\;[\ldots]$ keeps the winning path at each step.
• $\cdot \; f(o_t \mid s)$ captures the probability of this state, $s$, emitting observation $o_t$.”

However, before we try and compute this we need to realise that we are going to be multiplying many small numbers together. If we are multiply probabilities like 0.05*0.03 (~$10^{-4}$) at each time step we end up trying to compute numbers like $10^{-240}$ for our 60-step sequence. Obviously this is madness, so instead we will take the log-probabilities so we end up with the following equation:

For each destination state, we can recored which previous state $s’$ led to the maximum score at that step.

i.e. “for each destination state $s$, $\psi_t(s)$ records which previous state $s’$ achieved the max.”

At the end of the sequence we pick the highest-scoring final cell: \(\hat s_T \;=\; \arg\max_s \, \delta_T(s)\) and then walk the stored backpointers right-to-left to reconstruct the full path: \(\hat s_{t-1} \;=\; \psi_t(\hat s_t), \quad t = T, T-1, \ldots, 2\)

Better explanation here

Run through

Let’s walk through the first two steps of this algorithm, with the temperature and humidity readings, along with their true state, in the table below:

At step 1 there is no previous state to transition from, so we initialise with just the prior on the starting state and the likelihood of the first observation

For step 2, we compute three maxes (one per destination state), each giving us 3 new scores $\delta_2(s)$. Alongside each score we store a backpointer $\psi_2(s)$ that remembers which previous state achieved that max:

Working table — every candidate $\delta_1(s’) + \log A_{s’\to s}$

Using the transition matrix:

A = np.array([
    # Sunny  Cloudy  Rainy
    [0.75,   0.20,   0.05],   # from Sunny
    [0.25,   0.55,   0.20],   # from Cloudy
    [0.05,   0.35,   0.60],   # from Rainy
])

For each destination, the bold entry wins. The two right-hand columns record the winning score and which previous state achieved it:

So the backpointers are split between Cloudy (if step 2’s state is Sunny or Cloudy) and Rainy (if step 2 is Rainy).

Finishing $\delta_2(s)$

To get to $\delta_2(s)$, we need to add the emission term for today’s observation:

So the emission can change which destination is the overall best at this step, but it never changes the backpointers $\psi_2(s)$.

If we were to end the algorithm here, we would see that step = 2 has the highest score for Sunny. We can look back at $\psi_2(s)$ to see that if Sunny was step 2, then Cloudy would be step 1.

However, its very important to note that if we continue moving through the observations we could see a different path emerge as the global best score. In this case, the full sequence can be seen in the plot below, where it turns out the best path starts with the same Cloudy → Sunny as in our tabular example above

Rather than flipping between states like the naive model, the HMM through Viterbi’s algorithm is able to smoothly transition between states in a natural way and does very well when compared to the true states.

Modern uses

So there you go, its always fun to stumble across an algorithm that has been quietly decoding digital communications and tracking my sleep cycles and more.

Well, to answer that we need to create a fine grid of query points across London and then find the closest pub at each point by comparing distances. With a 5km radius around Buckingham palace I ended up with around 63,000 points to check against all 3631 pubs I could find on OpenStreetMap. That’s way too many distance calculations, if only there was a better way to find the nearest neighbouring pub…

Obviously this is a solved problem. We just need to create a binary tree to represent our points and then traverse the tree in a clever way to find the nearest neighbour. After converting the lat/lon of the pubs into radians we also need to tell the BallTree that we want to calculate the distance with the Haversine formula since we are all living on a big ball.

from sklearn.neighbours import BallTree

tree  = BallTree(pubs, metric = 'haversine')

nearest_neighbour = tree.query(query_point, k=1)

Normally I would leave it at that, but since I just got Claude code I thought I might as well create some cool diagrams to prove how much of a speed improvement we can get by using this data structure. By creating a BallTree we have our 3631 pubs as the leaf nodes of the tree, and 3630 internal nodes that represent circles that enclose all the pubs in the leaves at deeper levels. All the nearest neighbour algorithm has to do is progress down the tree, checking the internal nodes at each level. For an internal node with centre $C$ and radius $R$, the distance:

represents the minimum distance to the query point for the pubs within this circle. If this distance is larger than the closest distance found so far, we can ignore this entire branch of the tree!

For our example, we only checked 41 out of 7261 nodes of the tree, which is visualised in the plot below. Interestingly, we actually had to check two completely separate branches of the tree all the way down to the leaf node.

Now we have a quick way to find the closest pub, we can create our grid within 5 km of the palace and create a map like this. You can clearly see the effects of Hyde park and Regent’s park, but because of the many pubs looking over the Thames this is not visible at all!

We have our answer! You are always within 878m of a pub in London, with the furthest point from any pubs being the football pitches in Regent’s park.

You can find the code in this repository

I haven’t been writing much lately. I’ve convinced myself it’s nothing to do with my own motivation, but because my 2018 Macbook was so painful to use. It geniunely took 10 minutes before the cursor wouldn’t act drunk.

Your Macbook is so old that it still has Intel inside

I decided to upgrade to the M4 Air with 256Gb storage, placing my order on Feb 17th. Obviously I don’t pay attention to Apple’s release cycle, because less than 2 weeks later they announced the M5 Air with a minimum storage of 512Gb and the new M5 chip…ffs

Thankfully, Apple anticipated my annoyance and automatically upgraded me - turns out its quite a common thing. It probably makes perfect sense from their side (handling costs of returns, factory production rates etc) but it just gives you the same warm feeling as when Flat Iron gives you a free icecream.

After transferring my data to the new Mac I ran into an interesting problem

ImportError: 
dlopen(.venv/lib/python3.9/site-packages/rpds/rpds.cpython-39-darwin.so, 0x0002): 
tried: '.venv/lib/python3.9/site-packages/rpds/rpds.cpython-39-darwin.so' 
mach-o file, but is an incompatible architecture 
have 'x86_64', need 'arm64e' or 'arm64e.v1' or 'arm64' or 'arm64'

My old environment had x86-compiled Python packages, which don’t work when loaded by a native arm Python interpreter. The fix was simple enough, I ended up having to reinstall uv so that it would build environments with the new arm architecture. I just thought it was a fun issue everyone solved years ago.

An essential quote for exploring French food

Mains

Sautéed chicken with Tarragon

This was the first dish that showed me the power of classical technique and I just love how a whole chicken can be transformed into this elegant final product. After scoring Larousse Gastronomique for £4 in a car boot sale, I followed its terse instructions to sauté chicken “à brun” then add shallots and deglaze with white wine. In the meantime, create a browned chicken stock from the leftover carcass and use this thickened sauce to finish off the sauce and get that shine. It’s such a good dish I created it four times within the year.

Coq au vin

This coq au vin was what finally convinced me there was no such thing as cooking wine. I sacrificed two glasses of a nice Bordeaux as an experiment to marinate some old tough chicken legs. The result had that same zing I tasted in Paris and was much thinner than a classic British/Irish stew I was used to.

While I managed to make an excellent coq au vin, I was not so lucky with its cousin the beef Bourguignon. I was plagued by poor choice of beef cut, a reduced-price rib of beef disintegrated into flakes and another cheap cut from the local butchers was so chalky Dom Pérignon asked for their soil back.

Pommes Sardalaise

Being half Irish, I already had a pretty decent grasp on potatoes with mashed potato genuinely being my favourite food. So I was on the look out for other potato dishes to satiate my starchy appetite, and what’s the only way to beat butter? Duck fat.

Fair warning, this is an insane amount of duck fat so be prepared for the consequences the next day 💨.

Pan Bagnat

It’s all been a bit high brow up till now, so I’ll bring it down a level. One of my favourite guilty pleasure lunches is the Gregg’s tuna baguette. I can only assume they were inspired by this French picnic classic. This video is the over-the-top version of this dish but has a really infectious energy.

Blanquette de poulet (couldn’t find veau)

Another dish that we tried in Paris and reminded me of one of my favourite dishes growing up, Mum’s creamy chicken with rice. Instead of cream, this recipe is thickened with a roux to make a velouté. Using the stock from poaching the chicken and vegetables is such a genius technique and gives the sauce an amazing flavour. Its also mind blowing how much each element retains its own flavour, making every mouthful different.

French Onion soup

More of a recipe to prove I’ve done it than something I would make regularly. Needs even more cheese than you think. Slices worked much better than grating it on.

Consommé

The technique was like magic. I think I got the ratios of vegetables slightly off so the taste was a bit too carroty but it was still a cool thing to create.

Onion tart tatin

We definitely managed to capture the taste but our onions fell apart a bit compared to immaculate YouTube videos, but I am not willing to spend over £10 on Roscoff onions.

Ratatouille

I tried the fancy movie version of this dish a few years ago and it all just turned into mush… So I was happier with this fine dining version, but I still think the dicing is slightly overkill.

Dessert

I never thought I would be that guy, but a stand mixer purchase really improved my pâtisserie game towards the end of the year. Yes it did cost several hundreds of pounds, but I can now spend all day creating Lemon meringue tarts instead of spending £5.50 per tart at Choux so who’s laughing now… In my defense, it is the most fun I’ve ever had making a dessert.

Lemon meringue tart

Just look how cute these are! This dessert also unlocks lemon curd, sweet pastry and Italian meringue from the bucket list.

Madeleines

I bought the madeleine tray in Paris so I kind of had to learn how to make these. My humps can’t rival Aya’s, but at least I could tut at The Great British Bake Off for giving the contestants silicon madeleine moulds in the final. Don’t they know its the contrast of hot oven and cold tray that creates the bump?!

Profiteroles

Éclairs are another one of my favourite desserts that costs £5.50 a pop at Le Choux, which obviously justifies making too many to eat myself. I went for profiteroles instead after trying them at Paulette (below). Much like doing a physics degree is now only useful for answering University Challenge questions, I probably won’t make these more than once a year but at least I know what crème diplomat is.

Start with making the pastry cream, used this video for the choux pastry and crème diplomat but swapped to this video for the chocolate topping.

Somehow I forgot to take a picture!

Crème Brûlée

Actually much easier than it seems, I already had a blow torch in my endless quest to perfect egg fried rice. Be careful not to burn the sugar as it gets very bitter.

Chocolate Mousse

We tried so many recipes but we couldn’t get it quite right before the sight of mousse became sickening. I think the “French classics” (below) version is probably the best, but I just hate the idea of using an uneven number of egg whites and yolks.

Restaurants

Bouillon Chartier

Bouillon Chartier was just so perfectly French. A terse conversation with the waiter yielded all the classics we could fit into one sitting. I’m sure you can tell from the scribbles on our table, but we ordered 1/2 a Bordeaux, 12 escargot, pork terrine, leeks vinaigrette, beef Bourguignon, boudin noir and even tête de veau. Judging from their wandering eyes and tutting heads, this was far too much food according to the elderly French couple sharing our table. Thankfully the quality of the food meant I didn’t need any more encouragment from our geriatric neighbours to clean the plates.

The Bourguignon had huge chunks of tender beef and serving it with Macaroni rather than mashed potato was something new to me.

Thankfully, I still got my mash fix with the boudin noir, essentially a black pudding sausage. The taste was excellent, but the lack of oats in the sausage meant its texture was too similar to the mash.

While the picture doesn’t make the tête de veau look particularly appetising, the meat was exceptionally tender and the fat/gelatin had an amazingly chewy texture reminiscent of a beef tendon we had in another fancier restaurant.

We absolutely loved this place, it was just so grand yet down to earth at the same time. Like the horrible tourists we were, we ended up buying 4 wine glasses and two side plates with the Bouillon Chartier logo on (I’m sure you’ve noticed from some of the other pictures in this page).

Brasserie Zédel

Still can’t believe this place exists in London. The online menu makes it look like any other French bistro with inexplicably higher prices, but once you step into the dining room it all makes sense. The food was so good I didn’t even mind the live Jazz.

This special of Asparagus with Bearnaise and a poached duck egg was just perfectly creamy and fresh. It was gone before we knew it.

I had the Choucroute Zédel, the biggest of three choucroute options, as I wanted to try as many assorted meats as possible. It turns out to be a mountain of food which would normally be impossible to get through without the choucroute (sauerkraut) providing a fresh, tangy offset to the meat. My favourite was the smoked ham hock, which was reminiscent of those thick cut BBQ ribs. My only criticism is that the potatoes were surplus to requirement and were just a bit bland.

We also had the dressed crab, which was easily the best I’ve ever had.

Paulette

We went to this small French bistro for our 1st wedding anniversary after hearing about through work colleagues. If it wasn’t such a special event I would have paid more attention to the prices, but leaving that aside the food was really very good indeed.

For starters we tried three classics.

We wanted to see a real onion tarte tatin in the wild after trying our own version (above). This had a great taste but was served cold and therefore became a bit soggy. Obviously, we ordered Escargot Bourgogne but these were very different to normal garlic-y ones. Much more herby taste which wasn’t as good as normal in my opinion. The real star was the moules à la crème au piment d’Espelette - the best mussel sauce I’ve ever had. It tasted great, the little hint of heat in the background and strong mussel flavour. The thickness, as well as taste, of the sauce practically forced you to order another round of bread in spite of the £6 fee.

Confit duck leg with tarbais beans (the ones used in Cassoulet) was also very good. Simple but perfectly balanced, again a background spice to keep it lingering between mouthfuls and herby punch on top. Went really well with the garlic creamy spinach.

Just look at it. Beautiful.

I’ve tried making beurre blanc at home but I keep thinking “it can’t possibly be that much butter”. I think I was proved wrong with this Cod in buerre blanc sauce. The sauce was really mild and smooth, mainly tasted the chives with just a subtle butter in the background. Again, a beautiful presentation that’s not out of reach at home.

The Tart Bordaloue was a pleasant surprise, the chocolate layer must have used the exact same chocolate as a Pain au Chocolat.

The finale was profiteroles. The chocolate sauce was so fun, but the ice cream was actually a bit too cold. I would have preferred whipped cream or crème diplomat (above).

Summary

So what have I gained from eating like a Frenchman for a year? Well, from a technique perspective I think I’ve come a long way. The other day I made the blanquette the poulet almost a year after the first attempt. It tasted so much fuller than the first try, probably because of little things like salting in each step and not letting it boil too ferociously. Another example of the learning the “little things” is with the sautéed chicken and tarragon. Having made it so many times I can now instinctively judge when the shallots have been sweated down enough, and I know how to evaporate the wine until the reduction looks a bit jammy. These skills are applicable in so much other cooking, like a risotto or gravy, which is why I chose French as the cuisine to focus on first. The downside is that I do now use double the amount of pans for the same recipe, which is a real killer when we don’t have a dishwasher.

I have also learnt that you can find much better recipes when you search in the native language, something I plan on continuing when I take on Italian cuisine in the coming year. I already have a much better foundation in Italian than I did in French, but I am determined to learn how to make good fresh pasta. Although, the only Italian dessert I really enjoy is Tiramisu, so I think I will continue with French patisserie and even take on the dreaded Macaron.

So I’ll bid French cuisine adieu for now and start practicing my 🤌.

Sources

Youtube

• Pastry living with Aya for all things baking.
• Adam Byatt makes things look effortless
• Matthew Ryle is great for inspiration but only does shorts. See his book “French Classics” below
• Fallow are great when they cover French food

Books

• French Classics looks great and tastes great
• Mastering the Art of French Cooking is fun to look through but not massively useful to cook from
• Larouse Gastronomique is really fun to look through for inspiration but very few instructions. I managed to find my copy for £4 in a car boot sale when its worth £60 new
• Between Meals and The Food of France are both guides to French food written in the early 20th century and still make for fascinating reading

import logging
import jsonlogger

logger = logging.getLogger(name)
logger.setLevel(logging.DEBUG)

# StreamHandler to stdout
handler = logging.StreamHandler(sys.stdout)
handler.setLevel(logging.DEBUG)

# Define a simple message format
log_format = "%(asctime)s [%(module)s > %(funcName)] : %(message)s"
formatter = jsonlogger.JsonFormatter(log_format)
handler.setFormatter(formatter)

logger.addHandler(handler)

Of course, there is an excellent tutorial at calmcode.io

This has become very handy when I recently took over a machine learning pipeline that was churning out thousands of logs, with Pytorch printing every update in a progress bar and cmdstanpy insisting on telling me about its chains.

In this same logging configuration file, we can turn these annoying logs off. There could be a more consistent way to do this, but this is what worked for me.

import cmdstanpy
cmdstanpy.disable_logging()

noisy_libs = ["neuralforecast", "pandas", "snowflake.connector"]
for lib in noise_libs:
    logging.getLogger(lib).setLevel(logging.WARNING)

Finally, when looking at the logs in DataDog I could see that any logs not generated by me, but by other packages like pandas, were mising the lovely context data (i.e. environment, market, model). We can fix this by adding a filter to the base logger, which then adds our context to all logs in the stdout output.

class ContextFilter(logging.Filter):
    def __init__(self, context):
        super().__init__()
        self.context = context
    
    def filter(self, record):
        for key, value in self.context.items():
            setattr(record, key, value)
        return True

root_logger = logging.getLogger()
logHandler = logging.StreamHandler(stream = sys.stdout)

logHandler.addFilter(ContextFilter(context))

Luckily, like anything on the internet, there is a podcast for that.

The screen rot podcast is a sort of media literacy for the social media age. While anyone could poke fun at some internet figure for an hour, these guys are amazing at finding that one that killer insight. When analysing the enigma of Beavo, they presented a clip of Beavo saying “I will do anything” for views. In the process of throwing “trends” on the wall and seeing what sticks, we see how Beavo started eating food on camera and accidently became famous because it turns out he doesn’t chew food before swallowing it…

My favourite “internet” newsletter, Garbage Day, had a similar take on Mr Beast:

“His success is less of a reflection of his own entertainment knowhow and more a reflection of what YouTube’s algorithm looks like when stripped raw.”

I love this newsletter because it traces how memes and stories make it into the mainstream, which is increasingly important since memes can now directly influence White House policies. As Garbage day explains, “DOGE was cutting federal funding in direct response to posts from right-wing activist Chris Rufo […] Even the name, ‘Department of Government Efficiency,’ came from an Elon Musk reply guy going by ‘Sir Doge Of The Coin.’”

With this kind of stuff happening in the world, it’s probably better off reading this newsletter than paying for the Economist.

A more traditionally “serious” source of analysis is the excellent If you’re listening show on YouTube. This handles larger geopolitical issues, and does a really good job of painting the overall picture in an entertaining format. They also also picked up on the idea that politics is now being influence by memes and tweets. They traced how an AI video of a resort in Gaza was designed specifically to influence Trump’s policy in the Middle East.

Maybe all this analysis is futile, but at least it’s entertaining.

This aim has coincided with a requirement at work to 10x the speed of our Python API, which will probably require rewriting parts in another programming language.

Given its been >10 years since I attempted to learn any language, programming or natural, are there better ways to teach myself in 2025?

French

Duolingo

Duolingo isn’t the greatest app in the world, but my god is it good at peer pressure. Having to do at least some French every day is a good way to keep up my motivation and build vocabulary.

Luckily for me, 30% of English vocabulary is based on French so I can bluff my way past the easy levels. However, this app isn’t very helpful for learning about grammar rules or how French people actually speak.

Youtube

For that, Youtube is an absolute gold mine. I can watch:

• grammar explanations
• people being interviewed in the street
• Jokes about the language

Youtube’s auto-translation is so good that it opens up the chance to watch unbelievably French videos like:

• A man in a beret who kills his rooster to make coq au vin
• A different man in a beret showing me how Mont D’or is made
• a dude wearing a questionable number of knives

Rust

I’ve been using Python for 10+ years and have learnt a lot of general programming concepts through it, e.g. Object oriented, iterators, threading. However, I think I need to learn a low-level language that I can turn to when I need performance.

For example, I was working on some code that merged two dataframes and then exploded the columns to something like 5 millions rows. When written in pure Python it would take 4.4 seconds compared to a ridiculous 0.15s in Rust. It has become a bit of a meme to “re-write this in Rust”, so it was definitely on my radar but I couldn’t tell why it was so different.

The Rust Book

The rust book is an incredible resource. Not only does it show you the syntax, but it has diagrams like this to explain concepts like ownership and borrowing

So, I’m not only learning about one new language but I’m being guided through concepts like heap and stack memory, pointers and everything else Python abstracts away.

I will probably still use Python for 90% of what I do, but its nice to be able to see how another language handles common pain points in Python like error messages and packaging.

Rustlings

Rustlings is the perfect partner to the Rust book, as it gives you 94 example scripts with compiler errors that you need to fix. This also demonstrates just how incredible the compiler is at helping you fix mistakes.

Youtube

There is a lot of nonsense about “which programming language is the best”, but I found this gem of a channel that explains why Rust is great