Matthew Brown

FastAPI database session dependency injection considered harmful

Tue, 03 Feb 2026 00:00:00 GMT

The common FastAPI pattern of injecting a database session via Depends() creates a long-lived session that spans the entire request lifecycle. This causes subtle bugs.

The pattern

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.get("/users/{user_id}")
def get_user(user_id: int, db: Session = Depends(get_db)):
    return db.query(User).filter(User.id == user_id).first()

The problems

Stale reads. SQLAlchemy's identity map caches objects. If you read a user early in the request, then call an external service that modifies that user, subsequent reads return stale cached data.

@app.post("/process")
def process(db: Session = Depends(get_db)):
    user = db.query(User).get(1)  # cached
    external_service.update_user(1)  # modifies user in another transaction
    user = db.query(User).get(1)  # still returns cached version

Memory accumulation. Every object loaded stays in the session's identity map. Long-running requests that process many records accumulate memory.

Background tasks inherit dead sessions. FastAPI background tasks run after the response is sent, but the session is already closed.

@app.post("/submit")
def submit(background_tasks: BackgroundTasks, db: Session = Depends(get_db)):
    background_tasks.add_task(send_email, db)  # db is closed when this runs
    return {"status": "ok"}

Alternatives

Explicit session management. Create sessions where you need them with clear boundaries.

@app.post("/process")
def process():
    with SessionLocal() as db:
        user = db.query(User).get(1)
        # do work
    # session closed, cache cleared

    with SessionLocal() as db:
        user = db.query(User).get(1)  # fresh read

Expire on commit. Use expire_on_commit=True and commit frequently to force fresh reads. This is the default but often disabled.

Session-per-operation. For read-heavy endpoints, use db.expire_all() or create short-lived sessions for each logical operation.

The convenience of dependency injection hides the session lifecycle from you. Sometimes that's fine. Often it's not.

pytest asyncio testing without plugins

Tue, 03 Feb 2026 00:00:00 GMT

Python 3.11 introduced asyncio.Runner which makes it possible to run async tests in pytest without the pytest-asyncio plugin. We've been using this approach for a few months now.

Configuration

Add this to your root conftest.py:

import asyncio
import inspect
from contextlib import contextmanager
from typing import AsyncGenerator, Generator, TypeVar

import pytest

T = TypeVar("T")


@contextmanager
def async_to_sync_generator(
    runner: asyncio.Runner, agen: AsyncGenerator[T, None]
) -> Generator[T | None, None, None]:
    async def get_next(agen):
        try:
            return await agen.__anext__(), None
        except StopAsyncIteration:
            return None, StopIteration
        except Exception as e:
            return None, e

    try:
        while True:
            value, exc = runner.run(get_next(agen))
            if exc is not None:
                if exc is StopIteration:
                    break
                raise exc
            yield value
    finally:
        runner.run(agen.aclose())


def pytest_sessionstart(session):
    session.asyncio_runner = asyncio.Runner()


def pytest_sessionfinish(session):
    if hasattr(session, "asyncio_runner"):
        session.asyncio_runner.close()


@pytest.hookimpl(hookwrapper=True)
def pytest_fixture_setup(fixturedef, request):
    if inspect.isasyncgenfunction(fixturedef.func):
        generator = fixturedef.func

        def gen_wrapper(*args, **kwargs):
            runner = request.session.asyncio_runner
            with async_to_sync_generator(runner, generator(*args, **kwargs)) as v:
                yield v

        fixturedef.func = gen_wrapper

    elif inspect.iscoroutinefunction(fixturedef.func):
        coro = fixturedef.func

        def coro_wrapper(*args, **kwargs):
            return request.session.asyncio_runner.run(coro(*args, **kwargs))

        fixturedef.func = coro_wrapper

    yield


@pytest.hookimpl(hookwrapper=True)
def pytest_runtest_call(item):
    if inspect.iscoroutinefunction(item.obj):
        runner = item.session.asyncio_runner
        original = item.obj

        def wrapper(*args, **kwargs):
            return runner.run(original(*args, **kwargs))

        item.obj = wrapper

    yield

Writing tests

No decorators needed. Just write async functions:

async def test_create_user(session, factory):
    user = await factory(UserFactory, name="test")
    assert user.id is not None

async def test_fetch_user(session, factory):
    user = await factory(UserFactory)
    result = await get_user(session, user.id)
    assert result.name == user.name

Async fixtures work the same way:

@pytest.fixture
async def user(factory):
    return await factory(UserFactory)

Database test isolation

Wrap each test in a transaction that rolls back:

@pytest.fixture(scope="function", autouse=True)
async def test_transaction(engine: AsyncEngine):
    async with engine.connect() as connection:
        transaction = await connection.begin()
        try:
            session = AsyncSession(bind=connection, expire_on_commit=False)
            yield session
        finally:
            await session.close()
            await transaction.rollback()

All changes made during a test are rolled back automatically.

Factory fixture

Use factories with explicit session management instead of mocking:

T = TypeVar("T", bound=BaseFactory)

@pytest.fixture
async def factory(session: AsyncSession):
    async def fn(factory: type[T], **overrides):
        instance = factory.build(**overrides)
        session.add(instance)
        await session.flush()
        return instance

    return fn

Usage:

async def test_order_total(factory):
    user = await factory(UserFactory)
    order = await factory(OrderFactory, user=user, amount=100)
    assert order.user_id == user.id

Why a single event loop matters

The default pytest-asyncio behaviour creates a new event loop per test. This causes problems:

Database connection pooling breaks. SQLAlchemy's async engine maintains connections on the event loop. New loop = new connections = pool exhaustion.
Fixtures and tests on different loops. A known issue where session-scoped fixtures run on a different loop than tests.
aiohttp client sessions. These need to be created and closed on the same loop.

The asyncio.Runner approach uses one loop for the entire session, avoiding all of this.

Known pitfalls

Silent test failures. The biggest risk with any async detection approach. If an async test isn't properly awaited, it passes without running. Earlier pytest versions silently ignored unmarked async tests entirely. The hook-based approach handles this, but watch for the warning: RuntimeWarning: coroutine 'test_x' was never awaited.

Async generator cleanup. The async_to_sync_generator must call aclose() in the finally block. Missing this causes resource leaks with async context managers.

No multi-framework support. This only works with asyncio. If you need trio or curio, use pytest-asyncio.

Similar projects

alt-pytest-asyncio takes the same approach as a proper plugin:

Single event loop for the session
Auto-detects async tests (no decorators)
Cleaner error tracebacks (no asyncio internals)
Python 3.11+ only

If you want a maintained plugin rather than copying conftest code, use that.

Comparison

Advantages:

No @pytest.mark.asyncio decorators
Single event loop per session (connection pooling works)
Fixtures and tests guaranteed same loop
No plugin version compatibility issues

Limitations:

More setup code in conftest.py
Less documentation
Python 3.11+ only
asyncio only (no trio/curio)

Using the node 18+ native test runner with TypeScript and React

Thu, 04 Sep 2025 00:00:00 GMT

Node.js 18 introduced a native test runner that eliminates the need for jest, mocha or vitest in basic scenarios. We've been using it exclusively for the past couple of weeks with great success.

