Languages
Programming languages and runtimes we use: Go, Elixir, Rust and TypeScript.
Research notes
- Package-first Go, part 1: packages and import paths
The package as the base unit of a Go service and the import path as its identity, the first two of five rules for structuring a Go service.
- Package-first Go, part 2: wrapping types and choosing error patterns
Extend a Go type by wrapping it instead of editing it, and pick one of eight error-handling patterns on purpose, with a rule of thumb and failure mode for each.
- Package-first Go, part 3: type safety with generics and a repo checklist
Use type parameters and constraints so the compiler rejects a wrong type, then run a nine-line checklist that covers all five package-first rules against your repo.
- Why go?
An exploration of the reasons why Go is gaining traction as a preferred programming language for enterprise-level software development, including its simplicity,…
- Message queues and streaming platforms eg Kafka Nats Rabbitmq
An in-depth exploration of message brokers, their use cases, and implementation examples using RabbitMQ in Go. Covers the basics of message queues, their advantages and…
- Go JSON parser: number <-> interface
TLDR; be careful when using map[string]interface{} to hold json number value, use custom decoder with newDecoder.UseNumber() to decode the json string.
- Libcluster in Elixir: node clustering on Kubernetes
Learn how to set up Elixir node clustering with Libcluster on Kubernetes to build scalable, high-performance applications using Erlang features and reduce operational…
- Concurrency in Go, part 1: unexpected pitfalls
Five concurrency mistakes that Go programs make even with goroutines and channels: missing synchronization, time.After leaks, misused timers, copied sync values and…
Show all 34 notes
- Concurrency in Go, part 2: goroutines, channels, select and timeouts
Launching goroutines, passing values over channels, generator functions, multiplexing, restoring sequencing, select and timeouts.
- Concurrency in Go, part 3: quit channels and a concurrent search
How a quit channel stops a goroutine, the daisy-chain, and a worked example that turns a slow sequential search into a fast, replicated one.
- Go in software engineering
An overview of Go's key features, including simplicity, concurrency support, and interface-driven OOP. Explores Go's strengths in cloud applications and utility…
- Understanding Tidewave.ai
Discover how Tidewave connects AI assistants to your web framework's runtime through MCP, enabling real-time interaction with your application. Learn about its features,…
- Efficient union of finite automata in Golang: a practical approach
An in-depth guide on implementing the union of finite automata in Golang, focusing on practical efficiency and performance considerations.
- Why enterprise chose Java
Java has been widely adopted as the primary programming language for enterprise-level software development, emphasizing its platform independence, robust ecosystem, and…
- Erlang finite state machine
The Power of Finite State Machines
- A tour of Template method pattern with Golang
Template method: the problem, the concept, the solution, its use cases, implementations, pros & cons. The Template Method pattern in Go offers a powerful way to define…
- Leveraging Golang and WebRTC for high-performance video streaming
Explores using Golang and the Pion WebRTC library to build high-performance, scalable, low-latency video streaming infrastructure. Covers WebRTC basics (ICE, STUN,…
- Test doubles in Go, part 1: dummies and stubs
What test doubles are, when and why to use them in Go, and how dummies and stubs work with code examples.
- Test doubles in Go, part 2: spies, mocks, fakes and best practices
Spies, mocks and fakes in Go with code examples, plus best practices for choosing and using test doubles.
- The circuit breaker pattern in Go
Learn how to implement the circuit breaker pattern in Go to handle remote resource failures, improve fault tolerance, and redirect requests using the sony/gobreaker…
- Managing concurrent workloads in Go, part 1: worker pools and fan-out/fan-in
Two Go concurrency patterns for handling many tasks safely: the worker pool and fan-out/fan-in, each with a worked example.
- Managing concurrent workloads in Go, part 2: pipelines, semaphores and goroutine counts
The pipeline and semaphore patterns in Go, and how to choose the number of goroutines for a workload.
- Profiling in Go
Profiling in Go is a powerful tool that can help you identify and fix the subtle issues in your code quickly and efficiently. In this article, we'll explore the world of…
- Process groups in Elixir with Erlang pg
Learn how to use Erlang's pg library for process groups to broadcast messages across clustered Elixir services, enabling scalable WebSocket communication without…
- The atomic package in Go: fixing race conditions with sync/atomic
Learn how to solve race conditions in Go by using the sync/atomic package for atomic operations and pointers, offering faster and simpler alternatives to mutex locks in…
- Go concurrency
A comprehensive guide to concurrency in Go, covering goroutines, channels, and the Go scheduler. This article explains the differences between concurrency and…
- Rust language notes: ownership, lifetimes, traits and error handling
A tour of Rust for beginners, covering ownership, immutability, lifetimes, traits, and how to handle recoverable and unrecoverable errors.
- Slice and array in Golang
An in-depth exploration of arrays and slices in Go, covering their differences, internal implementations, and key operations like append. Learn about fixed-length…
Series
Tags in this topic
Writers
hieuphq7, tieubao7, datphamcode2953, mirageruler3, thangnt2943, fuatto2