dhbolton.com

Developer marketing is the practice of reaching software developers where they already learn and make tooling decisions—technical content, creator channels, open source, and community—and turning that attention into product signups. It differs from traditional marketing because the audience evaluates tools on technical merit, tries before trusting, and ignores polished ad copy. It's the right approach when your product is an AI or DevTools offering and your bottleneck is distribution rather than product quality.

Why distribution, not product, is usually the bottleneck

Most AI and DevTools teams are founded by people who can build. The failure mode described by DevTools Academy is "Great Product, Broken Distribution"—the tool works, but the people who would use it never hear about it in a context they trust.

Developers don't convert on impressions. They convert after seeing a credible peer use the tool, reading a technical walkthrough, or watching someone solve a real problem with it. That means the marketing job is not persuasion—it's placement in front of the right technical audience with proof attached.

How developer marketing differs from traditional marketing

The practical consequence: budget spent on speculative reach tends to underperform compared to a systematic creator partnership framework, which is the shift DevTools Academy describes making for Orchids.

The creator-led distribution model

Creator-led developer marketing means partnering with technical creators who already have the audience you want, rather than buying reach through ads. DevTools Academy runs this across YouTube, X, LinkedIn, Instagram, TikTok, Reddit, UGC, and technical newsletters.

The mechanics that make it work:

• Credibility transfer. A creator who understands the tooling explains it in their own voice, so the recommendation carries weight an ad cannot.
• Depth over volume. The goal is "developers, not just impressions"—a smaller, engaged technical audience beats a large passive one.
• Repeatability. A creator program built once can produce consistent output quarter after quarter instead of one-off spikes.

For Stream, this approach was credited with 6,600+ sign-ups across every quarter of FY-2025, with a program built from the ground up spanning 60+ creators across YouTube, X, LinkedIn, open source, and newsletters.

What execution looks like end to end

DevTools Academy frames its work as "end-to-end developer GTM execution" and "numbers, not narratives." A workable sequence for a team running this themselves:

1. Identify where your developers already are. Pick the two or three channels where your target users actually spend time—not all of them at once.
2. Recruit creators with technical credibility. Prioritize people who can use the product and explain it, over reach alone.
3. Give them something real to show. A working integration, a benchmark, or a solved problem produces better content than a feature list.
4. Let the content run in the creator's format. Tutorials and demos outperform scripted promotion on technical channels.
5. Measure signups and engagement, not just reach. Track comments, reposts, and sign-ups per channel so you can reallocate.

How to measure whether it's working

The evidence from DevTools Academy's case studies points to a measurement set that goes beyond impressions:

• Signups — the primary outcome. Stream: 6,600+ sign-ups across FY-2025 quarters.
• Engagement depth — comments and reposts as a signal of real technical interest. Oumi's LinkedIn launch produced 631+ comments and 269+ reposts on day one.
• Impressions and engagements at scale — Orchids reached 1.1M impressions and 10,000+ engagements in a single quarter.
• Consistency over time — growth that repeats every quarter, not a single viral moment.

Oumi's founder described the value as watching "the comment section turn into a deep-dive discussion on day one"—that discussion is the social proof that drives the next wave of signups.

When this approach fits

Creator-led developer marketing is a strong fit when:

• Your product is an AI or DevTools offering aimed at working developers.
• The product is good but under-distributed.
• You can support a program over multiple quarters rather than a single campaign.
• You're willing to trade speculative spend for a structured creator framework.

It's a weaker fit if your buyers are non-technical, if you have no working product to demonstrate, or if you need results within days rather than a quarter.

Where to start

If you want to assess your current position before committing, DevTools Academy offers a "See how your current GTM stacks up" entry point alongside strategy calls and published case studies. The useful first step for most teams is auditing which channels already produce signups, then concentrating creator partnerships there instead of spreading across every platform at once.

A blog is a website whose primary content is a stream of dated entries ("posts") shown newest-first, usually with an author byline and a way to browse older material by category, tag, or archive. It differs from a static site mainly in how content is organized and updated: a static site presents fixed pages you edit in place, while a blog is built around an accumulating timeline of posts. You'd choose a blog when you expect to publish repeatedly over time; you'd choose static pages when the content changes rarely and each page stands alone.