Configuration

The test script in package.json:

{
  "scripts": {
    "test": "node --import global-jsdom/register --import tsx --experimental-transform-types --experimental-test-module-mocks --test"
  }
}

Flag breakdown:

--import tsx: Handles TypeScript compilation
--import global-jsdom/register: Provides DOM environment for React components
--experimental-transform-types: Strips TypeScript types during execution
--experimental-test-module-mocks: Enables module mocking
--test: Activates Node's test runner

Dependencies

Required dev dependencies:

pnpm add --save-dev @testing-library/react global-jsdom jsdom tsx

TypeScript Unit Tests

import { describe, test } from "node:test";
import { strict as assert } from "node:assert";
import { getInitials } from "./stringUtils";

describe("String Utils", () => {
  test("should return correct initials", () => {
    const result = getInitials("John Smith");
    assert.equal(result, "JS");
  });
});

Uses Node's built-in assert module for assertions.

React Component Testing

React Testing Library can still work with jsdom to provide a DOM.

import React from "react";
import { describe, test } from "node:test";
import { strict as assert } from "node:assert";
import { render, fireEvent, screen, cleanup } from "@testing-library/react";
import { Toggle } from "./Toggle";

beforeEach(() => {
  cleanup(); // cleans the dom state between each test
});

describe("Toggle", () => {
  test("calls onToggleClick when clicked", () => {
    let callCount = 0;
    const { getByText } = render(
      <Toggle 
        options={["On", "Off"]}
        selected="On"
        onToggleClick={() => callCount++}
      />
    );
    
    fireEvent.click(getByText("On"));
    assert.equal(callCount, 1);
  });
});

Running Tests

# All tests
pnpm test

# Watch mode
pnpm test -- --watch

# Specific file
node --import global-jsdom/register --import tsx --experimental-transform-types --test src/components/Toggle.test.tsx

Comparison

Advantages:

No configuration files required
Direct TypeScript execution
Built into Node.js runtime
Smaller dependency footprint

Limitations:

Requires Node 18+
Uses experimental flags
Smaller ecosystem than Jest, vitest, etc. This means fewer examples

20 days, one porsche, and a greek wedding.

Sat, 14 Jun 2025 00:00:00 GMT

import { Image } from 'astro:assets'; import readyToGo from '../images/greece/ready to go in london.jpeg'; import waitingFolkestone from '../images/greece/waiting in folkstone.jpeg'; import goodbyeLondon from '../images/greece/goodbye london.jpeg'; import antwerp1 from '../images/greece/antwerp.jpeg'; import antwerp2 from '../images/greece/antwerp2.jpeg'; import antwerp3 from '../images/greece/antwerp3.jpeg'; import germanCoffee from '../images/greece/german service station iced coffee.jpeg'; import dresdenArrival from '../images/greece/arriving in dresden.JPG'; import dresdenFriends from '../images/greece/dresden friends.JPG'; import lamboLeMans from '../images/greece/lambo to le mans.jpeg';

The Setup

I've done my fair share of long road trips but when my Greek boss invited me to his "big fat Greek wedding", I had to make something of it.. yet another crazy plan.. could I buy a fun car, and skip the summer airport choas, and see some of the balkans enroute.

My wife had to work the week before the wedding, so the journey would start solo - we'd reunite in Greece and make the return journey together as a dynamic duo.

Finding the Perfect Steed

Over a couple of months, I became a little obsessed over the decision. Coupe or cabriolet? 996, 997, or Boxster 981? The internet unanimously voted cabriolet, but being a "ranga" (albeit an Aussie ranga), I knew better than to subject my pale skin to 20 days of European summer sun.

After test driving two 997s and a Boxster 981 S PDK, I couldn't feel much difference in performance – but the 997 looked 100x better. I found my match: a very well-maintained 2005 Tiptronic 997.1 (rego FMZ 997), which catches the light just right and looks blue in certain conditions. Given this blue tinge it was almost immediately nicknamed: "Bluey," after the world's most beloved Aussie dog.

Bore scope verified ✓
MOT and maintenance history reviewed ✓
IMS bearing variant checked against engine number ✓

I rang the specialist (GT One) that had recently serviced it - they noted nothing of interest on the post-service report, and given it's recent service history, bore scope and great maintenance record I didn't do the standard PPI. Time will tell if this was a good idea or not.

There's always risk with these long road trips. Really, the only car I'd 100% trust to make it there and back is a Toyota Land Cruiser – but it's neither economical nor European, and where's the fun in that?

