DEV Community: Vic Shóstak

🎉 Finally! Official launch of the Gowebly project on ProductHunt

Vic Shóstak — Fri, 19 Jul 2024 12:18:41 +0000

Hello, DEV friends! 😘

I'm pleased to present you the Gowebly project launch page on ProductHunt 👇

Yes, I know that many people have already tried using this CLI in their daily tasks. Therefore, I ask you to take the time and write a small (or large) review on the project page here. This will help me move on and improve Gowebly CLI every day! 😌

And for those who have just heard about Gowebly, here is a short reference 👇

The Gowebly CLI performs the same function as create-react-app (or similar) to start a new project without wasting time. Also, this project serves as a guide to the world of full-stack development on Go using the htmx library, hyperscript or Alpine.js.

Thank you for staying with me! 🔥 Together we can do more.

– Vic Shóstak aka @koddr

⚡️ Gowebly CLI now supports the PocketBase framework

Vic Shóstak — Fri, 10 May 2024 08:12:25 +0000

Introduction

Hello, DEV people! 👋

Now, I've released the Gowebly CLI v2.5.0 which includes PocketBase framework/backend support.

Okay, let's get started 😉

📝 Table of contents

What is PocketBase?
How to use PocketBase with Gowebly CLI?

What is PocketBase?

PocketBase is an open source ready-to-use framework/backend for your next SaaS and mobile application in a single file.

pocketbase / pocketbase

Open Source realtime backend in 1 file

PocketBase is an open source Go backend that includes:

embedded database (SQLite) with realtime subscriptions
built-in files and users management
convenient Admin dashboard UI
and simple REST-ish API

For documentation and examples, please visit https://pocketbase.io/docs.

Warning

Please keep in mind that PocketBase is still under active development and therefore full backward compatibility is not guaranteed before reaching v1.0.0.

API SDK clients

The easiest way to interact with the PocketBase Web APIs is to use one of the official SDK clients:

JavaScript - pocketbase/js-sdk (Browser, Node.js, React Native)
Dart - pocketbase/dart-sdk (Web, Mobile, Desktop, CLI)

You could also check the recommendations in https://pocketbase.io/docs/how-to-use/.

Overview

Use as standalone app

You could download the prebuilt executable for your platform from the Releases page. Once downloaded, extract the archive and run ./pocketbase serve in the extracted directory.

The prebuilt executables are based on the examples/base/main.go…

View on GitHub

Main features:

Realtime database. Embedded performant database with schema builder, data validations, realtime subscriptions and easy to use REST api.
Authentication. Manage your app users and handle email/password and OAuth2 sign-ups (Google, Facebook, GitHub, GitLab and more) without the hassle.
File storage. Sanely store files locally or in a S3 storage. Easily attach media to your database records and generate thumbs on the fly.
Extendable. Use as a standalone app OR as a framework, that you can extend via Go and JavaScript hooks to create your own custom portable backend.

↑ Table of contents

How to use PocketBase with Gowebly CLI?

The first thing you should do is verify that you are using Gowebly CLI version v2.5.0 or higher.

Next, when you start creating a new project, just switch the Go framework selector to the PocketBase option:

gowebly create

And Gowebly CLI created a new project with the PocketBase.

Yeah, it's just working! 🎉

↑ Table of contents

Photos and videos by

Vic Shóstak https://github.com/koddr
PocketBase authors https://pocketbase.io

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.

Preline UI + Gowebly CLI = ❤️

Vic Shóstak — Thu, 25 Apr 2024 14:13:20 +0000

Introduction

Hey, DEV friends! 👋

Today, I've released the Gowebly CLI v2.4.0 which includes Preline UI components library support for the frontend.

Yep, let's take a closer look 👇

📝 Table of contents

What is Preline UI?
How to use Preline UI with Gowebly CLI?

What is Preline UI?

Preline UI is an open-source set of prebuilt UI components based on the utility-first Tailwind CSS framework.

htmlstreamofficial / preline

Preline UI is an open-source set of prebuilt UI components based on the utility-first Tailwind CSS framework.

Why use Preline UI?

Based on the Tailwind CSS utility classes, Preline UI's prebuilt components and UI elements help you quickly design and customize responsive mobile-first websites with the components a website needs, including buttons, dropdowns, navigation bars, modals, and more.

What's in the box?

Components are grouped by visual usability criteria (components, navigation, forms, etc.) and styled directly on top of Tailwind CSS, making them easy to extend and customize. This is a lifesaver for developers looking to create a unique and eye-catching design system without the hassle of creating each component by hand.

Getting Started

Quick Setup

This guide will help you get started with Preline UI, including how to run, customize, update, and integrate your project!

First, you need to make sure that you have a working Tailwind CSS project…

View on GitHub

Most awesome features:

750+ Free Components & Examples. Hundreds of component examples for all your website needs that meet accessibility criteria.
Universal Framework Compatibility. Preline UI is fully compatible wherever Tailwind CSS is in action, from React to Vue and beyond.
Tailwind CSS Plugins. Completely unstyled, fully accessible UI plugins for popular features that for one reason or another don't belong in core.
Dark Mode. All components include a dark variant that lets you style your site differently when dark mode is enabled.
World's largest free Figma design system. Preline UI Figma is the largest free design system for Figma, crafted with Tailwind CSS styles and Preline UI components with extra top-notch additions.
Bring your ideas to life in no time. Preline UI provides all the essential components you need to convert your vision into thriving start-ups.

↑ Table of contents

How to use Preline UI with Gowebly CLI?

The first thing you should do is verify that you are using Gowebly CLI version v2.4.0 or higher.

Next, when you start creating a new project, just switch the CSS framework selector to the Tailwind CSS with Preline UI components option:

gowebly create

And Gowebly CLI created a new project with the Preline UI.

Yeah, it's just working! 🎉

↑ Table of contents

Photos and videos by

Vic Shóstak https://github.com/koddr
Preline UI authors https://preline.co

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.

🤓 My top 3 Go packages that I wish I'd known about earlier

Vic Shóstak — Fri, 01 Mar 2024 11:36:24 +0000

Introduction

Hello, my DEV friends! 🙌

Today, I'd like to travel back in time, find myself at the very beginning of planning my current project, and advise myself to familiarize myself with these wonderful Go packages…

Unfortunately, I can't do that! But I can introduce you to them. Here we go 👇

📝 Table of contents

Templ
Otter
River

Templ

a-h / templ

A language for writing HTML user interfaces in Go.

A language for writing HTML UI in Go

✨ In recent months, I have been developing web projects using GOTTHA stack: Go + Templ + Tailwind CSS + htmx + Alpine.js. As soon as I'm ready to talk about all the subtleties and pitfalls, I'll post it on my social networks.

By the way, you can subscribe! All links are here 👉 https://shostak.dev

Perhaps my favorite Go package in my entire practice of working with this programming language! The authors managed to combine two huge worlds at once:

The world of the frontend, which consists almost entirely of JSX-like web frameworks, such as React.js;
The world of the backend, where we are free to use our familiar Go principles and packages as usual.

