Tecnick.com LTD on Tecnick.com

Articles

Sun, 20 Sep 2026 00:00:00 +0000

The articles on individual nurago packages moved to nurago.org/articles/ in September 2026, so that each one sits next to the package it describes. Their old addresses here still resolve.

The twenty-part guide to building a production REST API in Go stays on this site.

Search

Mon, 01 Jan 0001 00:00:00 +0000

Software

Mon, 01 Jan 0001 00:00:00 +0000

Tecnick.com is strongly engaged in the development and maintenance of Open Source projects. Over the years we have contributed to several third-party Open Source projects and published many original ones. The actively maintained projects are listed first, followed by legacy and archived projects that are kept online for reference.

Actively Maintained

Go

nurago
Collection of modular and reusable Go (golang) packages for building services and infrastructure code, including a web-service project builder.
rpistat
Web-Service to collect system usage statistics.
rndpwd
Web-Service Random Password Generator written in Go (example project).
statsd
Simple and efficient StatsD client, supporting counter, gauge, timing and set metrics with InfluxDB and Datadog tags.

C and Multi-language Libraries

variantkey
Reversible numerical encoding for human genetic variants and regions. Available for C, Go, Python, Javascript and R.
farmhash64
Portable multi-language implementation of the FarmHash64 and FarmHash32 non-cryptographic fingerprint hash functions. Available for C, CGO, Go, Java, Javascript, PHP, Python, R, Rust and Zig.
binsearch
Fast binary search of unsigned integers in memory-mapped columnar binary files, including the Apache Arrow, Feather and BINSRC1 formats. Available for C, Go and Python.

PHP and Web Applications

TCExam
Computer-Based Assessment (CBA) system for universities, schools and companies, that enables educators and trainers to author, schedule, deliver and report on surveys, quizzes, tests and exams.
web-cctray
Web-based dashboard for CI/CD cctray.xml files.

PHP Libraries