Insuring it was a challenge (many specialist insurers didn't want to insure it with on-street parking in London) but Admiral were happy to - after I gave them one of my kidneys. Also got European wide road side assistance with AA - just in case.

High vis and UK sticker purchased - it was time to get a move on.

The Route (ever changing)

Originally, I planned to take the scenic route through Western Europe to Slovenia, then down the Adriatic coast through Croatia, Bosnia & Herzegovina, Montenegro, and Albania. Insurance and time constraints had other ideas – I needed to stay within the EU.

A last-minute route change (now via Serbia and Bulgaria) meant I did get to add in a short stop in Dresden to visit old friends.

The Journey Begins

Day 1: London to Antwerp

UK, France, Belgium

Woke up early Thursday morning after not sleeping super well - put that down to pre-trip nerves. Made the 9:36 (albeit delayed by an hour) Le Shuttle to Calais – there's something super cool about driving your car onto a train that goes under the sea. The train was absolutely packed with supercars heading to Le Mans, so I slipped past all the kids with cameras in Calais like a no descript 15-year-old Ford Focus.

The hop from Calais to Antwerp was quick and uneventful, arriving at the hotel by 3 PM. First concern: Bluey was making a funny "clonking" noise from the front suspension. Apparently common with 997s, but not exactly what you want to hear at the start of a 5,000km journey. It also only happens after highway driving for hours, so had not made itself known on the 200 mile shake down trip I'd done the weekend after I bought it.

Did a bit of work (always more to do), then took a bus into Antwerp's city center. Found a proper frituur for dinner – because when in Belgium, you eat frites – before jumping into bed early. Tomorrow would be the first real test.

Day 2: Antwerp to Dresden

Belgium, Netherlands, Germany

Left Antwerp just after 7 AM, pushing through thick Belgian and Dutch commuter traffic. Nothing quite prepares you for the organized chaos of morning rush hour in the Low Countries.

Another route change on the fly – realized I didn't have the appropriate environmental stickers (Umweltplakette) for Dortmund or Düsseldorf. Headed south instead via Köln, then southeast toward Frankfurt before turning north again on the A4 toward Dresden.

Multiple fuel stops along the way – the 997 getting ~550km to a tank but still chews through fuel. I also had some truely bad road side coffee. I can't wait for speciality coffee to arrive at service stations.

Arrived in Dresden with Bluey running strong, though that suspension clonk re-appeared, made extra apparent by the cobblestones into Dresden. I've since quasi-diagnosed it as one of the common 997 suspension issues that can wait until we're back in the UK. (Famous last words?)

My German friends (the Uli's) always open their arms and house with incredible hospitality so I've spent the last 24 hours surrounded by friends new and old.

more to come...

Impressions

The Good:

The power is immense. You can be cruising at 150km/h, apply a little more throttle, and the car jumps forward like a startled thoroughbred. The flat-six pulls hard.
The 8-disc CD changer is surprisingly awesome in 2024. Endless music without touching your phone. Also spent time scanning local radio stations, listening to incomprehensible chatter about news, gossip, and politics.
The sunroof was absolutely the right choice. Windows down, sunroof open – you feel connected to the world. Button everything up, and you're wrapped in a cocoon of German engineering.

The Reality Check:

Road noise really grates after a couple of hours. I'm wearing high-fidelity earplugs that help, but it's still prominent.

Defining AI tools in python

Wed, 26 Mar 2025 00:00:00 GMT

With the explosion of agent frameworks we’re seeing different approaches to defining agent “tools” in python. The two immediately obvious approaches are using the docstring or using a pydantic model to define the tool arguments.

Opinions wanted: I don’t have an agent framework to shill, nor do I really have a strong opinion about either right now.

I also reserve the right to change the pros and cons as they become obvious over time.

What do you think? Comment on Hacker News.

Option 1: docstring

A simple python function with an optional docstring to define additional context (like field descriptions).

def search_customer(postcode: str | None = None):
	"""Search for customers.

    Args:
        postcode: The customer's postcode
    """

Pros

This style is used by lots of agent frameworks:

PydanticAI (see docs)
OpenAI Agents Framework (see docs)
MCP Python SDK (see docs)

Internally all of these tools convert the signature + docstring into a pydantic model…

Can’t do funny things with models like union types. For example SearchCustomerParamsV1 | SearchCustomerParamsV2 which produces anyOf schemas which aren’t supported by the models.

You’re just writing normal python functions. Type hints in function signatures are more visible in IDEs without having to look at model definitions. Better integration with existing tooling (mypy, pylint, etc.)

Cons

Action arguments interleaved with magic/injected variables. For example in the below example it may not be super clear which arguments are model provided vs dependency injected.

@tool()
def search_customer(
	postcode: str | None = None, # tool argument
	ctx: Context,  # special variable name/type which is injected by us
	# dependency injected arguments (FastAPI style)
	crm_client: Client = Depends(get_crm_client),
    crm_customer: Customer | None = Depends(get_crm_customer),
    session: Session = Depends(get_db_session),
):
	"""Search for customers.

    Args:
        postcode: The customer's postcode
  """

Documentation and constraints are separated from the type definitions (i.e. no pydantic validation). Also docstrings can be unwieldy and long winded.

Option 2: pydantic model

In this case the function has one special argument called arguments or params which is a pydantic model that represents the tool arguments.

class SearchCustomerArguments(BaseModel):
    postcode: str | None = Field(description="The customer's postcode")

@tool()
def search_customer(arguments: SearchCustomerArguments):
	...

Pros

Very similar to FastAPI style

@tool()
async def create_diary_event(
    arguments: CreateDiaryEventV1Args,
    crm_client: Client = Depends(get_crm_client),
    crm_customer: Customer | None = Depends(get_crm_customer),
	session: Session = Depends(get_db_session),
):
    ...

Access to some useful pydantic features

Validation (field_validator, model_validator, Field(gt=0), etc)
Field descriptions

Cons:

Not easily adaptable: Difficult to adapt to other MCP server with your tools we’d you'd have to explode the pydantic model into a standard python function, or dive into the internals of the agent frameworks.

Unsupported pydantic features: Can use pydantic features that are not supported by models (union → anyOf, nested models, etc)

Option 3: hybrid/support both

In this scenario the @tool() magic would inspect the function signature:

If it finds an argument called arguments assumes it’s a pydantic model uses “Option 2”, or
It uses Option 1

In this case we could use the docstring approach for simple functions with few parameters/limited validation, and pydantic models where we want validation.

This is similar to LangChain

What are your thoughts?

pytest snippets for python 3.11+

Sun, 23 Feb 2025 00:00:00 GMT

Below is a set of snippets that I used frequently when using pytest in the later versions of python.

asyncio tests without any plugins

The following snippet adds very basic support to pytest for async tests in python 3.11 and above. Add it to your conftest.py and async tests will run in an an asyncio.Runner

import asyncio
import inspect
import logging
from contextlib import contextmanager
from typing import Any, AsyncGenerator, Generator, TypeVar

import pytest

# Set up logging for debugging
logger = logging.getLogger(__name__)

T = TypeVar("T")


@contextmanager
def async_to_sync_generator(
    runner: asyncio.Runner, agen: AsyncGenerator[T, Any]
) -> Generator[T | None, None, None]:
    """
    Converts an async generator into a synchronous generator using the provided asyncio.Runner.
    """

    async def get_next(agen):
        try:
            return await anext(agen), None
        except StopAsyncIteration:
            return None, StopIteration
        except Exception as e:
            return None, e

    try:
        while True:
            value, exc = runner.run(get_next(agen))
            if exc is not None:
                if exc is StopIteration:
                    break
                raise exc
            yield value
    finally:
        # Ensure cleanup for the async generator
        runner.run(agen.aclose())


def pytest_sessionstart(session):
    """Initialize an asyncio.Runner for the pytest session."""
    if not hasattr(asyncio, "Runner"):
        pytest.exit("This plugin requires Python 3.11 or higher", returncode=1)
    session.asyncio_runner = asyncio.Runner()
    logger.debug("Asyncio Runner initialized for the session.")


def pytest_sessionfinish(session):
    """Close the asyncio.Runner after the session ends."""
    if hasattr(session, "asyncio_runner"):
        try:
            session.asyncio_runner.close()
            logger.debug("Asyncio Runner closed after the session.")
        except Exception as e:
            logger.error(f"Error closing asyncio Runner: {e}")


async def anext(agen: AsyncGenerator):
    """Fetch the next item from an async generator."""
    return await agen.__anext__()


@pytest.hookimpl(hookwrapper=True)
def pytest_fixture_setup(fixturedef, request):
    """
    Convert async fixtures into their synchronous counterparts, handling both async generators and coroutines.
    """
    if inspect.isasyncgenfunction(fixturedef.func):
        generator = fixturedef.func

        def gen_wrapper(*args, **kwargs):
            runner: asyncio.Runner = request.session.asyncio_runner
            gen_obj = generator(*args, **kwargs)
            with async_to_sync_generator(runner, gen_obj) as v:
                yield v

        fixturedef.func = gen_wrapper
        logger.debug(f"Converted async generator fixture {fixturedef.func} to sync.")

    elif inspect.iscoroutinefunction(fixturedef.func):
        coro = fixturedef.func
        runner: asyncio.Runner = request.session.asyncio_runner

        def coro_wrapper(*args, **kwargs):
            return runner.run(coro(*args, **kwargs))

        fixturedef.func = coro_wrapper
        logger.debug(f"Converted coroutine fixture {fixturedef.func} to sync.")

    yield


@pytest.hookimpl(hookwrapper=True)
def pytest_runtest_call(item):
    """
    Convert async test functions to sync functions by running them in the asyncio.Runner.
    """
    if inspect.iscoroutinefunction(item.obj):
        runner = item.session.asyncio_runner
        original = item.obj

        def item_wrapper(*args, **kwargs):
            return runner.run(original(*args, **kwargs))

        item.obj = item_wrapper
        logger.debug(f"Converted async test {item.obj} to sync.")

    yield

integration tests

Mark tests as integration tests that don't run by default. You have to run pytest with the --integration flag to run them.

def pytest_addoption(parser):
    parser.addoption(
        "--integration",
        action="store_true",
        default=False,
        help="Run tests marked with @pytest.mark.integration",
    )


def pytest_configure(config):
    config.addinivalue_line(
        "markers", "integration: mark test to run only with --integration"
    )


def pytest_collection_modifyitems(config, items):
    if config.getoption("--integration"):
        # Only run tests marked with 'integration'
        integration_items = [item for item in items if "integration" in item.keywords]
        items[:] = integration_items
    else:
        # Skip tests marked with 'integration'
        skip_integration = pytest.mark.skip(reason="Need --integration option to run")
        for item in items:
            if "integration" in item.keywords:
                item.add_marker(skip_integration)

sqlalchemy async support with factory-boy

I find passing in an explicit session easier than the built in factory-boy session local behaviour. So this is a little snippet adds factory generated instances to the current session.


# factory
T = TypeVar("T", bound=BaseFactory)
Factory = Callable[Concatenate[Type[T], ...], Awaitable[T]]


@pytest.fixture(scope="function", name="factory")
async def factory_fixture(session: AsyncSession):
    """
    Creates a factory fixture for creating models.
    Explicitly uses the current active session
    """

    async def fn(factory: Type[T], **overrides):
        instance = factory.build(**overrides)
        session.add(instance)
        await session.flush()
        return instance

    return fn

### usage

async def test_user(factory: Factory):
    instance = await factory(UserFactory)

Flying notes

Fri, 23 Sep 2022 00:00:00 GMT

The following is my notes about flying GA to Europe from the UK. Last updated: 2022-09-23

Le Touquet, France

Notice: 2 hours before ETD (but seem flexible)
Service Hours: ATS
- Summer: 0700-1130, 1300-1700.
- Winter: 0800-1230, 1330-1800.
Handling: Not required
Landing fee: 25 euro (Schedule)
Runways: 13/31

Before you go:

File a flight plan through SkyDeamon. If flying VFR you don't need to enter an altitude.
UK GAR via OnlineGAR for the outbound and return.
LeTouquet customs notification via https://www.aeroport-letouquet.com/douanes-informations-de-vol/?lang=en (onlinegar can also send this)

Calais, France

Notice: 2 hours before ETA
Service: AFIS
- From 01/03 to 30/09, WED-FRI 0800-1600, SAT-SUN 0800-1100, 1200-1600.
- From 01/10 to 29/02 : TUE-SAT 0800-1500.
Handling: Not required
Landing Fee: 10 euro (Schedule)
Runways: 06/24

Before you go:

File a flight plan through SkyDeamon. If flying VFR you don't need to enter an altitude.
UK GAR via OnlineGAR for the outbound and return.
FR customs notification via http://www.aeroport.capcalaisis.fr/pilot/

Ostend, Belgium

Information Sheet

Notice: Not required
Hours: ATS 0700-2200
Handling: Optional
Landing fee: ~25 euros (Schedule)
Runways: 08/26

Before you go:

File a flight plan through SkyDeamon. If flying VFR you don't need to enter an altitude.
UK GAR via OnlineGAR for the outbound and return.
BE Gendec via https://www.police.be/bordercontrol/en/general-declaration#

Midden-Zeeland, Netherlands

Non-standard circuit, glider and skydiving ops. Circuit height 700ft AGL https://www.vliegveldzeeland.nl/piloten/

Notice: 2 hours before ETD
Service: Radio 0800-1900
Handling: Not required
Landing Fee:
Runways: 09/27

Before you go:

File a flight plan through SkyDeamon. If flying VFR you don't need to enter an altitude.
UK GAR via OnlineGAR for the outbound and return.
NL customs notification via https://www.gendec.eu/ (can also submit a UK GAR)

Sauce

Fri, 23 Sep 2022 00:00:00 GMT

The best tomato sauce in the world.

Add the following to a large pot:

9.0kg of tomato
1.5kg onion
100g garlic
1 tbsp ground ginger

Cover with sufficient water, cook for a couple of hours - the longer the better. Put through a course sieve.

Mix in and warm through:

1.5kg sugar
1/2 cup salt
1.25kg apple puree
1 cup ezy-sauce

Bottle.

Sandwich Loaf Bread Recipe

Thu, 26 Aug 2021 00:00:00 GMT

This is an easy mid-week loaf of bread based on Joshua Weissman's video.

Ingredients

125g whole milk
175g water
440g of strong white bread flour
8g of yeast
8g of salt
21g of sugar
30g of softened butter

Method

Mix 125g of milk and 175g of water in a saucepan and heat to ~36C.
Mix 440g of bread flour, 8g of yeast, 8g of salt and 21g of sugar in a mixer bowl.
Mix the warm milk/water mixture with the dry ingredients in a mixer for ~10mins. At the 2min mark add the 30g of softened butter.
Take the dough out of the mixing bowl, shape into a ball (as best as you can) and return to the mixing bowl.
Cover the mixing bowl with a damp cloth and let the dough rise until doubled in size - normally takes about an hour at room temperature.
Once doubled in size, punch it down to release some of the built up gas.
Tip out onto a lightly floured surface and roll into a rectangle about 20cm by 30cm. Roll this rectangle up into a cylinder.
Place the cylinder into a lightly oiled loaf tin, cover with a damp cloth and leave to rise for a second time - this time about 45mins.
Bake in 180 degree oven for 35 to 40 mins.

Leave to stand before eating - or don't (it normally smells too good to not eat straight out of the oven).

Pizza notes

Sat, 23 Jan 2021 00:00:00 GMT

In an attempt to match a restaurant quality Neopoliatan pizza, I've been experimenting with different pizza dough recipes and toppings. Most the experiments below have been made using an Ooni Koda 12" and use Shipton Mill's 00.

Jan 23 2021

For 4 pizzas... using the same ratios as last time (before I started documenting). Experimenting with timings from https://github.com/hendricius/pizza-dough.

Ingredients:

530g '00' flour
0.3g yeast
15g salt
330g water (64% hydration)

Method:

20:00: Mix ingredients
20:30: stretch and fold
21:00: stretch and fold
22:00: stretch and fold
22:30: stretch and fold, leave out overnight
08:00: stretch and fold
08:15: divide and shape, to fridge
18:00: remove from fridge, reshape
19:00: cook

Toppings

Margherita
Cajun beef mince + caramelised onions
Salami, mozerella, rocket
Mushroom, Jalepeno, mozerella

Eating notes

Toppings were great. Bases/dough is still a little "bready". I think this is maybe caused by either a. oven too hot (hence burning without the interior having time to cook) b. hydration or salt content percentage not quite right.

Feb 1 2021

For 4 pizzas... This time I used the ratios and timings from https://github.com/hendricius/pizza-dough.

Dough was cold-proofed for 48 hours instead of 24 hours. Also, I accidently covered the pre-proofed dough in oil.. this meant the dough tasted better (longer proofing time) but had a weird crisp and colour (because of the oil). So.. 1 step forward.. 1 step backward.

Toppings

Margherita
French salami, mozerrella, rocket
Prawn, Garlic and Chill
Mushroom, caramelised onion

Flour Tortilla Recipe

Sat, 16 Jan 2021 00:00:00 GMT

Inspired by Joshua Weissman's 5 Ingredient Homemade Flour Tortillas and a bunch of reddit comments about making the perfect mission style flour tortilla.

You can just mix all the ingredients together, then roll out but I find letting the dough autolyse for 30mins before adding the oil and salt makes the tortilla's extra soft and tasty.

Ingredients

350g plain white flour
190ml warm water
6g salt
33g oil

Method

Mix 350g of flour and 190ml water a shaggy mess. Doesn't have to be fully mixed. Just make sure most of the flour is hydrated.
Leave the flour/water mixture to autolyse for 30-40 minutes.
Mix autolysed dough with 33g of oil and 6g of salt.
Knead until salt is disolved and oil incorporated.
Cut into 16 approx. 35g balls (use scales - it makes them all nice and even)
Pre-heat a cast iron skittet or BBQ - you want it as hot as it gets.
Roll out each ball into a circle. Get it as thin as possible.
Place the rolled out ball into the pan. Cook until bubles start to form - then flip and repeat. You don't want to get it too brown (it's better to be undercooked and soft then overcooked and crispy).
Place cooked tortilla into a teatowel so it retains some heat.
Repeat with the remaining balls of dough.

Then fill with whatever ingredients tickle your fancy.

Pictures

Ragu alla Bolognese Recipe

Sat, 16 Jan 2021 00:00:00 GMT

My go-to recipe for spag bol sauce.

Ingredients

500g beef mince (not too lean - fat is tasty)
250g pancetta chopped (bacon will also do)
85g carrot finely chopped (normally ~1 carrot)
85g celery finely chopped
85g onion finely chopped (one medium onion)
50g tomato paste
210ml red or white wine
300ml milk

Method

Heat a bit of oil in a large saucepan and add 250g of chopped pancetta. Cook until the pancetta starts to release it's fat.
Add all the finely chopped vegetables (85g of carrot, celery and onion). Cook until onion is transparent
Add 500g of mince and cook until lightly browned.
Add 50g tomato paste and 210ml of red or white wine and mix through.
Add 300ml milk and mix through.
Cook, covered and stiring occationally, for 2 to 3 hours. The longer the better.

Serve with pasta or store - this is one of those dishes that tastes best a couple of days later.

Connecting Google Cloud Run to Cloud SQL

Tue, 29 Sep 2020 00:00:00 GMT

Cloud Run is a relatively new GCP service that means you can get a container up and serving traffic very quickly. This is just a quick guide to connecting your Cloud Run service to Cloud SQL.

This post is part of a Practical GCP for Software Engineers tutorial series I've written. If you'd like access to the rest of the content drop me an email on me@matthewbrown.io :)