Together with Templ we can write the following code:

// index.templ

package main

templ hello(name string) {
    if name == "Виктор" {
        <div>Привет, Виктор! Как твои дела сегодня?</div>
    } else {
        <div>Hello, { name }</div>
    }
}

templ greeting(person Person) {
    <div class="greeting">
        @hello(person.Name)
    </div>
}

// ...

Next, you just need to start the process of generating all *.templ files:

go run github.com/a-h/templ/cmd/templ@latest generate

Which will be converted into a regular Go function and ready for use on your backend. For example, like this:

// main.go

package main

// ...

// Simple user struct.
type Person struct {
    Name string
}

func main() {
    // Create a new user with name.
    user := Person{Name: "John"}

    // Create Templ handler.
    handler := templ.Handler(greeting(user))

    // Serve Templ handler with HTTP server.
    http.Handle("/", handler)

    // Start simple HTTP server.
    http.ListenAndServe(":3000", nil)
}

Open browser on http://localhost:3000 and see the result.

Yes, it's that simple! 😉

🔥 Templ authors have taken care of supporting popular IDE and special mode for hot-reload your *.templ files.

If you have never tried Templ in your code practice, then I strongly recommend doing it right now! It's really worth it.

↑ Table of contents

Otter

maypok86 / otter

A high performance cache for Go

High performance in-memory cache

I believe that the most important features of Otter are extremely simple API and autoconfiguration. And it works perfectly!

Just set the parameters you want in the builder and enjoy. Otter is automatically configured based on the parallelism of your application.

Just write like this to create a new cache instance:

// cache/new.go

package cache

// ...

// Cache struct contains all caches.
type Cache struct {
    People otter.CacheWithVariableTTL[string, []Person]
}

func New() (*Cache, error) {
    // Create a new cache instance for people.
    peopleCache, err := otter.MustBuilder[string, []Person](100_000).WithVariableTTL().Build()
    if err != nil {
        return nil, err
    }

    return &Cache{
        People: peopleCache,
    }, nil
}

And now, you can use it on your app, like this:

// main.go

// ...

func main() {
    // ...

    // Get people from database.
    people, err := dbexecutor.SelectPeople(context.Background(), "postgres://...", "SELECT * FROM people")
    if err != nil {
        slog.Error("can't select people from DB", "details", err.Error())
        return err
    }

    // Create a new cache instance.
    c, _ := cache.New() // don't forget to check errors!

    // Save people to the cache with TTL=180m.
    if c.People.Set("people", people, 180 * time.Minute) {
        slog.Info("people are successfully saved to the in-memory cache")
    }

    // ...

    // Get people from the cache.
    cachedPeople, isCached := c.People.Get("people")

    // Check, if data is cached.
    if isCached {
        // Your logic with cached data in cachedPeople here...
    }

    // ...
}

I would also like to point out such advantages as:

Generics: yes, you can safely use any comparable types as keys and any types as values;
TTL: expired values will be automatically deleted from the cache;
Cost-based eviction: supports eviction based on the cost of each item;
Excellent throughput: currently, Otter is the fastest cache library, with a huge lead over the competition;
Great hit ratio: new S3-FIFO algorithm is used, which shows excellent results.

And benchmark, of course! 😊

In this benchmark 8 threads concurrently read from a cache configured with a maximum size:

👋 You can find all benchmarks here.

↑ Table of contents

River

riverqueue / river

Fast and reliable background jobs in Go

I'm a big fan of all the new stuff that the Go programmer community is developing. River is one of them.

It represents a combination of modern Go practices and ease of use, even if you have never worked with similar tools before.

🔥 Atomic, transaction-safe, robust job queueing for Go applications. Backed by PostgreSQL and built to scale.

And yet, this package has one of the best documentation on the market. Just read how the authors describe writing of reliable workers' principle! Love it 😘

Start with add a simple job that sorts a slice of strings:

// jobs/sort.go

package jobs

// ...

// sortArgs is a struct that contains a slice of strings to sort.
type sortArgs struct {
    // Strings is a slice of strings to sort.
    Strings []string `json:"strings"`
}

// Kind returns the kind of the job.
func (sortArgs) Kind() string { return "sort" }

// SortWorker is a worker that sorts a slice of strings.
type SortWorker struct {
    river.WorkerDefaults[sortArgs]
}

// Work sorts a slice of strings.
func (w *SortWorker) Work(_ context.Context, job *river.Job[sortArgs]) error {
    slices.Sort(job.Args.Strings)
    fmt.Printf("Sorted strings: %+v\n", job.Args.Strings)
    return nil
}

// ...

Next, let's create a new River queue with workers pool:

// queue/new.go

package queue

// ...

func pool() (*river.Workers, error) {
    // Create a new River instance.
    w := river.NewWorkers()

    // Add workers to River.
    _ = river.AddWorkerSafely(w, &jobs.SortWorker{}) // don't forget to check errors!

    return w, nil
}

func New() (*river.Client[pgx.Tx], error) {
    // Create workers pool.
    workers, _ := pool() // don't forget to check errors!

    // Create and return a new River client
    // (for PostgreSQL over pgx/v5, by the way).
    return river.NewClient(riverpgxv5.New(db), &river.Config{
        Queues: map[string]river.QueueConfig{
            river.QueueDefault: {MaxWorkers: 100},
        },
        Workers: workers,
    })
}

And now, you can use it on your app, like this:

// main.go

// ...

func main() {
    // ...

    // Create a sample data to sort.
    str := []string{"foo", "baz", "bar"}

    // Create a new River instance.
    q, _ := queue.New() // don't forget to check errors!

    // Set job to queue.
    _, err := q.Insert(context.Background(), jobs.SortArgs{Strings: str}, nil)
    if err != nil {
        slog.Error("can't insert job to River queue", "details", err.Error())
    }

    // ...
}

That's all you have to do! 💥 You can create arbitrarily complex background jobs that River can easily complete for you.

💡 River is still under rapid development, but I recommend trying it now!

↑ Table of contents

And what do you use?

Tell us about it in the comments! It will be very interesting to find new Go packages and tools for yourself.

Peace to all and a successful code! ❤️

↑ Table of contents

Photos and videos by

Vic Shóstak https://github.com/koddr

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.

🎉 The Gowebly CLI has grown to v2.0.0

Vic Shóstak — Thu, 11 Jan 2024 07:45:29 +0000

Introduction

Happy New Year, my DEV friends! 🎊

While everyone was relaxing and thinking about Christmas, I was hard at work in my studio to prepare a massive update for the Gowebly CLI number v2.

I don't like to drag out the intro, so here we go! 😉

📝 Table of contents

What is Gowebly?
Breaking changes
Live reload mode on code updates
Other notable improvements

What is Gowebly?

A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx & hyperscript and the most popular CSS frameworks on the frontend.

gowebly / gowebly

🔥 A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js, and the most popular CSS frameworks on the frontend.

The Gowebly CLI

