Bits, Bobs & Breakpoints — Aaron Holmes

Browser-Based URL and vCard QR Code Generator

2026-06-01T17:06:58+00:00

Browser-Based URL and vCard QR Code Generator#

25 May 2026

JavaScript, QR Code, SVG, Utility, Frontend

This is a single HTML file that turns a URL or vCard contact details into a QR code and saves it as a scalable SVG - handy for business cards, signage, or anything headed to print. It runs entirely in your browser with no internet connection, so nothing you type ever leaves your device.

Opening It#

Open the generator in your browser, or access it right in this page, or download that file and open a local copy - it behaves the same either way, since the whole thing runs client-side. The build form is on the left; the QR code, the download buttons, and the design controls are on the right. The code re-renders automatically whenever you change a field - there is no “generate” button to press.

Build a QR For#

The buttons at the top pick what the code encodes:

URL - any link, including https://, mailto:, tel:, sms:, geo:, and custom app schemes. This is the default.
Contact (vCard) - a contact card a phone can import directly into its address book.

The form below changes to match. Each mode keeps its own saved data, so you can switch back and forth without losing what you’d typed.

Entering a URL#

In URL mode, paste your address into the URL field. The same scheme prefixes that work on a phone work here too. The preview updates live, and the encoded payload is shown beneath it. Clear URL wipes the field and its saved copy.

Entering a Contact#

Fill in whatever applies: name, organization, title, address, website, and a note. Every field is optional, and blank ones are simply left out of the code. As you type, the preview and the vCard payload beneath it update live.

Phones and Emails#

Use + Add phone and + Add email to add rows, and the × on a row to remove it. Each row has a type, an optional custom label, and a primary star.

Types and Labels#

Pick a type from the dropdown - Mobile, Work, Home, and so on. To give an entry a custom name like Store, type it into the label field on the row.

For an entry you really want to read as its label, set the type to None / label only. On Android a standard type can override the label, so dropping the type lets the label win. iOS shows the label either way.

The Primary Star#

Tap the ★ to mark one phone and one email as primary. Whatever imports the card treats that entry as the default.

Country Codes#

Phone rows have a country picker; search it by country name or dial code. If you paste or type a number that begins with +, the tool detects the country and strips the prefix for you, leaving just the local number.

Designing the Code#

The QR card on the right has its design controls in two places:

The block of options directly beneath Download SVG / Copy / Reset design controls the QR matrix itself - background, color, gradient.
The LOGO / SHAPE / FRAME tabs below it control everything that wraps the QR - a center icon, the module shape, and the surrounding frame and label.

Every choice applies live, is saved in your browser, and survives reloads.

Background and Color#

Background - check Transparent to drop the white plate. Useful when placing the code over artwork.
Color - click the swatch to open the color picker (hue strip, a 2D saturation/value square, and an editable hex field).
Gradient - check the box to fill the QR’s dark modules with a gradient instead of a flat color. A To row appears for the end color and a Linear / Radial toggle. Linear adds a Direction row with an eight-point compass; pick where the second color should sit. Radial doesn’t need a direction - it goes center to edge. Turning the gradient on auto-bumps error correction to H, because the varying contrast across modules is harder for scanners to threshold. If you pick a color light enough that the contrast against the white background gets soft, the tool warns you with a toast.

Error Correction#

Below the QR’s options is a small L / M / Q / H selector. Higher levels survive more wear and dirt but produce a denser code. M is a sensible default; drop to L if a long contact won’t fit. The tool auto-bumps to H whenever a center logo, a gradient, or a risky module shape is in use, so the code can recover what’s covered or softened.

Center Logo#

The LOGO tab puts a small icon at the center of the code. Pick one of the social presets (Instagram, Facebook, X, LinkedIn, YouTube, Email, Phone, Website, Location) or use Upload custom image to load your own (PNG, JPEG, GIF, WebP, or SVG - SVG keeps everything vector and stays sharp at any size). The uploaded image shows up as a Custom tile in the picker, and re-uploading replaces it.

Size - the icon and its plate, as a percentage of the QR.
Background - the shape of the plate behind the icon, Square or Circle. The plate clears the QR modules in its footprint exactly, with no partial-module artifacts.
Color - the logo color. By default it tracks the QR’s foreground; if you change the QR color, the logo follows. Once you pick a color explicitly it becomes independent, and a Match QR button appears next to the gradient toggle so you can re-inherit at any time. Custom raster images ignore this setting - the image has its own pixels.
Gradient - same controls as the QR’s gradient. Applies to preset SVG icons by substituting their stroke and fill references; custom raster images aren’t affected.

Selecting any logo automatically bumps error correction to H so the code can recover the modules the logo covers.

Shape#

The SHAPE tab changes how the data modules look. The default is Square. Other choices include Dots (small circles), Rounded (corner radii fill in where neighbors are absent), Horizontal rounded (pill-shaped), and several decorative variants: Pointed, Notched, Hooks, and Triangles.

The three corner finder patterns stay as plain squares regardless of the shape - scanners use them to locate the code, so leaving them predictable keeps things scannable. The more decorative shapes (dots, hooks, triangles, notched) auto-bump error correction to H for the same reason.

Frame#

The FRAME tab puts a border around the code and an optional text label:

Style: None, Square, Rounded, or Circle.
Color - the frame’s stroke color, independent of the QR’s foreground.
Gradient - a gradient fill for the frame’s stroke, with the same Linear / Radial / Direction controls as the QR. For a Circle frame, Radial does what you’d expect: the gradient transitions exactly across the stroke’s inside edge to its outside edge, since the geometry is naturally radial. For Square and Rounded frames a true inside-to-outside gradient isn’t representable on a rectangular stroke; Radial falls back to a centered halo where the corners pick up more of the end color than the side midpoints do. Linear works as expected on every frame shape.
Padding - the gap between the QR matrix and the inner edge of the frame. 0 makes the frame touch the QR’s outermost dark modules; higher values add space between them. If you turn on a gradient while padding is 0, the tool bumps it to 1 - a frame touching gradient-filled modules with no quiet zone tends to defeat scanners.
Thickness - the stroke width. 0 is allowed, useful for text-only setups where you want the label but not a visible border.

Below those, a divider separates the frame’s appearance from its text:

Text - up to 40 characters, e.g. SCAN ME.
Font - Sans, Serif, or Mono.
Placement - Outside the frame (the canvas grows beyond it) or Inside (the frame grows to enclose the text alongside the QR). Circle frames only support outside.
Position - Top or Bottom.
Size - how big the text is.
Text color - independent of the frame color. Like the logo color, it defaults to tracking the frame color until you pick something explicitly; a Match frame button reverts to inheriting.
Gradient - end color, Linear / Radial, and Direction, applied to the text fill. At small text sizes the effect is subtle because the gradient spans only the text’s bounding box - pick high-contrast endpoints or a horizontal direction if you want a strongly visible gradient.

Resetting the Design#

Reset design, to the right of Download and Copy, clears every visual setting - background, color, all four gradients (QR, frame, logo, text), logo, shape, frame, frame text, error correction - back to defaults. The contact or URL itself isn’t touched.

Saving Your Work#

Everything you enter is saved in your browser automatically, so what you had open is still there when you come back. Clear all fields wipes the vCard form and its saved copy; Clear URL does the same in URL mode. Reset design clears just the design choices.

Note: the saved copy is tied to the specific browser and file location. Moving or renaming the file starts fresh, and some browsers are strict about storage on file:// URLs - serving the file over http avoids that.

Exporting#

Download SVG - the QR code as a vector file, for print or design tools. Stays crisp at any size. The one exception is a custom raster image used as a logo; if you want full vector all the way through, upload an SVG.
Download .vcf - the raw contact card, to import or share directly. (vCard mode only.)
Copy URL / Copy vCard - copies the encoded payload to your clipboard.

Before You Print#

Always scan and import the finished code on a real phone before sending anything to print. A code that looks fine but imports the wrong details is worse than none at all. Gradients, dense shapes, and tight padding all push on a scanner’s ability to find and decode the code - the tool nudges settings toward safer choices (ECC, padding) when you turn those on, but nothing beats verifying on the actual device the recipient will use.

One harmless quirk to expect: on Windows the country flags in vCard mode appear as two-letter codes instead of emoji - the dial code is always shown beside them, so nothing is actually missing.

Interview Coding Take-Homes: Part 3

2026-01-17T01:50:22+00:00

Interview Coding Take-Homes: Part 3#

15 December 2025

Programming, Software, Interviewing

UCLA Health - Population Analysis#

This take-home was about the data ingestion and cleaning population data. The goal was to take messy JSON from an API and turn it into a clean CSV, so the analysis and visualization could focus on the real questions without getting bogged down in data cleanup.

Goals#

Produce a CSV with a fixed header order and stable types.
Keep each transformation small and unit-testable.
Fail fast on missing required fields and log useful diagnostics.

Why this approach#

Even though the dataset was small and straightforward, it had all the typical real-world issues: keys with spaces, inconsistent casing, and numbers as strings. Instead of using heavy tools, I focused on keeping things clear, with predictable output and a simple flow I could easily follow.

Repository#

The implementation is in the population-analysis repo under the Analysis/ directory. See the source and examples at:

population-analysis (Analysis)

Process overview#

Load JSON from the API or from the cached sample used in tests.
Rename and normalize keys so everything aligns with the internal schema.
Coerce types (strings -> ints/dates) and fail if required data is missing.
Emit two CSVs: one raw mapping for auditing and one cleaned file for analysis.

Key implementation details#

Handling messy JSON keys#

The prompt demanded a tight mapping between API fields and output columns. Because the API returns keys with spaces and wobbly casing, the data model leans on [JsonPropertyName] attributes to translate them into clean C# properties:

PopulationEntry.cs#

[JsonPropertyName("ID State")]
public string IdState { get; set; } = "";
public string State { get; set; } = "";
[JsonPropertyName("ID Year")]
public int IdYear { get; set; }
public string Year { get; set; } = "";
public int Population { get; set; }
[JsonPropertyName("Slug State")]
public string SlugState { get; set; } = "";

This keeps the mapping explicit and makes it obvious which API field feeds each column.

Fetching and caching the data#

The application calls the public census API, but I do not re-fetch on every test run. Instead the client caches the payload locally so the API stays quiet while I iterate:

Api.cs#

var data = await GetFromCache();
if (data != null) return data;

var httpClient = httpClientFactory.CreateClient(nameof(Api));
httpClient.BaseAddress = new Uri("https://datausa.io/");

On a fresh pull, the JSON hits disk before deserialization. That keeps the workflow testable and reinforces a clean separation of concerns:

Api.cs#

try
{
    json.Seek(0, SeekOrigin.Begin);
    await json.CopyToAsync(cacheDestination);
    await cacheDestination.FlushAsync();
    log.LogDebug("API data written to cache.");
}
catch
{
    log.LogDebug("Failed to write API JSON result cache.");
}
json.Seek(0, SeekOrigin.Begin);
data = await JsonSerializer.DeserializeAsync<Result>(json);

Example input (trimmed)#

This is an example of the API shape-keys with spaces, mixed casing, and numeric types that arrive as JSON numbers.

sample_input.json#

{
    "data": [
        { "ID State": "04000US01", "State": "Alabama", "Year": 2023, "Population": 5054253, "Slug State": "alabama" },
        { "ID State": "04000US02", "State": "Alaska", "Year": 2023, "Population": 733971, "Slug State": "alaska" }
    ]
}

The ingest pipeline renames those columns to id, state, slug, etc., and asserts that the types stay stable before writing the normalized CSV.

Normalized CSV (representative rows)#

The cleaned CSV fixes the header order and uses explicit types. Representative rows:

id,state,slug,year,population
04000US01,Alabama,alabama,2023,5054253
04000US02,Alaska,alaska,2023,733971

Notes on implementation#

API keys such as "ID State" and "Slug State" map to canonical names (id, slug) so downstream code never reasons about the raw schema.
Validation is blunt by design: missing required fields fail the run; weird values get logged for inspection instead of disappearing quietly.
Every time a new API field appeared, I did the same ritual: dump a single response to disk, diff it against the schema, and verify the mapping by regenerating the CSV. That quick loop kept regressions visible without a ton of ceremony.

Testing and verification#

Testing the pipeline#

Before trusting the CSV, I walk through the same routine I use on most take-homes: run the automated suite, then spot-check the binary output.

$ cd population-analysis
$ dotnet test

The tests live in population-analysis/Test and use xUnit + Moq. They verify that the ingestion pipeline does what I expect even when the API or filesystem behaves badly.

What the tests cover#

Test/AnalysisApi.cs drives the API client through both code paths. It ensures cached payloads short-circuit HTTP calls, verifies that cache files are written before parsing, and checks that failures log meaningful errors.
Test/AnalysisReport.cs exercises the aggregation layer. It confirms that populations group by state/year, headers stay deterministic, sorted tables behave, and the factor column lines up with each year.
Test/AnalysisReport.cs also reflection-loads the Report helpers so I can assert on the tables without spinning up the CLI.

Manual sanity checks#

Automated tests catch regressions, but I still run a quick end-to-end pass to see the CSV with my own eyes:

$ cd population-analysis
$ dotnet run --project Analysis/Analysis.csproj
Enter a path to write the CSV file to:

I point it at population.csv, inspect the generated CSV/raw pair, and spot-check a few rows against the original JSON. When a slug or population looks wrong, I can walk back through the normalization rules immediately.

Running with Docker#

If you prefer not to set up .NET locally, the application also runs in a Docker container. The image is multi-arch and supports both AMD64 and ARM64, so it should work on most systems.

Pull and run it like this:

$ docker run \
>    -u $(id -u):$(id -g) \
>    -v /path/to/output/directory:/csv_destination \
>    --rm -it \
>    aholmes0/population-analysis:latest

This mounts a local directory to /csv_destination inside the container, where the CSV files get written. The -u flag runs as your user ID to avoid permission issues with the output files.

Tradeoffs#

The pipeline favors clarity and observability over extreme throughput. It assumes the dataset fits on one machine without drama.
Formal schema enforcement (JSON Schema, etc.) would help for larger teams, but I skipped it here to keep iteration fast.

Analysis and findings#

With the cleaned CSV ready, I shifted into exploration mode. The dataset spans multiple years across every U.S. state and territory, so it is a natural fit for trend comparisons. The headline question people kept asking was: Are Californians moving to Texas? Rather than lean on anecdotes, I ran the numbers.

Key steps:

Compute year-over-year population changes per state.
Normalize growth rates with z-scores and compare peers head-to-head.
Flag periods where migration signals diverged.
Plot each view so the story is obvious without reading code.

Result: both California and Texas keep growing, and their growth curves tend to move in tandem. That implies broader economic or demographic drivers rather than a one-way California -> Texas pipeline.

Testing the idea#

I do not accept charts at face value, so I poked at the data from a few angles:

Cross-check the raw counts. Before normalizing, I spot-checked California and Texas populations against the Census CSV to ensure the ingest layer did not mangle digits. Having the raw CSV beside the formatted one made this painless.
Validate the story with multiple transforms. The z-score plot highlights divergences, but I also built the rank-change visualization to confirm the same periods popped out. If two independent views disagree, the notebook gets deleted.
Interrogate the edges. Whenever a state’s growth looked extreme, I tracked it back to the underlying rows to see if the spike came from a real trend or a data glitch. That habit kept the write-up grounded in facts, not vibes.

Output and visualization#

The cleaned population data:

population.csv (first 10 rows)#

"State Name","2013","2014","2015","2016","2017","2018","2019","2020","2021","2022","2022 Factors"
"Alabama","4799277","4817678 (0.38%)","4830620 (0.27%)","4841164 (0.22%)","4850771 (0.20%)","4864680 (0.29%)","4876250 (0.24%)","4893186 (0.35%)","4997675 (2.14%)","5028092 (0.61%)","2;2;97;12959"
"Alaska","720316","728300 (1.11%)","733375 (0.70%)","736855 (0.47%)","738565 (0.23%)","738516 (-0.01%)","737068 (-0.20%)","736990 (-0.01%)","735951 (-0.14%)","734821 (-0.15%)","389;1889"
"Arizona","6479703","6561516 (1.26%)","6641928 (1.23%)","6728577 (1.30%)","6809946 (1.21%)","6946685 (2.01%)","7050299 (1.49%)","7174064 (1.76%)","7079203 (-1.32%)","7172282 (1.31%)","2;13;311;887"
"Arkansas","2933369","2947036 (0.47%)","2958208 (0.38%)","2968472 (0.35%)","2977944 (0.32%)","2990671 (0.43%)","2999370 (0.29%)","3011873 (0.42%)","3006309 (-0.18%)","3018669 (0.41%)","3;47;79;271"
"California","37659181","38066920 (1.08%)","38421464 (0.93%)","38654206 (0.61%)","38982847 (0.85%)","39148760 (0.43%)","39283497 (0.34%)","39346023 (0.16%)","39455353 (0.28%)","39356104 (-0.25%)","2;2;2;53;92821"
"Colorado","5119329","5197580 (1.53%)","5278906 (1.56%)","5359295 (1.52%)","5436519 (1.44%)","5531141 (1.74%)","5610349 (1.43%)","5684926 (1.33%)","5723176 (0.67%)","5770790 (0.83%)","2;5;59;9781"
"Connecticut","3583561","3592053 (0.24%)","3593222 (0.03%)","3588570 (-0.13%)","3594478 (0.16%)","3581504 (-0.36%)","3575074 (-0.18%)","3570549 (-0.13%)","3605330 (0.97%)","3611317 (0.17%)","3611317"
"Delaware","908446","917060 (0.95%)","926454 (1.02%)","934695 (0.89%)","943732 (0.97%)","949495 (0.61%)","957248 (0.82%)","967679 (1.09%)","981892 (1.47%)","993635 (1.20%)","5;37;41;131"
"District of Columbia","619371","633736 (2.32%)","647484 (2.17%)","659009 (1.78%)","672391 (2.03%)","684498 (1.80%)","692683 (1.20%)","701974 (1.34%)","683154 (-2.68%)","670587 (-1.84%)","3;223529"

Key analysis code blocks and observations:

Helper Functions for Analysis#

Before diving into visualizations, I defined helper classes and functions to handle the data transformations consistently across plots.