Blog vs. static site vs. wiki

The lines blur in practice. A project site can host a blog as one section, and a blog can contain static pages (About, Contact) alongside the post stream. The distinguishing feature is the post timeline, not the software.

The typical structure of a blog

• Posts — the individual dated entries. Each usually has its own URL, title, date, author, and body.
• Reverse-chronological index — the home page or a "blog" page listing posts newest-first.
• Categories — broad, usually pre-defined groupings (e.g., "Releases," "Tutorials").
• Tags — finer, often free-form labels that can cut across categories.
• Archives — views by month, year, or author for reaching older posts.
• Feeds — an RSS or Atom file that lets readers and other tools subscribe to new posts.
• Comments — optional; some blogs enable them, many disable them to avoid spam and moderation work.

Categories and tags both help readers and search engines, but they only work if you apply them consistently. A common failure is creating a new tag for every post, which produces dozens of one-item tag pages that help no one.

Hosted or self-hosted?

The main decision is who runs the software and the server.

• Hosted platforms (e.g., WordPress.com, Blogger, Medium-style services) handle hosting, updates, and often the domain for you. You trade control and sometimes portability for less maintenance.
• Self-hosted means you install and run the software yourself on a server or static host. You get full control over themes, plugins, and data, but you own backups, updates, and security.

A middle path is a static site generator such as Jekyll, which builds plain HTML files from templates and Markdown posts. These are fast and cheap to host, but they have no built-in comment system or admin interface, so publishing means running a build step. The OpenBVE project homepage, for example, is a project site that publishes dated release notes in a blog-like stream — the August 10, 2026 entry lists OpenBVE v1.14.0.3 changes such as a fix for builds failing to launch on non-Windows platforms and new quality options for viewers. That is the blog pattern applied to software releases: dated, newest-first, each entry a discrete update.

Basic steps to start a blog

1. Decide hosted vs. self-hosted based on how much control and maintenance you want.
2. Choose a platform that matches that choice — a hosted service, a self-hosted CMS, or a static generator.
3. Pick a domain — either a subdomain on the platform or your own registered name. Your own domain makes it easier to move later.
4. Select a theme that is responsive, so it works on phones as well as desktops.
5. Configure the basics — site title, author, time zone, and permalink structure.
6. Write and publish your first post, then verify it appears on the index and at its own URL.
7. Set up a feed so readers can subscribe, and check that it validates.

Ongoing tasks

Publishing is the visible part; the rest is upkeep.

• Comments — if enabled, expect spam. Most platforms offer moderation queues and spam filters; many bloggers simply turn comments off.
• Feeds — keep the feed working and decide whether to publish full text or excerpts.
• SEO basics — descriptive titles, clean URLs, sensible headings, and internal links between related posts. Avoid duplicating the same content across multiple URLs.
• Backups — especially self-hosted. A blog is a database plus files; back up both.
• Updates — self-hosted software needs security patches. Skipping them is the most common way small blogs get compromised.

How to tell it's working

After the first few posts, check that: the index lists posts newest-first, each post has a stable URL, categories and tags resolve to real pages, the feed validates, and the layout holds up on a narrow screen. If any of those fail, fix them before publishing more — structural problems get harder to correct as the archive grows.

raylib is a simple, easy-to-use programming library for making videogames, written for C and usable from C++. It is code-first: there is no fancy interface, no visual helpers, no GUI tools or editors — you build games by writing code. That makes it a good fit if you already know some C or C++ and want direct control without an engine's editor layer, or if you want a small library you can learn from a cheatsheet and a pile of examples. If you want a drag-and-drop scene editor, raylib is deliberately not that.

What raylib actually is

raylib is a library, not a game engine. You write a program, call raylib functions for windows, input, graphics, audio, and math, and compile it like any other C program. The project describes itself as "a programming library to enjoy videogames programming; no fancy interface, no visual helpers, no gui tools or editors... just coding in pure spartan-programmers way."

Two consequences follow from that design:

• You learn by reading code. The project states it does not provide the typical API documentation or a big set of tutorials. Instead, it is meant to be learned from a cheatsheet covering the required functionality plus a large collection of examples.
• You bring your own structure. There is no editor to organize scenes, assets, or build settings, so project layout and build steps are yours to set up.

How it differs from Unity or Godot

The practical difference is where the work happens.

Neither column is "better" in the abstract. Choose raylib when you want to write the game as a program and keep the toolchain small. Choose an editor-based engine when you want visual scene assembly, asset pipelines, and a guided project structure.

The recommended learning path

The project points to a specific route rather than a tutorial series:

1. Start with the cheatsheet. It lists the functionality you need, so you can see the available calls without reading full API docs.
2. Read the examples. The project's stated position is that the best way to learn to code is reading code, and the examples show how each piece of functionality is used.
3. Use the raylib game template if the options overwhelm you. It provides some structure and a Makefile that are quick to pick up, which is useful when you want a working layout instead of assembling one yourself.
4. Join the Discord community. The project recommends it for staying up to date on raylib news and asking for help. Community-made tutorials also exist outside the official materials.

A concrete first task looks like this: install raylib, open one example that draws something and responds to input, compile and run it unchanged, then modify one value and recompile to confirm your build loop works. That verifies your setup before you write anything original.

Platforms and language bindings

raylib has been tested on multiple target platforms. The project notes that technically any platform supporting the C language and OpenGL graphics (or similar) can run raylib, or can be ported to it fairly easily.

You are not limited to C and C++. There are more than 60 language bindings, so you can use raylib from many other programming languages. If your preferred language is not C, check whether a binding exists before assuming you need to switch languages.

Extending it and what it powers

raylib can be combined with extra libraries for additional functionality. Some of those libraries are already used internally by raylib, while others are provided for you to integrate; most are single-file, header-only, and have no external dependencies — which keeps them easy to drop into a project.

raylib is also the base technology behind the raylib technologies tools: several multiplatform tools have been built with raylib and raygui. That is a useful signal if you want to see what the library looks like at application scale rather than in minimal examples.

Getting started checklist

• Confirm you are comfortable writing and compiling C or C++ (or pick one of the 60+ bindings for a language you already know).
• Accept that there is no editor: your project structure and build configuration are your responsibility.
• Learn from the cheatsheet and the examples rather than expecting full API documentation.
• Use the raylib game template if you want a ready-made structure and Makefile.
• Join the Discord community for news and help.
• Check the extra libraries before writing utility code that may already exist as a single-file dependency.

If that workflow sounds appealing — code, compile, read examples, iterate — raylib is designed exactly for it. If you want a visual editor and a guided project structure, an editor-based engine will get you to a running game with less setup work.

Delphi is an Object Pascal-based language and integrated development environment (IDE) used to build native applications, historically for Windows and now for cross-platform targets. If you write Delphi code, the practical question is usually not "what is Delphi" but "what do I use to profile it, script it, or measure test coverage?" The DelphiTools.info project is one place that answers that: it hosts a free sampling profiler, the DWScript (Delphi Web Script) engine, and related Pascal developer tools, plus optimization and coding tips.

What Delphi actually is

Delphi combines a compiled language (Object Pascal) with a visual IDE. You write Pascal source, the compiler produces native machine code, and the IDE handles forms, components, and debugging. That compiled-native model is why performance tooling matters: there is no interpreter or VM sitting between your code and the CPU, so bottlenecks show up as real CPU time in your own routines.

Tool categories in the Delphi ecosystem

How a sampling profiler helps

A sampling profiler interrupts execution at intervals and records the current call stack, then aggregates the samples. The routines that appear most often are where your program spends its time. This differs from instrumenting every function: sampling adds little overhead and does not require you to modify source, so you can profile a realistic build.

For example, if a Delphi app feels slow when loading a large dataset, a sampling profile will show whether the time sits in parsing, in string handling, or in a database call — and you optimize the routine that actually dominates rather than guessing.

What DWScript offers