A next-generation CLI tool that makes it easy to create amazing web applications
with Go on the backend, using htmx, hyperscript or Alpine.js,
and the most popular CSS frameworks on the frontend.

↘ The official Gowebly CLI documentation ↙

English · Русский · 简体中文 · Español

↘ Share the project's link to your friends ↙

✨ Features

100% free and open source under the Apache 2.0 license.
For any developer's level of knowledge and technical expertise, as the intelligent CLI does most of the routine project setup for you, creates an understandable structure, and prepares code for use and deployment in production.
Cross-platform and multi-architecture allows successful running on any GNU/Linux distros, Microsoft Windows (including WSL) and Apple macOS.
Well-documented, includes translations in many other languages (Русский, 简体中文, Español).
Enables you to start a new project faster with Go…

View on GitHub

↑ Table of contents

Breaking changes

After gathering the opinion of the most active users and based on the experience of my other successful CLI project Create Go App, I decided to remove the possibility of configuring with a YAML file.

✨ Yes, .gowebly.yml is no longer needed!

The handy and incredibly beautiful huh library from the Charm team is now in charge of that. Just upgrade to the latest version of the Gowebly and type the familiar command in the terminal:

gowebly create

And just look at this:

The same thing happened with the unknown and the doctor commands, which now look (and feel) completely different:

gowebly doctor

↑ Table of contents

Live reload mode on code updates

It was highly anticipated, and I decided not to delay and make it as soon as possible. Since version v2.0.0, the Gowebly CLI supports reloading a project running in development mode if changes are made to it:

Go code;
Templ or HTML templates;
SASS/CSS styles;
TypeScript/JavaScript files;
Frontend part settings (JSON).

This is made possible thanks to the Air tool, which now comes with every project you create. The configuration is as follows:

# .air.toml

root = "."
tmp_dir = "tmp"

[build]
pre_cmd = ["bun run build"]
cmd = "templ generate && go build -o ./tmp/gowebly_default ."
bin = "tmp/gowebly_default"
include_ext = ["go", "templ", "html", "json", "js", "ts", "css", "scss"]
exclude_dir = [".parcel-cache", "bin", "dist", "node_modules", "static", "tmp", "tests", "vendor"]
exclude_regex = ["_test\\.go", "_templ\\.go"]
exclude_unchanged = false
follow_symlink = false
log = "build-errors-air.log"
poll = false
poll_interval = 500
delay = 1000
stop_on_error = true
send_interrupt = false
kill_delay = 500
rerun = false
rerun_delay = 500

# ...

If you don't want to use Air, when creating a new project, select "No" when the CLI prompts you to use the tool. In this case, this Makefile will be created.

↑ Table of contents

Other notable improvements

The backend has been completely reimagined:

Repetitive elements in templates have been removed;
The configs for creating a Docker container have been simplified;
Add the htmx-go package to simplify the htmx handling at the server layer of the application.

The frontend part has received the following refresh:

Repetitive elements in templates have been removed;
Add a ./assets/scripts.js file for your reactive logic;
Add the Flowbite components library for the Tailwind CSS;
Add the Prettier for code formatting.

And not only that! 😊 Keep an eye out for updates and new releases on the project's GitHub page and official documentation.

↑ Table of contents

Photos and videos by

Vic Shóstak https://github.com/koddr

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.

🔥 Big frontend update: the Gowebly CLI now supports Bootstrap and Bulma

Vic Shóstak — Tue, 19 Dec 2023 11:17:51 +0000

Introduction

Hey, DEV friends! 😉

Since v1.9.0 release, the Gowebly CLI includes support for Bootstrap and Bulma CSS frameworks.

Let's take a closer look.

📝 Table of contents

What is Bootstrap?
What is Bulma?
How to use new CSS frameworks with Gowebly CLI?

What is Bootstrap?

Powerful, extensible, and feature-packed frontend toolkit. Build and customize with Sass, utilize prebuilt grid system and components, and bring projects to life with powerful JavaScript plugins.

twbs / bootstrap

The most popular HTML, CSS, and JavaScript framework for developing responsive, mobile first projects on the web.

↑ Table of contents

What is Bulma?

The modern CSS framework that just works. Free & open source framework that provides ready-to-use frontend components that you can easily combine to build responsive web interfaces. No CSS knowledge required.

jgthms / bulma

Modern CSS framework based on Flexbox

↑ Table of contents

How to use new CSS frameworks with Gowebly CLI?

The first thing you should do is verify that you are using Gowebly CLI version v1.9.0 or higher.

Next, start creating the configuration file:

gowebly init

The CLI will generate a .gowebly.yml file with the following config:

backend:
  module_name: project
  go_framework: default
  template_engine: default
  port: 7000
  timeout:
    read: 5
    write: 10

frontend:
  package_name: project
  css_framework: default
  runtime_environment: default
  htmx: latest
  hyperscript: latest

Now, just switch the css_framework option in the frontend block to bootstrap or bulma.

Now, start creating a project:

gowebly create

And Gowebly CLI create a new project with the selected CSS framework.

It works! 💥

↑ Table of contents

Photos and videos by

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.

🔥 Frontend update: the Gowebly CLI now supports daisyUI components library

Vic Shóstak — Tue, 21 Nov 2023 11:50:35 +0000

Introduction

Hello, DEV Community! 😉

I've released the Gowebly v1.8.0 which includes daisyUI components library support for the frontend.

But let's not get ahead of ourselves, let's take a closer look.

📝 Table of contents

What is daisyUI?
How to use daisyUI with Gowebly CLI?

What is daisyUI?

daisyUI is the most popular, free and open-source component library for Tailwind CSS. This library adds component class names to Tailwind CSS, so you can make beautiful websites faster than ever.

saadeghi / daisyui

🌼 🌼 🌼 🌼 🌼 The most popular, free and open-source Tailwind CSS component library

Take Tailwind CSS to the next level

daisyUI adds class names to Tailwind CSS for all common UI components, like btn, card, toggle and many more. This allows us to focus on important things instead of styling basic elements for every project.

Instead of writing 100 class names...

Use semantic class names! It's descriptive, faster, cleaner and easier to maintain.

No more ugly HTML

Write fewer class names, use component class names, modify them using Tailwind CSS utilities. For example, daisyUI can convert this HTML code:

<div class="w-80 rounded-2xl bg-gray-100">
  <div class="flex flex-col gap-2 p-8">
    <input placeholder="Email" class="w-full rounded-lg border border-gray-300 bg-white px-4 py-3 focus:outline-none focus:ring-2 focus:ring-gray-700 focus:ring-offset-2 focus:ring-offset-gray-100" />
    <label class="flex cursor-pointer items-center justify-between p-1">
      Accept terms of use
      <div class="relative inline-block">
        <input type="checkbox" class="peer h-6 w-12 cursor-pointer appearance-none rounded-full border border-gray-300 bg-white checked:border-gray-900 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-gray-900 focus-visible:ring-offset-2" />
        <span class="pointer-events-none absolute start-1 top-1 block h-4 w-4 rounded-full bg-gray-400 transition-all duration-200 peer-checked:start-7 peer-checked:bg-gray-900"></span>
      </div>
    </label>
    <label class="flex cursor-pointer items-center justify-between p-1">
      Submit to newsletter
      <div class="relative inline-block">
        <input type="checkbox" class="peer h-6 w-12 cursor-pointer appearance-none rounded-full border border-gray-300 bg-white checked:border-gray-900 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-gray-900 focus-visible:ring-offset-2" />
        <span class="pointer-events-none absolute start-1 top-1 block h-4 w-4 rounded-full bg-gray-400 transition-all duration-200 peer-checked:start-7 peer-checked:bg-gray-900"></span>
      </div>
    </label>
    <button class="inline-block cursor-pointer rounded-md bg-gray-700 px-4 py-3.5 text-center text-sm font-semibold uppercase text-white transition duration-200 ease-in-out hover:bg-gray-800 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-gray-700 focus-visible:ring-offset-2 active:scale-95">Save</button>
  </div>
</div>

To this:

<div class="card bg-base-200 w-80">
  <div class="card-body">
    <input placeholder="Email" class="input input-bordered" />
    <label class="label cursor-pointer">
      Accept terms of use
      <input type="checkbox" class="toggle" />
    </label>
    <label class="label cursor-pointer">
      Submit to newsletter
      <input type="checkbox" class="toggle" />
    </label>
    <button class="btn btn-neutral">Save</button>
  </div>
</div>

Fewer class names, faster development, smaller file size

With daisyUI, you write 80% fewer class names and your HTML size will be about 70% smaller.

Highly customizable

Powered by Tailwind CSS utility classes. daisyUI is built on top of Tailwind CSS, so you can customize everything using utility classes.

Pure CSS, framework-agnostic, works everywhere!

daisyUI is a plugin for Tailwind CSS. It works on all JS frameworks and doesn't need a JS bundle file. Install daisyUI as a dev dependency and use the class names just like any other Tailwind CSS class name.

↑ Table of contents

How to use daisyUI with Gowebly CLI?

The first thing you should do is verify that you are using Gowebly CLI version v1.8.0 or higher.

Next, start creating the configuration file:

gowebly init

The CLI will generate a .gowebly.yml file with the following config:

backend:
  module_name: project
  go_framework: default
  template_engine: default
  port: 7000
  timeout:
    read: 5
    write: 10

frontend:
  package_name: project
  css_framework: default
  runtime_environment: default
  hyperscript: latest

Yes, you're right! ✨ Just switch the css_framework option in the frontend block to daisyui.

Now, start creating a project:

gowebly create

And Gowebly CLI created a new project with the daisyUI.

Yeah, it's just working! 🎉

↑ Table of contents

Photos and videos by

Vic Shóstak https://github.com/koddr
daisyUI authors https://daisyui.com

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.

🔥 Big update: the Gowebly CLI now supports Templ

Vic Shóstak — Wed, 01 Nov 2023 11:39:41 +0000

Introduction

Hello, everyone! 🙌

I've released a big update to the Gowebly CLI project in v1.5.0 which includes Templ support for built-in net/http and all Go web frameworks: Fiber, go-chi and echo.

But let's not get ahead of ourselves, let's take a closer look.

📝 Table of contents

What is Templ?
How to use Templ with Gowebly CLI?
Templates content
Backend handler changes

What is Templ?

Templ is a language for writing HTML user interfaces in Go.

a-h / templ

A language for writing HTML user interfaces in Go.

You can use it to write code like this, which will be compiled into native Go functions to generate HTML:

// hello.templ

package main

templ Hello(name string) {
  <div>Hello, { name }</div>
}

templ Greeting(person Person) {
  <div class="greeting">
    @Hello(person.Name)
  </div>
}

💡 Note: A complete user guide is here: https://templ.guide/

Create components that render fragments of HTML and compose them to create screens, pages, documents, or apps.

TOP features:

Server-side rendering: Deploy as a serverless function, Docker container, or standard Go program.
Static rendering: Create static HTML files to deploy however you choose.
Compiled code: Components are compiled into performant Go code.
Use Go: Call any Go code, and use standard if, switch, and for statements.
No JavaScript: Does not require any client or server-side JavaScript.
Great developer experience: Ships with IDE autocompletion.

Yes, Templ has plugins for most popular IDEs:

Visual Studio Code: https://marketplace.visualstudio.com/items?itemName=a-h.templ
VSCodium: https://open-vsx.org/extension/a-h/templ
Vim / Neovim: https://github.com/Joe-Davidson1802/templ.vim
Helix: https://helix-editor.com/

💡 Note: Settings and useful tips you can read here.

↑ Table of contents

How to use Templ with Gowebly CLI?

The first thing you should do is verify that you are using Gowebly CLI version v1.5.0 or higher.

Next, start creating the configuration file:

gowebly init

The CLI will generate a .gowebly.yml file with the following config:

backend:
   module_name: project # (string) option can be any name of your Go module (for example, 'github.com/user/project')
   go_framework: default # (string) option can be one of the values: 'fiber', 'echo', 'chi', or 'default'
   template_engine: default # (string) option can be one of the values: 'templ', or 'default'
   port: 5000 # (int) option can be any port that is not taken up on your system
   timeout:
      read: 5 # (int) option can be any number of seconds, 5 is recommended
      write: 10 # (int) option can be any number of seconds, 10 is recommended

frontend:
   package_name: project # (string) option can be any name of your package.json (for example, 'project')
   css_framework: default # (string) option can be one of the values: 'tailwindcss', 'unocss', or 'default'
   runtime_environment: default # (string) option can be one of the values: 'bun', or 'default'
   htmx: latest # (string) option can be any existing version
   hyperscript: latest # (string) option can be any existing version

Yes, you're right! ✨ There is a new option template_engine in the backend block, which can take (so far) two values:

default to create a new project without a template engine;
templ to create a new project using Templ;

Now, change the value of this setting to templ and start creating a project:

gowebly create

And CLI created a new project with the following structure:

.
├── assets
│   └── styles.css
├── static
│   ├── favicons
│   │   ├── apple-touch-icon.png
│   │   ├── favicon.ico
│   │   ├── favicon.png
│   │   ├── favicon.svg
│   │   ├── manifest-desktop-screenshot.jpeg
│   │   ├── manifest-mobile-screenshot.jpeg
│   │   └── manifest-touch-icon.svg
│   ├── images
│   │   └── logo.svg
│   ├── htmx.min.js
│   ├── hyperscript.min.js
│   ├── manifest.json
│   └── styles.css
├── templates
│   ├── pages
-   │   ├── index.html
+   │   ├── index.templ
+   │   └── index_templ.go
-   ├── main.html
+   ├── main.templ
+   └── main_templ.go
├── go.mod
├── go.sum
├── handlers.go
├── main.go
├── package-lock.json
├── package.json
└── server.go

Files with the extension *.templ are our working files, and those with *_templ.go in the name are automatically generated for us with Templ.

❗️ Attention: Do not edit the *_templ.go Go files in any way. They will be generated automatically. Work only with *.templ files.