Before you start you will need a couple of things before you get started:

A running Cloud Run service ($SERVICE_NAME)
The service account email you're using for the Cloud Run Service ($CLOUD_RUN_SERVICE_ACCOUNT_EMAIL)
Your project ID ($GOOGLE_PROJECT_ID)

1. Create a CloudSQL instance

This a pretty simple step. For this example I'm using a db-f1-micro instance running PostgreSQL 12 in GCP's London region (europe-west2).

gcloud sql instances create cloud-run-example \
  --tier=db-f1-micro \
  --region=europe-west2 \
  --database-version=POSTGRES_12 \
  --root-password=correcthorsebatterystaple \
  --storage-auto-increase

This will take a couple of minutes to run.

2. Give your Cloud Run service account the needed role/permissions.

Allow your Cloud Run service account access to Cloud SQL.

gcloud projects add-iam-policy-binding $GOOGLE_PROJECT_ID \
  --role roles/cloudsql.client \
  --member serviceAccount:$CLOUD_RUN_SERVICE_ACCOUNT_EMAIL

By default Cloud Run uses the default compute service account so in that case $CLOUD_RUN_SERVICE_ACCOUNT_EMAIL would be $GOOGLE_PROJECT_ID-compute@developer.gserviceaccount.com

3. Configure the connection from Cloud Run to CloudSQL.