FillData class and zscore helper functions#

class FillData(NamedTuple):
    year1: str
    year2: str
    zscore1: float
    zscore2: float
    change1: float
    change2: float
    middle_x: float
    middle_y: float

def zscore(change):
    """Calculate the zscore of a change."""
    return (change - change.mean()) / change.std()

def get_fill_data(year_idx, change1, change2, zscore1, zscore2):
    """Get data needed for plot_fill(...) and fill(...)"""
    year1, year2 = change1.index[i], change1.index[i + 1]
    zscore_change1 = zscore1.iloc[i + 1] - zscore1.iloc[i]
    zscore_change2 = zscore2.iloc[i + 1] - zscore2.iloc[i]
    middle_x = (year_idx + year_idx + 1) / 2
    middle_y = (zscore1.iloc[i] + zscore1.iloc[i + 1]) / 2
    return FillData(year1, year2, zscore1, zscore2, zscore_change1, zscore_change2, middle_x, middle_y)

def plot_fill(change1: float, change2: float, fill_data: FillData, color1: str = '#1f77b4', color2: str = '#ff7f0e'):
    """Draws the plot for fill data between fill_data.year1 and fill_data.year2"""
    if change1 < 0 and change2 < 0:  # Both changes are declining
        if abs(change1) > abs(change2):  # First change declines more
            fill(fill_data, color1, ('\u2193', color1), ('\u2193', color2), 0.5)
        else:  # Second change declines more
            fill(fill_data, color2, ('\u2193', color1), ('\u2193', color2), 0.5)
    elif change1 > 0 and change2 > 0:  # Both changes are growing
        if abs(change1) < abs(change2):  # Change1 grows less
            fill(fill_data, color2, ('\u2191', color1), ('\u2191', color2), 0.1)
        else:  # Change2 grows less
            fill(fill_data, color2, ('\u2191', color1), ('\u2191', color2), 0.1)
    else:  # One is growing, the other is declining
        change1_arrow = '\u2193' if change1 < 0 else '\u2191'
        change2_arrow = '\u2193' if change2 < 0 else '\u2191'
        if change1 < change2:  # Change1 declines more or grows less
            fill(fill_data, color1, (change1_arrow, color1), (change2_arrow, color2), 0.5)
        else:  # Change 2 declines more or grows less
            fill(fill_data, color2, (change1_arrow, color1), (change2_arrow, color2), 0.5)