↑ Table of contents

Templates content

Okay, now let's take a look at the template files.

The ./templates/main.templ template contains the basic layout for the web application and can be modified as you wish:

// ./templates/main.templ

package templates

import "project/templates/pages"

// Define a secure policy for Content-Security-Policy header.
var metaContentSecurePolicy = "default-src 'self'; style-src 'self' 'unsafe-inline'; script-src 'self' https://unpkg.com 'unsafe-inline' 'unsafe-eval';"

templ Layout(title string, metaTags, bodyContent templ.Component) {
    <!DOCTYPE html>
    <html lang="en">
        <head>
            <meta charset="UTF-8"/>
            <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
            <meta http-equiv="X-UA-Compatible" content="ie=edge"/>
            <meta http-equiv="Content-Security-Policy" content={ metaContentSecurePolicy }/>
            <meta name="theme-color" content="#FEFEF5"/>
            <title>{ title }</title>
            {! metaTags }
            <link rel="manifest" href="/static/manifest.json"/>
            <link rel="apple-touch-icon" href="/static/favicons/apple-touch-icon.png"/>
            <link rel="shortcut icon" href="/static/favicons/favicon.ico" type="image/x-icon"/>
            <link rel="icon" href="/static/favicons/favicon.svg" type="image/svg+xml"/>
            <link rel="icon" href="/static/favicons/favicon.png" sizes="any"/>
            <link href="/static/styles.css" rel="stylesheet"/>
        </head>
        <body onload={ pages.BodyScripts() }>
            {! bodyContent }
            <script src="/static/htmx.min.js"></script>
            <script src="/static/hyperscript.min.js"></script>
        </body>
    </html>
}

And the ./templates/pages/index.templ template will contain the content of the home page (accessible at /):

// ./templates/pages/index.templ

package pages

// MetaTags defines meta tags.

templ MetaTags(keywords, description string) {
    <meta name="keywords" content={ keywords }/>
    <meta name="description" content={ description }/>
}

// styledTextStyles defines CSS styles for component.

css styledTextStyles() {
    color: blue;
    margin: 1rem 0;
}

// BodyContent defines HTML content.

templ BodyContent(h1, text string) {
    <main>
        <div>
            <p>
                <img width="224px" src="/static/images/logo.svg" alt="logo"/>
            </p>
            <div>
                <h1>{ h1 }</h1>
                <p>{ text }</p>
                <p class={ styledTextStyles() }>
                    Hello from <strong>templ</strong>!
                    <br/>
                    Edit this styled text in the './templates/pages/index.templ' file.
                </p>
                <p>
                    <a href="https://gowebly.org" target="_blank">Documentation</a>,
                    <a href="https://github.com/gowebly/gowebly" target="_blank">GitHub</a>
                </p>
            </div>
            <div>
                <p><button hx-get="/api/show" hx-target="#htmx-result">Show content</button></p>
                <div id="htmx-result"></div>
            </div>
        </div>
    </main>
}

// BodyScripts defines JavaScript code.

script BodyScripts() {
    console.log("Hello from templ!", "Edit this JavaScript code in the './templates/pages/index.templ' file.");
}

The code in the templates is as readable and easy to understand as possible for any developer who has ever made sites in HTML and understands Go.

↑ Table of contents

Backend handler changes

If it is clear with the templates themselves, here are the changes that handlers.go has undergone:

// handlers.go

// ...

// indexViewHandler handles a view for the index page.
func indexViewHandler(w http.ResponseWriter, r *http.Request) {
    // Check, if the current URL is '/'.
    if r.URL.Path != "/" {
        // If not, return HTTP 404 error.
        http.NotFound(w, r)
        slog.Error("render page", "method", r.Method, "status", http.StatusNotFound, "path", r.URL.Path)
        return
    }

    // Define template functions.
    metaTags := pages.MetaTags(
        "gowebly, htmx example page, go with htmx",               // define meta keywords
        "Welcome to example! You're here because it worked out.", // define meta description
    )
    bodyContent := pages.BodyContent(
        "Welcome to example!",                // define h1 text
        "You're here because it worked out.", // define p text
    )

    // Define template layout.
    if err := templates.Layout(
        "Welcome to example!", // define title text
        metaTags, bodyContent,
    ).Render(r.Context(), w); err != nil {
        // Send HTTP 500 error with log.
        w.WriteHeader(http.StatusInternalServerError)
        slog.Error("render template", "method", r.Method, "status", http.StatusInternalServerError, "path", r.URL.Path)
        return
    }

    // Send log message.
    slog.Info("render page", "method", r.Method, "status", http.StatusOK, "path", r.URL.Path)
}

// ...

The templates.Layout() Go function is the Templ function from the ./templates/main.templ template, which was kindly generated automatically when the project was created.

💡 Note: The Gowebly CLI knows that your project contains a Templ templer and will generate code from the *.templ templates every time it changes (hot-reload).

Let's run your project:

gowebly run

Yeah, it's just working! 🎉

↑ Table of contents

Photos and videos by

Vic Shóstak https://github.com/koddr
Templ authors https://github.com/a-h/templ

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.

💡 An important addition on deploying a Go application in Docker, if net/http is used

Vic Shóstak — Tue, 17 Oct 2023 05:41:48 +0000

Hey, everybody! 🙌

This is a short note article that I can't help but share with the community, as I ran into this problem myself in my latest wonderful-readme-stats project.

So, this will be a very short post, but so important for anyone who wants to deploy a Go application that uses the built-in net/http package, in a Docker container.

OK, here we go!

📝 Table of contents

Description of the problem
Useful links for explanation
Solving the problem

Description of the problem

I have a helper in my Go project that helps me make a request to the GitHub API and return a response. It is absolutely simple, but saves time as it is used in many places in the code (DRY):

// customHTTPClient makes an HTTP request to download the image from the given URL and returns the response.
func customHTTPClient(uri string) (*http.Response, error) {
    // Check, if the URL is valid.
    _, err := url.Parse(uri)
    if err != nil {
        return nil, err
    }

    // Create a new HTTP client with options.
    client := &http.Client{
        Timeout: 15 * time.Second,
        Transport: &http.Transport{
            TLSHandshakeTimeout:   10 * time.Second,
            ResponseHeaderTimeout: 10 * time.Second,
            ExpectContinueTimeout: 1 * time.Second,
        },
    }

    // Make an HTTP request to download the image from the given URL.
    req, err := http.NewRequest(http.MethodGet, uri, http.NoBody)
    if err != nil {
        return nil, err
    }
    defer req.Body.Close()

    // Set authorization header.
    req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", os.Getenv("GITHUB_TOKEN"))

    // Send the request to the HTTP server.
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }

    return resp, nil
}

You may have noticed that I use strictly defined options to create a custom HTTP client. This is done for a reason! For more information, see this Cloudflare blog post.

📝 Note: Building the project for the Docker image is done automatically with GoReleaser. Therefore, I will not cover Dockerfile in detail.