gcloud run services update $SERVICE_NAME \
  --add-cloudsql-instances $GOOGLE_PROJECT_ID:europe-west2:cloud-run-example \
  --update-env-vars DATABASE_URL='postgres://postgres:correcthorsebatterystaple@/postgres?host=/cloudsql/$GOOGLE_PROJECT_ID:europe-west2:cloud-run-example'

This will make a socket available in the Cloud Run container at /cloudsql/$GOOGLE_PROJECT_ID:europe-west2:cloud-run-example/.s.PGSQL.5432. You can then configure your container to connect via that socket (the example above sets a environment variable called DATABASE_URL)

4. (Optional) Connect SQLAlchemy and connection limit gotchas.

If you're using SQLAlchemy you can then configure it like follows:

import os

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import scoped_session, sessionmaker

engine = create_engine(os.getenv("DATABASE_URL"))
session = scoped_session(sessionmaker(bind=engine))

Base = declarative_base()

But be careful - behind the scenes Cloud Run is just containers. By default it will allow 80 concurrent requests to a container before spinning up a 2nd. SQLAlchemy's connection pool defaults to a min of 5 and max of 10 connections. If you're using a small db instance (like the one in this example) and expecting some load you can quickly exhaust connection limits.

Getting started with r and r-studio on MacOS

Sat, 05 May 2018 00:00:00 GMT

I've enrolled myself in the Duke University course Statistics with R on Coursera. This is a quick note around how I setup R and R-studio on MacOS Sierra and above.

Step 1: Install Homebrew and Cask. Homebrew is a package manager for MacOS and Cask allows you to install Apps using the Homebrew CLI.

/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
brew tap caskroom/cask

Step 2: Install R, XQuartz and R Studio. You no longer have to tap the science homebrew repository to install R - it has been included in the standard repository since 2017.

brew install r
brew cask install xquartz rstudio

Setting up python, pipenv and jupyter notebook on Ubuntu 18.04

Sat, 05 May 2018 00:00:00 GMT

Ubuntu 18.04 Bionic Beaver (the latest LTS version) was released last week. The little script below will get pip3 and pipenv up and running.

# Install pip and pipenv
sudo apt install python3-pip python3-dev
pip3 install --user pipenv

# Add pipenv (and other python scripts) to PATH
echo "PATH=$HOME/.local/bin:$PATH" >> ~/.bashrc
source ~/.bashrc

Create a new project and install some dependencies (include jupyter)

mkdir project-name && cd project-name
pipenv install numpy matplotlib jupyter

Start a jupyter notebook

pipenv run jupyter notebook

The factory method pattern in Go

Sat, 23 Jan 2016 00:00:00 GMT

I have been writing web services in Go for approaching 2 years now. The factory pattern is something I have found particularly useful, especially for writing clean, concise, maintainable and testable code. Originally I used it just for the data access layer so I could swap in and out upon MySQL, PostgreSQL, etc without changing the application layer code but it has proved useful in many other places.

