u/dumindunuwan

https://deepwiki.com/ziglang/zig

Still uses GitHub repo though. But anybody can add any repo.

Updated https://learning-cloud-native-go.github.io/docs/building-a-containerized-restful-api/

Initial submission: https://www.reddit.com/r/golang/comments/deam7y/building_a_dockerized_restful_api_application/

Even though I updated the codebase of the project frequently, the docs kept outdated for few years. This is a quite a rewrite to sync with codebase that uses Go JSON v2, Generics helpers, Distroless production images and etc, in 2026.

In this series,

We build a production-ready containerized RESTful API server application using following packages and tools.

1. Go Standard Library net/http: The most idiomatic way to write web API applications in Go.
2. Chi: The most idiomatic router with middleware and route groups support.
3. Zerolog: Zero Allocation JSON Logger and Faster than slog.
4. Goose: The database migration CLI builder library with lease dependency.
5. Gorm CLI: Generate Go generics-based, type safe, repository functions with no runtime wrappers.
6. Swag and Validator v10: The most prominent OpenAPI specification generator and validation library in Go.

https://github.com/learning-cloud-native-go/myapp

Codebase recently hit 1000 GitHub stars. Also I've added Kubernetes Kustomize, ArgoCD based CD to cover the deployment flow.

If anybody wanna try same implementation with Rust,

https://learning-rust.github.io/labs/building-a-containerized-restful-api/

Thanks.

This is a new series that answers the question, “what’s next after the mastery of Rust language syntax?”.

In this series,

We build a production-ready containerized RESTful API server application using Axum, Tokio, Tower, Serde, Toasty ORM, Garde, Utoipa with Docker and PostgreSQL.

• Hyper, Axum, Tokio and Tower: The most prominent HTTP server ecosystem at the time of writing.

• Toasty ORM: The most promising Object-Relational Mapper (ORM), built by the creators of Tokio and Axum.

• Serde and Utoipa: The most prominent serialization framework and OpenAPI 3.1 specification generator.

• Garde: The most promising and most feature-rich validation library in Rust at the time of writing.

Documentation/ Labs: https://learning-rust.github.io/labs/building-a-containerized-restful-api

Go officially support,

• Thin handlers that can directly attached to a struct created in application start, with relevant dependencies(without additional controller-> service layer) guarantee at compile-time.

• multi-module workspaces that support incremental and parallel compilation. The workspace can have properly isolated domains via modules.

• And each module can simply have vertically slicing app/{usecase} or /{usecase} folders with isolated handler, repo, and non-shared model.

• Structs support json and format attributes and Custom Unmarshaler(UnmarshalJSON) to directly decode/ encode JSON streams(zero-copy) without using a separate intermediate struct.

• most importantly, concurrent programming and event driven architecture to trigger other services parallel and asynchronously.

Why in 2026 in Go, some people still promote/ use structures like DDD, Hexagonal architecture, clean architecture, etc... while language itself can provide better architectural forms to organize complex projects, without using pure technical layers.

Nowadays, with AI those non-standards are becoming standards at the highest rate due to legacy projects and practices. Most of those standards mainly created for the languages and frameworks do not having official modules, workspaces and parallel compilations and especially to manage dependencies in runtime environments.

We have to write and promote idiomatic Go even for complex domains.

PS. https://www.reddit.com/r/golang/comments/1vktdlh/comment/p397pp0/

Welcome to the era of building AI slop learning sites with .org domains.

• https://learningrust.org
• https://learningtypescript.org
• https://learningjavascript.org
• https://learningphp.org
• https://learningzig.org
• https://learningsql.org

https://omnirun.io

> Anthropic's brain. > > Your hands.

Cringe!

If it is not a validation error,

Why not log the actual error with trace with span, request ID and etc, and return simple errors.Error enum variant with impl IntoResponse.

For example,

#[instrument(name = "update_book", skip(state, payload))]
pub async fn update(
    State(mut state): State<AppState>,
    Path(id): Path<Uuid>,
    Json(payload): Json<BookRequest>,
) -> Result<impl IntoResponse, Error> {
    
    // Validation errors

    let mut book = Book::get_by_id(&mut state.db, &id).await.map_err(|err| {
        if err.is_record_not_found() {
            Error::NotFound
        } else {
            error!(target: "database", "failed to fetch: {err:?}");
            Error::DbFetch
        }
    })?;

    toasty::update!(book {
        title: payload.title,
        published_date: payload.published_date,
        image_url: payload.image_url,
        description: payload.description,
    })
    .exec(&mut state.db)
    .await
    .map_err(|err| {
        error!(target: "database", "failed to update: {err:?}");
        Error::DbUpdate
    })?;

    info!(id = %id, "book updated");

    Ok((StatusCode::OK, Json(BookResponse::from(book))))
}

.await.map_err(|err| { }) inside map_err log actual error and return errors.Error

fn into_response(self) -> Response {
        let (status, bytes): (StatusCode, &'static [u8]) = match self {
                // ...
                Error::DbUpdate => {
                        (StatusCode::INTERNAL_SERVER_ERROR, b"{\"error\": \"DB_UPDATE_FAILED\"}")
               }
               // ... 
       };


        let mut response = Response::new(Body::from(bytes));
        *response.status_mut() = status;
        response
            .headers_mut()
            .insert(header::CONTENT_TYPE, HeaderValue::from_static("application/json"));

        response
}

For validations, different story and return errors map json.

Still Toasty is lacking many things, even many-to-many support. But the best DX so far. Can compete even with GORM in Go ecosystem.

Mostly, I will add this to https://learning-rust.github.io/ in future with long-awaited /labs section.

Still missing few things. Warmly welcome contributions.

Repo: https://github.com/dumindu/axum

I haven't worked in over six months. So, No LLMs Used. Also I'm currently open to new opportunities as well.

Inspiration

• Build a simple and modular technical documentation and blog.
• Build the website without using node/npm or any external frameworks(CSS, JS, icon, font).
• Only GoHugo normal binary + pageFind binary needed.

Features

• Responsive and adaptive layouts.
• Support for light and dark modes.
• Support for multiple documentation sets.
• Support for a blog.
• Implement a menu via Hugo configs.
• Customizable sidebars using Hugo data templates.
• Plug-and-play/ repeatable home page blocks using separate partials/ css/ data templates.
• Integrate a search via Pagefind.
• Inline SVG icons based on Google's Material Symbols

GitHub Repo: https://github.com/dumindu/E25DX

Example Docs: https://github.com/dumindu/E25DX/tree/gh-pages/example

Example Live: https://dumindu.github.io/E25DX/