It is often said that there are two hard problems in computer science; cache invalidation, naming things, and off-by-one errors. This post is about the approach I’ve taken over the years to name things - how I’ve named my projects.

The very first project that I ever really created is also one that I released - called technowax. It’s actually still online today, in a fashion; http://technowax.net/ . I’m ashamed so say now, after all these years that the name was not original - and it was actually a distant family friend who had a web design company, I think it was, called TechnoWax. I’m not sure if they are still around, but I do remember that I thought it was a cool name at the time.

This is just a quick article to describe how the GoConSPA stack implements the 15 Factor App principles.

1. One Codebase, Ont Application

• GitHub: All code for the application is stored in a single repository.

2. API First

• ConnectRPC: The api is defined in protobuf, and exposed via ConnectRPC.

3. Dependencies

• Go Modules: All dependencies are managed via Go modules, and vendored in the repository.

4. Configuration

• GitOps: Configuration is stored in Git, allowing for version control and easy collaboration.
• ** Environment Variables**: Configuration is stored in environment variables, and loaded via viper.
• ** YAML Configuration**: Configuration is stored in YAML files, and loaded via viper.

5. Backing Services

• Docker: All backing services are run in Docker containers, and managed via docker-compose.

6. Build, Release, Run

• GitHub Actions: All builds are done via GitHub Actions, and released to a container registry.

7. Processes (Statelessness)

• Stateless Services: All services are stateless, and can be scaled horizontally.

8. Port Binding

• HTTP/2: All services are exposed via HTTP/2, and can be accessed via a load balancer.

9. Concurrency

• Docker: All services are run in Docker containers - no PID files, daemons, or init systems.

10. Disposability

• Docker: All services are run in Docker containers, and can be started and stopped quickly.

11. Log (streamiing)

• Docker: All logs are written to stdout and stderr, and can be collected via a log collector.

12. Admin Processes

• Docker: All admin processes are run in Docker containers - which mirror the production environment.

13. APi First

• ConnectRPC: The api is defined in protobuf, and exposed via ConnectRPC.

14. Telemetry

• Prometheus: All services expose metrics in a standard format, and can be scraped by Prometheus.

15. Authentication

• OAuth2: All services use OAuth2 for authentication, and can be accessed via a token.

I’m eager to write about a technology stack that I’ve stumbled into, which I believe is the nicest one I’ve ever worked with. The stack is called GoConnSPA, and it consists of the following technologies and tools;

Overview

  flowchart TD
    A[Backend Service] <-->|websocket| B[Single Page App]

Technologies

• Go: The Go programming language, which is known for its simplicity and efficiency.
• ConnectRPC: A gRPC framework for Go that simplifies the process of building and consuming gRPC services.
• SPA (+CSR): Single Page Application with client side rendering - not reliant on the server.

Tools

• Air: A live reloading tool for Go applications, which automatically reloads the application when code changes are detected.
• Vite: A build tool that provides a fast development environment and optimizes the build process for production.
• Goreleaser: A tool for building and releasing Go applications, making it easy to create binaries and publish them to various platforms.
• precommit: A framework for managing and maintaining multi-language pre-commit hooks, ensuring code quality and consistency.
  • conventional-pre-commit: A pre-commit hook that enforces conventional commit messages, helping to maintain a clean and understandable commit history.
• GitHub Actions: A CI/CD tool that allows you to automate your software development workflows directly in your GitHub repository.
  • goreleaser-action: A GitHub Action that integrates with Goreleaser, automating the process of building and releasing Go applications.
  • semantic-release-action: A GitHub Action that automates the release process based on semantic versioning, ensuring that releases are consistent and predictable.
• Docker: Just release containers

I’m just throwing this blog post out there to get it started, and because otherwise I’ll never find the time to finish the perfect blog post. However, I’ve ported the majority of projects I maintain to use this stack now.

So many interactions with friends, family and coworkers now happen via our chat apps, and so many of the best bits of these chats just scroll by and are forgotten. Faridoon is a simple app that lets you save and publish your favourite chat quotes for you to save, for your community, or for the world to see.

I was inspired to write Faridoon a long time ago, when I was chatting with friends mostly on Mumble chat. We really liked the awesome simple interface of bash.org (now long since gone), but wanted to save our own quotes.

This article is about how I often invest time in ambitious projects just for the joy of working on the project, often without the intention of finishing or publishing the project. By the end of this article I hope you can see why investing your time in such projects is interesting and useful, so you can understand why I spend so much time on this, and why you might consider doing the same too.