Starting at the very beginning we define our package and import the required libraries.

// Package definition and import the required stdlib packages.
package main

import (
	"fmt"
	"log"
	"errors"
	"strings"
	"database/sql"
	"sync"
)

For the purposes of illustration we will create a DataStore interface that is implemented by PostgreSQLDataStore and MemoryDataStore. The DataStore interface will specify 2 methods: Name and FindUserNameById.

var UserNotFoundError = errors.New("User not found")

type DataStore interface {
	Name() string
	FindUserNameById(id int64) (string, error)
}

Then create 2 structs that implement the the interface.

//The first implementation.
type PostgreSQLDataStore struct {
	DSN string
	DB sql.DB
}

func (pds *PostgreSQLDataStore) Name() string {
	return "PostgreSQLDataStore"
}

func (pds *PostgreSQLDataStore) FindUserNameById(id int64) (string, error) {
	var username string
	err := pds.DB.Query("SELECT username FROM users WHERE id=$1", id).Scan(&username)
	if err != nil {
		if err == sql.ErrNoRows {
			return "", UserNotFoundError
		}
		return "", err
	}
	return username, nil
}

//The second implementation.
type MemoryDataStore struct {
	sync.RWMutex
	Users map[int64]string
}

func (mds *MemoryDataStore) Name() string {
	return "MemoryDataStore"
}

func (mds *MemoryDataStore) FindUserNameById(id int64) (string, error) {
	mds.RWMutex.RLock()
	defer mds.RWMutex.RUnlock()
	username, ok := mds.Users[id];
	if !ok {
		return "", UserNotFoundError
	}
	return username, nil
}

Now we can start to explore the power of the Factory method pattern.

...create objects without having to specify the exact 'type' of the object that will be created...

First we must create factory methods for all our implementations that return the common interface. These are essentially constructors that accept a common argument. In our case this common argument is a map[string]string.

type DataStoreFactory func(conf map[string]string) (DataStore, error)

func NewPostgreSQLDataStore(conf map[string]string) (DataStore, error) {
	dsn, ok := conf.Get("DATASTORE_POSTGRES_DSN", "")
	if !ok {
		return nil, errors.New(fmt.Sprintf("%s is required for the postgres datastore", "DATASTORE_POSTGRES_DSN"))
	}

	db, err := sqlx.Connect("postgres", dsn)
	if err != nil {
		log.Panicf("Failed to connect to datastore: %s", err.Error())
		return nil, datastore.FailedToConnect
	}

	return &PostgresDataStore{
		DSN: dsn,
		DB:  db,
	}, nil
}

func NewMemoryDataStore(conf map[string]string) (DataStore, error) {
	 return &MemoryDataStore{
	 	Users: &map[int64]string{
	 		1: "mnbbrown",
	 		0: "root",
	 	},
	 	RWMutex: &sync.RWMutex{},
	 }, nil
}

Now we must store these factory methods somewhere to be called upon as needed. I'll create a Register helper method to add factories to datastoreFactories. The init function registers both the factories we created above using easy to remember names.

var datastoreFactories = make(map[string]DataStoreFactory)

func Register(name string, factory DataStoreFactory) {
	if factory == nil {
		log.Panicf("Datastore factory %s does not exist.", name)
	}
	_, registered := datastoreFactories[name]
	if registered {
		log.Errorf("Datastore factory %s already registered. Ignoring.", name)
	}
	datastoreFactories[name] = factory
}

func init() {
	Register("postgres", NewPostgreSQLDataStore)
	Register("memory", NewMemoryDataStore)
}

Now the magic happens. Using the Create function below the appropriate factory method will be called using the the conf argument to create an instance of the DataStore interface.

func CreateDatastore(conf map[string]string) (DataStore, error) {

	// Query configuration for datastore defaulting to "memory".
	engineName := conf.Get("DATASTORE", "memory")

	engineFactory, ok := datastoreFactories[engineName]
	if !ok {
		// Factory has not been registered.
		// Make a list of all available datastore factories for logging.
		availableDatastores := make([]string, len(datastoreFactories))
		for k, _ := range datastoreFactories {
			availableDatastores = append(availableDatastores, k)
		}
		return nil, errors.New(fmt.Sprintf("Invalid Datastore name. Must be one of: %s", strings.Join(availableDatastores, ", ")))
	}

	// Run the factory with the configuration.
	return engineFactory(conf)
}

You can use the above CreateDatastore method in your application code as follows:

datastore, err := CreateDataStore(&map[string]string{
	"DATASTORE": "postgres",
	"DATASTORE_POSTGRES_DSN": "dbname=factoriesareamazing",
})

of use another datastore:

datastore, err := CreateDataStore(&map[string]string{
	"DATASTORE": "memory",
})

This interface driven approach allows you to do injection and makes mocking simple for unit tests. i.e you can test against MockDataStore which implements the DataStore interface rather than having to spin up an instances of PostgreSQL for your unit tests. That said, you should still be writing integration tests against a real version of PostgreSQL to account for SQL errors and other quirks you could have missed.

Like what you read? Or think I'm wrong - let me know via @mnbbrown.

Thanks to @smitec and @davidghooper for reading my draft.

Ireland

Sun, 18 Jan 2015 00:00:00 GMT

Day 1 & 2: Dublin - Kilkenny

Landing in Dublin was eventful. The wind meant the plane was thrown around like a rag doll with wings all the way down. After surviving the descent and getting our bags, we met up with our friend Bronte, who was on exchange in Glasgow. She was taking a couple of days off before returning to Glasgow for exams. Then it was time for hire car number 2. Our steed for the next 6 days was to be a ~~pink~~ wine-coloured, Nissan Micra. It was like driving a peanut after the Audi we had in Germany.

We drove straight to our B&B just outside Kilkenny, a 1.5 hour journey that ended up taking 2.5 hours with the poor weather and my need for snacks. After checking in to our B&B we made our way back into the city for dinner with Gen's Irish relatives. Bronte holed up in a nearby pub nearby to do some study while Gen and I got lost trying to find the restaurant. With an almost-flat phone, no wifi or data, and only a vague (wrong) recollection of where we were going, it took forever to find the restaurant, but we got there in the end! Gen was expecting two, maybe three people tops, but the entire family turned out! We had a fantastic dinner.

The next morning we awoke to a rare sunny Irish day, enjoyed the first of the incredible Irish breakfasts and headed back into Kilkenny. We toured Kilkenny Castle (with a large group of Russian school students) where the National Trust has done a great restoration job. The tour guide talked us through the history of the Butlers (the main family who lived there).

After our history-filled morning, we saw Penguins of Madagascar for some comedic relief before eating dinner at a local pub, complete with live folk music.

Day 3: Kilkenny - Killarney

After another amazing breakfast we checked out and started the long drive to Killarney, made only slower by tractors on the winding Irish roads. Our first stop for the day was Cashel, where we spent a couple of hours exploring the Rock of Cashel, an imposing ruined castle and cathedral on top of a hill whose only inhabitants are crows (or jackdaws?). Perched upon a bare hill (or rock?) the Rock of Cashel was commanding. Unfortunately we missed out on learning most of its history as the tour was after we had to be back on the road.

After exploring the castle, we strolled down to explore the ruins of a wild and rugged looking abbey - Hore Abbey.

Bronte then made her way back to Glasgow via Dublin, and we drove on to Killarney! We checked into our AirBnB and found a delicious dinner at a local pub.

Day 4: Killarney - Galway

Our trip to Galway was a long one. A decent breakfast and postcard hunt was followed by 1.5 hours to Limerick, where we planned to stop for a light lunch. However, the size of the city defeated us and we decided to continue on. Still hungry, we stopped at Ennis and wandered down the quaint streets until we found a great little cafe. Then it was on to the Cliffs of Moher. We decided not to stop at the tourist trap and instead drove down the coastal road - the Wild Atlantic Way - by far my favourite part of the entire Ireland trip! It was an incredible drive, and the Wild Atlantic Way definitely lived up to its name.

All the houses along the coast are hunkered down against the regular wind and storms that come over the ocean. The weather was rough, making the Atlantic look powerful and savage. We took a detour down to Doolin Pier, where the ferries depart, and got up close (well, not too close) and personal with the ferocity of the waves. The weather was so bad that none of the ferries were running, answering our question for how boats would be able to survive in such harsh weather!

We continued down the coastal road, passing a lighthouse perched on a rock, cows on the cliffs, and what passes for an Irish beach. It was windy, cold and miserable, although it might be alright in summer. Not quite up to the Australian standard of beach.

An hour's driving (plus many stops) saw us at our next AirBnB, a quirky house and garden owned by an artist. For the first time we had a full kitchen, so we made use of it to make a homemade meal and save some of those euros!

Day 5: Galway - Westport

A leisurely mid-morning checkout was followed by the highlight of the trip: a guided hike into the mountains of Oughtmama. We arrived at the farmhouse early and were the only two people on the hike, making for a very personal tour! Our guide, Darragh, told us about much of the folk lore and history of Ireland. This included the potato famine, the role of Fairies in Irish folklore (and fairy trees), how Ireland shaped the church, why the Irish lost the skill of fishing, and the how central farming was to the Irish way of life.

We saw a large tribe of goats and learned about the architecture used in the ancient ruined churches. All sorts of weather were had in the 2 hours: sleet, snow, soft hail, wind and sunshine! At the end of the tour we went back to the farmhouse for a hot drink to warm us up, before exploring their boutique chocolate shop. We couldn't help buying some of the elderberry and hazelnut (both of which are grown and picked on the farm) chocolate.

After our hike it was straight up to Westport, a 2 hour drive that took 3.5 due to Ireland's inability to deal with snow. There was less than an inch on the ground and some people were doing 30 km/h. Then, to make matters worse, they closed all entrances to Westport meaning we were stuck for nearly an hour.

We finally got to our AirBnB, a room with a friendly sailing couple who greeted us with tea and cake, which was welcome after our long drive!

Day 6: Westport - Athlone

Another delicious traditional Irish breakfast (including black pudding) was a great start to another day adventuring. We continued to follow the Wild Atlantic Way up to Achill Ireland. The seas were very rough again, and the wind caused our little car to feel like it was about to picked up and blown away! Many multicoloured sheep were huddled behind rocks and walls away from the wind.

Not sure the life ring would be much help.

At the end of the road, we sat on a lookout and had tea and biscuits from our thermos. It was quite a view to have over morning tea! Then it was the long drive to Athlone. Along the way our exhaust pipe started rattling, which was comforting. We hoped the car would hold together long enough for us to get it back. Never getting a Nissan Micra!

In Athlone we made a quick stop for pizza before arriving at our next AirBnB, a cute self-contained loft. The family had a very friendly dog called Oscar, who kept wanting to join us and would open the door if it wasn't locked!

Day 7: Athlone - Dublin

The next day it was leftovers (cold pizza, bread and cheese) for breakfast as we scrambled to get the car back and catch our flight on time. Thankfully they put the rattling exhaust down to general wear and tear. Then it was on a long-haul flight to Canada!

Total kilometres: approx. 1,150 km
Total time driving: approx. 21 hours
Weather types: wind, rain, snow, sleet, sun
Wildlife count: lots of sheep, a few woolly cows, a tribe of goats, and the odd horse

You can explore some more pictures from our trip on Facebook

Cold weather, canals and culture.

Fri, 09 Jan 2015 00:00:00 GMT

After a relatively short bus ride in from Schiphol Amsterdam we arrived at our first AirBnB. AirBnB lets people put their spare bedroom or granny flat to good use, meet people from around the world and make some money at the same time. I love it because it means you're not in an impersonal hotel or hostel and get to meet the locals! Amsterdam is famous for its skinny houses and steep staircases as a tax was levied on home owners depending on the width of the property. As you can see in the picture below where we stayed was no different. At the top of this staircase was our little ensuite bedroom - perfect for a couple of nights in Amsterdam.

We spent the first afternoon walking around Amsterdam exploring the canals and shops, and devouring a serving of the Netherland's famous hot chips (frietjes) covered in Samurai sauce. Later on we met up with one of Gen's best school friends who is studying in Maastricht on exchange for a drink and some nibbles at one of Amsterdam's many little restaurants.

Day two we awoke to cold rainy weather but that didn't stop us. First stop was Anne Frank house. Anne Frank was persecuted and ultimately killed after the Nazi invasion of The Netherlands. After hearing of the impeding invasion Anne's father hid the whole family in the back of the family factory. The were eventually found but not before Anne wrote about her experience in her diary, which has now been published. After Anne Frank House we met Caroline for breakfast in a great little cafe and met an Irishman living the ex-pat life in Amsterdam.

On the basis of a recommendation from Amanda (our AirBnB host) we decided to explore Amsterdam from sea level onboard a canal boat tour. We saw the famous seven bridges, the narrowest house in Amsterdam and much more of the city we wouldn't have otherwise seen!

Each museum in Amsterdam is open late one evening per week. On the day we were in Amsterdam (a Thursday) it happened to be the gallery of modern art - Stedelijk. We spent a great evening being cultured by exploring one of Amsterdam's biggest private collections of modern art, as well as the permanent exhibits. Then it was drinks, nachos and goodbyes to Caroline - the next time we will see her is when she returns to Brisvegas in February.

It was a great quick trip to Amsterdam exploring the canals, bearing the cold (and wet) weather and adding a bit of culture to #mattandgenvsworld. The next morning we woke up early and made our way back to the airport ready to fly to Dublin!

A Home Away From Home

Wed, 07 Jan 2015 00:00:00 GMT

I love Dresden. It feels like my second home and one of the few places where I feel like a local. Known as the Florence on the Elbe it is a city with a rich and colourful history. It was firebombed at the end of World War 2 and many buildings remained destroyed until the fall of the Berlin Wall and East Germany in 1989. Since then millions of hours and euros have been spent rebuilding the city to its former glory. The centrepiece of this rebuilding it the Frauenkirche (or Church of our Lady) which was rebuilt stone for stone. It looks like a very 'European' city with old buildings and many cobblestone streets - dust it with snow and you have a picture straight from a postcard.

