This new job scheduler for Postgres is written in Go and has some seriously advanced features such as chaining tasks, mix-and-match SQL with executables, configurable repetitions, cron-style scheduling, and much more.
Little bored. Not learning as much as I used to. I’ve been doing the same thing too long and need a change. It’d be nice to primarily work in Go rather than work on Go.
When I first joined Google it was a chaotic first couple years while I learned Google’s internal codebase, build system, a bunch of new languages, Borg, Bigtable, etc. Then I joined Android it was fun/learning chaos again. Go was the same when I joined and it was a new, fast-moving experiment. Now Go is very popular, stable…
In this episode, we’re joined by Kelsey Hightower to discuss the evolution of cloud infrastructure management, the role Kubernetes and its API play in it, and how we, as developers and operators, should be adapting to these changes.
GoatCounter is a web analytics platform, roughly similar to Google Analytics or Matomo. It aims to give meaningful privacy-friendly web analytics for business purposes, while still staying usable for non-technical users to use on personal websites. The choices that currently exist are between freely hosted but with problematic privacy (e.g. Google Analytics), hosting your own complex software or paying $19/month (e.g. Matomo), or extremely simplistic “vanity statistics”.
Jaana, Jon, and Mat are joined by John Graham-Cumming, the CTO of Cloudflare, to discuss Go at Cloudflare along with John’s unique involvement in Gordon Brown’s apology to Alan Turing. How did Cloudflare get started with Go? What problems do they use Go for and when to they turn to other languages? And how exactly did John’s petition for an apology to Turing get so popular?
Think of this like jq, but for people who love parentheses. 😀
cat test.json | jql '(elem "countries" (elem (keys) (elem "name")))' [ "Poland", "United States", "Germany" ]
Mat, Carmen, and Jon are joined by Dan Scales to talk about Mat’s favorite keyword in Go - defer. Where did the defer statement come from? What problems can it solve? How has it shaped how we write Go code? How are other languages solving similar problems? And what exactly was changed in Go 1.14 to improve the performance of defer?
It features small explicit keys, no config options, and UNIX-style composability.
$ age-keygen -o key.txt Public key: age1ql3z7hjy54pw3hyww5ayyfg7zqgvc7w3j2elw8zmrj2kg5sfn9aqmcac8p $ tar cvz ~/data | age -r age1ql3z7hjy54pw3hyww5ayyfg7zqgvc7w3j2elw8zmrj2kg5sfn9aqmcac8p > data.tar.gz.age $ age -d -i key.txt data.tar.gz.age > data.tar.gz
If Rust is more your thing, check out the perfectly named port: rage.
What is the complete path between visiting thepiratebay and sublimating an mp3 file from thin air? In this post, we’ll implement enough of the BitTorrent protocol to download Debian.
It isn’t a full-fledged client (no magnet links, no multi-file torrents, no seeding), but that makes it an excellent candidate for reading and learning. Here’s the resulting source code.
Chaos Mesh is a cloud-native Chaos Engineering platform that orchestrates chaos on Kubernetes environments. At the current stage, it has the following components:
- Chaos Operator: the core component for chaos orchestration. Fully open sourced.
- Chaos Dashboard: a visualized panel that shows the impacts of chaos experiments on the online services of the system; under development; curently only supports chaos experiments on TiDB(https://github.com/pingcap/tidb).
For the uninitiated, chaos engineering is when you unleash havoc on your system to prove out its resiliency (or lack thereof).
This package is intended to give you more control over error handling via error wrapping, stack tracing, and output formatting. Basic error wrapping was added in Go 1.13, but it omitted user-friendly
Wrapmethods and built-in stack tracing. Other error packages provide some of the features found in
erisbut without flexible control over error output formatting. This package provides default string and JSON formatters with options to control things like separators and stack trace output. However, it also provides an option to write custom formatters via
Guests are catching the bug, so we decided to spend this episode talking about bugs! How do you find and fix your bugs? Do you sketch things out, whip out the debugger, or something else?
The scare quotes around generator are there because Staticgen doesn’t actually generate a static site for you. Instead, it downloads your dynamic site and produces a static version of it. A slightly new twist on an old idea:
If you’re unfamiliar, you can actually use the decades-old wget command to output a static website from a dynamic one, this project is purpose-built for the same idea, letting your team to use whatever HTTP servers and frameworks you’re already familiar with, in any language.
Grab a hot beverage and a warm blanket because it’s time for a fireside chat with the Go Time panel! We discuss many topics of interest: what we’d build if we had 2 weeks to build anything in Go, the things about Go that “grind our gears”, our ideal work environments, and advice we’d give ourselves if we were starting our career all over again.
Go was designed with concurrency in mind. That’s why we have language primitives like goroutines, channels, wait groups, and mutexes. They’re very powerful when used correctly, but they can be very complicated if used unwisely.
Roberto Clapis joins the team once again to drop async wisdom in your ears. Don’t worry, we do it in serial. 😉
If you’re looking for a thorough primer of Go modules, Bill Kennedy has you covered:
In this post, I will focus on the transition from GOPATH to modules and the problems modules are solving. Along the way, I will provide just enough of the semantics so you can have a better understanding of how modules work at a high level. Maybe more importantly, why they work the way they do.
When you’re done with this, check out part 2 of the series about projects, dependencies, and
This package is does not have the goal of parsing all possible date formats and timestamps, I recommend you attempt parsing those first and then falling back on this package to provide “natural language” support.
Mat, Johnny, and Jaana are joined by Francesc Campoy to talk about Graph databases. We ask all the important questions — What are graph databases (and why do we need them)? What advantages do they have over relational databases? Are graph databases better at answering questions you didn’t anticipate? How is data structured? How do queries work? What problems are they good at solving? What problems are they not suitable for? And…since we had Francesc on the hot seat, we asked him about Just for Func and when it’s coming back.
Thorsten Ball and Tim Raymond join Mat Ryer and Mark Bates to talk about compilers and interpreters. What are the roles of compilers and interpreters? What do they do? The how and why of writing a compiler in Go. We also talk about Thorsten’s books “Writing an Interpreter in Go” and “Writing a Compiler in Go.”
Quickly view and search notifications, mark notifications as read (or unsubscribe entirely), add comments to issues (and more) all from the warm glow of your trusty terminal.
The RadVPN doesn’t need any central point as it connects to other nodes directly (full mesh) it has built-in router that helps packets to route to the appropriate destinations.
Linux only at the moment.
In this episode we talk with Ramya Rao about code editors and language servers. We share our thoughts on which editor we use, why we use it, and why we’d switch. We also discuss what a language server is and why it matters in connecting editors and the languages they support. We also dive into various ways to be effective with VS Code including shortcuts, plugins, and more.