The Curious Engineer

All blogs / Go

Redowan's Reflections

rednafi.com

Software engineering blog by Redowan Delowar covering platform engineering, backend systems, distributed systems, reliability, databases, Go, Python, TypeScript, and pragmatic engineering practice.

GoPythonDatabasesDistributed systems / cloudTesting / QA

’20’21’22’23’24’25’26
Posts
246 from 12 Mar 2020 to 12 Oct 2026
Posting
weekly (50 in the last year)
Kind
personal blog
Feed
https://rednafi.com/index.xml

2026 46

  1. Partial updates with field masks
  2. Go
  3. Why do we listen to people with no skin in the game?
  4. Zephyr
  5. Misc
  6. The irrational effectiveness of the Pi harness
  7. Postgres as an isolation reference model
  8. System
  9. Shards
  10. Accepted proposal: range over all command-line flags
  11. Accepted proposal: Go examples with any signature
  12. Supervised fire-and-forget in Go
  13. GC shape stenciling in Go generics
  14. Modernizers & go fix
  15. Request coalescing with Go singleflight
  16. Channel iteration and goroutine leak
  17. Accepted proposal: a goroutine leak profile in the Go standard library
  18. Reading your own writes with WAIT FOR LSN in Postgres 19
  19. Migrating from GNU stow to chezmoi
  20. Putting this blog on ATProto with standard.site
  21. If you won't carry the pager, maybe don't push to mainline
  22. Testing Go CLIs with testscript
  23. A tour of txtar
  24. Type-safe slogging
  25. Hoisting wire plumbing out of your Go handlers
  26. Go quirks: function closures capturing mutable references
  27. Accepted proposal: UUID in the Go standard library
  28. Peeking into Go struct tags
  29. Error translation in Go services
  30. Dynamo: Amazon's highly available key-value store
  31. Stacked log lines considered harmful
  32. What's the ideal dispatch mechanism?
  33. Background jobs and inherited file descriptors
  34. Testing unary gRPC services in Go
  35. Repositories, transactions, and unit of work in Go
  36. How do you handle transactions with the repository pattern?
  37. Is passing user ID through context an antipattern?
  38. What belongs in Go's context values?
  39. Do you need a repository layer on top of sqlc?
  40. Wrapping a gRPC client in Go
  41. In praise of the etcd codebase
  42. Go errors: to wrap or not to wrap?
  43. Mutate your locked state inside a closure
  44. What canceled my Go context?
  45. Structured concurrency & Go
  46. Your Go tests probably don't need a mocking library

2025 27

  1. Tap compare testing for service migration
  2. Splintered failure modes in Go
  3. Re-exec testing Go subprocesses
  4. Revisiting interface segregation in Go
  5. Avoiding collisions in Go context keys
  6. Organizing Go tests
  7. Subtest grouping in Go
  8. Let the domain guide your application structure
  9. Test state, not interactions
  10. Early return and goroutine leak
  11. Lifecycle management in Go tests
  12. Gateway pattern for external service calls
  13. Flags for discoverable test config in Go
  14. You probably don't need a DI framework
  15. Preventing accidental struct copies in Go
  16. Go 1.24's "tool" directive
  17. Capturing console output in Go tests
  18. Deferred teardown closure in Go testing
  19. Three flavors of sorting Go slices
  20. Nil comparisons and Go interface
  21. Stacked middleware vs embedded delegation in Go
  22. Why does Go's io.Reader have such a weird signature?
  23. Go slice gotchas
  24. The domain knowledge dilemma
  25. Hierarchical rate limiting with Redis sorted sets
  26. Dynamic shell variables
  27. Link blog in a static site

2024 40

  1. Running only a single instance of a process
  2. Function types and single-method interfaces in Go
  3. SSH saga
  4. Injecting Pytest fixtures without cluttering test signatures
  5. Explicit method overriding with @typing.override
  6. Quicker startup with module-level __getattr__
  7. Docker mount revisited
  8. Topological sort
  9. Writing a circuit breaker in Go
  10. Discovering direnv
  11. Notes on building event-driven systems
  12. Bash namerefs for dynamic variable referencing
  13. Behind the blog
  14. Shell redirection syntax soup
  15. Shades of testing HTTP requests in Python
  16. Taming parametrize with pytest.param
  17. HTTP requests via /dev/tcp
  18. Log context propagation in Python ASGI apps
  19. Please don't hijack my Python root logger
  20. The *nix install command
  21. Here-doc headache
  22. The sane pull request
  23. I kind of like rebasing
  24. Protobuffed contracts
  25. TypeIs does what I thought TypeGuard would do in Python
  26. ETag and HTTP caching
  27. Crossing the CORS crossroad
  28. Dysfunctional options pattern in Go
  29. Einstellung effect
  30. Strategy pattern in Go
  31. Anemic stack traces in Go
  32. Retry function in Go
  33. Type assertion vs type switches in Go
  34. Patching pydantic settings in pytest
  35. Omitting dev dependencies in Go binaries
  36. Eschewing black box API calls
  37. Annotating args and kwargs in Python
  38. Rate limiting via Nginx
  39. Statically enforcing frozen data classes in Python
  40. Planning palooza

2023 48

  1. Reminiscing CGI scripts
  2. Debugging dockerized Python apps in VSCode
  3. Banish state-mutating methods from data classes
  4. Finding flow amid chaos
  5. The diminishing half-life of knowledge
  6. Oh my poor business logic
  7. Pesky little scripts
  8. Footnotes for the win
  9. Dotfile stewardship for the indolent
  10. An ode to the neo-grotesque web
  11. Self-hosted Google Fonts in Hugo
  12. Configuring options in Go
  13. Dummy load balancer in a single Go script
  14. Limit goroutines with buffered channels
  15. Writing a TOTP client in Go
  16. Interface guards in Go
  17. Writing on well-trodden topics
  18. Go structured logging with slog
  19. Notes on exit interviews
  20. Taming conditionals with bitmasks
  21. Using DNS record to share text data
  22. Memory leakage in Python descriptors
  23. Unix-style pipelining with Python's subprocess module
  24. Enabling repeatable lazy iterations in Python
  25. Descending into the aether
  26. Escaping the template pattern hellscape in Python
  27. Python dependency management redux
  28. Implementing a simple traceroute clone in Python
  29. Bulk request Google search indexing with API
  30. Building a CORS proxy with Cloudflare Workers
  31. Fixed-time job scheduling with UNIX 'at' command
  32. Sorting a Django queryset by a custom sequence of an attribute
  33. Periodic readme updates with GitHub Actions
  34. Associative arrays in Bash
  35. Deduplicating iterables while preserving order in Python
  36. Process substitution in Bash
  37. Dynamic menu with select statement in Bash
  38. Simple terminal text formatting with tput
  39. Building a web app to display CSV file stats with ChatGPT & Observable
  40. Pushing real-time updates to clients with Server-Sent Events (SSEs)
  41. Tinkering with Unix domain sockets
  42. Signal handling in a multithreaded socket server
  43. Switching between multiple data streams in a single thread
  44. Skipping the first part of an iterable in Python
  45. Pausing and resuming a socket server in Python
  46. Debugging a containerized Django application in Jupyter Notebook
  47. Manipulating text with query expressions in Django
  48. Using tqdm with concurrent.fututes in Python

2022 61

  1. Colon command in shell scripts
  2. Faster bulk_update in Django
  3. Installing Python on macOS with asdf
  4. Save models with update_fields for better performance in Django
  5. Python logging quirks in AWS Lambda environment
  6. Dissecting an outage caused by eager-loading file content
  7. Auditing commit messages on GitHub
  8. To quote or not to quote
  9. Returning values from a shell function
  10. Verifying webhook origin via payload hash signing
  11. Recipes from Python SQLite docs
  12. Prefer urlsplit over urlparse to destructure URLs
  13. Pick random values from an array in SQL(ite)
  14. ExitStack in Python
  15. Compose multiple levels of fixtures in pytest
  16. Patch where the object is used
  17. Partially assert callable arguments with 'unittest.mock.ANY'
  18. When to use 'git pull --rebase'
  19. Apply constraints with 'assert' in Python
  20. Automerge Dependabot PRs on GitHub
  21. Stream process a CSV file in Python
  22. Bulk operations in Django with process pool
  23. Read a CSV file from s3 without saving it to the disk
  24. Distil git logs attached to a single file
  25. Safer 'operator.itemgetter' in Python
  26. Guard clause and exhaustiveness checking
  27. Health check a server with 'nohup $(cmd) &'
  28. Return JSON error payload instead of HTML text in DRF
  29. Decoupling producers and consumers of iterables with generators in Python
  30. Pre-allocated lists in Python
  31. In favor of sentence case
  32. Disallow large file download from URLs in Python
  33. Declaratively transform data class fields in Python
  34. Mocking chained methods of datetime objects in Python
  35. How not to run a script in Python
  36. Caching connection objects in Python
  37. Declarative payloads with TypedDict in Python
  38. Parametrized fixtures in pytest
  39. Modify iterables while iterating in Python
  40. Github action template for Python based projects
  41. Self type in Python
  42. Patching test dependencies via pytest fixture & unittest mock
  43. Narrowing types with TypeGuard in Python
  44. Why 'NoReturn' type exists in Python
  45. Add extra attributes to enum members in Python
  46. Peeking into the internals of Python's 'functools.wraps' decorator
  47. Limit concurrency with semaphore in Python asyncio
  48. Amphibian decorators in Python
  49. Go Rusty with exception handling in Python
  50. Variance of generic types in Python
  51. Create a sub dictionary with O(K) complexity in Python
  52. Gotchas of early-bound function argument defaults in Python
  53. Use 'assertIs' to check literal booleans in Python unittest
  54. Static typing Python decorators
  55. Inspect docstrings with Pydoc
  56. Check whether an integer is a power of two in Python
  57. Uniform error response in Django Rest Framework
  58. Difference between constrained 'TypeVar' and 'Union' in Python
  59. Don't wrap instance methods with 'functools.lru_cache' decorator in Python
  60. Cropping texts in Python with 'textwrap.shorten'
  61. String interning in Python

2021 12

  1. Structural subtyping in Python
  2. Automatic attribute delegation in Python composition
  3. Access 'classmethod's like 'property' methods in Python
  4. Don't add extensions to shell executables
  5. Use __init_subclass__ hook to validate subclasses in Python
  6. Use daemon threads to test infinite while loops in Python
  7. Running tqdm with Python multiprocessing
  8. Use 'command -v' over 'which' to find a program's executable
  9. Write git commit messages properly
  10. Use strict mode while running bash scripts
  11. Use curly braces while pasting shell commands
  12. Python's 'functools.partial' flattens nestings Automatically

2020 12

  1. Pedantic configuration management with Pydantic
  2. Interfaces, mixins and building powerful custom data structures in Python
  3. Deciphering Python's metaclasses
  4. Implementing proxy pattern in Python
  5. Effortless API response caching with Python & Redis
  6. Untangling Python decorators
  7. Effortless concurrency with Python's concurrent.futures
  8. No really, Python's pathlib is great
  9. Running Python linters with pre-commit hooks
  10. Generic functions with Python's singledispatch
  11. The curious case of Python's context manager
  12. Reduce boilerplate code with Python's dataclasses