I spent my GAP year here in 2010 working as a assistant english teacher (think teachers aide) at St. Benno. Gymnasium helping students develop their professional and conversational English skills.

On arrival into Dresden this time we made our way down to Schillergarten - a small beer garden in the shadow of the Blue Wonder (Blaues Wunder) bridge (it's kind of like the Dresden version of Brisbane's Story Bridge Hotel - only with glühwein and bratwurst instead of XXXX and steak).

One of the 'conditions' on staying with the Kirchberg's is that you must cook them a meal. This meant that much of our first full day in Dresden was spent cooking roast beef and vegetables, with pavlova for desert. I invited a couple of my friends over and it was a great evening of food, drink and conversation. One big topic of conversation was the big protests that have been happening in Dresden. 18,000 supporters of the Patriotic Europeans Against the Islamisation of the Occident (PEGIDA) had taken part in protests in Dresden, but in true German style counter-demonstrations took place in basically every major German city including 3,000 in Dresden. You can read more about it here: German 'anti-Islamisation' group PEGIDA draws 18,000 to protest in Dresden

New Year's Eve or "Silvester" in German is a very crazy affair! In the afternoon we partook in some real german engineering and built a ice bar ready for the party the Kirchberg's were hosting! We then escaped for the evening to one of my friend's (Leo Kaßner - founder of fingercoding) flat where we ate all kinds of unhealthy food and spent 3 or so hours catching up. Whenever I come visit Germany it always feels like I never left! It was then back to the Kirchbergs and up to their rooftop terrace to watch the fireworks. Fireworks are freely available for private use in Germany meaning that for New Year's Eve you feel like you are walking through a war zone. Disappointingly the city was covered in a thick fog and you couldn't see more than 10 metres - meaning any fireworks further than a couple of meters away were invisible.

Dresden is a very cultural city. You can enjoy everything from a very serious evening of Opera at the Semperoper in the Altstadt to a local Jazz quartet at the Blue Note bar in the bohemian Neustadt. This time we saw The King's Son - an opera from the same writer as Hansel and Gretel. This was a tragic fairytale gone wrong, and a great Christmas present from the Ulis! We also spent one evening listening to some very experimental Jazz, and another being blown away by some of Dresden's top Jazz performers, the Jazzfanatics.

It may seem like we crammed a lot in, but our time was mainly spent eating great food (especially German breakfast), catching up with friends, long walks on sunny days and doing a lot of nothing. After a busy year of study and work, it was brilliant.

Much love and thanks to the Kirchbergs, Sedlacks and Heckers for their hospitality!

Let it snow, let it snow, let it snow!

Thu, 01 Jan 2015 00:00:00 GMT

Following our graduation a couple of weeks ago my better half (Genevieve) and I decided we should do something to mark the occasion. As we both share a love of travel and will only get 4 weeks of annual leave this year we decided to fill our last couple of months of freedom with one big holiday - a last hurrah!

Over 52 days we will visit Dresden (via Munich), Amsterdam, Ireland, Toronto, Winnipeg, Yellowknife, Calgary, Big White and Vancouver, before flying back home on the 15th of February.

Flying to Europe is always a mixture of excitement, boredom and frustration - it is exciting to go travelling but there are only so many movies and TV shows you can watch! The fact that it signalled the start of our trip only exacerbated these emotions.

On arriving in Singapore (our first stopover) Gen found a massage chair and that was the last I heard from her for 30 minutes. After this short stopover it was back on the plane for another 7 hours.

Our second stopover was in Dubai for 2 or so hours - if you ever get the chance to visit Dubai airport I highly recommend visiting Shakeshack near gate A10 for some homemade lemonade and the thickest of milkshakes! Gen noticed that Shakeshack also offered something called a Concrete - it is described as a "dense frozen custard ice cream blended at high speed with mix-ins". We thought that might be delicious but after getting off a plane such a dense drink is just not appealing.

After downing a croissant from Paul (a French bakery that apparently has the best coffee in Dubai Airport) it was onto an A380 for the last leg to Munich! Emirates has never disappointed me - the planes are new, the food is nice, the flight attendants friendly and there's free Wifi on their fleet of A380s.

Landing onto a snow lined runway, we finally arrived in Munich. We deplaned, went through (a surprisingly friendly and funny) immigration, collected our bags, and made our way to the Europcar counter. Now came the first big test of my planning aptitude. Hiring cars as a 'young driver' (under 25) is difficult and expensive. Add to this the strange QLD/Australian graduated driving licence system and you have a recipe for uncertainty and noncommittal emails from car rental companies. Would they accept my QLD provisional licence as a full licence (I had been informed they would) and would they be happy to rent the car to 22 year old me?

Well luckily the answer happened to be yes and Gen and I were presented with the keys to an Audi A3! What. A. Car. It looked fantastic and had more buttons and gadgets on it then you could poke a stick at! That said, driving a manual on the opposite side of the road, through two roundabouts, in the snow and dark, following instructions from a very german GPS could have been a recipe for disaster but it was non-eventful, helped by the bucketloads of adrenaline that was surging through my body.

We found our hotel (Hotel Hallbergerhof) and were pleased to find out our room had been upgraded from a twin room with a shared bathroom to a double room with our own bathroom! We were early to bed and woke again early the next morning ready for the big drive to Dresden. Before we got on our way we found a small local bakery and bought breakfast - it cost us €4.50 for a day's worth of bread and an excellent cup of coffee.

The drive to Dresden was great! Cruising along German Autobahns at an average of 140km/h through snow covered mountains is an surreal experience. It was a team effort with Gen letting me know when I was drifting too far in one direction and watching out for cars when changing lanes - essentially a beautiful lane assist. It is invaluable when you are driving on the opposite side of the road.

It was a reasonably uneventful trip minus getting stuck behind a couple of snowploughs and occasionally being overtaken by someone going way too fast given the snowy conditions!

Finally, after hours of travel we made it to Dresden where I spent my GAP year in 2010 as a teaching assistant and lived with, what is now my German family, the Kirchbergs. Catching up with the Kirchbergs, and all my other German friends, is always great! They are some of the friendliest, open-minded and interesting people I have ever met.

After dropping the car back off to the airport it was back to the Kirchbergs and early to bed. We were buggered!

Why I'm In Silicon Valley

Mon, 17 Nov 2014 00:00:00 GMT

Steve Baxter is an entrepreneur, investor, founder of River City Labs and board member for StartupAUS. He will appear as a ‘Shark’ on Channel Ten’s Shark Tank Australia when it airs in 2015. He is also the man behind the Startup Catalyst program that has brought me and 19 other young potential entreprenuers to Silicon Valley for 12 days! He recently wrote an article for Business Spectator titled 'Why I’m sending 20 young Queenslanders to Silicon Valley'.

Our economy is still hugely reliant on stuff we dig out of the ground, yet we live in an age when next generation technology is creating opportunities to break into every industry sector. Australia needs technologically capable and entrepreneurially inspired young people.

You can read the rest here: Why I'm sending 20 young Queenslanders to Silicon Valley and follow all the action from Silicon Valley on our blog http://blog.startupcatalyst.com.au/!