Next, I run the finished image as always with this command on the remote server (Ubuntu 22.04):

docker run -d -p 9876:9876 koddr/wonderful-readme-stats:latest

But in the logs, I see the following error when trying to make a request from http.Client to the GitHub API: tls: failed to verify certificate: x509: certificate signed by unknown authority.

Wait a minute, why is that? 🤔

↑ Table of contents

Useful links for explanation

Here are some useful links that helped me understand the cause of the problem and solve it:

Feel free to post your own in the comments.

↑ Table of contents

Solving the problem

The solution was so simple that I didn't even believe it!

It was enough to add a Docker volume pointing to the directory of the server containing the certificates (/etc/ssl/certs) when starting the container to make it work:

docker run -d \
  -p 9876:9876 \
+  -v /etc/ssl/certs:/etc/ssl/certs:ro \
  koddr/wonderful-readme-stats:latest

❗️ Important: Don't forget to add Docker volume in read-only mode (:ro).

And now the container works without errors and displays awesome statistics about the defined repository! 🎉

↑ Table of contents

Photos and videos by

Vic Shóstak https://github.com/koddr

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.

🔥 A next-generation CLI tool for building amazing web apps in Go using htmx & hyperscript

Vic Shóstak — Sat, 30 Sep 2023 11:11:57 +0000

Introduction

Hey, my DEV friends! 👋

It's been a while since I've been here, hasn't it? Sorry I've been missing, but there was a good reason... one of which I'm going to talk about in this article.

So, here is a new CLI tool that I have named gowebly 👇

📝 Table of contents

What is gowebly?
What is the enjoyment of using it?
Motivation in CLI creation
Mutually beneficial cooperation

What is gowebly?

It's a next-generation CLI tool that makes it easy to create amazing web applications using Go on the backend (net/http, Fiber, Echo, chi, etc.), htmx and hyperscript, and the most popular atomic/utility-first CSS frameworks (Tailwind CSS, UnoCSS, etc.) on the frontend.

Fully configured Docker files, as well, are included in your project.

gowebly / gowebly

🔥 A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js, and the most popular CSS frameworks on the frontend.

The Gowebly CLI

↘ The official Gowebly CLI documentation ↙

English · Русский · 简体中文 · Español

↘ Share the project's link to your friends ↙

✨ Features

100% free and open source under the Apache 2.0 license.
For any developer's level of knowledge and technical expertise, as the intelligent CLI does most of the routine project setup for you, creates an understandable structure, and prepares code for use and deployment in production.
Cross-platform and multi-architecture allows successful running on any GNU/Linux distros, Microsoft Windows (including WSL) and Apple macOS.
Well-documented, includes translations in many other languages (Русский, 简体中文, Español).
Enables you to start a new project faster with Go…

View on GitHub

↑ Table of contents

What is the enjoyment of using it?

The main purpose of gowebly CLI is to make it easier to create a new project. And it does this very well! But it's better to see it once than to hear it a hundred times:

The first thing you need to do is to install it. This can be done via:

Homebrew (for GNU/Linux and Apple macOS users);
Native Go installation (any platforms);
Docker image (any platforms);
Downloading a ready-made executable (any platforms).

💡 Note: No matter how exactly you want to install the gowebly CLI, it will work fine either way.

Once the gowebly CLI is installed on your system, the following commands are available to you: init, create, run, and build.

Let's take a closer look at them 😊

💡 Note: Also, keep in mind that the documentation of the gowebly project has already been translated to: Русский, 中文 and Español.

And the original language, of course, English.

`init` command

Command to create a default config file (.gowebly.yml) in the current folder.

Every time you make gowebly init command in the empty folder:

CLI validates the current folder;
CLI creates a default .gowebly.yml config file.

Typically, a created config file contains the following options:

backend:
   module_name: project # (string) option can be any name of your Go module (for example, 'github.com/user/project')
   go_framework: default # (string) option can be one of the values: 'fiber', 'echo', 'chi', or 'default'
   port: 5000 # (int) option can be any port that is not taken up on your system
   timeout:
      read: 5 # (int) option can be any number of seconds, 5 is recommended
      write: 10 # (int) option can be any number of seconds, 10 is recommended

frontend:
   package_name: project # (string) option can be any name of your package.json (for example, 'project')
   css_framework: default # (string) option can be one of the values: 'tailwindcss', 'unocss', or 'default'
   runtime_environment: default # (string) option can be one of the values: 'bun', or 'default'
   htmx: latest # (string) option can be any existing version
   hyperscript: latest # (string) option can be any existing version

You can choose any Go framework for your project's backend:

Go framework	Description
`default`	Don't use any Go framework (only built-in net/http package)
`fiber`	Use a Go backend with the Fiber web framework
`echo`	Use a Go backend with the Echo web framework
`chi`	Use a Go backend with the chi composable router

In additional, you can choose versions of the htmx, hyperscript, and one of the most popular atomic/utility-first CSS framework to your project:

CSS framework	Description
`default`	Don't use any CSS framework (only default styles for the code example)
`tailwindcss`	Use the Tailwind CSS as a CSS framework
`unocss`	Use the UnoCSS as a CSS framework

Also, you can set one of the JavaScript runtime environment for your frontend part:

JavaScript runtime	Description
`default`	Use the Node.js as a JavaScript runtime environment
`bun`	Use the Bun as a JavaScript runtime environment

`create` command

Command to create a new project with the Go backend, htmx & hyperscript, and (optionally) atomic/utility-first CSS framework.

💡 Note: If you don't run init command to create a config file (.gowebly.yml), the gowebly CLI creates a new project with a default configuration.

Every time you make gowebly create command for your project:

CLI validates the config and applies all settings to the current project;
CLI prepares the backend part of your project (generates the project structure and needed utility files, runs go mod tidy);
CLI prepares the frontend part of your project (generates the needed utility files, runs npm|bun install and npm|bun run build:dev for the first time);
CLI downloads minimized versions of htmx and hyperscript (from official and trusted unpkg.com CDN) to the ./static folder and places them as separated <script> tags (at the bottom of the <body> tag) in the Go HTML template templates/main.html.

Typically, a created project contains the following files and folders:

.
├── assets
│   └── styles.css
├── static
│   ├── favicon.ico
│   ├── htmx.min.js
│   ├── hyperscript.min.js
│   └── styles.css
├── templates
│   ├── pages
│   │   └── index.html
│   └── main.html
├── .gitignore
├── go.mod
├── go.sum
├── handlers.go
├── main.go
├── package-lock.json
├── package.json
└── server.go

`run` command

Command to run your project in a development (non-production) mode.

💡 Note: If you don't run init command to create a config file (.gowebly.yml), the gowebly CLI runs your project with a default configuration.

Every time you make gowebly run command for your project:

CLI validates the config and applies all settings to the current project;
CLI prepares the frontend part of your project (runs npm|bun run build:dev);
CLI prepares a development (non-production) version of the selected CSS framework to the ./static folder and places it as a <link> tag (at the bottom of the <head> tag) in the Go HTML template templates/main.html;
CLI starts a project's backend with settings from the default configuration (or from the .gowebly.yml config file) by a simple go run command.

`build` command

Command to build your project for production and prepare Docker files for deploy.

💡 Note: If you don't run init command to create a config file (.gowebly.yml), the gowebly CLI builds your project with a default configuration.

You might add the following options:

Option	Description	Required?
`--skip-docker`	Skip generation process for the Docker files (it's helpful if you've your own)	no

Every time you make gowebly build command for your project:

CLI validates the config and applies all settings to the current project;
CLI downloads minimized versions of htmx and hyperscript (from official and trusted unpkg.com CDN) to the ./static folder and places them as separated <script> tags (at the bottom of the <body> tag) in the Go HTML template templates/main.html;
CLI prepares a production version of the selected CSS framework and places it as a <link> tag (at the bottom of the <head> tag) in the Go HTML template templates/main.html;
If the --skip-docker option is not set, CLI generate a clear and well-documented Docker files (.dockerignore, Dockerfile, docker-compose.yml) in the root of the project folder to deploy it in isolated containers via Portainer (recommended), or manually, to your remote server.

↑ Table of contents

Motivation in CLI creation

Tell me, how often have you had to start a new project from scratch and had to make painful manual configurations? 🤔 Especially, when you are just getting acquainted with a new technology or stack, where everything is new to you.

For many developers, including me, this process is as tedious and even depressing as possible, and doesn't carry any useful workload. It is a very frustrating process that can push any developer away from technology a lot.

Why not just give all that awful manual work to machines? Let them do all the hard work for us, and we will just create awesome web products and not have to think about build and deploy.

That's why I created the gowebly CLI and its helpers' library, which helps you start an amazing web applications in Go using htmx, hyperscript and popular atomic/utility-first CSS frameworks.

I am here to save you (and myself) from this routine pain! ✨

Earlier, I have already saved the world once, it was Create Go App (yep, that's my project too). The GitHub stars statistics of this project can't lie: more than 2.2k developers of any level and different countries start a new project through this CLI tool.

↑ Table of contents

Mutually beneficial cooperation

And now, I invite you to participate in this project! Let's work together to create the most useful tool for developers on the web today.

Issues: ask questions and submit your features.
Pull requests: send your improvements to the current.

Your PRs & issues are welcome! Thank you 😘

↑ Table of contents

Photos and videos by

Vic Shóstak https://github.com/koddr

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.

⚡️ Speed up development? The handy library of most used snippets for Go apps

Vic Shóstak — Sat, 13 May 2023 10:13:00 +0000

Introduction

Well, hello, my DEV friends! 👋

It's been a long time since I had the time, and then the opportunity, to write this blog. But thank you, anyway, for staying with me and asking questions!

I really appreciate it. Love you people! 😘

Today I'm going to tell you about my personal little project, which I put out to the public quite recently. But it helped me all these years to write Go programs as fast as possible and in full compliance with the DRY (Don't Repeat Yourself) principle.

Intrigued? Then welcome, it will be interesting! 👇

📝 Table of contents

Motivation in library creation
Basic use of the library
Regular snippets
Universal snippets
Benchmarks
A win-win cooperation

Motivation in library creation

As you already know from my previous articles, I take an approach to software development that makes the developer's life totally easy.

Why repeat the same snippet, for example, to translate a byte slice to a string, if you can add the most efficient solution to the library once and import it where you need it? Exactly right! It's an unnecessary cognitive load for those who will read your code in the future (and for you as well).

It is for these reasons that The Go Snippet Library (or gosl for a short) provides snippets collection for working with routine operations in your Go programs with a super user-friendly API and the most efficient performance.

↑ Table of contents

Basic use of the library

Yes, simply add gosl to your project:

go get github.com/koddr/gosl

Add the needed snippet to your code, like this:

import (
   fmt
   log

   "github.com/koddr/gosl"
)

func main() {
    b := []byte("Hello, World!")

    s, err := gosl.ToString(b) // convert byte slice to string
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(s)
}

Or like this to have access to snippets as embedded struct:

type App struct {
    // ...

    utils    *gosl.Utility                         // add regular snippets
    genUtils *gosl.GenericUtility[any, comparable] // add generic snippets
}

func (a *App) handleSomething(b []byte) error {
    // ...

    s, err := a.utils.ToString(b) // convert byte slice to string
    if err != nil {
        return err
    }

    // ...

    u, err := a.genUtils.Unmarshal(json, model) // unmarshal JSON data to struct
    if err != nil {
        return err
    }

    // ...
}

And you are already saving your time and energy. Trust me ✌️

↑ Table of contents

Regular snippets

The regular snippets of the gosl package are aimed at solving one single task with the smallest possible allocation of your machine's resources.

Concat

Concatenate strings s to the one string:

s1 := "this "
s2 := "is "
s3 := "my string"

s := gosl.Concat(s1, s2, s3)

ContainsCaseInsensitive

Report if string substr is within string s (case-insensitive by default):

s := "Hello, WORLD!"
substr := "r"

b := gosl.ContainsCaseInsensitive(s, substr)

RandomString

Generates a (really) random string with a given size:

size := 8

s, err := gosl.RandomString(size)
if err != nil {
    log.Fatal(err)
}

ToString

Convert byte slice b to string or error:

b := []byte("Hello, World!")

s, err := gosl.ToString(b)
if err != nil {
    log.Fatal(err)
}

ToBytes

Convert string s to byte slice or error:

s := "Hello, World!"

b, err := gosl.ToBytes(s)
if err != nil {
    log.Fatal(err)
}

↑ Table of contents

Universal snippets

The universal (or generic) snippets of the gosl package are aimed at solving one particular task with the smallest possible allocation of your machine's resources, but can be applied to a huge number of user types.

ContainsInSlice

Report if value v is within slice s:

s := []string{"one", "two", "three"}
v := "two"

b := gosl.ContainsInSlice(s, v)

ContainsInMap

Report if key k is within map m:

m := map[string]int{"one": 1, "two": 2, "three": 3}
k := "two"

b := gosl.ContainsInMap(m, k)

Marshal

Marshal struct user to JSON data j (byte slice) or error:

type user struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

u := &user{}

j, err := gosl.Marshal(u)
if err != nil {
    log.Fatal(err)
}

💡 This snippet is a 100% compatible drop-in replacement for the standard encoding/json library.

Unmarshal

Unmarshal JSON data j (byte slice) to struct user or error:

type user struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

j := []byte(`{"id":1,"name":"Viktor"}`)
m := &user{}

u, err := gosl.Unmarshal(j, m)
if err != nil {
    log.Fatal(err)
}

💡 This snippet (also) is a 100% compatible drop-in replacement for the standard encoding/json library.

↑ Table of contents

Benchmarks

My results for all snippets in the library (the test stand is Apple MacBook Air M1, 16 GB RAM, macOS 13.3.1):