def fill(
    fill_data: FillData,
    color: str,
    arrow_left: tuple[str, str],
    arrow_right: tuple[str, str],
    alpha: float
):
    """Fills the space between fill_data.year1 and fill_data.year2"""
    plt.fill_between([fill_data.year1, fill_data.year2],
                     fill_data.zscore1.iloc[i:i + 2], fill_data.zscore2.iloc[i:i + 2],
                     facecolor=color, alpha=alpha)
    middle_x = fill_data.middle_x
    middle_y = fill_data.middle_y
    plt.gca().add_patch(FancyBboxPatch((middle_x - 0.10, middle_y - 0.05), 0.1, 0.1,
                                        boxstyle="round,pad=0.01", facecolor='white', edgecolor='none', zorder=2))
    plt.gca().add_patch(FancyBboxPatch((middle_x + 0.0, middle_y - 0.05), 0.1, 0.1,
                                        boxstyle="round,pad=0.01", facecolor='white', edgecolor='none', zorder=2))
    plt.annotate(
        arrow_left[0],

Year-over-Year Change Analysis#

The first visualization examines year-over-year population changes, normalized by z-scores to compare states on the same scale. The plot highlights periods where California and Texas growth rates diverged significantly, using filled areas and arrows to mark those intervals.

YoY change calculation and plotting#

plt.figure(figsize=(15, 10))
plt.gca().yaxis.set_major_formatter(FuncFormatter(percent_formatter))
plt.plot(california_change.index, california_zscore, marker='o', label='California', color=COLOR1)
plt.plot(texas_change.index, texas_zscore, marker='o', label='Texas', color=COLOR2)
for i in range(len(california_zscore) - 1):
    fill_data = get_fill_data(i, california_change, texas_change, california_zscore, texas_zscore)
    ca_change = fill_data.change1
    tx_change = fill_data.change2
    plot_fill(ca_change, tx_change, fill_data)
plt.title('Normalized Year-over-Year Percentage Change in Population for California and Texas')
plt.xlabel('Year')
plt.ylabel('Z-Score of % Change')
draw_legend('California', 'Texas')
plt.grid(True)
plt.show()

Rank Change Visualization#

This plot shows how states’ population ranks shifted from 2013 to 2022, with bars representing 2022 populations and curved arrows indicating rank changes. States that moved up or down in ranking are highlighted with colored bars and connecting arcs.

Rank change plotting with custom legend handler#

class HandlerArrowLine(HandlerLine2D):
    def create_artists(self, legend, orig_handle, xdescent, ydescent, width, height, fontsize, trans):
        # Create a line and an arrowhead as separate artists
        padding = 2
        line = Line2D([xdescent + padding, width - xdescent], [height / 2, height / 2], linestyle=orig_handle.get_linestyle(), color=orig_handle.get_color())
        arrow = Line2D([xdescent + padding], [height / 2], marker='<', color=orig_handle.get_color(), markersize=fontsize / 2, linestyle='None')
        return [line, arrow]

plt.figure(figsize=(15, 10))
plt.gca().yaxis.set_major_formatter(FuncFormatter(millions_formatter))
bars_2022 = plt.bar(pop_2022_sorted.index, pop_2022_sorted, color=COLOR5)
plt.title('Relative population rank change between 2013 and 2022')
plt.xlabel('State')
plt.ylabel('Population')
plt.xticks(rotation=90)

line_handles = [
    Line2D([0], [1], color=COLOR3, marker='<', linestyle='-', label='rank change'),
    Line2D([0], [1], color=COLOR1, marker='<', linestyle='-', label='top three largest rank changes'),
    Line2D([0], [1], color=COLOR2, marker='<', linestyle='-', label='top three smallest rank changes'),
]
block_handles = [
    patches.Patch(color=COLOR5, label='Population & unchanged rank'),
    patches.Patch(color=COLOR4, label='Population & changed rank')
]
plt.legend(handles=line_handles + block_handles,  handler_map={handle: HandlerArrowLine() for handle in line_handles}).get_frame().set_alpha(1)
ax = plt.gca()
for bar, state in zip(bars_2022, pop_2022_sorted.index):
    if state in changed_states:
        bar.set_color(COLOR4)
        prev_pos = order_2013.index(state)
        new_pos = order_2022.index(state)
        con = ConnectionPatch(
            xyA=(prev_pos, pop_2013_sorted[state]),
            xyB=(new_pos, pop_2022_sorted[state]),
            coordsA="data", coordsB="data",
            axesA=ax, axesB=ax,
            color=COLOR1 if state in top_3_states_by_position_change else (COLOR2 if state in bottom_3_states_by_position_change else COLOR3),
            arrowstyle=ArrowStyle("simple", head_width=1, head_length=1, tail_width=0.1), 
            fill=True,
            linewidth=1,
            connectionstyle="arc3,rad=0.9"
        )
        ax.add_patch(con)
plt.show()

Average Annual Growth Rate Map#

The final visualization maps average annual growth rates across all states using a color gradient, with vertical markers for California and Texas. The horizontal color bar provides context for the growth spectrum from highest growth to population loss.

Gradient colormap visualization#

colors = ["green", "yellow", "red"]
cmap = LinearSegmentedColormap.from_list("mycmap", colors)
norm = plt.Normalize(0, len(average_annual_rate_of_change_sorted) - 1)
fig, ax = plt.subplots(figsize=(15, 10))
plt.gca().yaxis.set_major_formatter(FuncFormatter(percent_formatter))
bars = plt.bar(
    average_annual_rate_of_change_sorted.index,
    average_annual_rate_of_change_sorted,
    color=[cmap(norm(i)) for i in range(len(average_annual_rate_of_change_sorted))],
    zorder=2 # hide grid behind bars
)
ax = plt.gca()
for state in ['California', 'Texas']:
    idx = average_annual_rate_of_change_sorted.index.get_loc(state)
    bar = bars[idx]
    x = bar.get_x() + bar.get_width() / 2
    ax.axvline(x=x, color='red', linestyle='--', linewidth=1)
plt.title('Average Annual Rate of Change in Population for All States')
plt.xlabel('State')
plt.ylabel('Average Annual Rate of Change (%)')
plt.xticks(rotation=90)
plt.grid(True, zorder=0) # hide grid behind bars
sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
sm.set_array([])
sm.set_clim(0, len(average_annual_rate_of_change_sorted) - 1)
cbar_ax = fig.add_axes([0.161, 0.86, 0.698, 0.02])
cbar = plt.colorbar(sm, cax=cbar_ax, orientation='horizontal')
cbar.set_ticks([])
cbar_ax.text(0.0, 0.5, 'Highest Growth', va='center', ha='left', color='white', fontweight='bold', transform=cbar_ax.transAxes)
cbar_ax.text(0.5, 0.5, 'Moderate Growth', va='center', ha='center', color='black', fontweight='bold', transform=cbar_ax.transAxes)
cbar_ax.text(1.0, 0.5, 'Loss', va='center', ha='right', color='white', fontweight='bold', transform=cbar_ax.transAxes)
plt.show()

The full analysis including charts and findings is available in the Jupyter notebook:

PopulationAnalysis.ipynb

Conclusion#

In the end, this take-home took raw JSON and turned it into a clean CSV by breaking it down into small, clear steps. That makes it simple to test and audit, and gets you ready for the analysis. The practical approach-caching to skip repeated API calls, clear key mappings, and straightforward validation- shows good thinking and communication, not unnecessary complexity.

Interview Coding Take-Homes: Part 2.b

2025-08-28T23:26:51+00:00

Interview Coding Take-Homes: Part 2.b#

28 August 2025

Programming, Software, Interviewing

UCLA Health - Terraform Module#

This take-home was for a Senior Cloud DevOps Engineer position in a key IT organization at UCLA Health.

This is part b of a two-part take-home. Read the first part, Interview Coding Take-Homes: Part 2.a.

Prompt#

You are a terraform developer building a new module to help with naming resources deployed within the cloud environment. You will have two inputs to this module identifying a “base_name” and “resource_type” with which you will have to evaluate and generate a “resource_name” as an output. The “resource_name” that you generate should follow these rules:

You should setup the “resource_type” to only allow the values of “virtual_machine”, “key_vault”, and “storage_account”

If the resource_type is “virtual_machine” you should take the “base_name” and append “vm-” to the front of it and “-00” to the back. If the base name and and values you’re appending are greater than 15 characters you should truncate the “base_name” only in order to be 15 characters when combined with your additional characters. Note that the base_name can be greater than 15 characters.

If the resource_type is “key_vault” you should append “kv-” to the front of “base_name” and then set all characters to lower case.

If the resource_type is “storage_account” you should append “sa” to the front of “base_name and then remove all “-” from the name and then set all characters to lower case.

You should also build a secondary module that calls your naming module. This parent module should intake a map which has the “base_name” as the key and the “resource_type” as the value. It should present each key/value pair in this map to your naming module.

The Parent Module should reflect all the outputs of the child module and allow for additional outputs if the child module outputs are expanded in the future without further modification to the parent.

Please write these modules as you would for a production environment following best practices and structure that makes it easy to share with other team members and allows them to use it quickly after receiving it.

You can reference the naming module either through a local path or a github URL as long as the entire package can be run from a computer with public internet access.

My Approach#

Whew - that’s a lot to read.

Although I knew what Terraform is, my experience with it is very limited. So first and foremost, I read the Get Started - AWS tutorial. To avoid unintentionally incurring costs, I used LocalStack instead of AWS for my testing.

After completing the tutorial, I relied heavily on the Terraform documentation to complete the prompt.

Here is the project structure I ended up with.

The specifics of these files is documented in Resource Name Mapper.

`resource_type` Constraints#

You should setup the “resource_type” to only allow the values of “virtual_machine”, “key_vault”, and “storage_account”

naming/variables.tf#

variable "resource_type" {
    description = "Must be one of `virtual_machine`, `key_vault`, or `storage_account`."
    type = string

    validation {
        condition = contains(["virtual_machine", "key_vault", "storage_account"], var.resource_type)
        error_message = "`resource_type` must be one of `virtual_machine`, `key_vault`, or `storage_account`."
    }
}

This requirement uses an input variable block that contains a validation block. The contains(list, value) function is used to constrain the input variable to the three acceptable values.

`base_name` and `resource_name` Alterations#

If the resource_type is “virtual_machine” you should take the “base_name” and append “vm-” to the front of it and “-00” to the back. If the base name and and values you’re appending are greater than 15 characters you should truncate the “base_name” only in order to be 15 characters when combined with your additional characters. Note that the base_name can be greater than 15 characters.

If the resource_type is “key_vault” you should append “kv-” to the front of “base_name” and then set all characters to lower case.

If the resource_type is “storage_account” you should append “sa” to the front of “base_name and then remove all “-” from the name and then set all characters to lower case.

naming/locals.tf#

    base_name = (
        var.resource_type == "virtual_machine" ? substr(var.base_name, 0, 15 - length("vm-") - length("-00")) :
        var.resource_type == "key_vault" ? lower(var.base_name) :
        lower(replace(var.base_name, "-", "")) # storage account
    )

This requirement is handled by a lengthy conditional expression.

Line 3 is specific to virtual_machine’s base_name. As the requirements state, we truncate the base_name to 15 characters, minus the length of the vm- prefix and -00 suffix we add to the resource_name.

Both key_vault and storage_account are handled here as well.

naming/locals.tf#

    resource_name = (
        var.resource_type == "virtual_machine" ? "vm-${local.base_name}-00" :
        var.resource_type == "key_vault" ? "kv-${local.base_name}" :
        "sa${local.base_name}" # storage account
    )

And here we use another conditional expression to add the prefix and suffix to the resource names.

Secondary Module#

You should also build a secondary module that calls your naming module. This parent module should intake a map which has the “base_name” as the key and the “resource_type” as the value. It should present each key/value pair in this map to your naming module.

I’ve named this module batch because it processes a “batch” of resources together.

batch/variables.tf#

variable "resources" {
    description = "A map of base names and resource types."
    type = map(string) # {"app":"virtual_machine", "data":"storage_account", ...}
}

The module takes the input resources as a string map.

batch/main.tf#

module "naming" {
    for_each = var.resources
    source = "../naming"

    base_name = each.key
    resource_type = each.value
}

The batch module uses the naming module. From the resources input variable, base_name is set to its key, and resource_type is set to its value.

The Parent Module should reflect all the outputs of the child module and allow for additional outputs if the child module outputs are expanded in the future without further modification to the parent.

batch/outputs.tf#

output "resource_names" {
    description = "A map of base names to formatted resource names."
    value = { for k, v in module.naming: k => v.resource_name }
}

The module sets the resource_names output variable as an object that reflects the outputs from the naming module.

batch/outputs.tf#

output "all_naming_outputs" {
    value = module.naming
}

The requirement for “future” outputs wasn’t completely clear to me, so I opted to just return all possible outputs from the naming module. This way, any new outputs added to that module will also output in the batch module as the all_naming_outputs output variable.

Production Quality#

Please write these modules as you would for a production environment following best practices and structure that makes it easy to share with other team members and allows them to use it quickly after receiving it.

To the best of my knowledge, I followed Terraform’s best practices when writing these modules, and the structure (the names of the files and their contents) reflects what I found in their documentation.

Tests#

Of course, any production system needs tests. I added several tests for both modules.

Their contents are truncated here, but you can download the files to see each test.

tests/batch.tf#

run "long_vm_name_is_truncated" {
    command = plan
    module {
        source = "./batch"
    }

    variables {
        resources = {
            "fooBARbaz-FOObarBAZ" = "virtual_machine"
        }
    }

    assert {
        condition = output.resource_names["fooBARbaz-FOObarBAZ"] == "vm-fooBARbaz-00"
        error_message = "VM name is wrong"
    }
}

tests/naming.tf#

run "resource_type_can_be_virtual_machine" {
    command = plan
    module {
        source = "./naming"
    }

    variables {
        base_name = "foo"
        resource_type = "virtual_machine"
    }

    assert {
        condition = output.resource_name == "vm-foo-00"
        error_message = "VM name is wrong"
    }
}

Interview Coding Take-Homes: Part 2.a

2025-08-28T23:26:51+00:00

Interview Coding Take-Homes: Part 2.a#

18 August 2025

Programming, Software, Interviewing

UCLA Health - Maze Bug#

This take-home was for a Senior Cloud DevOps Engineer position in a key IT organization at UCLA Health.

This is part a of a two-part take-home. Read the second part, Interview Coding Take-Homes: Part 2.b.

Prompt#

This is an intentionally incorrect python script to play through a maze. Can you spot the error and get it working?

pymaze-broken.py#

import random

# Maze dimensions
MAZE_WIDTH = 10
MAZE_HEIGHT = 10

# Maze symbols
WALL = '#'
EMPTY = ' '
PLAYER = 'P'
EXIT = 'E'
ITEM = '*'

# Function to initialize the maze
def initialize_maze():
    maze = [[EMPTY] * MAZE_WIDTH for _ in range(MAZE_HEIGHT)]
    # Place walls
    for i in range(MAZE_HEIGHT):
        maze[i][0] = WALL
        maze[i][-1] = WALL
    for j in range(MAZE_WIDTH):
        maze[0][j] = WALL
        maze[-1][j] = WALL
    # Place player
    maze[1][1] = PLAYER
    # Place exit
    maze[MAZE_HEIGHT - 2][MAZE_WIDTH - 2] = EXIT
    # Place items
    for _ in range(3):  # Adjust the number of items as needed
        while True:
            x = random.randint(1, MAZE_WIDTH - 2)
            y = random.randint(1, MAZE_HEIGHT - 2)
            if maze[y][x] == EMPTY:
                maze[y][x] = ITEM
                break
    return maze

# Function to print the maze
def print_maze(maze):
    for row in maze:
        print(''.join(row))

# Function to move the player
def move_player(maze, direction):
    player_pos = find_player(maze)
    new_pos = (player_pos[0] + direction[0], player_pos[1] + direction[1])
    if maze[new_pos[0]][new_pos[1]] != WALL:
        maze[player_pos[0]][player_pos[1]] = EMPTY
        maze[new_pos[0]][new_pos[1]] = PLAYER
        return True
    return False

# Function to find the player's position
def find_player(maze):
    for i in range(len(maze)):
        for j in range(len(maze[i])):
            if maze[i][j] == PLAYER:
                return (i, j)

# Main function to run the game
def main():
    maze = initialize_maze()
    print("Welcome to the maze game!")
    print("Use WASD to move. Try to find the exit (E) while collecting items (*)!")
    while True:
        print_maze(maze)
        direction = input("Enter your move (WASD): ").upper()
        if direction == 'W':
            moved = move_player(maze, (-1, 0))
        elif direction == 'S':
            moved = move_player(maze, (1, 0))
        elif direction == 'A':
            moved = move_player(maze, (0, -1))
        elif direction == 'D':
            moved = move_player(maze, (0, 1))
        else:
            print("Invalid move! Use WASD.")
            continue
        if not moved:
            print("Cannot move there! Try another direction.")
        else:
            player_pos = find_player(maze)
            if maze[player_pos[0]][player_pos[1]] == EXIT:
                print("Congratulations! You found the exit!")
                break

if __name__ == "__main__":
    main()

My Approach#

Testing the Application#

First, I executed the code to see what it does and how it behaves.

$ python pymaze-broken.py
Welcome to the maze game!
Use WASD to move. Try to find the exit (E) while collecting items (*)!
##########
#P       #
#        #
#        #
#  *     #
#*       #
# *      #
#        #
#       E#
##########
Enter your move (WASD):

So far, so good.

The code states to gather items and find the exit, so let’s do that.

##########
#        #
#        #
#        #
#        #
#        #
#        #
#       P#
#       E#
##########
Enter your move (WASD):

The P moves around, so that’s us, the player.

Gathering items worked without issue, so let’s try to “find the exit.”

Enter your move (WASD): s
##########
#        #
#        #
#        #
#        #
#        #
#        #
#        #
#       P#
##########
Enter your move (WASD):

Uh oh … looks like the game doesn’t finish when the user finds the exit.

In fact, we can keep moving around, but now the exit is gone.

Enter your move (WASD): w
##########
#        #
#        #
#        #
#        #
#        #
#        #
#       P#
#        #
##########
Enter your move (WASD):

Examining the Code#

Next, I looked at parts of the code, starting from the application entrypoint.

def main():
    maze = initialize_maze()
    print("Welcome to the maze game!")
    print("Use WASD to move. Try to find the exit (E) while collecting items (*)!")
    while True:
        print_maze(maze)
        direction = input("Enter your move (WASD): ").upper()
        if direction == 'W':
            moved = move_player(maze, (-1, 0))
        elif direction == 'S':
            moved = move_player(maze, (1, 0))
        elif direction == 'A':
            moved = move_player(maze, (0, -1))
        elif direction == 'D':
            moved = move_player(maze, (0, 1))
        else:
            print("Invalid move! Use WASD.")
            continue
        if not moved:
            print("Cannot move there! Try another direction.")
        else:
            player_pos = find_player(maze)
            if maze[player_pos[0]][player_pos[1]] == EXIT:
                print("Congratulations! You found the exit!")
                break

We can see several calls to move_player in response to the WASD inputs, and then a check for whether the player has moved onto the exit position.

This last check seems to be what stops the main while loop on line 65, so we need to figure out what prevented that condition from triggering. My intuition says we need to understand what maze contains in order to check whether this condition is correct.

if maze[player_pos[0]][player_pos[1]] == EXIT:
    print("Congratulations! You found the exit!")
    break

Debugging#

Because this is new code I haven’t seen before, the most expedient next step is to run the application in a debugger. This way I can see what maze contains without needing to manually walk through the code. This quickly gives me a mental map of what’s happening in the application.

Python includes a debugger called pdb that I will use for this. There are other tools, such as VSCode, but this application is simple enough that we should be able to figure this out on the command line.

We start pdb with python -m pdb <script>.

$ python -m pdb pymaze-broken.py
> pymaze-broken.py(1)<module>()
-> import random

It helps to get a quick reference of the commands available to us.

(Pdb) ?

Documented commands (type help <topic>):
========================================
EOF    cl         disable     ignore    n        return  u          where
a      clear      display     interact  next     retval  unalias
alias  commands   down        j         p        run     undisplay
args   condition  enable      jump      pp       rv      unt
b      cont       exceptions  l         q        s       until
break  continue   exit        list      quit     source  up
bt     d          h           ll        r        step    w
c      debug      help        longlist  restart  tbreak  whatis

Miscellaneous help topics:
==========================
exec  pdb

I know I want to see what maze looks like, so I will put a breakpoint right after that, on line 63. Then, I will let the application continue running.

(Pdb) b 63
Breakpoint 1 at pymaze-broken.py:63
(Pdb) c
> pymaze-broken.py(63)main()
-> print("Welcome to the maze game!")
(Pdb) l
 58                     return (i, j)
 59
 60     # Main function to run the game
 61     def main():
 62         maze = initialize_maze()
 63 B->     print("Welcome to the maze game!")
 64         print("Use WASD to move. Try to find the exit (E) while collecting items (*)!")
 65         while True:
 66             print_maze(maze)
 67             direction = input("Enter your move (WASD): ").upper()
 68             if direction == 'W':
(Pdb)

If we type a variable’s name, pdb prints its string representation.

(Pdb) maze
[['#', '#', '#', '#', '#', '#', '#', '#', '#', '#'], ['#', 'P', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#'], ['#', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '#'], ['#', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#'], ['#', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#'], ['#', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#'], ['#', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '#'], ['#', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#'], ['#', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'E', '#'], ['#', '#', '#', '#', '#', '#', '#', '#', '#', '#']]

Fortunately for us, maze is a list and we don’t need to do anything fancy to see its contents.

That said, it is nearly unparseable in a single line, so we can tell pdb to “pretty print” the objet instead.

(Pdb) pp maze
[['#', '#', '#', '#', '#', '#', '#', '#', '#', '#'],
 ['#', 'P', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#'],
 ['#', ' ', ' ', ' ', ' ', ' ', '*', ' ', ' ', '#'],
 ['#', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#'],
 ['#', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#'],
 ['#', '*', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#'],
 ['#', ' ', ' ', ' ', ' ', '*', ' ', ' ', ' ', '#'],
 ['#', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#'],
 ['#', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'E', '#'],
 ['#', '#', '#', '#', '#', '#', '#', '#', '#', '#']]

So we know we’re looking at a matrix whose values represent the different characters seen in the maze. Given that we’re trying to figure out the comparison of the player position within the maze to the EXIT variable, let’s check what some of these values are too.

(Pdb) player_pos
*** NameError: name 'player_pos' is not defined

Oops - that didn’t work. Let’s see where player_pos gets set. If we look back at the code, we see that it gets set in both move_player …

def move_player(maze, direction):
    player_pos = find_player(maze)
    new_pos = (player_pos[0] + direction[0], player_pos[1] + direction[1])
    if maze[new_pos[0]][new_pos[1]] != WALL:
        maze[player_pos[0]][player_pos[1]] = EMPTY
        maze[new_pos[0]][new_pos[1]] = PLAYER
        return True
    return False

and in the main loop …

if not moved:
    print("Cannot move there! Try another direction.")
else:
    player_pos = find_player(maze)

In Python, block-level assignments in methods are scoped to those methods, so we know that the move_player assignment is irrelevant here, which means we need line 82 to run.

Let’s put a breakpoint there and step through the code.

(Pdb) b 82
Breakpoint 2 at pymaze-broken.py:82
(Pdb) c
Welcome to the maze game!
Use WASD to move. Try to find the exit (E) while collecting items (*)!
##########
#P       #
#     *  #
#        #
#        #
#*       #
#    *   #
#        #
#       E#
##########
Enter your move (WASD):

Now it can get a little tricky to manage both the application flow and the debugger. My command line input will currently be sent to the application, not the debugger, because the application is reading from STDIN.

Here’s what happens when I enter input into the application.

Enter your move (WASD): d
> pymaze-broken.py(82)main()
-> player_pos = find_player(maze)
(Pdb)

We hit the breakpoint we set earlier! The application is now paused again, and we can input into the debugger.

(Pdb) l
               print("Invalid move! Use WASD.")
               continue
           if not moved:
               print("Cannot move there! Try another direction.")
           else:
B->             player_pos = find_player(maze)
               if maze[player_pos[0]][player_pos[1]] == EXIT:
                   print("Congratulations! You found the exit!")
                   break
 86
   if __name__ == "__main__":

We want to see what find_player is doing, so let’s “step into” it.

(Pdb) s
--Call--
> pymaze-broken.py(54)find_player()
-> def find_player(maze):
(Pdb) n
> pymaze-broken.py(55)find_player()
-> for i in range(len(maze)):
(Pdb) l
 50             return True
 51         return False
 52
 53     # Function to find the player's position
 54     def find_player(maze):
 55  ->     for i in range(len(maze)):
 56             for j in range(len(maze[i])):
 57                 if maze[i][j] == PLAYER:
 58                     return (i, j)
 59
 60     # Main function to run the game

I also stepped to the “next” instruction, so we’re now at the beginning of the outer for loop. Let’s see what some of these instructions are doing.

Given that maze is a matrix, it seems like the outer for loop will iterate over rows. Let’s make sure.

(Pdb) list(range(len(maze)))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

That looks right - there are ten rows in the maze. Let’s step into the first iteration, and double-check whether the inner for loop iterates over columns.

(Pdb) s
> pymaze-broken.py(56)find_player()
-> for j in range(len(maze[i])):
(Pdb) list(range(len(maze[i])))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

That also looks right - there are ten columns for the row i, which is currently row 0:

(Pdb) i
0
(Pdb) maze[i]
['#', '#', '#', '#', '#', '#', '#', '#', '#', '#']

Let’s step into this and check the next instructions.

(Pdb) s
> pymaze-broken.py(57)find_player()
-> if maze[i][j] == PLAYER:
(Pdb) i
0
(Pdb) !j # we need a preceeding `!` because `j` is the pdb "jump" command
0
(Pdb) maze[i][j]
'#'
(Pdb) PLAYER
'P'
(Pdb) maze[i][j] == PLAYER
False

So it seems that we’re iterating over every character in the maze to determine whether that character is P. If the character is P then we know we’ve found the player, and we return their (i,j) position.

Let’s make sure - we’ll set a breakpoint at the return statement.

(Pdb) b 58
Breakpoint 3 at pymaze-broken.py:58
(Pdb) c
> pymaze-broken.py(58)find_player()
-> return (i, j)
(Pdb) (i, j)
(1, 2)

If we print the maze again, we’ll see that (1, 2) is indeed where the character P is.

(Pdb) pp maze
[['#', '#', '#', '#', '#', '#', '#', '#', '#', '#'],
 ['#', ' ', 'P',
# truncated

We should also note that the position the player was in is now a space, while the position that the player now occupies was a space and is now a P.

By now we can start to postulate on the behavior and the possible origin of the error.

We know, in the UI:

When the player reaches E, the application does not exit
The player can continue to move around, and the E disappears

And in the code:

Previous player positions are replaced with a space
The current player position is replaced with a P
Some value is compared with the variable EXIT (the character E)

Is it possible that we want to compare P with E, but we can’t because E is now gone?

Let’s continue on to our exit condition.

To save us some sanity, let’s clear all the breakpoints.

(Pdb) b
Num Type         Disp Enb   Where
1   breakpoint   keep yes   at pymaze-broken.py:63
        breakpoint already hit 1 time
2   breakpoint   keep yes   at pymaze-broken.py:82
        breakpoint already hit 7 times
3   breakpoint   keep yes   at pymaze-broken.py:58
        breakpoint already hit 5 times
(Pdb) cl 1
Deleted breakpoint 1 at pymaze-broken.py:63
(Pdb) cl 2
Deleted breakpoint 1 at pymaze-broken.py:82
(Pdb) cl 3
Deleted breakpoint 3 at pymaze-broken.py:58

We need to get the character to the final position before the exit, then we add that breakpoint. We know we can do this because the application pauses for our input anyway.

Once the character is where we need it, press ^C to switch input from the application back to pdb, then press enter once. This lets us issue commands to pdb again.

Add the breakpoint back to line 82, continue execution, and move the player onto the exit.

Enter your move (WASD): s
##########
#        #
#     *  #
#        #
#        #
#*       #
#    *   #
#       P#
#       E#
##########
Enter your move (WASD):
Program interrupted. (Use 'cont' to resume).

> pymaze-broken.py(67)main()
-> direction = input("Enter your move (WASD): ").upper()
(Pdb) b 82
Breakpoint 5 at pymaze-broken.py:82
(Pdb) c
Invalid move! Use WASD.
##########
#      * #
#        #
#        #
#        #
#        #
# *      #
#       P#
#       E#
##########
Enter your move (WASD): s
> pymaze-broken.py(82)main()
-> player_pos = find_player(maze)

Let’s check player_pos.

(Pdb) n
> pymaze-broken.py(83)main()
-> if maze[player_pos[0]][player_pos[1]] == EXIT:
(Pdb) player_pos
(8, 8)

Is that right?

(Pdb) pp maze
[['#', '#', '#', '#', '#', '#', '#', '#', '#', '#'],
 ['#', ' ', ' ', ' ', ' ', ' ', ' ', '*', ' ', '#'],
 ['#', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#'],
 ['#', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#'],
 ['#', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#'],
 ['#', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#'],
 ['#', ' ', '*', ' ', ' ', ' ', ' ', ' ', ' ', '#'],
 ['#', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '#'],
 ['#', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'P', '#'],
 ['#', '#', '#', '#', '#', '#', '#', '#', '#', '#']]

It is … but the E has been replaced with P! In fact, where we expected to check whether the player was on the exit, it turns out we’ve been checking whether the player position is P this whole time, which it always is!

(Pdb) maze[player_pos[0]][player_pos[1]]
'P'

So that’s our error - we always check the character at the current player position after the player has moved, which means it is always P, and therefore never E.

My Solution#

pymaze-working.py#

import random

# Maze dimensions
MAZE_WIDTH = 10
MAZE_HEIGHT = 10

# Maze symbols
WALL = '#'
EMPTY = ' '
PLAYER = 'P'
EXIT = 'E'
ITEM = '*'

EXIT_POS = (MAZE_HEIGHT - 2, MAZE_WIDTH - 2)

# Function to initialize the maze
def initialize_maze():
    maze = [[EMPTY] * MAZE_WIDTH for _ in range(MAZE_HEIGHT)]
    # Place walls
    for i in range(MAZE_HEIGHT):
        maze[i][0] = WALL
        maze[i][-1] = WALL
    for j in range(MAZE_WIDTH):
        maze[0][j] = WALL
        maze[-1][j] = WALL
    # Place player
    maze[1][1] = PLAYER
    # Place exit
    maze[EXIT_POS[0]][EXIT_POS[1]] = EXIT
    # Place items
    for _ in range(3):  # Adjust the number of items as needed
        while True:
            x = random.randint(1, MAZE_WIDTH - 2)
            y = random.randint(1, MAZE_HEIGHT - 2)
            if maze[y][x] == EMPTY:
                maze[y][x] = ITEM
                break
    return maze

# Function to print the maze
def print_maze(maze):
    for row in maze:
        print(''.join(row))

# Function to move the player
def move_player(maze, direction):
    player_pos = find_player(maze)
    new_pos = (player_pos[0] + direction[0], player_pos[1] + direction[1])
    if maze[new_pos[0]][new_pos[1]] != WALL:
        maze[player_pos[0]][player_pos[1]] = EMPTY
        maze[new_pos[0]][new_pos[1]] = PLAYER
        return True
    return False

# Function to find the player's position
def find_player(maze):
    for i in range(len(maze)):
        for j in range(len(maze[i])):
            if maze[i][j] == PLAYER:
                return (i, j)

# Main function to run the game
def main():
    maze = initialize_maze()
    print("Welcome to the maze game!")
    print("Use WASD to move. Try to find the exit (E) while collecting items (*)!")
    while True:
        print_maze(maze)
        direction = input("Enter your move (WASD): ").upper()
        if direction == 'W':
            moved = move_player(maze, (-1, 0))
        elif direction == 'S':
            moved = move_player(maze, (1, 0))
        elif direction == 'A':
            moved = move_player(maze, (0, -1))
        elif direction == 'D':
            moved = move_player(maze, (0, 1))
        else:
            print("Invalid move! Use WASD.")
            continue
        if not moved:
            print("Cannot move there! Try another direction.")
        else:
            player_pos = find_player(maze)
            if player_pos == EXIT_POS:
                print("Congratulations! You found the exit!")
                break

if __name__ == "__main__":
    main()

My solution checks the player’s position against the known exit position, rather than the characters at those positions.

This means we set up a variable to hold that position.

EXIT_POS = (MAZE_HEIGHT - 2, MAZE_WIDTH - 2)

Which we use to replace line 29 in the broken code to set up the maze. This reduces code duplication and eases future maintenance.

maze[EXIT_POS[0]][EXIT_POS[1]] = EXIT

Which is then used to make the final exit condition.

if player_pos == EXIT_POS:

Here is a full diff between the two files.

--- /home/runner/work/aaronholmes.net/aaronholmes.net/source/_static/files/2025/interview_coding_take_homes_part_2a/pymaze-broken.py
+++ /home/runner/work/aaronholmes.net/aaronholmes.net/source/_static/files/2025/interview_coding_take_homes_part_2a/pymaze-working.py
@@ -10,6 +10,8 @@
 PLAYER = 'P'
 EXIT = 'E'
 ITEM = '*'
+
+EXIT_POS = (MAZE_HEIGHT - 2, MAZE_WIDTH - 2)
 
 # Function to initialize the maze
 def initialize_maze():
@@ -24,7 +26,7 @@
     # Place player
     maze[1][1] = PLAYER
     # Place exit
-    maze[MAZE_HEIGHT - 2][MAZE_WIDTH - 2] = EXIT
+    maze[EXIT_POS[0]][EXIT_POS[1]] = EXIT
     # Place items
     for _ in range(3):  # Adjust the number of items as needed
         while True:
@@ -80,7 +82,7 @@
             print("Cannot move there! Try another direction.")
         else:
             player_pos = find_player(maze)
-            if maze[player_pos[0]][player_pos[1]] == EXIT:
+            if player_pos == EXIT_POS:
                 print("Congratulations! You found the exit!")
                 break
 

Interview Coding Take-Homes: Part 1

2025-08-11T17:33:16+00:00

Interview Coding Take-Homes: Part 1#

3 August 2025

Programming, Software, Interviewing

As software engineers, we are frequently asked to demonstrate our ability to architect and implement software. Sometimes this is done through algorithm and data structure live-coding interviews, sometimes through take-home assignments, often both, or through other means.

I have been given a number of take-home assignments, which I usually focus on polishing and treating like production-grade software (within reason). The downside of this focus is the energy it can take - which is compounded when actively looking for new work.

To that end, I would like to showcase my past take-homes, which demonstrate my ability to architect and write software.

UCLA Health - Data Corruption#

This take-home was for a Senior Software Engineer position in a research lab at UCLA Health. You can find the full repository here.

Prompt#

This is the prompt provided by UCLA Health.

Your local grocery store, Half Foods, have been encountering issues with their system and needs you to help process some of their data. Every time a customer makes a purchase, a text file is generated, containing the barcodes of each product they bought as well as other information. A sample file CustomerG.txt is as follows:

01232020Jamie
BEVGTTKYGDGJHGTFBNGDVZJGDIPXVS
CANFDNSKAVOUXSCGSYBHQYHNMDQOBL
FRZNQQNPSESCHIMIXOUHNAWLXRZEPT
BEVGZYUFGNIHDCZIPWLZJLPDSGNEAH

The first line includes the date (MMDDYYYY) as well as the customer information. Each line following that is an item barcode, in no particular order.

The barcode can be broken down into these components:

[Product Type][Subtype][Unique ID]
[BEVG][TTKYGD][GJHGTFBNGDVZJGDIPXVS]

The product type is always 4 letters long, the subtype is 6 letters long, and the unique id is 20 letters long.

You are also provided a product type key: BEVG - Beverages BAKE - Baked Goods CANF - Canned Foods CNSB - Condiments/Spices/Baking SNCN - Snacks/Candy DREG - Dairy/Eggs FRZN - Frozen Foods FRVG - Fruits/Vegetables GRPA - Grains/Pastas MTSF - Meat/Seafood MISC – Misc

My Approach to the Code#

This application is a .NET Core Console application written in C#.

Structure#

The domain code is organized per Domain-Driven Design (DDD) principles and guidelines.

Business logic is shared between the DDD classes and a set of classes I’ve named ConsoleWriters.

Domain#

The domain of the application is broken down as follows.

Aggregates#

An Aggregate called PurchaseAggregate is responsible for processing questions about a set of Purchases (a PurchaseEntity) in a file. For example, this Aggregate can return the most common Product purchases in a file.

Entities#

An Entity called PurchaseEntity contains information on the Purchase, representing the entire Purchase file.

This Entity holds the Purchase date, Customer name, and the three parts of a Product entry in a file.
This Entity is able to construct itself from a file. It parses this file and sets the appropriate properties.
No instance methods exist on this Entity.

A Purchase is considered an Entity because every Purchase is unique regardless of the data contained within that Purchase. For example—however unlikely it may be—two Customers with the same name may buy the exact same Products at the same time as another Customer.

Values#

A Value type exists for each of the following:

Barcode (BarcodeValue)
Customer (CustomerValue)
Product ID (ProductIdValue)
Product Type (ProductTypeValue)
Product Subtype (ProductSubtypeValue)
Timestamp (TimestampValue)

These are considered Value types because, in relation to a Purchase, each Value is equivalent based on its properties. For example, a Product ID of "BEVG" represents a Product ID of "BEVG" regardless of how many "BEVG" entries there are for a Purchase.

Review classStructure.puml to understand the relations between these types.

With the exception of BarcodeValue, these Value types extend ValueBase<T>. This is done to manage the code that determines equality between instances of Value types.

Each Value type overrides the default == and != operators in order to equate their values by value rather than each instance by reference.

Each Value type implements implicit cast methods between string (except for TimestampValue whose T type is DateTime) simply for ease of use in treating these value types as strings.

Business logic#

The business logic for this application is primarily contained within Program.cs (Main), the PurchaseAggregate, and the PurchaseEntity classes. The code is documented and should be reviewed for further clarification.

Some of the business logic is non-Domain and is thus managed outside the DDD guidelines. In this case, the output of information about purchases is handled in classes that I’ve named ConsoleWriters.

These classes work using the Visitor Pattern.

In this design, the Visitor visits a writer that handles unique output for each of the PurchaseAggregate and PurchaseEntity types. The output of these Dispatchers is returned and written to the console by the Visitor.

Searching#

In order to handle corrupted Purchase Type data, a BK Tree is implemented to discover the closest-matching Product Type when inputting data, or when outputting Product Subtypes for a Product Type.

References used:

Other Considerations#

As much as possible, this code was written to be easily unit-testable. Accordingly, the Wrapper Pattern is employed to avoid using the static Console class directly.

Unit Tests#

The application is thoroughly unit tested. The tests run on the xUnit testing framework for .NET and C#.

Scenarios#

The prompt included several questions I needed to answer.

Question 1#

Write a program that takes any customer text file, and prints the following information to the console:

Name of the customer

Formatted date of purchase

Total number of items they purchased

Here is an example of the expected output, from my application.

Question 1 solution:

a) Customer: Jamie
b) Date: 1/23/2020 12:00:00 AM
c) Total Items Purchased: 4

Question 2#

Part 1#

Extend your program so that a grocery store employee can easily access more detailed information about a purchase given the same customer text file input. It is up to you how you want organize and display this, but you should be able to print the following information:

For every existing product type, the number and list of unique IDs of items purchased by the customer

The most common product type

Here is an example of the expected output.

Question 2 part 1 solution:

a) The number of unique items purchased: 4
    The unique IDs that were purchased:
    GJHGTFBNGDVZJGDIPXVS
    OUXSCGSYBHQYHNMDQOBL
    SCHIMIXOUHNAWLXRZEPT
    IHDCZIPWLZJLPDSGNEAH
b) The most common product type purchased: BEVG

Part 2#

The employee should also be able to put in a specific product type input, and get the following information:

Subtypes for that product type

In addition, make sure your design allows for new product types to be added in the future, as the grocery store expands its inventory. Create a function that can easily add a new product type with its code to the key, without affecting your program’s functionality.

The application pauses to accept user input.

The expected input is a 4-character Product Type code, e.g., “BEVG,” “MISC,” etc.

The application will accept one character at a time, showing suggestions for possible Product Types as the user types.

When the 4th character is entered, the application will display the following Product Subtype information for the best match of the user’s Product Type input.

If there are no matches, the application will let the user know.

Here is an example of the expected output when the user types “BEVG”

Question 2 part 2 solution:

Input a 4-character Product Type to list Subtypes in this Purchase.
Press Enter to stop searching.
 - Possible matches: # this outputs when "B" is typed
        BEVG
        BAKE
        DREG
        CANF
        CNSB
        SNCN
        FRZN
        GRPA
        MISC
        MTSF
        FRVG
 - Possible matches: # this outputs when "E" is typed after the previous "B"
        BEVG
        BAKE
 - Possible matches: # this outputs when "V" is typed after the previous "E"
        BEVG
 - Possible matches: # this outputs when "G" is typed after the previous "V"
        BEVG
 > BEVG

Searching for best match 'BEVG'

a) Subtypes for product type BEVG:
    TTKYGD
    ZYUFGN

Input a 4-character Product Type to list Subtypes in this Purchase.
Press Enter to stop searching.
 >

Either way, Part 2 will repeat forever until the user presses Enter/Return.

Once this occurs, the application prompts the user to press Enter/Return to exit.

The application is finished after this.

Question 3#

A problem arises with the Half Foods database, partially corrupting some of the customer purchase data. Luckily, you managed to figure out that the data only changed in a consistent way, making it possible to fix.

The first line of each text file remained the same, but for some of the barcodes, a random letter was changed somewhere in product type.

For example:

05242020James
FRZNQQNPSESCHIMIXOUHNAWLXRZEPT
BENGTTKYGDGJHGTFBNGDVZJGDIPXVS
CDNFDNSKAVOUXSCGSYBHQYHNMDQOBL

Extend your program and modify your answer for Question 2 to account for these errors.

When the application first loads file data, it will ensure correct Product Type keys are parsed. It will attempt to find the intended Product Type key with the use of a BK Tree.

When a match is found, or if the Product Type key is already correct, this Product Type key is imported.

This same functionality is used for Question 2 Part 2, when the user types a Product Key.

Question 4#

The repository also contains this question and answer. I’ve repeated it here for posterity.

If only some of the files in the customer purchase database are corrupt, how would you address this problem going forward? What if the database was extremely large? How do you prepare for future data corruptions? Write a brief summary of your approach.

Fortunately, I read the entire project requirement before starting. As such, I started with a unit test that tested these problems, and I developed the application with these questions in mind. These problems are solved, and the unit tests now pass.

Let me address each question in order.

If only some of the files in the customer purchase database are corrupt, how would you address this problem going forward?

This concern is moot. The application begins with importing purchase data and validates against the corrupted data scenario (where Product Types can be wrong by a single character). This validation does require additional cycles and memory to complete, but in most cases should not be a problem.

My approach: always validate; never assume the data is correct.

One issue that may arrise is with huge data sets, but in reality, how many customers will purchase the excessive number of products that would be necessary to significantly slow down a BK Tree? Taking some measurements, this list of 370k words is indexed in ~20 seconds, and can search a worst-case scenario, e.g., “zwitterionic” in ~100ms.

This approach is not a concern across multiple purchases either if the system can be parallelized. More than one purchase can be analyzed at a time, reducing the total processing time further.

What if the database was extremely large?

Generally, I would start with considering what is actually possible or likely. As I started in the previous question, it is unlikely customers will purchase an unbelievable number of products. This means the use of an efficient text searching data structure and algorithm, like a BK Tree, should never become a bottle neck. Hopefully the bottle neck is I/O (network, disk, etc).

If we are processing purchase data across many sets of purchases, this could realistically be problematic. If we were, say, analyzing every purchase made at Amazon for its entire existence, that is a lot of data! In this case, I would rely on parallelization first. Multiple cores, multiple machines, or multiple cloud processing instances can give you the raw resources required to churn through so much data. If this is still insufficient, then it’s time to start looking at different algorithms, or perhaps using statistics and probabilities, and whether 100% accurate numbers are needed.

How do you prepare for future data corruptions?

Future data corruptions are handled the same - the application supports this from the start. Now, if we are processing data that we have already processed because it is now corrupt, then we need to devise a mechanism to relate the corrupted data to the corrected data. In some cases, reprocessing like that may be best to just start anew.

If we can’t do that, having implemented some infrastructure that can help us manage this data would be a good idea. For example, an SNS topic could be used to respond immediately to a Product ID change in a purchase, which can then be validated and reinserted, and you could receive notifications that data is becoming corrupt and stop it before it gets out of hand.

Making a Copper Wire Tree

2025-08-03T05:23:22+00:00

Making a Copper Wire Tree#

8 August 2024

Plants, Crafts

This presentation shows the steps I took to create a wire tree out of copper wire in the shape of an informal upright bonsai.

This is an embedded Microsoft Office presentation, powered by Office.

Winter is Canning 2022

2025-08-03T05:23:22+00:00

Winter is Canning 2022#

22 September 2022

Programming, Software

This presentation shows the steps I took to prepare for this years 6-month long “Winter is Canning” challenge. Growers compete for the glory of winning the best looking pepper plant in a soda can.

This is an embedded Microsoft Office presentation, powered by Office.

Pair Programming

2025-08-03T05:23:22+00:00

Pair Programming#

6 April 2022

Programming, Software

Why should you pair program, and how do you do it?

This is an embedded Microsoft Office presentation, powered by Office.

My Dog Cleo

2025-08-03T05:23:22+00:00

My Dog Cleo#

28 October 2021

Dog

This presentation is about my Great Dane, Cleo. She has passed recently, after I created this presentation.

This is an embedded Microsoft Office presentation, powered by Office.

Types in Software

2025-08-03T05:23:22+00:00

Types in Software#

21 April 2021

Programming, Software

This presentation is about types in software, why they are important, and what they do to help us.

The presentation source code is at this repository.

This is an embedded Microsoft Office presentation, powered by Office.

Displaying response headers and pretty JSON with cURL

2026-01-17T01:50:22+00:00

Displaying response headers and pretty JSON with cURL#

19 September 2019

HTTP, Bash, curl, Utility, Productivity, Shell

The Problem#

I tend toward using cURL when testing HTTP services, but I had a difficult time parsing the result when these services spit back unformatted JSON responses. To make my life a little easier, I set out to find a way to bend cURL to my will.

The Solution#

Let’s get straight to it. To make cURL display both response headers and formatted JSON, we need to make cURL send the headers to STDERR, so we can then send STDOUT to a formatting utility.

We can accomplish this as so.

$ curl -s -D "/dev/stderr" -X POST 'http://example.org/some/url' \
>       --data-binary @some-file | python -m json.tool

This will show a nicely formatted response like this.

HTTP/1.1 500 Internal Server Error
Content-Type: application/json; charset=utf-8
X-Powered-By: ASP.NET
Date: Wed, 18 Sep 2019 22:39:24 GMT
Content-Length: 114

{
    "Status": 3,
    "Timestamp": "2019-09-18T22:39:24.1659165Z",
    "Error": {
        "Code": 1,
        "Message": "An error has occurred."
    }
}

What’s Going On Here?#

Let’s break this down a bit.

After some initial research into how to send the HTTP headers to STDERR, I found this article that demonstrated the use of -D "/dev/stderr".

Breaking the command down:

-s will silence the statistics output of cURL
-D "/dev/stderr" will send the HTTP headers to STDERR
python -m json.tool receives STDOUT, which is the JSON response of my service
The other options are specific to my service request, and are not relevant to the formatting

Note: you can also pipe the cURL output to a utility like jq, I just happen to use python -m json.tool.

A Step Further#

These commands and then be turned into Bash aliases and functions.

I have this in my ~/.bashrc.

alias curl-json='curl -s -D "/dev/stderr"'
curl-json-format()
{
        curl-json "$@" | python -m json.tool
}

Now I can use this command!

$ curl-json-format -X POST 'http://example.org/some/url' \
>      --data-binary @some-file | python -m json.tool

The Behavior of C# Nested Static Classes

2025-08-03T01:20:00+00:00

The Behavior of C# Nested Static Classes#

26 July 2018

C#, .NET, Experimental, Documentation

While working on a code review, I found a nested static class that I needed to verify the validity of. I had three questions:

Does the CLR create new instances when the containing class is instantiated?
Do the static class members retain the same values across all instances of the containing class?
Is the nested class truly static?

As you’ll read below, it turns out the nesting of a static class is a bit of a red herring. If you write C# regularly, you already know how this works.

Check the Documentation#

Like any good dev, I checked the documentation first.

The Microsoft C# docs for Static Classes and Static Class Members states the following.

As is the case with all class types, the type information for a static class is loaded by the .NET Framework common language runtime (CLR) when the program that references the class is loaded. The program cannot specify exactly when the class is loaded. However, it is guaranteed to be loaded and to have its fields initialized and its static constructor called before the class is referenced for the first time in your program. A static constructor is only called one time, and a static class remains in memory for the lifetime of the application domain in which your program resides.

This is pretty clear on static class behavior, but I still wasn’t sure whether there were additional nuances regarding nested static classes. We can find more information in the documentation regarding Nested Types, however, this documentation is missing any information about static classes.

Solving the Unknown#

With my questions unanswered, and a desire to be certain in my code review, it was time to create a test case. Here’s the code I wrote.

By the way, I typically use RoslynPad for one-off tests like this.

// Foo is the containing/outer class that is instantiated
public class Foo
{
    // OuterI is used to retrieve the value of the integer
    // parameter for the constructor
    public static int OuterI;

    public Foo(int i)
    {
        OuterI = i;
    }

    // BarI returns the value of the nested static
    // class's value, which points to the containing
    // class's OuterI property
    public int BarI => Bar.InnerI;

    // This is the nested static class being tested
    private static class Bar
    {
        // This is used to retrieve the containing class's
        // value of the OuterI property, which is set by
        // an instance of Foo. Keep in mind, this is a value type,
        // not a reference type, and this is a field,
        // not a property.
        public static int InnerI = Foo.OuterI;
    }
}

I then tested two scenarios.

The first scenario observes what happens when 1+n Foo s are instantiated, followed by printing the value of each instance’s BarI property.

var f1 = new Foo(1);
var f2 = new Foo(2);
var f3 = new Foo(3);
var f4 = new Foo(4);

Console.WriteLine(f1.BarI);
Console.WriteLine(f2.BarI);
Console.WriteLine(f3.BarI);
Console.WriteLine(f4.BarI);

The second scenario observes what happens when n+1 Foo s are instantiated, then immediately followed by printing the value of the instances BarI property.

Console.WriteLine(new Foo(1).BarI);
Console.WriteLine(new Foo(2).BarI);
Console.WriteLine(new Foo(3).BarI);
Console.WriteLine(new Foo(4).BarI);

A Challenger Appears!#

Before reading further, I’d like to offer you a challenge; predict what happens in both scenario 1 and 2.

The Behavior, Discovered#

Figured it out?

The output of the first scenario is:

The output of the second scenario is:

While this may be surprising (the first scenario caught me off guard), the behavior is explained in the Static Classes and Static Class Members documentation. Indeed, this line applies to all static classes.

A static constructor is only called one time, and a static class remains in memory for the lifetime of the application domain in which your program resides.

Why Does this Occur?#

So with that in mind, what’s actually happening here? Let’s make a couple changes to observe the application execution in both scenarios.

Add a static constructor to Bar, and insert a new Console.WriteLine statement.

private static class Bar
{
    static Bar()
    {
        Console.WriteLine("initialized");
    }

    public static int InnerI = Foo.OuterI;
}

Then, for both scenario 1 and 2, insert new Console.WriteLine statements between each operation.

Scenario 1

Console.WriteLine("new 1");
var f1 = new Foo(1);
Console.WriteLine("new 2");
var f2 = new Foo(2);
Console.WriteLine("new 3");
var f3 = new Foo(3);
Console.WriteLine("new 4");
var f4 = new Foo(4);

Console.WriteLine("bar 1");
Console.WriteLine(f1.BarI);
Console.WriteLine("bar 2");
Console.WriteLine(f2.BarI);
Console.WriteLine("bar 3");
Console.WriteLine(f3.BarI);
Console.WriteLine("bar 4");
Console.WriteLine(f4.BarI);

Scenario 2

Console.WriteLine("bar 1");
Console.WriteLine(new Foo(1).BarI);
Console.WriteLine("bar 2");
Console.WriteLine(new Foo(2).BarI);
Console.WriteLine("bar 3");
Console.WriteLine(new Foo(3).BarI);
Console.WriteLine("bar 4");
Console.WriteLine(new Foo(4).BarI);

Now, if we execute these scenarios, the application execution flow becomes clear. The reason for the observed behavior is as stated in the documentation. The static class is set up before it is accessed, and it is initialized only one time.

Scenario 1 outputs the following:

new 1

new 2

new 3

new 4

bar 1

initialized (BarI is accessed for the first time, and the static class is initialized)

4

bar 2

4

bar 3

4

bar 4

4

Scenario 2 outputs the following:

bar 1

initialized (BarI is called for the first time, and the static class is initialized)

1

bar 2

1

bar 3

1

bar 4

Now I am curious what the non-gaurantee of when the static class is initialized means in runtimes other than the CLR.

Transparent Video in all Browsers from Cross-Domain Sources

2025-08-03T01:20:00+00:00

Transparent Video in all Browsers from Cross-Domain Sources#

6 January 2017

JavaScript, Canvas, Experimental, AJAX, XMLHttpRequest, Video

A brief history of time cross-domain transparent video#

Transparent video is not a terribly new concept in web development, however, because browsers do not support transparency in videos, accomplishing this requires a unique solution that involves a canvas element and a video with a separate alpha channel.

This solution does actually work very well to work around the limitation. There is a gotcha to be aware of when using video sources from a different origin, however; drawing to the canvas with data from a different origin “taints” the canvas. Once a canvas has been tainted, you are no longer able to extract data from the canvas. This breaks the workaround for transparent video, which relies on extracting the values of the alpha channel stored in a canvas. Thankfully, this can be worked around in most browsers by configuring CORS correctly and setting the crossorigin attribute on the source video element.

Where this fails#

Unfortunately, like many things in web development, the latest versions of Safari 9.0.2, Internet Explorer 11, and Edge 25 do not correctly honor the CORS configuration when cross-domain data is drawn to a canvas. This means there was no way to achieve transparent video in these three browsers unless the source video comes from the same origin.

After a lot of research, I stumbled across this answer regarding drawing cross-domain images to a canvas. The missing piece for me was the existence of the URL.createObjectUrl() method.

The solution in its entirety#

Please reference How to use transparency info from a video on a website for a more descriptive writeup on the basics of video transparency in browsers. The primary piece I have left out here is that you will need a video with the alpha channel stored in a separate position.

First, the HTML. The page needs:

A single video element that does not display (because the video will be drawn to the canvas)
A canvas whose width and height match the video, which is used to draw the video data to
A canvas whose width matches the video, and whose height is twice the video height

The main JavaScript file execution is deferred in order to run after the page has finished loading.

<head>
    <script src="script/main.js" defer></script>
</head>
<body>
    <video style="display:none" autoplay>
        <source src="video.mp4" type='video/mp4' />
    </video>
    <canvas width="1920" height="1080" id="output"></canvas>
    <canvas style="display:none;" width="1920" height="2160" id="buffer"></canvas>
</body>

The JavaScript will reference all three HTML elements, references to the canvas’ 2D contexts and video width and height are saved, and the buffer and output canvas widths and heights are set.

var outputCanvas = document.getElementById('output'),
    output       = outputCanvas.getContext('2d'),
    bufferCanvas = document.getElementById('buffer'),
    buffer       = bufferCanvas.getContext('2d');

outputCanvas.width  = Math.floor(outputCanvas.clientWidth );
outputCanvas.height = Math.floor(outputCanvas.clientHeight);
bufferCanvas.width  = Math.floor(bufferCanvas.clientWidth );
bufferCanvas.height = Math.floor(bufferCanvas.clientHeight);

var video  = document.getElementById('video');
var width  = outputCanvas.width;
var height = outputCanvas.height;

In order to avoid excessive CPU usage, and to continually draw video frames to the canvas, a recursive method, determineDraw() is used in conjunction with requestAnimationFrame().

var lastDrawTime = -1;
function determineDraw() =>
{
    // If the video has finished, there is no need to execute again, and this ends the script.
    if (vid.paused || vid.ended)
    {
        URL.revokeObjectURL(url);
        return;
    }

    // If the current playhead of the video has not changed since the last time this method executed,
    // there is no need to draw the same frame again.
    // lastDrawTime's initial value is -1 because video.currentTime will never be -1.
    if (video.currentTime !== lastDrawTime)
    {
        // If the video playhead has changed, the current frame is drawn (explained below).
        draw();
        // Store the current playhead position.
        lastDrawTime = video.currentTime;
    }

    // Recurse.
    requestAnimationFrame(determineDraw);
};

To kick things off

var xhr = new XMLHttpRequest();
xhr.onload = function()
{
    var url = URL.createObjectURL(this.response);
    var vid = document.createElement('video');
    (<any>vid).crossorigin = 'anonymous';

    vid.addEventListener('loadeddata', () =>
    {
        // now that our in-memory video element has loaded, we can remove the original video element.
        (video.remove && video.remove()) || ((<any>video).removeNode && (<any>video).removeNode());

        // Once the video starts playing, recursion begins, and we draw to the canvas roughly every 16ms.
        video.addEventListener('play', determineDraw, false);

        // start playback
        vid.play();
    });

    // setting the in-memory video source URL to the in-memory object bypasses the tainted canvas cross-origin check.
    vid.src = url;
};

function draw() =>
{
    buffer.drawImage(video, 0, 0);

    // this can be done without alphaData, except in Firefox which doesn't like it when image is bigger than the canvas
    var image = buffer.getImageData(0, 0, width, height),
        imageData = image.data,
        alphaData = buffer.getImageData(0, height, width, height).data;

    // Grabs every 4th data point (the alpha value) and overwrites the same data point on the RGB channel.
    for (var i = 3, len = imageData.length; i < len; i = i + 4)
    {
        imageData[i] = alphaData[i - 1];
    }

    output.putImageData(image, 0, 0, 0, 0, width, height);
}

An admission#

I started writing this post almost a year ago now, and I never got back around to breaking the code down into more describable parts.

I also, unfortunately, am unable to include another significant portion of the code that allows these same concepts to work in some older browers, or those with iffy CORS support. I can give a hint, though: it uses XMLHttpRequest to get the video (instead of a video tag) and draws the request result to the canvas.

Using Git with the .git directory outside the Git repository directory

2025-08-03T01:20:00+00:00

Using Git with the .git directory outside the Git repository directory#

19 August 2016

Git, Git-Bash, Bash

I have a particular use case where I want to use Git on top of another version control system. The only problem I ran into is that the other VCS wanted to track the .git directory that Git creates for its own tracking purposes.

Rather than mess about with making the existing VCS ignore this directory, I set out to make Git store the .git directory somewhere else. Turns out it’s pretty easy, but Git is fickle, and you have to set a couple environment variables rather than simply using --git-dir or --work-tree.

The bash script below creates a function named git in your environment that shells out to the real Git binary. It will also attempt to create a new directory in your home directory (~/gitdirs) to hold these new .git directories. This script also works in Git Bash!

# Store a reference to the Git binary
GIT_BIN=`which git`

# The function that runs when you type `git`
function git
{
    # The location .git directories are stored in
    gitdirroot=~/gitdirs
    # Create that directory if it does not exist
    if [ ! -d $gitdirroot ]; then
        mkdir -p $gitdirroot
    fi

    # Use the current working directory as the .git directory name
    gitdirname="$gitdirroot/`pwd | tr "/" '_'`"

    # Set the two environment variables Git needs to use the new .git directory
    export GIT_DIR=$gitdirname
    export GIT_WORK_TREE=.

    # Execute the Git command
    $GIT_BIN $@
}

Simple Way to Prevent Websites Jumping from Scrollbars

2025-08-03T01:20:00+00:00

Simple Way to Prevent Websites Jumping from Scrollbars#

1 April 2016

CSS

A common occurance I see on websites, and a frequent question I see as well regards websites “jumping” when more content loads onto the page and a scrollbar becomes visible in the browser. The solution to this is remarkably easy, but I don’t think I’ve seen many developers mention it.

The trick is simply to make the scrollbar present at all times.

If your site creates a vertical scrollbar, use this CSS:

.body {
    overflow-y: scroll;
}

If horizontal, use this CSS:

.body {
    overflow-x: scroll;
}

And lastly, if your site creates scrollbars in both directions, you can just use overflow.

.body {
    overflow: scroll;
}

Just be aware that overflow-x and overflow-y may not be supported in your target browsers!

https://developer.mozilla.org/en-US/docs/Web/CSS/overflow-y

https://developer.mozilla.org/en-US/docs/Web/CSS/overflow-x

Update Jan 10th, 2019#

It turns out Mac OS and iOS may hide scrollbars regardless of the overflow: scroll rule. Check out this fix to override this behavior.

Two short ack filetype definitions for TypeScript

2025-08-03T01:20:00+00:00

Two short ack filetype definitions for TypeScript#

9 February 2016

ack, TypeScript

I search my TypeScript code a lot and finally got tired of using awk, grep, and friends to filter out irrelevant files. Here’s a definition for .ts files and .d.ts files to help you out.

--type-set=ts:ext:ts
--type-set=tsdef:match:/.+\.d\.ts/

Put this in your .ackrc file (or use those switches at the command line).

Now you can search just your .ts files without also searching compiled .js and .d.ts files with ack --ts --notsdef mySearch.

More information in the ack manpage.

Simple programming patterns and conventions

2025-08-06T20:21:59+00:00

Simple programming patterns and conventions#

24 December 2015

Patterns, Conventions, Programming

I thought it might be helpful to some developers to see some simple patterns and conventions in a variety of languages. Many of us know about more complex and abstract patterns, like the Abstract Factory Pattern or the Flyweight Pattern, but smaller patterns are rarely discussed outside of answers to questions.

These are some patterns and conventions that I tend to use in any code I write. They range from one-liners to a couple of methods, and are mostly understandable at first glance. I’ve avoided going too much into why someone might choose any given pattern, and leave it as an exercise to the reader to determine where these patterns might be useful for them.

As of now, I’ve only listed a single convention because I use it in a number of the patterns below. I’m sure the convention is controversial, so if you don’t agree with it, please keep in mind that the meat of this post is in the patterns.

I will add other conventions and patterns in the future, and may add others from comments here or on reddit.

A final note on the code below. I did not enclose all code in the required class or method blocks in order to keep the focus on the patterns alone. Additionally, I’ve specified the language that each example is written for; many of them work just fine in other languages. If you have any questions on why a pattern doesn’t make sense, or is not executing, don’t hesitate to ask.

Enjoy!

Code Conventions#

Branching flow-control statements#

For branching flow-control statements, do not use braces and keep the code on a single line.

Return statements#

Language: C#, most C-like languages with some contingencies

if (MyBoolean) return null;

Continuing in a loop#

Language: C#, most C-like languages

Breaking out of a loop#

Language: C#, most C-like languages

Code Patterns#

Prevent a method from executing more than once#

This is an easy way to prevent a method from executing multiple times. By checking a condition at the beginning, and then ensuring that condition is true immediately after, any subsequent calls will return immediately.

Language: C#, Java with some contingencies

static boolean executed;
static void MyFoo()
{
    if (executed) return null; // simply check the condition before any other code
    executed = true; // then assign your variable
    /* ... */
}

Using a `switch` statement as a compact alternative to if statements#

Language: JavaScript

switch(true)
{
    case myFoo === myBar: FooBar(); break; // while the next statement is false if this is true, the additional check is avoided with the `break` statement
    case myFoo === myBaz: FooBaz(); break;
    default: DefaultMethod();
}

Execute multiple `using` blocks without braces#

Like any other block statement, in C#, using can be used without braces as well. This is especially useful to avoid excessive visual nesting.

Language: C#

using(var myDisposableObject = new Disposable())
using(var myFoo = new Foo())
using(var myBar = new Bar())
{
    // Each of myDisposableObject, myFoo, and mBar are accessible here
    /* ... */
}

Avoid unnecessary awaits by passing the `Task` around#

At least for me, using async / await in C# seemed to require making your methods that called asynchronous methods async themselves, and making those methods await. Instead, if your method does not need to await, you can make it return a Task and then pass the task returned from an asynchronous method wherever you need it. This is especially helpful if you need to use out or ref in a method that calls an asynchronous method.

Language: C#

static void Main()
{
    MySyncMethod().Wait();
}

static async Task MyAsyncMethod()
{
    Console.WriteLine("Waiting 1 second @ " + DateTime.UtcNow);
    await Task.Delay(1000); // here we await the result so we can execute code immediately after, usually to operate on the result of the Task
    Console.WriteLine("Finished waiting @ " + DateTime.UtcNow);
}

static Task MySyncMethod()
{
    Console.WriteLine("Calling asynchronous method");
    return MyAsyncMethod(); // MySyncMethod doesn't need to execute code immediately after, so it is synchronous and only returns the Task
}

Prevent a method call with a specific type during compile time#

I happened across this solution when clicking around Stack Overflow. Apologies for not crediting the solution; I don’t recall where I found it.

You may have a method that accepts an abstract class, an interface, or some form of “base” class, but you want to restrict a certain subclass of that type from being used (perhaps the subclass is obsolete). Rather than checking the type during runtime and throwing an exception, you use this pattern to gain a compile time check in addition to a runtime check. This example uses constructors, but it works for methods as well.

By default, the Obsolete annotation will display a warning. You can configure msbuild or Visual Studio to treat warnings as errors, which will prevent the following code from compiling.

Language: C#

public interface IBar {}

public class Bar: IBar {}
public class Baz: IBar {}

public class Foo
{
    public Foo(IBar bar)
    {
    }

    [Obsolete("Foo cannot be instantiated with a Baz.")]
    public Foo(Baz baz) // overload the IBar constructor with the type that is disallowed
    {
        throw new NotImplementedException();
    }
}

public class Program
{
    public static void Main()
    {
        new Foo(new Bar());
        new Foo(new Baz()); // this generates a warning during compile time, and an exception during runtime
    }
}

Define and declare the type of arrays and objects in TypeScript#

I think this is a problem and solution unique to TypeScript. You need to define a variable as an array or an object, but either you’ve disallowed implicity any, or you need to declare the type of the variable. There are, of course, other ways to accomplish this, but I believe this is the most compact way.

Language: TypeScript

var myFoos = <Foo[]>[]; // here we simply cast the array to the specific type needed
var myFood = <Foo>{}; // the same pattern is used for objects as well

Execute multiple async tasks in parallel#

You may need to execute a series of asynchronous tasks in parallel, and then await their result. There are a couple different ways I accomplish this, depending on how the tasks are created. You can use the pattern Avoid unnecessary awaits by passing the ``Task`` around here as well.

Language: C#

static async Task MyFirstMethod()
{
    var tasks = new List<Task>(); // here we use a List<Task> in order to optionally add tasks to await

    tasks.Add(Task.Delay(1000));

    if (aCondition) // if aCondition is true, two tasks are added to the list
    {
        tasks.Add(Task.Delay(1000));
        tasks.Add(Task.Delay(1000));
    }

    Console.WriteLine(DateTime.UtcNow);
    await Task.WhenAll(tasks); // this method will complete after 1 second, when all three tasks are completed
    Console.WriteLine(DateTime.UtcNow);
}

static async Task MySecondMethod()
{
    var tasks = new[] // here an array is initialized because there is no need to conditionally add more tasks
    {
        Task.Delay(1000),
        Task.Delay(1000),
        Task.Delay(1000)
    };

    Console.WriteLine(DateTime.UtcNow);
    await Task.WhenAll(tasks);
    Console.WriteLine(DateTime.UtcNow);
}

Printing function body in Chrome’s console

2025-08-03T01:20:00+00:00

Printing function body in Chrome’s console#

1 July 2015

Chrome

Chrome used to, by default, print a function body in the console if you entered a function name into it, or if you called console.log() with a function name.

What happens now is that Chrome will print a link to the function which, when clicked, will navigate your source viewer to that function.

For example, executing (or logging) BLT.TypeScript.Text.truncate will print function truncate(input, length, ellipsize).

For me, navigating away from my source viewer when I want a reference to a function is distracting. I am not aware of a way to re-enable the old behavior, but an alternative is to now call toString() on the function. Unfortunately, it does not appear that whitespace is preserved.

BLT.TypeScript.Text.truncate.toString()

Here is the actual function body:

function truncate(input, length, ellipsize) {
    if (ellipsize === void 0) { ellipsize = true; }
    if (input.length <= length) return input;
    var whitespace = new RegExp('\\s');
    var truncatedStr = input.substr(0, length);
    if (!whitespace.test(truncatedStr)) return truncatedStr + (ellipsize ? ' ...'
    while (length > 0 && !whitespace.test(input.substr(--length, 1))) { }
    return input.substr(0, length) + (ellipsize ? ' ...' : '');
}

Reading an HTTP Request Response Body from Exceptions

2025-08-03T01:20:00+00:00

Reading an HTTP Request Response Body from Exceptions#

16 April 2015

C#, .NET, HTTP, Debugging

Every so often I need to read the response body of a failed HTTP request while debugging a .NET application in Visual Studio. It’s not immediately obvious how you can do this, so here’s a quick way to do so. You can use these same methods when working directly with an HTTP response object or an HTTP request object as well.

Open the Immediate Window under Debug > Windows > Immediate, or by pressing CTRL + ALT + I.
You’ll need to cast your exception to a WebException. Try either of these, depending on what kind of exception you’re working with.

e as System.Net.WebException

e.InnerException as System.Net.WebException

Still no luck? Look in the Locals window and see if you can find the correct exception that has the HTTP response object in it. You’ll know you have the right one when the Immediate Window prints something other than null. For example:

{"The remote server returned an error: (404) Not Found."}
    base: {"The remote server returned an error: (404) Not Found."}
    Response: {System.Net.HttpWebResponse}
    Status: ProtocolError

Now you can get the response stream from the WebException.

var s=(e.InnerException as System.Net.WebException).Response.GetResponseStream();

{System.Net.SyncMemoryStream}
     [System.Net.SyncMemoryStream]: {System.Net.SyncMemoryStream}
    base: {System.Net.SyncMemoryStream}
    CanRead: true
    CanSeek: true
    CanTimeout: true
    CanWrite: true
    Length: 78
    Position: 0
    ReadTimeout: -1
    WriteTimeout: -1

Create a new StreamReader object just for ease of use.

var sr = new System.IO.StreamReader(s);

{System.IO.StreamReader}
    base: {System.IO.StreamReader}
    BaseStream: {System.Net.SyncMemoryStream}
    CurrentEncoding: {System.Text.UTF8Encoding}
    EndOfStream: false

Finally, read the stream contents. This is the HTTP response body:

sr.ReadToEnd();

"{\"Message\":\"The index 'products' for service 'search' was not found.\"}"

Circuit Scribe art project step #3

2025-08-03T01:20:00+00:00

Circuit Scribe art project step #3#

25 January 2015

Circuit-Scribe, Circuit-Scribe-Seattle

I finally took the time to start maping out where I’ll need to draw my Circuit Scribe ink lines. I also drew where I want to place LEDs and calculated resistor values. I may need to revisit some of this to use less resistors to lower the load on the circuit, but I’m not sure. I’ll have to draw out a couple circuits and test.

The LEDs I have need a forward voltage of 3.2 and a max forward current of 20mA. With one LED, I’ve found that 3 80.6Ω resistors in series gives an appropriate brightness without hitting the max current rating. I’m hoping that the ~130Ω resistance I’ve placed in a few places will allow a similar brightness for two LEDs in series. Some individual LEDs are placed on the ~130Ω resistance rail as well, and for those I added two additional 80.6Ω resistors in series bringing the total resistance up to ~290Ω. I may have to drop my source voltage to 5V to avoid burning out some LEDs, or add more resistors.

Some individual LEDs are placed on the ~130 Ω resistance rail as well, and for those I added two additional 80.6 Ω resistors in series bringing the total resistance up to ~290 Ω. I may have to drop my source voltage to 5 V to avoid burning out some LEDs, or add more resistors.

Some calculations follow.

Measurement              Value
Source voltage           9
LED forward voltage      3.2
LED max forward current  20 mA
Single resistor          80.6Ω

For single LEDs I calculated R = ((9 - 3.2) / 0.02) = 290.

I need R / 80.6 = 3.6 resistors. I rounded down to 3. I didn’t experience any excessive heat with this configuration.

For two LEDs in series I used four 80.6Ω resistors; two in series, and those two in parallel with two more 80.6Ω resistors also in parallel. The total resistance is R = 1 / (1/80 + 1/80 + 1/(80 + 80)) = 32.

The power, then, is calculated as I = (9 - 3.2 - 3.2) / 32 = 8.1mA.

For driving a single LED off the 32Ω rail, we need to add additional resistors in series to limit the maximum forward current into the LED.

We already know that the resistance required for a single LED is 290Ω. From here, we can subtract 32Ω to determine how many more ohms of resistance we need to add. 290 - 32 = 258. We can then figure out how many 80.6Ω resistors are needed just with division. 258 / 80.6 = 3.2. That’s 3 resistors.

Oops! I only drew two additional resistors, which gives us a forward current of about 30mA - about 10mA too many. I’ll have to revisit that circuit, or simply use a third resistor. That would give this rail about 274Ω of resistance.

Next up, I should have the corrected circuits drawn out and I’ll actually be able to draw them on my canvas!

Circuit Scribe art project step #2

2025-08-03T01:20:00+00:00

Circuit Scribe art project step #2#

20 January 2015

Circuit-Scribe, Circuit-Scribe-Seattle

I put another hour into this and started sketching out the buildings surrounding the Space Needle. The landscape is starting to take shape, but it lacks any depth. Next I need to figure out where I’m going to route my circuit, and then I’ll start drawing some of the details in the buildings.

Also I really need to get my camera to pick up the pencil marks as I’m working. It looks like I’m just zipping all over a black board and doing nothing.

Circuit Scribe art project step #1

2025-08-06T20:39:41+00:00

Circuit Scribe art project step #1#

19 January 2015

Circuit-Scribe, Circuit-Scribe-Seattle

I finally started my “cityscape” project with Circuit Scribe! Here’s a quick video showing the first pencil sketches. I will be posting these as I go along under the Circuit-Scribe-Seattle tag, so stay tuned for more!

Writing AngularJS directives as TypeScript classes

2025-08-06T20:28:01+00:00

Writing AngularJS directives as TypeScript classes#

12 January 2015

JavaScript, TypeScript, AngularJS, Directives

Introduction#

TL;DR? Read the implementation details here.

Note: This post was written for AngularJS 1.x. Angular 2+ has different conventions that make parts of this post obsolete.

TypeScript is a fantastic language that extends JavaScript by providing static typing syntax. Writing TypeScript to utilize AngularJS can be clunky at times, and one pain point for me was in writing directives.

AngularJS expects to be fed a factory function that returns an object that defines parameters and functionality for your directive.

In JavaScript, that looks like this.

module.directive('myDirective', function()
{
    return {
        scope: {},
        template: '<div>{{name}}</div>',
        link: function (scope)
        {
            scope.name = 'Aaron';
        }
    };
}

A direct translation of this to TypeScript looks like this. By the way, I am using the angular.d.ts type definition file from definitelytyped.org.

module MyModule.Directives
{
    export interface IMyScope extends ng.IScope
    {
        name: string;
    }

    export function MyDirective(): ng.IDirective
    {
        return {
            template: '<div>{{name}}</div>',
            scope : {},
            link  : (scope: IMyScope) =>
            {
                scope.name = 'Aaron';
            }
        };
    }
}

The registration is then handled as follows.

module.directive('projects', MyModule.Directives.MyDirective.Factory());

Not too different, really, but I feel this doesn’t encapsulate a directive very well, nor does it really take advantage of the utility of TypeScript.

Why this is problematic#

If MyDirective is a base class, I would not be able to extend MyDirective with a subclass. Granted, because TypeScript is a superset of JavaScript, it would be possible to extend this function through prototypal inheritance, or one of a plethora of such approaches. This, however, has the disadvantage of muddying your TypeScript with syntax and code that doesn’t necessarily need to be there.

A real-world example without a class#

To bring my examples into the real world, here’s a previous iteration of a directive I wrote for my personal site. This uses the export function syntax.

module AaronholmesNet.Directives
{
    interface IProject extends Resources.IProject
    {
        title: string;
        active: boolean;
    }

    interface IProjectsScope extends ng.IScope
    {
        [key: string] : any;

        projects: Interfaces.IListInterface<IProject>
    }

    // return my repositories first, and forks second.
    // from there, sort by last change time.
    function ProjectSort(a: Resources.IProject, b: Resources.IProject): number
    {

        if (a.fork === false && b.fork === true) return -1;

        if (a.fork === true && b.fork === false) return 1;

        if (a.updated_at > b.updated_at) return -1;

        if (a.updated_at < b.updated_at) return 1;

        return 0;
    }

    export function ProjectsDirective(ProjectResource: Resources.IProjectResource, $location: ng.ILocationService, $sanitize: ng.sanitize.ISanitizeService, $sce: ng.ISCEService): ng.IDirective
    {
        return {
            templateUrl: '/Views/Home/projects.html',
            scope : {},
            link  : (scope: IProjectsScope) =>
            {
                var projectMap: { [key: number]: IProject; } = {};

                scope.projects = [];

                ProjectResource.query((data: IProject[]) =>
                {
                    data.sort(ProjectSort);

                    var pathname = $location.path();

                    var activeSet = false;
                    data.forEach((project: IProject) =>
                    {
                        project.active = pathname == '/' + project.id;
                        activeSet = activeSet || project.active;

                        project.name        = $sanitize(project.name);
                        project.description = $sanitize(project.description);
                        project.url         = $sce.trustAsUrl(project.url);
                        project.readme      = $sce.trustAsHtml(project.readme);

                        project.title = project.name + (project.fork ? ' (fork)' : ' (repo)');

                        scope.projects.push(project);

                        projectMap[project.id] = scope.projects[scope.projects.length - 1];
                    });

                    if (!activeSet)
                    {
                        data[0].active = true;
                    }
                },
                (data: any) =>
                {
                    throw new Error(data);
                });

                // toggle which tab and tab detail is visible when a link is clicked
                scope.$on('$locationChangeStart', (event, next, current) =>
                {
                    var a = <HTMLAnchorElement>document.createElement('A');

                    a.href = current;
                    var pathname = (<string>(a.pathname.match(/^\/(\d+)/) || [,0]))[1];
                    var currentId = pathname == undefined ? 0 : parseInt(pathname, 10);

                    a.href = next;
                    pathname = (<string>(a.pathname.match(/^\/(\d+)/) || [,0]))[1];
                    var nextId = pathname == undefined ? 0 : parseInt(pathname, 10);

                    currentId && (projectMap[currentId].active = false);
                    nextId    && (projectMap[nextId].active    = true);
                });
            }
        };
    }

    ProjectsDirective['$inject'] = ['ProjectResource', '$location', '$sanitize', '$sce'];
}

The issues with this approach#

Because the exported function does not utilize a class structure, it’s necessary to either use prototypal inheritance or methods exposed in the exported functions scope. ProjectSort is a function that would be better served as a private method in a class.
The link method is much larger than it needs to be and could be slimmed down by moving the $locationChangeStart and Query handler methods into the outer function scope. However, this becomes cumbersome to manage with many enclosed methods outside of the link function body and when you need to expose variables like scope, and $location. You then have to manage those variables in the outer scope as well.
Due to the length of ProjectsDirective, the minification-safe list of dependencies (ProjectsDirective['$inject']) is quite removed from the function signature. It would be easy to forget to include this, or to update it if your dependencies change.
I’ve never been a huge fan of returning an object from a function to define my directive, and I would simply like to avoid it.

What can be done instead#

Thankfully, it’s possible to write directives as a class with a bit of a shift in thinking about how you would organize TypeScript, as opposed to how you would organize JavaScript.

The key point to keep in mind is that AngularJS still expects a function that returns an object. It turns out it’s simple and clean to do this with a static Factory method on your class.

That first example of a TypeScript directive looks like this as a class.

module MyModule.Directives
{
    export interface IMyScope extends ng.IScope
    {
        name: string;
    }

    export class MyDirective
    {
        public link: (scope: IMyScope, element: ng.IAugmentedJQuery, attrs: ng.IAttributes) => void;
        public template = '<div>{{name}}</div>';
        public scope = {};

        constructor()
        {
            MyDirective.prototype.link = (scope: IMyScope, element: ng.IAugmentedJQuery, attrs: ng.IAttributes) =>
            {
                scope.name = 'Aaron';
            };
        }

        public static Factory()
        {
            var directive = () =>
            {
                return new MyDirective();
            };

            directive['$inject'] = [''];

            return directive;
        }
    }
}

What this accomplishes#

We now have proper properties, fields, and methods on our class instance. link, template, and scope are exposed in JavaScript as function properties. If I extend this class, my subclass can override these properties and still utilize the base class functionality.
The link method is now another property on the class where its initialization can utilize the class instances scope for property access.
The factory function is very short, and so the list of dependencies is immediately in front of the developer. While not perfect, it makes it a little more obvious that the directive function and its $inject property are related.
This completely avoids having to return an object from a function because your class instance is the object that Factory returns to angular.

A real-world example with a class#

Now let’s take a look at how I refactored my original ProjectsDirective to utilize a class structure. You can see here how I take advantage of exposing public properties as the same properties the directive method would normally set in the object it returns. You can also see the private methods and properties I’ve made available to the class instance in order to avoid relying on function scoping.

module AaronholmesNet.Directives
{
    'use strict';

    export interface IProject extends Resources.IProject
    {
        title: string;
        active: boolean;
    }

    export interface IProjectsScope extends ng.IScope
    {
        [key: string] : any;

        projects: Interfaces.IListInterface<IProject>
    }

    export class ProjectsDirective
    {
        // #region Angular directive properties, fields, and methods
        public templateUrl = '/Views/Home/projects.html';
        public scope       = {};
        public link: (scope: IProjectsScope, element: ng.IAugmentedJQuery, attrs: ng.IAttributes) => void;
        // #endregion

        // #region Initialization and destruction
        constructor(ProjectResource: Resources.IProjectResource, $location: ng.ILocationService, $sanitize: ng.sanitize.ISanitizeService, $sce: ng.ISCEService)
        {
            this._$location = $location;
            this._$sanitize = $sanitize;
            this._$sce      = $sce;

            ProjectsDirective.prototype.link = (scope: IProjectsScope, element: ng.IAugmentedJQuery, attrs: ng.IAttributes) =>
            {
                scope.projects = [];

                ProjectResource.query(this._handleProjectQuerySuccess.bind(this), this._handleProjectQueryError.bind(this));

                // toggle which tab and tab detail is visible when a link is clicked
                scope.$on('$locationChangeStart', this._handleLocationChangeStart.bind(this));

                scope.$on('$destroy', this.destruct);

                this._scope = scope;
            }
        }

        public static Factory()
        {
            var directive = (ProjectResource: Resources.IProjectResource, $location: ng.ILocationService, $sanitize: ng.sanitize.ISanitizeService, $sce: ng.ISCEService) =>
            {
                return new ProjectsDirective(ProjectResource, $location, $sanitize, $sce);
            };

            directive['$inject'] = ['ProjectResource', '$location', '$sanitize', '$sce'];

            return directive;
        }

        private destruct()
        {
            this._projectMap = null;
            this._$location  = null;
            this._$sanitize  = null;
            this._$sce       = null;
            this._scope      = null;
        }
        // #endregion

        // #region Private class properties, fields, and methods
        private _projectMap : { [key: number]: IProject; } = {};
        private _$location  : ng.ILocationService;
        private _$sanitize  : ng.sanitize.ISanitizeService;
        private _$sce       : ng.ISCEService;
        private _scope      : IProjectsScope;
        // #endregion

        // #region Private event handlers
        // return my repositories first, and forks second.
        // from there, sort by last change time.
        private _projectSort(a: Resources.IProject, b: Resources.IProject): number
        {
            if (a.fork === false && b.fork === true) return -1;

            if (a.fork === true && b.fork === false) return 1;

            if (a.updated_at > b.updated_at) return -1;

            if (a.updated_at < b.updated_at) return 1;

            return 0;
        }

        private _handleProjectQuerySuccess(data: IProject[]): void
        {
            data.sort(this._projectSort);

            var pathname = this._$location.path();

            var activeSet = false;
            data.forEach((project: IProject) =>
            {
                project.active = pathname == '/' + project.id;
                activeSet      = activeSet || project.active;

                project.name        = this._$sanitize(project.name);
                project.description = this._$sanitize(project.description);
                project.url         = this._$sce.trustAsUrl(project.url);
                project.readme      = this._$sce.trustAsHtml(project.readme);

                project.title = project.name + (project.fork ? ' (fork)' : ' (repo)');

                this._scope.projects.push(project);

                this._projectMap[project.id] = this._scope.projects[this._scope.projects.length - 1];
            });

            if (!activeSet)
            {
                data[0].active = true;
            }
        }

        private _handleProjectQueryError(data: any): void
        {
            throw new Error(data);
        }

        private _handleLocationChangeStart(event: ng.IAngularEvent, next: string, current: string): void
        {
            var a = <HTMLAnchorElement>document.createElement('A');

            a.href = current;
            var pathname = (<string[]>(a.pathname.match(/^\/(\d+)/) || [, 0]))[1];
            var currentId = pathname == undefined ? 0 : parseInt(pathname, 10);

            a.href = next;
            pathname = (<string[]>(a.pathname.match(/^\/(\d+)/) || [, 0]))[1];
            var nextId = pathname == undefined ? 0 : parseInt(pathname, 10);

            currentId && (this._projectMap[currentId].active = false);
            nextId && (this._projectMap[nextId].active = true);
        }
        // #endregion
    }
}

Takeaways and wrap up#

This approach is not perfect, however I feel it has real strength when focusing heavily on object-oriented programming. I don’t demonstrate it here, but the ability to extend base class directives has been very helpful in another project. I also believe the encapsulation is much more clear, and lends itself to avoiding many of the issues we’re all familiar with in regards to prototypal inheritance and JavaScript’s strange function scoping rules.

Gotchas#

It’s important to note that you may have to bind contexts for event handlers. For example, with this call scope.$on('$locationChangeStart', this._handleLocationChangeStart.bind(this)); we must bind _handleLocationChangeStart to the class instance context because scope.$on will call it within the context of window. If someone knows of a way to handle this in TypeScript without bbid, I’d love to hear your input.
The scope property is public, and is the same property that is returned from a directive function. _scope is private and is the actual directive’s scope object, not the isolate scope definition.
It sucks that many parts of the directive function signature are duplicated in the function returned from Factory, the instantiation call, and the constructor signature. I would love to hear alternate ways to accomplish this.
- b091 discovered a way to avoid both the redundancies and the Factory method by using decorators. See this comment for more information.
It is possible to unintentially create only a single instance of your directive by binding functions and variables in the constructor. For any data members that need to be unique between instances, ensure that they are added to the classes prototype rather than the instance itself. See this comment for more information.

Back to the basics#

To summarize, here are the basic pieces you need to get this working.

A static factory method and a constructor.

class MyDirective
{
    constructor(/*list of dependencies*/)
    {
    }

    public static Factory()
    {
    }
}

A public link method that accepts the same parameters any AngularJS directive accepts, and returns void. Include any other directive properties you need, such as template and scope.

class MyDirective
{
    public link: (scope: ng.IScope, element: ng.IAugmentedJQuery, attrs: ng.IAttributes) => void;
    public template = '<div>{{name}}</div>';
    public scope = {};

    constructor(/*list of dependencies*/)
    {
    }

    public static Factory()
    {
    }
}

The initialization of the link method.

class MyDirective
{
    public link: (scope: ng.IScope, element: ng.IAugmentedJQuery, attrs: ng.IAttributes) => void;
    public template = '<div>{{name}}</div>';
    public scope = {};

    constructor(/*list of dependencies*/)
    {
        // It's important to add `link` to the prototype or you will end up with state issues.
        // See https://aaronholmes.net/2015/writing_angularjs_directives_as_typescript_classes.html#comment-2111298002 for more information.
        MyDirective.prototype.link = (scope: ng.IScope, element: ng.IAugmentedJQuery, attrs: ng.IAttributes) =>
        {
            /*handle all your linking requirements here*/
        };
    }

    public static Factory()
    {
    }
}

The instantiation call from your Factory method.

class MyDirective
{
    public link: (scope: ng.IScope, element: ng.IAugmentedJQuery, attrs: ng.IAttributes) => void;
    public template = '<div>{{name}}</div>';
    public scope = {};

    constructor(/*list of dependencies*/)
    {
        // It's important to add `link` to the prototype or you will end up with state issues.
        // See https://aaronholmes.net/2015/writing_angularjs_directives_as_typescript_classes.html#comment-2111298002 for more information.
        MyDirective.prototype.link = (scope: ng.IScope, element: ng.IAugmentedJQuery, attrs: ng.IAttributes) =>
        {
            /*handle all your linking requirements here*/
        };
    }

    public static Factory()
    {
        var directive = (/*list of dependencies*/) =>
        {
            return new MyDirective(/*list of dependencies*/);
        };

        directive['$inject'] = ['/*list of dependencies*/'];

        return directive;
    }
}

And finally, the registration of your directive with AngularJS by calling the Factory method.

It’s important to note that Factory is executed here, and its returned value (the directive) is passed to Angular’s registration function. Be sure to include the parenthesis!

Using Time as a Color Generator

2025-08-03T01:20:00+00:00

Using Time as a Color Generator#

20 December 2014

JavaScript, CSS, Codepen, Fiddle, Experimental

The idea#

I saw the site What colour is it? and thought the concept was really cool. For whatever reason, visualization generators pique my interest. I wanted to alter the original to see a wider range of colors, and to play with the attr() function in CSS’ ::after psuedo-element. I also wanted to add a slider just to allow the user to tweak the generated color.

See the Pen Time color by Aaron Holmes (@aholmes) on CodePen.

The HTML and CSS#

First set the attribute on your element. I decided to call it data-text.

<h1 id="time" data-text="00 : 00 : 00"></h1>

We only need two lines of CSS to get the attribute function to display.

h1::after
{
  display:block;
  content:attr(data-text);
}

Normally the content attribute is set to a static string, but there’s also the attr() function that let’s you use an attribute value on your element instead.

You can find more information about attr() on MDN.

NOTE: Browser compatibility is sketchy at best. There are some gotchas to be careful of too.

Updating the content with JavaScript#

There are no DOM API methods that let us access ::after or ::before psuedo-elements with JavaScript. We can at least use the attr() function in conjunction with the setAttribute() method or dataset property to change the content of the psuedo-elements.

With the HTML element above, here’s how we can change the value of the data-text attribute. This change will then be rendered with our CSS rules to display new text in the psuedo-element.

var timeHeader = document.getElementById('time');

var time = "15:30:25";

if (timeHeader.dataset !== undefined)
{
    timeHeader.dataset.text = time;
}
else
{
    timeHeader.setAttribute('data-text', time);
}

Theoretically that should be all we need! With a little more code to set the correct time value on a loop, the site will show a new time every second.

A repaint issue on Chrome version 39.0.2171.95#

My experiment didn’t go perfectly. I discovered that changing the attribute value does not always trigger a repaint, and thus the new time would not display. I have not figured out exactly what caused this; it was sporadic, and I wonder if it’s partly related to how CodePen works.

Thankfully there’s an easy way to trigger a repaint. It’s not exactly the prettiest solution, but it does ensure the new time is displayed each second.

timeHeader.style.display='none';
timeHeader.offsetHeight;
timeHeader.style.display='';

A little extra#

The original code uses the time values as the hexidecimal values for the background color. A time of 9 hours, 23 minutes, and 40 seconds give you the hex color #092340. Given that this will increment the 0th digit for each red, green, and blue hex value, we end up with a similar color for each second, minute, and hour.

If the time value is 09 23 40, then our RGB values are as follows.

	Hex	Dec	Conversion
Red	0x09	9	(0 × 16¹) + (9 × 16⁰)
Green	0x23	35	(2 × 16¹) + (3 × 16⁰)
Blue	0x40	64	(4 × 16¹) + (0 × 16⁰)

After 1 second, blue becomes 65, then 66, 67, 68, and so on. This is a very slow increase!

Additionally, because there are only 24 hours in a day, 60 minutes to an hour, and 60 seconds to a minute, our scale of colors is limited. Red ranges from 0 - 23, green 0 - 59, and blue 0 - 59.

Here’s a visualization of all possible red, green, and blue values individually.

To get a wider range of colors, each hexidecimal string value can be flipped. For example, 9 is “09” as a string, and “90” flipped. Here’s what our example above looks like with the values flipped.

	Hex	Dec	Flipped String
Red	0x09	9	90
Green	0x23	35	53
Blue	0x40	64	46

And here’s the range of colors and the pattern in which they occur.

Speech Synthesis on Windows Phone 8.1

2025-08-03T01:20:00+00:00

Speech Synthesis on Windows Phone 8.1#

7 December 2014

C#, .NET, Windows-Phone, Speech

I recently wrote an application to make my phone report current Los Angeles traffic conditions. I used the Windows.Media.SpeechSynthesis namespace to read in either a plain-text string, or an SSML-formatted string, and to speak it until the end. It turns out that speech synthesis with .NET libraries is incredibly simple, but some information takes a little effort to find. For me, searching for “text-to-speech windows phone 8.1” shows me a bunch of results for how to accomplish this with Silverlight! Definitely not what I want.

The setup#

Because this was for a Windows Phone application, I needed a way to access a MediaElement object to play, pause, and stop the speaking if I pressed a button to do this. I opted to create a private object on my MainPage instance.

namespace PhoneTraffic
{
    public sealed partial class MainPage : Page
    {
        private MediaElement media;

        public MainPage()
        {
            this.InitializeComponent();
            this.NavigationCacheMode = NavigationCacheMode.Required;
            media = new MediaElement();
        }
    }
}

From here, we instantiate a SpeechSynthesizer object.

using(var synth = new SpeechSynthesizer())

Then we need to pass a plain-text string into the synthesizer, and store the outputted stream so we can set it on the media object.

var stream = await synth.SynthesizeTextToStreamAsync("Hello, World!");

Then set the stream source on our media object.

media.SetSource(stream, stream.ContentType);

Now we’re ready to tell the phone to play, pause, or stop the speaking of our sentence. Here’s how it looks in my application.

Using plain-text#

private async void GetTrafficButton_Click(object sender, RoutedEventArgs e)
{
    var incidents = await Task.Run(() => JsonConvert.DeserializeObject<TrafficIncident[]>(trafficJson));

    if (incidents.Length == 0)
    {
        using(var synth = new SpeechSynthesizer())
        {
            var stream = await synth.SynthesizeTextToStreamAsync("There are no incidents right now.");
            media.SetSource(stream, stream.ContentType);
            media.Play();
        }
    }
    else
    {
        using(var synth = new SpeechSynthesizer())
        {
            var toSay = String.Empty;

            for(var i = 0; i < incidents.Length; i++)
            {
                var incident = incidents[i];

                toSay += " At " + incident.Time + " there was a " + incident.Incident + " incident at " + incident.Location;
                toSay += (i < incidents.Length - 1) ? " and another " : ".";
            }

            var stream = await synth.SynthesizeTextToStreamAsync(toSay);
            media.SetSource(stream, stream.ContentType);
            media.Play();
        }
    }
}

My pause and stop methods are simpler:

private void PausedSpeechButton_Click(object sender, RoutedEventArgs e)
{
    media.Pause();
}

private void StopSpeechButton_Click(object sender, RoutedEventArgs e)
{
    media.Stop();
}

Using SSML#

If you want to use SSML, use the method SynthesizeSsmlToStreamAsync instead of SynthesizeTextToStreamAsync and pass an SSML-formatted string to it.

My application supports both modes. I create the SSML string on my API server, and the phone consumes it. Here’s what the code looks like (replaces the “else” block in the plain-text example).

using(var synth = new SpeechSynthesizer())
{
    var stream = await synth.SynthesizeSsmlToStreamAsync(ssml);
    media.SetSource(stream, stream.ContentType);
    media.Play();
}

Here are some resources I used.

Wikipedia Speech Synthesis Markup Language
W3 Speech Synthesis Markup Language (SSML) Version 1.0
Microsoft MSDN Windows.Media.SpeechSynthesis namespace
Microsoft MSDN SSML say-as Examples
Jayway Windows Phone 8.1 for Developers - Text to speech

My Ghost theme; Casper for developers

2025-08-06T20:56:37+00:00

My Ghost theme; Casper for developers#

1 December 2014

Ghost

I started using Ghost about a week ago. My (honest) first impression was that code blocks are unstyled and uneditable, which is a huge pet peeve of mine. I fixed that problem by forking Casper and adding Ace editor. You can find my fork of the theme here: https://github.com/aholmes/Casper.

For whatever reason, I still wasn’t satisfied with things, so I kept changing bits. Here’s a list of the changes I made, and what is available to you if you use this theme.

Hope you enjoy, and I will definitely accept pull requests if you send them!

Ace Editor
Google+ comments
Disqus comments
Google Analytics
Linkable headers
Fixed-position header and footer across the site

Ace editor#

As mentioned above, my first change was to add Ace editor. You can see it in action in this post, but here’s a screenshot as well.

Google+ comments#

Casper, and Ghost in general, doesn’t have a commenting system for posts out-of-the-box. My first pass at adding them was by adding some JS and CSS to use Google+’s commenting system.

This feature is optional in my theme.

Code link

<!-- Uncomment this to add Google Plus comments to your posts. -->
<!--div id="comments"></div>
<script>
    (function ()
    {
        // Load G+ comments
        var po = document.createElement('script'); po.type = 'text/javascript'; po.async = true;
        po.src = 'https://apis.google.com/js/client:plusone.js?onload=gapiOnload';
        var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(po, s);
    })();
</script-->

Disqus comments#

I wasn’t satisfied with Google+ comments, so I added this next. In my branch of this theme, I have Google+ comments disabled, and Disqus enabled.

This feature is optional in my theme.

Here’s what the module looks like in each post’s footer.

Code link

<!-- Uncomment this to add Disqus comments to your posts. -->
<!--div id="disqus_thread"></div>
<script type="text/javascript">
    var disqus_shortname = 'REPLACE WITH DISQUS FORUM NAME';
    (function ()
    {
        var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true;
        dsq.src = '//' + disqus_shortname + '.disqus.com/embed.js';
        (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
    })();
</script-->

Google Analytics#

I wanted to track how much traffic my blog would get, so I added Google Analytics.

This feature is optional in my theme.

Code link

<!-- Uncomment this to enable Google Analytics. -->
<!--script>
    (function (i, s, o, g, r, a, m)
    {
        i['GoogleAnalyticsObject'] = r; i[r] = i[r] || function ()
        {
        (i[r].q = i[r].q || []).push(arguments)
        }, i[r].l = 1 * new Date(); a = s.createElement(o),
        m = s.getElementsByTagName(o)[0]; a.async = 1; a.src = g; m.parentNode.insertBefore(a, m)
    })(window, document, 'script', '//www.google-analytics.com/analytics.js', 'ga');
    ga('create', 'CHANGE THIS TO YOUR KEY', 'auto');
    ga('send', 'pageview');
</script-->

Linkable headers#

Casper was lacking a way to get the direct link to any headers in my posts. This feature shows a “link” icon when the header is hovered over. When the link is clicked, the URL hash is changed, and the link becomes “active.” The currently linked-to header always displays the link until another header is clicked.

Here’s what a header looks like when hovered over:

Here’s what a header looks like when it’s the active link:

Fixed-position header and footer across the site#

I found another theme I liked called Decode for Ghost that allowed blog content to flow over the header. It also didn’t cause the header image to take up the entire screen on the home page (another pet peeve of mine). Unfortunately, I didn’t like other parts of the theme, so I adopted the fixed header and footer idea to my fork of Casper.

This one is harder to capture with screenshots, but here they are anyway.

Here’s what the home page looks like when first loaded. Notice that the image doesn’t take over the entire screen.

Here’s what the home page looks like when scrolled part way. Notice that the content covers the header, and the header has not moved at all.

Lastly, here’s what the footer looks like. The content scrolls over this as well.

Running Entity Framework Migrations on Application Start

2025-08-06T19:26:29+00:00

Running Entity Framework Migrations on Application Start#

28 November 2014

C#, Entity Framework, ASP.NET, .NET

Entity Framework is an ORM developed by Microsoft. It has a useful set of tools and conventions for automatically managing database schema changes called Code First Migrations. My only gripe is that, unless you are willing to do some digging, migrations can only be managed with the PowerShell commands Add-Migration and Update-Database. Even automatic migrations require users to run Update-Database.

There may be many reasons you would want to have migrations automatically run, rather than managing them manually. One reason for me is that I did not want to require that other developers on my team manually run Update-Database any time there is a database schema change. I feel that it is disruptive to the philosophy of Getting Shit Done. On the flip side, not manually managing your databases runs the risk of things breaking and going unnoticed, so use this with care.

Well, I did the digging, and here’s what I came up with to run migrations when an ASP.NET website starts.

Update 2014-11-29#

Somehow I had forgotten that using the database initializer MigrateDatabaseToLatestVersion is another way to accomplish this. Definitely give it a once over.

My ApplicationDbContext.cs is fairly straightforward.

namespace MyNamespace.DAL
{
    public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
    {
        public ApplicationDbContext()
            /* This is a static class I use to store environment settings from Web.config. */
            : this(EnvironmentSettings.Current.DatabaseConnections.DatabaseConnectionString())
        {
        }

        public ApplicationDbContext(string connectionString)
            : base(connectionString, throwIfV1Schema: false)
        {
            Configuration.UseDatabaseNullSemantics = true;

#if DEBUG
            Database.Log = s => System.Diagnostics.Debug.WriteLine(s);
#endif
        }
    }
}

This is my Migrations/Configuration.cs file.

namespace MyNamespace.DAL.Migrations
{
    public class ConfigurationBase : DbMigrationsConfiguration<ApplicationDbContext>
    {
        public ConfigurationBase()
        {
            AutomaticMigrationsEnabled = false;
            ContextKey = "MyNamespace.DAL.ApplicationDbContext";
        }

        protected void Initialize(string environment = null)
        {
            /*
                Do some stuff to get your database connection string(s).
                I store mine in Web.config, and initialize a static class with
                the values read from that file. This is the same class referenced
                in my ApplicationDbContext.
            */
        }

        /*
            I use a different class for each environment I need to account for.
            That includes Local, Debug, Stage, and Production.
        */
        public sealed class Local : ConfigurationBase
        {
            public Local()
                : base()
            {
                Initialize("local");
            }
        }
    }
}

And lastly, my Startup.cs file. This is the important bit.

namespace MyNamespace
{
    public partial class Startup
    {
        public void Configuration()
        {
#if DEBUG
            MigrateDB();
#endif
        }

        static void MigrateDB()
        {
            var settings = EnvironmentSettings.Current;
            var migratorConfig = new MyNamespace.DAL.Migrations.Local();
            migratorConfig.TargetDatabase = new System.Data.Entity.Infrastructure.DbConnectionInfo(settings.DatabaseConnections.DatabaseConnectionString(), "System.Data.SqlClient");

            var dbMigrator = new DbMigrator(migratorConfig);

            dbMigrator.Update();
        }
    }
}

Let’s break it down a little bit.

First, I only want to run this in my debug environments, so I wrapped the call in a preprocessor block.

#if DEBUG
    MigrateDB();
#endif

Then I pull my current environment settings from a static class. This class stores my database connection strings. You may need to find another way to pull your database connection strings in.

var settings = EnvironmentSettings.Current;

Armed with our migration configuration class and our connection string, we can instantiate a new “migrator config” and attach a new DbConnectionInfo instance to it. Again, settings.DatabaseConnections.DatabaseConnectionString() comes from my EnvironmentSettings class, so this will be your own connection string.

You could add some logic here to use different migration configurations instead of just Local.

var migratorConfig = new MyNamespace.DAL.Migrations.Local();
migratorConfig.TargetDatabase = new System.Data.Entity.Infrastructure.DbConnectionInfo(settings.DatabaseConnections.DatabaseConnectionString(), "System.Data.SqlClient");

Finally, we instantiate a DbMigrator and call Update().

var dbMigrator = new DbMigrator(migratorConfig);
dbMigrator.Update();

JavaScript Vector Animations with Divs or Canvas

2025-08-06T19:26:29+00:00

JavaScript Vector Animations with Divs or Canvas#

28 November 2014

JavaScript, Canvas, Pixi.js, Animation, Codepen, GitHub, Fiddle

See the Pen Vector Animations by Aaron Holmes (@aholmes) on CodePen.

What’s this all about?#

A few months ago I found the post Vector animations with Python. I thought the presented demos were very cool, and the code interesting, but I was disappointed with the lack of interactivity. You can’t very well change a GIF while you’re watching it!

Because of that, I was inspired to recreate the first example. I started with rendering the animation with a bunch of <div> elements, and then I moved onto to rendering the animation with in a <canvas> element using Pixi.js. You can play with the codepen above to alter the animation’s look and behavior.

The HTML#

I wanted to keep the HTML for this demo simple. A single <div> exists on the page which acts as the container for either the <canvas> element, or the list of <div> elements. Some HTML exists to handle the options dialog as well.

<!-- This block is for the options dialog. -->
<div id="options">
    <a href="" id="hide-options">Hide Options</a>
    <label><input type="checkbox" name="opacity"/> Opacity</label>
    <label><input type="checkbox" name="inverse"/> Inverse</label>
    <label><input type="checkbox" name="reverse"/> Reverse</label>
    <label><input type="checkbox" name="chill"/> Chill</label>
    <label><input type="checkbox" name="running" checked="checked"/> Running</label>
    <label><input type="text" name="colorbg" value="#FFFFFF"> BG color</label>
    <label><input type="text" name="colorborder" value="#000000"> Border color</label>
    <label><input type="range" step="10" min="0" max="800" value="400" name="width"> Width</label>
    <label><input type="range" step="1" min="-60" max="60" value="20" name="fps"> FPS</label>
    <button name="reset">Reset</button>
    <button name="fullscreen">Fullscreen</button>
</div>
<div id="toggle-options"><a href="" id="show-options">Show Options</a></div>

<!-- This is the container for the animation. It's really all we need. -->
<div class="container" id="container"></div>

Accomplishing this with `<div>`#

My first approach with this was to render the animations with a bunch of div elements. I used JavaScript to recalculate their positions relative to their container on each “tick” (using requestAnimFrame()).

Application loop#

The script has a main application loop that is a function called run(). Because this is JavaScript, we can’t use a real while loop, or the browser would never repaint anything.

/**
 * Start the application loop.
 * @param {Function} make_frame The method returned from bootstrap().
 */
function run()
{
    run.t = run.t || 0;

    var frame = run.t / runOptions.fps;
    if (run.t === runOptions.frameRate)
    {
        run.t = 0;
    }

    run.make_frame(frame);

    // continue painting new frames when not running, but don't animate the disks
    // this way, chill mode, with, and opacity can be changed when the frames are "still."
    if (diskOptions.running)
    {
        run.t++;
    }

    requestAnimFrame(run);
}

run.make_frame = makeFrameMethod;

The animation is bootstrapped at the very end with run().

This same method is used by both the <div> and <canvas> approach. We run run.make_frame = makeFrameMethod; to generate the method we need to use based on the “mode” option, which is either “dom” or “canvas”.

Bootstrapping the `<div>` rendering method#

Okay, here’s the fun part. makeFrameMethod does two things when running in “dom” mode.

First, we set up some run-time parameters. These parameters are used in “canvas” mode as well.

var delay_between_disks = runOptions.duration / 2 / runOptions.ndisks_per_cycle,
    total_number_of_disks = parseInt(runOptions.ndisks_per_cycle / runOptions.speed, 10),
    start = 1.0 / runOptions.speed;

Then we create a bunch of <div> elements and store them in an array. This we, we avoid creating a bunch of elements during each animation frame, and we don’t have to make calls to the DOM to get properties of the existing elements. This is different from the GIF rendering method, which creates a blank frame and draws new circles for each frame.

We create two circles here to act as the containers for the whole animation. If the site background is not black, you would see a black stroke around the inner circle.

var container = document.getElementById('container');

var circle1 = new Disk(0.65 * diskOptions.width, [0.65 * diskOptions.width, 0.65 * diskOptions.width]),
    circle2 = new Disk(0.42 * diskOptions.width, [0.42 * diskOptions.width, 0.42 * diskOptions.width]);

circle1.disk.id = 'circle1';
circle2.disk.id = 'circle2';
circle1.disk.className = '';
circle2.disk.className = '';

circle1.disk.appendChild(circle2.disk);
container.appendChild(circle1.disk);

Finally, we can push new <div> elements into an array and add them to the DOM.

var disks = [];
for (var i = 0; i < total_number_of_disks; i++)
{
    disks.push(new Disk(0, [0, 0]));
    circle2.disk.appendChild(disks[i].disk);
}

You may have noticed the code is calling new Disk(...). Disk is a helper method to create a new DOM element. The setParams method ensures that the disk will be positioned correctly.

/**
 * The object container for the disks that animate
 * @param {Number} radius Radius of disk
 * @param {[Number, Number]} xy cartesian coords of disk
 * @constructor
 */
function Disk(radius, xy)
{
    this.disk = document.createElement('div');
    this.disk.className = 'disk';

    this.setParams(radius, xy);
}

/**
 * Set the radius and cartesian coords of the disk
 * @param {Number} radius
 * @param {Number} xy
 * @returns {Disk}
 */
Disk.prototype.setParams = function (radius, xy)
{
    this.disk.style.width = (radius * 2) + 'px';
    this.disk.style.height = (radius * 2) + 'px';
    this.disk.style.left = (xy[0] === radius ? 0 : (xy[0] - radius)) + 'px';
    this.disk.style.top = (xy[1] === radius ? 0 : (xy[1] - radius)) + 'px';

    return this;
}

The rendering method itself#

Once makeFrameMethod finishes initializing the <div> elements that are actually animated, it then creates and returns the method that will handle positioning each <div> on every frame.

I am not particularly skilled at math, and will do a terrible job explaining how this works. However, you can read up on calculating polar coordinates to better understand the code below.

The color variable is just for some extra fun to variably change the opacity of a few circles along the horizontal plane of the animation.

function make_frame(t)
{
    var angle, radius, cartCoords, color, circle;

    for (var i = 0; i < total_number_of_disks; i++)
    {
        angle = (Math.PI / runOptions.ndisks_per_cycle) * (total_number_of_disks - i - 1);
        radius = Math.max(0, 0.05 * (t + start - delay_between_disks * (total_number_of_disks - i - 1)));

        cartCoords = polar2cart(radius, angle);
        cartCoords[0] = (cartCoords[0] + 0.5) * parseInt(circle2.disk.style.width, 10);
        cartCoords[1] = (cartCoords[1] + 0.5) * parseInt(circle2.disk.style.height, 10);

        color = ((i / runOptions.ndisks_per_cycle) % 1.0);

        circle = disks[i].setParams(0.3 * diskOptions.width, cartCoords, i).disk;

        circle.style.opacity = diskOptions.opacity ? color : 1;
    }
}

Now whenever requestAnimFrame(run) succeeds, make_frame(t) will iterate over every circle and reposition them. The end result is a very cool animation looking like an endless circle of circles flowing out of the center of the container.

Accomplishing this with `<canvas>`#

While the <div> method works, it’s unfortunately very inefficient. Even when using GPU rendering with .disk { transform : translate3d(0, 0, 0); }, it’s just too expensive and chugs along. Canvas, on the other hand, is perfect for animations. Previously, I worked with the raw DOM API when toying around with an online Ascension clone. I didn’t want to do that this time, so I used Pixi.js, which saved me hours of work.

All the methods for the <canvas> approach to this project have the same name as the <div> approach. Only the inner-workings have changed.

Bootstrapping the `<canvas>` rendering method#

We have to do a little more work to get set up using <canvas>.

Both of these variables are meant to store objects and functions for rendering with Pixi.js. This was, we don’t need to constantly recreate things.

var runModeHelpers = {}, getGraphics;

getGraphics() returns the shape-drawing object in Pixi.js.

getGraphics = function ()
{
    return new PIXI.Graphics()
        .beginFill(Hex2Num(diskStyles.backgroundColor), diskStyles.opacity)
        .lineStyle(diskStyles.stroke, Hex2Num(diskStyles.borderColor), diskStyles.opacity);
};

runModeHelpers.Graphics = getGraphics();

runModeHelpers.Reset = function ()
{
    runModeHelpers.Stage.removeChild(runModeHelpers.Graphics);
    runModeHelpers.Graphics.clear();
    runModeHelpers.Graphics = getGraphics();
    runModeHelpers.Stage.addChild(runModeHelpers.Graphics);
};

runModeHelpers.Stage = new PIXI.Stage(0x000000);
runModeHelpers.Stage.addChild(runModeHelpers.Graphics);

runModeHelpers.Renderer = undefined;

The Disk class has changed as well. It now creates a new circle object from the Pixi.js Graphics object. Disk.prototype.setParams is now a NOOP.

function Disk(radius, xy)
{
    this.disk = runModeHelpers.Graphics;

    this.disk.drawCircle(
        xy[0],
        xy[1],
        radius
    );
}

Finally, we create the <canvas> element and add it to the DOM.

runModeHelpers.Renderer = new PIXI.autoDetectRenderer(
    0.42 * diskOptions.width * 2,
    0.42 * diskOptions.width * 2,
    null, // view
    false, // transparent
    true // antialias
);
runModeHelpers.Renderer.view.id = 'canvas';
container.appendChild(runModeHelpers.Renderer.view);

runModeHelpers.Renderer.render(runModeHelpers.Stage);

The rendering method itself (part two)#

With the <canvas> method, the rendering method is very similar to the <div> methods. New positions are calculated, and circle are drawn. What’s different, however, is that each frame is cleared before redrawing, similar to how the GIF method renders each frame.

function make_frame(t)
{
    var angle, radius, cartCoords, color;

    runModeHelpers.Reset();

    for (var i = 0; i < total_number_of_disks; i++)
    {
        angle = (Math.PI / runOptions.ndisks_per_cycle) * (total_number_of_disks - i - 1);
        radius = Math.max(0, 0.05 * (t + start - delay_between_disks * (total_number_of_disks - i - 1)));

        cartCoords = polar2cart(radius, angle);
        cartCoords[0] = (cartCoords[0] + 0.5) * runModeHelpers.Renderer.width;
        cartCoords[1] = (cartCoords[1] + 0.5) * runModeHelpers.Renderer.height;

        if (diskOptions.opacity)
        {
            color = ((i / runOptions.ndisks_per_cycle) % 1.0);

            runModeHelpers.Graphics
                .endFill()
                .beginFill(Hex2Num(diskStyles.backgroundColor), color)
                .lineStyle(diskStyles.stroke, Hex2Num(diskStyles.borderColor), color);
        }

        new Disk(0.3 * diskOptions.width, cartCoords);
    }

    runModeHelpers.Renderer.render(runModeHelpers.Stage);
}

Wrap up#

That’s just about the end of the interesting bits of this demo. It all boils down to drawing circle in the correct place, and porting the concept to JavaScript. The dialog on the page allows the user to change colors, the size of the circles, the rate at which frames are renered, and so on. The code is available on GitHub if you’d like to see how the rest works.

Thanks for reading!

-Aaron Holmes

Displaying code with Ace on Ghost

2025-08-06T19:26:29+00:00

Displaying code with Ace on Ghost#

28 November 2014

Ghost, Ace, Theme, JavaScript, CSS

After getting Ghost set up, I was disappointed to see the lack of syntax highlighting in Casper’s codeblocks. Additionally, code posted on sites where I can’t copy, edit, or scroll around is a huge pet peeve of mine. I wanted to provide a usable codeblock for any readers of my site. Having used Ace before, I knew it did exactly what I was looking for. After some quick Googling and not finding a solution for this already, I decided to do it myself.

Update 2014-11-30#

You can skip all the work below and use my theme, which includes these changes.

Adding Ace to your blog#

First I copied the Casper theme to a new directory and created “my own” theme.

Aaron@PINGU ~/Source/Repos/aholmes blog (master)
$ cd content/themes/

Aaron@PINGU ~/Source/Repos/aholmes blog/content/themes (master)
$ cp -a casper/ casper-aholmes

Edit your “new” theme’s package.json to give it a new name and version number.

Aaron@PINGU ~/Source/Repos/aholmes blog/content/themes (master)
$ vi casper-aholmes/package.json

{
  "name": "Casper-aholmes",
  "version": "1.0"
}

Change back to the root directory for your blog.

Aaron@PINGU ~/Source/Repos/aholmes blog/content/themes (master)
$ cd -

Aaron@PINGU ~/Source/Repos/aholmes blog (master)
$

Add Ace as a Git submodule.

Aaron@PINGU ~/Source/Repos/aholmes blog (master)
$ git submodule add https://github.com/ajaxorg/ace-builds.git ./content/themes/casper-aholmes/assets/js/ace-builds

Then check out the latest tagged version:

Aaron@PINGU ~/Source/Repos/aholmes blog (master)
$ cd content/themes/casper-aholmes/assets/js/ace-builds/

Aaron@PINGU ~/Source/Repos/aholmes blog/content/themes/casper-aholmes/assets/js/ace-builds (master)
$ git tag
v1.0.0
v1.1.01
v1.1.1
v1.1.2
v1.1.3
v1.1.4
v1.1.5
v1.1.6
v1.1.7
v1.1.8

Aaron@PINGU ~/Source/Repos/aholmes blog/content/themes/casper-aholmes/assets/js/ace-builds (master)
$ git checkout -b tags/v1.1.8 tags/v1.1.8
Checking out files: 100% (1744/1744), done.
Switched to branch 'tags/v1.1.8'

Aaron@PINGU ~/Source/Repos/aholmes blog/content/themes/casper-aholmes/assets/js/ace-builds (tags/v1.1.8)
$ cd -

Then we need to add the checked out tag to our repository.

Aaron@PINGU ~/Source/Repos/aholmes blog (master)
$ git status
# On branch master
# Changes not staged for commit:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#       modified:   content/themes/casper-aholmes/assets/js/ace-builds (new commits)

Aaron@PINGU ~/Source/Repos/aholmes blog (master)
$ git add content/themes/casper-aholmes/assets/js/ace-builds

Aaron@PINGU ~/Source/Repos/aholmes blog (master)
$ git commit -m "Checked out v1.1.8 from ace-build repository."

Including Ace on your blog#

Now that we have Ace available to us, we need to edit the default.hbs file to include ace.js on the page.

Aaron@PINGU ~/Source/Repos/aholmes blog (master)
$ vi content/themes/casper-aholmes/default.hbs

Add this line after the index.js inclusion.

<script type="text/javascript" src='{{asset "js/ace-builds/src-min/ace.js"}}'></script>

Rendering code blocks with Ace#

I added this code in a <script> block immediately following the ace.js inclusion, but you may want to add it to content/themes/casper-aholmes/assets/js/index.js instead.

$('pre code').each(function (i, el)
{
    var newEl = document.createElement('CODE');
    newEl.className = el.className + (el.className ? ' ' : '') + 'ace-editor';
    newEl.innerHTML = el.innerHTML;
    // the three-backticks syntax for code blocks in markdown allows you to specify the language name, which Ghost gets set as a class on the code element.
    newEl.setAttribute('data-language', (el.className.match(/language-([^ ]+)/) || [, 'c_cpp'])[1]);

    var editor = ace.edit(newEl);

    editor.setOptions(
    {
        minLines: 1,
        maxLines: 20
    });

    // el.dataset only works in IE11. :(
    // c_cpp is a safe bet for most languages I work with.
    editor.session.setMode('ace/mode/' + newEl.getAttribute('data-language'));

    // Who needs <pre> when you have Ace? Replace the pre element with the newEl <code> element.
    $(el.parentElement).replaceWith(editor.container);
});

This code replaces any instances of <pre><code> with a new <code> element that has been initialized with Ace after your site renders. It also supports using different syntax definitions, which you can control for your code blocks by using three backticks instead of tabs when writing your post. Of course, the options in setOptions() can be changed as well.

CSS Tweaks#

To override some CSS from Ghost, I needed to use the ace-editor class the JavaScript above adds for us. Open your content/themes/casper-aholmes/assets/css/screen.css file and add the following.

.ace-editor
{
    display: block;
    width: 100%;
    line-height: normal;
    white-space: pre-wrap;
    -ms-word-break: break-all;
    word-break: break-all;
    border-radius: 0;
    padding: 0;
}

I didn’t like that my paragraphs following a code block would “stick” to the bottom of each code block, so I added this CSS to make each paragraph “stick” to the top of each code block following a paragraph. The same holds true for headers, but the margin is smaller.

.ace-editor + p
{
    margin-top : 1.75em;
}

.ace-editor + h1,
.ace-editor + h2,
.ace-editor + h3,
.ace-editor + h4,
.ace-editor + h5,
.ace-editor + h6
{
    margin-top: 0.4em;
}

p + .ace-editor
{
    margin-top: -1.75em;
}

h1 + p,
h2 + p,
h3 + p,
h4 + p,
h5 + p,
h6 + p
{
    margin-top: -0.4em;
}

Bits, Bobs & Breakpoints — Aaron Holmes

Browser-Based URL and vCard QR Code Generator

Browser-Based URL and vCard QR Code Generator#

Opening It#

Build a QR For#

Entering a URL#

Entering a Contact#

Phones and Emails#

Types and Labels#

The Primary Star#

Country Codes#

Designing the Code#

Background and Color#

Error Correction#

Center Logo#

Shape#

Frame#

Resetting the Design#

Saving Your Work#

Exporting#

Before You Print#

Interview Coding Take-Homes: Part 3

Interview Coding Take-Homes: Part 3#

UCLA Health - Population Analysis#

Goals#

Why this approach#

Repository#

Process overview#

Key implementation details#

Handling messy JSON keys#

Fetching and caching the data#

Example input (trimmed)#

Normalized CSV (representative rows)#

Notes on implementation#

Testing and verification#

Testing the pipeline#

What the tests cover#

Manual sanity checks#

Running with Docker#

Tradeoffs#

Analysis and findings#

Testing the idea#

Output and visualization#

Helper Functions for Analysis#

Year-over-Year Change Analysis#

Rank Change Visualization#

Average Annual Growth Rate Map#

Conclusion#

Interview Coding Take-Homes: Part 2.b

Interview Coding Take-Homes: Part 2.b#

UCLA Health - Terraform Module#

Prompt#

My Approach#

resource_type Constraints#

base_name and resource_name Alterations#

Secondary Module#

Production Quality#

Tests#

Interview Coding Take-Homes: Part 2.a

Interview Coding Take-Homes: Part 2.a#

UCLA Health - Maze Bug#

Prompt#

My Approach#

Testing the Application#

Examining the Code#

Debugging#

My Solution#

Interview Coding Take-Homes: Part 1

Interview Coding Take-Homes: Part 1#

UCLA Health - Data Corruption#

Prompt#

My Approach to the Code#

Structure#

Domain#

Aggregates#

Entities#

Values#

Business logic#

Searching#

Other Considerations#

`resource_type` Constraints#

`base_name` and `resource_name` Alterations#

Using a `switch` statement as a compact alternative to if statements#

Execute multiple `using` blocks without braces#

Avoid unnecessary awaits by passing the `Task` around#