DWScript is an embeddable scripting engine that brings a Pascal-like language into a Delphi host application. Instead of recompiling the whole program to change behavior, you expose parts of your app to scripts and let users or your own team write logic in a familiar Pascal syntax. It is aimed at developers who want scripting inside a compiled Delphi product without adopting an unrelated language.

Code coverage and coverage-gap analysis

DelphiCodeCoverage measures which parts of your code your tests actually run. The project's fork added a "Code Coverage Gaps" .ccg format designed to be consumed by AI tooling, which the author notes can reduce token usage when you ask an AI to improve unit test coverage. The practical use: run your tests, generate coverage data, and identify untested paths — then target new tests at those gaps rather than at code already covered.

Choosing what to reach for

• Performance problem in a compiled build → start with a sampling profiler.
• Need user- or config-driven logic without recompiling → consider an embeddable engine like DWScript.
• Tests exist but you don't know what they miss → use a code coverage tool and review the gaps.

Each of these solves a different problem, and they are complementary: profile to find slow code, script to make behavior flexible, and measure coverage to keep tests honest.

MySQL is an open-source relational database management system (RDBMS) that stores data in tables and lets applications read and write that data with SQL. Developers use it mainly as the persistence layer behind web applications, content management systems, e-commerce sites, and analytics backends. It fits projects that need a mature, widely supported SQL database with a large ecosystem of drivers, hosting options, and GUI tools. It is a poor fit when you need a single-file embedded database (SQLite) or when your workload depends heavily on advanced SQL features and strict standards compliance (PostgreSQL).

The core relational model

MySQL organizes data into tables, which are made of rows (records) and columns (fields). Each column has a data type such as INT, VARCHAR, or DATETIME.

Two kinds of keys hold the structure together:

• A primary key uniquely identifies each row in a table.
• A foreign key points to a primary key in another table, creating a relationship between them.

You interact with the data using SQL (Structured Query Language). A minimal example:

CREATE TABLE customers (
  id INT PRIMARY KEY AUTO_INCREMENT,
  name VARCHAR(100) NOT NULL,
  email VARCHAR(255) UNIQUE
);

CREATE TABLE orders (
  id INT PRIMARY KEY AUTO_INCREMENT,
  customer_id INT,
  total DECIMAL(10,2),
  FOREIGN KEY (customer_id) REFERENCES customers(id)
);

SELECT c.name, o.total
FROM customers c
JOIN orders o ON o.customer_id = c.id
WHERE o.total > 100;

The JOIN is the part that makes a relational database relational: it combines rows from two tables based on a shared key.

What developers actually use it for

The common thread is an application that needs durable, concurrent, multi-user access to structured data over a network.

How MySQL compares to related options

Upscene, which publishes database development tools, lists MySQL and MariaDB alongside PostgreSQL, SQLite, Oracle, SQL Server, InterBase, Firebird, and NexusDB as the databases its products support. That grouping reflects how these engines are typically treated: as interchangeable targets for the same development workflow, not as one-size-fits-all choices.

The basic workflow

1. Install a server. Run MySQL locally or use a managed instance. This gives you a running process that listens for connections.
2. Connect with a client or GUI tool. Use the mysql command-line client or a GUI such as Database Workbench, which Upscene describes as a multi-database tool with a consistent user interface, ER designer, and metadata browsing.
3. Create a schema. Define your tables, columns, keys, and constraints with CREATE TABLE statements.
4. Run queries. Insert, select, update, and delete data with SQL. Verify results after each step.
5. Add indexes on columns you filter or join on frequently, then re-check query performance.

Common beginner pitfalls

• Connection errors. Usually a wrong host, port, username, or password, or the server is not running. Confirm the server is up before changing application code.
• Character set issues. Mismatched encodings produce garbled text. Set a consistent character set (commonly utf8mb4) at the database, table, and connection level.
• Missing indexes. Queries that scan whole tables get slow as data grows. Add indexes on join and filter columns.
• Ignoring foreign keys. Without them, orphaned rows accumulate and data integrity drifts.

If you are choosing a database for a new project, start by asking whether you need a networked, multi-user SQL database (MySQL or PostgreSQL) or an embedded one (SQLite). If you need the former and want the widest hosting and tooling support, MySQL is a reasonable default.