BenchmarkConcat_String2-8                           58663996            20.06 ns/op       32 B/op          1 allocs/op
BenchmarkConcat_String8-8                           26829356            44.16 ns/op      128 B/op          1 allocs/op
BenchmarkConcat_String32-8                           9321133           127.8 ns/op       448 B/op          1 allocs/op

BenchmarkToString_HelloWorld-8                      100000000           10.56 ns/op       16 B/op          1 allocs/op

BenchmarkToBytes_HelloWorld-8                       1000000000           0.6288 ns/op      0 B/op          0 allocs/op

BenchmarkRandomString_Size1-8                        3488678           344.6 ns/op         6 B/op          3 allocs/op
BenchmarkRandomString_Size8-8                        3394548           353.3 ns/op        24 B/op          3 allocs/op
BenchmarkRandomString_Size64-8                       2313856           517.9 ns/op       160 B/op          3 allocs/op
BenchmarkRandomString_Size512-8                      1423572           838.9 ns/op      1280 B/op          3 allocs/op
BenchmarkRandomString_Size4096-8                      185337          6350 ns/op       10240 B/op          3 allocs/op

BenchmarkMarshal_StructField_4-8                     8584442           139.9 ns/op        48 B/op          3 allocs/op
BenchmarkMarshal_StructField_16-8                    2838062           420.8 ns/op       192 B/op          3 allocs/op

BenchmarkUnmarshal_StructField_4-8                   6960462           169.3 ns/op        32 B/op          3 allocs/op
BenchmarkUnmarshal_StructField_16-8                   764182          1553 ns/op         864 B/op         45 allocs/op

BenchmarkContainsCaseInsensitive_HelloWorld-8       24856041            48.46 ns/op       16 B/op          1 allocs/op
BenchmarkContainsCaseInsensitive_LoremIpsum-8        1797150           695.9 ns/op       448 B/op          1 allocs/op

BenchmarkContainsInSlice-8                          122999034            9.758 ns/op       0 B/op          0 allocs/op

BenchmarkContainsInMap-8                            19123504            62.61 ns/op        0 B/op          0 allocs/op

↑ Table of contents

A win-win cooperation

I invite every user of Dev.to (and my lowly blog, certainly) to participate in this project! Let's work together to create the largest and most useful library of snippets for Go programs on the web today.

Ask questions and submit your features to the Issues section.
Send your snippets or improvements to the current to the Pull requests section.

Your PRs & issues are welcome! Thanks 😉

↑ Table of contents

Photos and videos by

Marc Sendra Martorell https://unsplash.com/photos/-Vqn2WrfxTQ
Vic Shóstak https://github.com/koddr

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.

Kotlin short recipes: Generating a chessboard for a console game

Vic Shóstak — Wed, 29 Dec 2021 09:35:54 +0000

Introduction

Hello, DEV friends! 👋

This series of a really short (but useful) articles will aim at a general demonstration of how the Kotlin language can elegantly solve many of the (non-)trivial problems.

🔥 Disclaimer: The purpose of this article is to show the essence of the solution, not to dive into the subject in detail. For a deeper dive, links to the Kotlin documentation pages will be left.

Yes, let's do it! 👇

📝 Table of contents

The result of our efforts
Project structure
Create the UI package
Create the entry point
Learn Kotlin

The result of our efforts

Let's go backwards. This will help you better understand what we will be trying to get out of this.

I chose a game of chess to show you how to work with repetitive elements and draw a console UI for your projects (or even games). This is what the result of our program will look like:

Let's play Chess!
+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   | 8
+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   | 7
+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   | 6
+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   | 5
+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   | 4
+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   | 3
+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   | 2
+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   | 1
+---+---+---+---+---+---+---+---+
  a   b   c   d   e   f   g   h

As you may notice, the numbers are on the right, not on the left, as many people have used to. This is because it is much easier to position elements in a line-by-line printout.

☝️ If you don't like it that much, you can always change just one line of code (which I'll show below). That will be your homework! That's it, yeah.

↑ Table of contents

Project structure

The structure of the project (game) will be as Kotlin idiomatic as possible.

As always, the entry point will be in Main.kt. All UI elements and the drawing class itself in the ui package:

↑ Table of contents

Create the UI package

To improve reusability, let's immediately put some UI elements into the Kotlin's built-in enum class:

// ./src/main/kotlin/ui/Element.kt

package ui

enum class Element(val view: String) {
    EMPTY_CELL(" "),
    DIVIDER("+---+---+---+---+---+---+---+---+"),
    ALPHABETICAL_INDEXES("a   b   c   d   e   f   g   h")
}

Okay, move on to the rendering engine itself.

😉 By the way, I'll use a wonderful Kotlin data classes for it.

So, let's create an array-structure with the given number of rows and cells and display the entire assembled UI via println() in our draw() method.

Sounds like a plan, let's do it! 👇

// ./src/main/kotlin/ui/Board.kt

package ui

data class Board(val title: String) {
    // Array for building the board:
    private val board = Array(8) { Array(8) { Element.EMPTY_CELL } }

    // Function for forming and drawing the board with
    fun draw() {
        // 1️⃣
        val boardAsString = board.mapIndexed { index, row ->
            val cells = row.joinToString(" | ") { it.view }
            "| $cells | ${index + 1}\n${Element.DIVIDER}"
        }

        println(title) // print game's title
        println(Element.DIVIDER) // print starting divider

        // 2️⃣
        println(boardAsString.reversed().joinToString("\n"))

        // print ending string with left padding
        println("  ${Element.ALPHABETICAL_INDEXES}")
    }
}

1️⃣ : To simplify, we will expand our array with the function mapIndexed(), where each element will be a string with an already prepared UI.

2️⃣ : To display line numbering reverse, we use Kotlin's built-in reversed() function. And then just output the result using the joinToString() function, which specifies the string translation (\n), as an element separator.

↑ Table of contents

Create the entry point

And, finally, let's create an entry point of our console game (Main.kt):

// ./src/main/kotlin/Main.kt

import ui.Board

fun main() {
    val board = Board("Let's play Chess!")
    board.draw()
}

💡 You can give your playing field any name you want. Just add it to the primary constructor of the Board data class.

Run our program (Shift + Ctrl + R) and 💥 BOOM 💥 everything works the way we wanted it to:

↑ Table of contents

Learn Kotlin

Do you want to learn Kotlin? 👩‍🎓 👨‍🎓

Then come to JetBrains Academy, where there is a free basic course in this language for free! There you will find both theoretical part and many practical tasks of any level of complexity.

↑ Table of contents

Photos and videos by

Kotlin mascot authors https://kotlinlang.org/docs/kotlin-mascot.html
Vic Shóstak https://github.com/koddr

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

❗️ You can support me on Boosty, both on a permanent and on a one-time basis. All proceeds from this way will go to support my OSS projects and will energize me to create new products and articles for the community.

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My main projects that need your help (and stars) 👇

🔥 gowebly: A next-generation CLI tool that makes it easy to create amazing web applications with Go on the backend, using htmx, hyperscript or Alpine.js and the most popular CSS frameworks on the frontend.
✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.

Other my small projects: yatr, gosl, json2csv, csv2api.