tc-lib-pdf
PHP PDF library (TCPDF), to generate PDF documents on-the-fly without requiring external extensions.
tc-lib-barcode
PHP library to generate 70+ linear, 2D and postal barcodes as SVG, PNG, HTML or text.
tc-lib-pdf-font
PHP library containing PDF font methods and utilities.
tc-lib-pdf-page
PHP library containing PDF page formats and definitions.
tc-lib-pdf-image
PHP library containing PDF Image methods.
tc-lib-pdf-graph
PHP library containing PDF graphic and geometric methods.
tc-lib-pdf-sign
PHP library containing digital signature primitives for PDF documents (PKCS#7, CAdES, PAdES).
tc-lib-pdf-parser
PHP library to parse PDF documents.
tc-lib-pdf-encrypt
PHP library to encrypt data for PDF documents.
tc-lib-pdf-filter
PHP library to decode PDF compression and encryption filters.
tc-lib-unicode
PHP library containing Unicode methods, including UTF-8 conversions, the Unicode Bidirectional Algorithm (UAX #9) and script-specific character substitutions.
tc-lib-unicode-data
PHP library containing UTF-8 font definitions.
tc-lib-file
PHP library to read byte-level data from files.
tc-lib-color
PHP library to parse, convert and format the color representations used in web and PDF output.

Font Assets

Data-only packages that provide the font resources used by the PDF toolchain.

Websites

Mon, 01 Jan 0001 00:00:00 +0000

Tecnick.com owns and manages a portfolio of technology-focused websites that provide open resources, practical tools, and technical documentation for developers, engineers, students, and digital makers.

technick.net - Guides and online tools for electronics, hardware and software
allpinouts.org - Archive of cable and connector pinouts
circuitsarchive.org - Archive of electronic circuit schematics and projects
nurago.org - Open Source collection of modular Go packages for backend services
tcpdf.org - Open Source PHP library to generate PDF documents (TCPDF and tc-lib-pdf)
tcexam.org - Open Source Computer-Based Assessment (CBA) system
testimages.org - Archive of free test images for research and display testing
atletix.net - [IT] Guide, strumenti e calcolatori per l’attività motoria e l’atletica leggera
appunti.asuni.xyz - [IT] Appunti universitari di Nicola Asuni
nicola.asuni.xyz - Nicola Asuni’s personal website and professional profile

Guides

Mon, 01 Jan 0001 00:00:00 +0000

Long-form, multi-part guides. Where an article takes one subject apart, a guide builds one thing from start to finish.

Building a Production REST API in Go

Twenty parts, in six sections, building a booking service in Go from a bound socket to a deployment manifest. Configuration, startup and shutdown, logging and redaction, servers and middleware, the request lifecycle, response formats, outbound clients and retries, connection pools and transactions, health and metrics, one complete feature with its write and read paths, four layers of testing, packaging, and the probes that watch it in production.

Legal

Mon, 01 Jan 0001 00:00:00 +0000

Disclaimer

Please be aware that any information you find on this website may be inaccurate, misleading or out of date.

Some information on Tecnick.com may create a risk for readers who choose to apply or use it in their own activities, or who promote it for use by third parties. None of the authors or contributors connected with Tecnick.com can be held responsible, in any way whatsoever, for your use of the information contained in or linked from these pages.

TCPDF: 25 Years of Generating PDFs in PHP

Sun, 28 Jun 2026 00:00:00 +0000

Many PHP applications end up needing to produce a PDF. An invoice, a shipping label, a course certificate, a signed contract, a monthly report. It is one of those unglamorous requirements that turns up on project after project, and it is rarely as simple as it first sounds.

I know, because I have been writing the code that does it for twenty-five years.

If you have generated a PDF from PHP at any point in the last two decades, there is a good chance some of my code was involved. TCPDF, the library I started in 2002, has been installed more than 109 million times through Composer alone, and it is a dependency of a long list of applications you already know. I have even found documents generated by TCPDF sitting on NASA’s own data-centre websites. More on that below.

Software Quality Is a System, Not an Act: Inside the Quality Pipeline of nurago

Sat, 11 Jul 2026 00:00:00 +0000

Saying a project cares about software quality is easy. Pointing at the exact mechanisms that produce it is harder.

Quality is not a final inspection step, and it is not a property you can bolt on before a release. It is the cumulative result of dozens of small, boring, automated decisions that either happen on every commit or do not happen at all.

That is what the title of this article means. An act is something a person performs at a moment in time: a QA phase before the release, a yearly security audit, a reviewer being especially careful on a good day. Acts depend on memory, time, and goodwill, and they are the first casualty of deadline pressure; their results start decaying the moment they end. A system is a standing structure that produces quality as its normal output: automated, continuous, redundant, and measured, regardless of who is busy that week. W. Edwards Deming made the underlying point about manufacturing decades ago: you cannot inspect quality into a product; you have to build it into the process that makes it.

Building a Production REST API in Go

Sun, 13 Sep 2026 00:00:00 +0000

Most guides to writing an HTTP service in Go stop at the handler. It is the part that is easiest to teach, and the smallest part of what it takes to run the service.

Production is not the environment the code was written in. The process does not run once on a laptop under a developer’s eye: it is started, restarted, scaled to many copies, rescheduled onto another node and killed mid-request by an orchestrator that knows nothing about what it was doing. It runs against configuration nobody re-read, on dependencies that are up but slow, under load that arrives in bursts, from clients that retry. Its failures are rarely a clean crash and usually a degradation: a few instances answering slowly, a connection pool exhausted since the last deploy, a timeout budget larger than the caller’s patience. Nobody is attached to the process, so what you learn about it afterwards is only what it wrote down while it was still working.

What a REST Service Is Made Of

Sun, 13 Sep 2026 00:00:00 +0000

A REST service is one operating system process. It starts, reads its configuration, opens some sockets and some database connections, then accepts connections until something tells it to stop. Everything else in this guide is a detail of that sentence.

From the outside it is a set of URLs that return JSON, which says little about the thing you have to deploy, watch and debug at an inconvenient hour.

The Standard Library Underneath All of This

Sun, 13 Sep 2026 00:00:00 +0000

Go’s HTTP server is in the standard library, it is production quality, and six types do most of the work. Learn them here and most of what a framework, router or toolkit adds later reads as a layer over them.

This page is entirely net/http, net and context. No dependencies, no toolkit, nothing from the guide’s reference implementation.

From main to Listening

Sun, 13 Sep 2026 00:00:00 +0000

Startup is a sequence of steps that can each fail, arranged so that the ones most likely to fail happen first and report clearly. Get the order wrong and a service crashes with a nil pointer dereference and no log line, because logging was configured after the thing that broke.

Configuration That Is Wrong Before It Is Late

Sun, 13 Sep 2026 00:00:00 +0000

The same binary has to run on a laptop with a JSON file next to it, in CI with a handful of environment variables, and in production with secrets injected by a platform the developer has never logged into. It has to behave the same way in all three, and when it cannot start it has to say which value was wrong.

A configuration mistake usually does not stop the service. It starts a service that is subtly wrong: the read pool pointed at the write database, a timeout set to zero, the thing you needed disabled, and nobody finds out until the behaviour is strange enough to investigate.

The Lifecycle: One Context, One Channel, One Wait Group

Sun, 13 Sep 2026 00:00:00 +0000

srv.Shutdown(ctx) stops the server accepting new connections and waits for the in-flight ones to finish. That is about a third of the problem. A real service also has a database pool that should close after the last query, background goroutines that need telling, a metrics client with buffered measurements, and an orchestrator that will send SIGKILL if the process takes too long. Getting one of those wrong turns a deploy into a small outage: dropped requests, a truncated metrics window, or a pod that hangs until the grace period expires.

Logs You Can Search, and Secrets You Cannot Read

Sun, 13 Sep 2026 00:00:00 +0000

Logs are written for the moment when something is wrong, you have no idea what, and the only evidence is what the process happened to record. A line is useful then if it is findable, meaning machine-parseable fields rather than sentences, and safe, meaning no secret in it, because logs are copied into search systems that many more people can read than can read production.

Structured, meaning fields

// Not this.
l.Info(fmt.Sprintf("item %s created with quantity %d in %dms", id, qty, ms))

// This.
l.InfoContext(ctx, "item created",
	slog.String("item_id", id),
	slog.Uint64("quantity", uint64(qty)),
	slog.Int64("duration_ms", ms),
)

The first produces a line a human can read and a machine has to guess at. The second produces JSON with named fields, so item_id:"019813a0-..." is a query rather than a substring search that also matches every other identifier of that shape. The message stays a short fixed string and everything variable becomes an attribute, because a message that interpolates values makes every occurrence unique and defeats grouping. InfoContext rather than Info passes the context, which is how the trace ID gets onto the record.

Servers, Binders, and the Routes You Get for Free

Sun, 13 Sep 2026 00:00:00 +0000

The server page 02 built from net.Listen, http.Server and a ServeMux works. What it lacks is timeouts set to something other than infinity, a route list that cannot contain a route nothing can reach, operational endpoints, and a shutdown that drains rather than drops.

Routes are data

type Route struct {
	Method string
	Path string
	Description string
	Handler http.HandlerFunc
	Middleware []MiddlewareFn
	DisableLogger bool
	Timeout time.Duration
}

and a handler package returns a list of them:

The Middleware You Will Actually Need

Sun, 13 Sep 2026 00:00:00 +0000

Before writing any middleware, answer a different question: is something in front of this process already doing it? A service that implements everything itself carries code its platform already runs, and occasionally code that fights it: two components both answering a Cross-Origin Resource Sharing (CORS) preflight send two Access-Control-Allow-Origin headers, and a browser rejects that.

The boundary

Concern	Usually lives at	What the service still owns
Transport Layer Security (TLS) termination	The edge	Supporting TLS for direct and mesh-internal exposure, and knowing which mode it is in
Response compression	The edge	Not compressing twice, and knowing which end negotiates
Rate limiting	Gateway, ingress, content delivery network (CDN) or web application firewall (WAF)	A last-resort limit for direct and internal callers
CORS and preflight	The gateway, when there is one	Answering preflight when there is not
Request body caps	The ingress, commonly	Its own cap, because the edge cap does not cover internal callers
Client Internet Protocol (IP) address	The proxy sets the header; the platform decides the trusted hop depth	Being told the hop count rather than guessing it
Authentication	Frequently an edge concern	Reading an established identity, per page 17

One Request, All the Way Down

Sun, 13 Sep 2026 00:00:00 +0000

One request, from the byte arriving on the socket to the last log line, through the machinery pages 07 and 08 assembled. Following it end to end shows which layer owns what, and it shows the deadline the request carries and how that gets spent.

The trace

The Envelope Argument

Sun, 13 Sep 2026 00:00:00 +0000

Two decisions here outlive most of the code around them: what shape a response body has, and how an error from four layers down becomes the right status code. A response format is a contract with every consumer you have, and changing it is a versioning event rather than a refactor.

The envelope

The reference service’s default response writer wraps a payload in this structure:

type Response struct {
	Program string `json:"program"`
	Version string `json:"version"`
	Release string `json:"release"`
	DateTime string `json:"datetime"`
	Timestamp int64 `json:"timestamp"`
	Status httputil.Status `json:"status"`
	Code int `json:"code"`
	Message string `json:"message"`
	Data any `json:"data"`
}

A success:

Talking to Other Services Without Losing the Thread

Sun, 13 Sep 2026 00:00:00 +0000

Every outbound call is a place the service can hang, leak a goroutine, lose the trace, or make somebody else’s outage worse, and http.Get handles none of it. What a call needs is a timeout, structured logging of what went out and came back, a metric, the trace ID forwarded, and secrets kept out of the log line. Every client needs the same list, so it is built once.

One base, many clients

httpClientOpts := []httpclient.Option{
	httpclient.WithLogger(l),
	httpclient.WithRoundTripper(m.InstrumentRoundTripper),
	httpclient.WithTraceIDHeaderName(traceid.DefaultHeader),
	httpclient.WithComponent(appInfo.ProgramName),
	httpclient.WithRedactFn(logRedactor.BytesToString),
}

Built once in bind and passed to each client constructor, which appends only its own; inside newIpifyClient the parameter is baseHTTPClientOpts:

The Database Connection Is a Long-Lived Thing

Sun, 13 Sep 2026 00:00:00 +0000

*sql.DB is a pool of connections, safe for concurrent use, created once at startup and borrowed by requests that last milliseconds. Most database problems a Go service has come from treating it as a single connection: one per request exhausts the server’s connection limit, closing it after a query destroys the pool, and copying a size from a blog post produces a service that queues under load for reasons the logs do not show.

Ping, Status, Metrics: Three Different Questions

Sun, 13 Sep 2026 00:00:00 +0000

/ping answers is this process alive, /status can it do its job, and /metrics what has it been doing.

Confusing the first two is expensive. Point readiness at /ping and the orchestrator sends traffic to a pod that cannot reach its database. Point liveness at /status and a database blip restarts every replica at once, turning a degradation into an outage.

/ping

httpserver.WithPingHandlerFunc(jsx.DefaultPingHandler(appInfo))

Returns 200 and the envelope, touching no dependency, running no query, making no outbound call. A 200 from /ping means the process is running, the listener is bound, the router works and a goroutine was available to serve the request.

Designing the Feature: Contract, Schema, Seams

Sun, 13 Sep 2026 00:00:00 +0000

Parts I to IV covered the machinery a service needs before it does anything for anybody. The reference implementation carries one feature on top of it: four endpoints over a table of items, in internal/item and internal/httphandlerpub/item.go.

Part V reads that feature, then covers what it leaves out. Every snippet in these four pages is code from the generated tree, at the path named above it. Where a section goes past what ships, it opens by saying so.

The Write Path: Decode, Validate, Commit

Sun, 13 Sep 2026 00:00:00 +0000

A write path takes bytes from a client that may be hostile, careless or merely retrying, and turns them into a row. Three questions sit between: is this readable, is it allowed, and is it already there.

The Read Path: What the Client Can Ask For

Sun, 13 Sep 2026 00:00:00 +0000

The item list takes one query parameter. That is enough to show the whole mechanism, because the interesting part of a list endpoint is not how many parameters it has: it is that the query string is a public interface a client can put anything into, and every parameter is a promise about what the database will be asked to do.

What Is Reachable From Where

Sun, 13 Sep 2026 00:00:00 +0000

Page 01 said the three listeners are an enforcement mechanism, and there is now a real feature to place.

The question here is narrow: which listener is this endpoint on. Who a caller is and what they may do is a different problem, and the last section says what this guide does about it.

The three zones

Tests That Would Have Caught It

Sun, 13 Sep 2026 00:00:00 +0000

Four layers, each catching a class of bug the others cannot, ordered by how fast they run and how much they need.

Layer	Runs in	Needs	Catches
Unit	Microseconds	Nothing	Logic, branches, error paths
In-process end to end	Milliseconds	A free port	Routing, middleware, encoding, status codes
Container integration	Minutes	Docker, MySQL, Flyway	Migrations, real SQL, wiring, configuration
Contract and fuzz	Minutes	A running service	Spec drift, unhandled inputs

Building, Packaging, and the Probes That Watch It

Sun, 13 Sep 2026 00:00:00 +0000

Everything from page 03 onward has been the process’s own behaviour. This is the machinery that produces the binary, wraps it, and puts it somewhere it will be watched. A shutdown timeout the orchestrator ignores does nothing.

Growing the Service Without Growing the Wiring

Sun, 13 Sep 2026 00:00:00 +0000

The service in this guide serves HTTP requests and nothing else. Growth past that follows a few recognisable shapes: scheduled work, queue work, a second data store, and secrets that cannot sit in a file, with one structural question underneath all four: how bind stays readable while they arrive.

Work that has to happen on a schedule

The idempotency keys from page 15 accumulate, items nobody has touched in a year can be archived, and a cache warms better if something warms it. The shape is a goroutine that wakes on an interval, registered the way page 05 registers everything: