Albertyw.com

California Oak Tree Identification

February 7, 2026

Location	Leaf	Trunk & bark	Size	Other characteristics	Species
Coastal	1‑2.5 in long, thick leathery, spiny margins; glossy green above, faint hair line in vein axils below	Trunk grows to 3 ft thick; bark smooth gray‑brown when young, darker gray with broad ridges	Up to 100 ft tall	Evergreen, dense rounded crown	Coast Live Oak (Quercus agrifolia)
Coastal	2‑6 in long, 3‑7 deep lobes, finely haired underside	Trunk 3 ft thick (up to 5 ft), bark gray and fissured	Up to 100 ft tall	Deciduous, alligator‑like bark; acorns mature in one year	Oregon White Oak Oak (Quercus garryana)
Inland	5‑10 cm (2‑4 in) long, round deeply lobed; matte green top, pale green underside, soft fuzz	Bark alligator‑hide ridged; trunk up to 10 ft diameter	Up to 98 ft tall, trunk up to 10 ft diameter	Deciduous; acorns 2‑3 cm; masting	Valley Oak (Quercus lobata)
Inland	4‑8 in long, 6 lobes, bristle‑tipped	Bark dark with small plates; grey bark	30‑80 ft tall, trunk 2 ft diameter	Acorns 2‑3 in, mature second season	Black Oak (Quercus kelloggii)
Inland	Thick leathery, 1‑3.5 in long, margins spinose or entire, fuzzy then smooth	Bark thin ~1 in, smooth, gray‑brown, may develop small tight scales	Up to 80 ft tall, 2 ft diameter	Acorns 1/2‑1.5 in long, two seasons to mature; twig slender; crown may be dense shrub or tree	Canyon Live Oak (Quercus chrysolepis)
Inland	1.5‑2 in long, entire or sharply pointed teeth; flat shiny green above, yellow‑green below	Young bark smooth gray; older rough irregularly furrowed with scaly ridges; short trunk, broad crown	30‑75 ft tall, spread 30‑80 ft	Acorns 1‑1.5 in, mature two seasons; male catkins 2‑3 in	Interior Live Oak (Quercus wislizeni)
Inland	1‑3 in long, wavy margins, bluish‑green upper, pale lower	Bark light gray checkered	≤60 ft tall, 2 ft diameter	Acorns 0.75‑1.5 in, single season	Blue Oak (Quercus douglasii)
Inland	1.5‑3 in long, leathery, entire or few sharp teeth; dull blue‑gray above, greener below, somewhat fuzzy	Bark gray with narrow scaly ridges, shallow furrows	Up to 50 ft tall, short crooked trunk, large twisted limbs, sparse crown	Acorns 1 in long with thick warty cap, mature one season	Engelmann Oak (Quercus engelmannii)

Permalink

Claude Code With Ollama Setup

January 31, 2026

I tried claude-code-router with Ollama and it didn’t really work with Ollama due to mismatching input/output formats. Even Claude Code with Anthropic doesn’t work well out-of-the box with local (not cloud) models. Instead, at least in my experience, you have to do some more setup to get a useful Claude Code CLI working with Ollama.

The below is a from-scratch setup that makes Claude Code run with a locally running gpt-oss:20b model on Ollama. It’s not as strong as cloud-based SOTA models but at least this runs locally with 32GB of memory and an Nvidia RTX 4090:

Install ollama and claude code

curl -fsSL https://claude.ai/install.sh | bash
curl -fsSL https://ollama.com/install.sh | sh

Declare a new ollama model with expanded context:

# create this file with the name "Modelfile"
FROM gpt-oss:20b
PARAMETER num_ctx 65536

Create model
```
ollama create gpt-oss-64k -f Modelfile
```

Set env vars

# Recommended: add this to ~/.bashrc
export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_BASE_URL=http://localhost:11434

Run claude code
```
claude --model gpt-oss-64k
```

Test prompts:

> list files in current directory
> create a python script that calculates the first 10 fibonacci numbers called fib.py
> Run fib.py and show its output

Permalink

Switching From Python requirements.txt to pyproject.toml

December 6, 2025

In python, a lot of projects are switching over from the old requirements.txt format of declaring dependencies to pyproject.toml and others. pyproject.toml can condense multiple requirements-*.txt files as well as other package metadata into a single file, simplifying several package maintenance processes.

The steps to switch are:

Create a bare bones pyproject.toml file in the root of your package:
```
[project]
name = "<NAME>"
version = "<VERSION>"
dependencies = [
    "dependency1",
    "dependency2",
]
```
Copy a name and version from your setup.py if you’re still using that. Copy dependencies from your requirements.txt. Dependencies in pyproject.toml follow the same format as requirements.txt and support dependency versioning with ==, >=, and < limits.
If you’ve split your requirements-test.txt or other types of dependencies, you can include them in your pyproject.toml as optional dependencies:
```
[project]
...

[project.optional-dependencies]
test = [
    "dependency3",
    "dependency4",
]
```
Delete your requirements.txt. Hopefully you’re using version control.
Switch your build commands from pip install -r requirements.txt to pip install -e .. If you want to install optional test dependencies too, you can do that with pip install -e .[test].

Permalink

Generating Cloudflare Origin Certificate for Multiple Domains

November 8, 2025

Cloudflare recommends having an Origin Certificate installed on the server that hosts your website (your Origin) so that requests between Cloudflare and your Origin are encrypted and Cloudflare can authenticate your server’s data.

This gets problematic if you host multiple domains on your server. It’s not possible to do so through the UI, but Cloudflare actually supports multi-domain Origin Certificates through its API. To generate and install a multi-domain certificate, use this script:

"""
This script generates an origin certificate from Cloudlare using their API.
It requires the 'requests' library to make HTTP requests.
"""

from cryptography import x509
from cryptography.x509.oid import NameOID
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import rsa
import requests


# Origin SSL Certificate Update API Token
# Generate at https://dash.cloudflare.com/profile/api-tokens
# Create a Token -> Create Custom Token
# Settings: Permissions Zone + SSL and Certificates + Edit
AUTH_TOKEN = "<TOKEN>"

INSTRUCTIONS = """
sudo cp certificates/server.key /etc/nginx/ssl/server.key
sudo cp certificates/server.pem /etc/nginx/ssl/server.pem
sudo chmod 640 /etc/nginx/ssl/server.key
# Restart nginx
# /etc/init.d/nginx restart
"""


def get_domains() -> list[str]:
    return [
        "example.com",
        "example2.com",
        "example3.com",
    ]


def generate_key() -> rsa.RSAPrivateKey:
    # Generate our key
    key = rsa.generate_private_key(
        public_exponent=65537,
        key_size=2048,
    )
    # Write our key to disk for safe keeping
    with open("certificates/server.key", "wb") as f:
        private_bytes = key.private_bytes(
            encoding=serialization.Encoding.PEM,
            format=serialization.PrivateFormat.TraditionalOpenSSL,
            encryption_algorithm=serialization.NoEncryption(),
        )
        print("Private Key for signing")
        print(private_bytes.decode("utf-8"))
        f.write(private_bytes)
    return key


def generate_csr(key: rsa.RSAPrivateKey) -> str:
    # Generate a CSR
    csr = x509.CertificateSigningRequestBuilder().subject_name(x509.Name([
        # Provide various details about who we are.
        x509.NameAttribute(NameOID.COUNTRY_NAME, "<COUNTRY>"),
        x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, "<STATE>"),
        x509.NameAttribute(NameOID.LOCALITY_NAME, "<CITY>"),
        x509.NameAttribute(NameOID.ORGANIZATION_NAME, "<ORGANIZATION>"),
        x509.NameAttribute(NameOID.COMMON_NAME, "<COMMON_NAME>"),
    ])).sign(key, hashes.SHA256())
    csr_bytes = csr.public_bytes(serialization.Encoding.PEM)
    with open("certificates/csr.pem", "wb") as f:
        f.write(csr_bytes)
    csr_string = csr_bytes.decode("utf-8")
    print("Certificate Signing Request:")
    print(csr_string)
    return csr_string


def request_origin_certificate(csr: str, domains: list[str]) -> None:
    # Request the origin certificate from Cloudflare
    url = "https://api.cloudflare.com/client/v4/certificates"
    headers = {
        "Content-Type": "application/json",
        "Authorization": "Bearer %s" % AUTH_TOKEN,
    }
    domains += ["*.%s" % d for d in domains]
    print("Domains:")
    print(domains)
    data = {
        "csr": csr,
        "hostnames": domains,
        "request_type": "origin-rsa",
        "requested_validity": 5475,  # Valid for 15 years
    }
    response = requests.post(url, json=data, headers=headers)
    if response.status_code == 200:
        print("Origin certificate requested successfully.")
        data = response.json()
        certificate_pem = data["result"]["certificate"]  # type: ignore
        with open("certificates/server.pem", "w") as f:
            f.write(certificate_pem.strip())
        print("Origin certificate:")
        print(certificate_pem)
    else:
        print("Failed to request origin certificate.")
        print("Status Code:", response.status_code)
        print(response.text)


def main() -> None:
    domains = get_domains()
    key = generate_key()
    csr_string = generate_csr(key)
    request_origin_certificate(csr_string, domains)
    print(INSTRUCTIONS)


if __name__ == "__main__":
    main()

Permalink

Introductory Computer Science and Software Engineering Topics

August 3, 2025

A list of practical topics to learn as an introduction to computer science and beginner software engineering:

Algorithms and Data Structures (textbook) - the basics of computer science; emphasis on the data structures such as arrays, maps, and graphs
Programming languages to learn well:
- Python (or some scripting language)
- Typescript (for a well-implemented but accessible strongly-typed language)
- Go (for a simple language with good support for parallelization)
- SQL (widely applicable for talking to databases)
Programming languages to learn:
- C (the fount of current languages)
- Java (the most common language for backend engineering)
- Javascript (the Lingua Franca for frontend engineering)
- HTML (because you’re sooner or later going to need to build a website)
- Bash (so you can improve your tools)
How to learn a language: write small programs for it in Leetcode, Rosalind, Advent of Code, or similar to learn the syntax. Write small projects in it to learn the language ecosystem.
Topics to go deeper on:
- Unix/Linux basics - Environment variables, everything is a file
- 12-factor app - Some rules for designing backend systems
- HTTP/JSON - How to send messages between systems like they’re websites
- gRPC/Proto - How to send messages between systems (grown up)
- Designing Data-Intensive Applications - A dive into architecture around storage, indexing, and processing of data
- Code architecture - Learn how to break software down into modules with abstractions
Tooling:
- IDE and/or Text editor (try Neovim) - Know and/or configure the capabilities of your text editor or terminal environment
- Terminal - Learn CLI commands as you need them but be familiar with things like piping data from one command to another
- Git - Version control everything. Be familiar with rebase.
- (Optional) Set up and configure your dotfiles - Once you start version controlling your configuration, you’ll more actively customize your working environment
Projects (because building things is more fun than reading)
- Build a static website
- Build a web scraper
- Build a CLI
- Build a program that reads/writes data to a database
- Build a program that reads, processes, and writes data to a file

Permalink

Notes

California Oak Tree Identification

Claude Code With Ollama Setup

Switching From Python requirements.txt to pyproject.toml

Generating Cloudflare Origin Certificate for Multiple Domains

Introductory Computer Science and Software Engineering Topics