はてなブックマーク

I'm working on an application that needs the ability to schedule tasks. Many applications have a similar need, but requirements can vary greatly. Advanced cases might require persistence and distribution, typically depending on external systems (like a database or queue) to do much of the heavy lifting. My needs are simpler: I don't have a huge variety of tasks or a high number of them. Thread-Per

home Learning Zig Welcome to Learning Zig, an introduction to the Zig programming language. This guide aims to make you comfortable with Zig. It assumes prior programming experience, though not in any particular language. Zig is under heavy development and both the Zig language and its standard library are constantly evolving. This guide targets the latest development version of Zig. However, it's

Update: CockroachDB is rapidly evolving and many of the original limitations and issues listed in this post have been addressed. I'll try to keep this post updated with bolded notes. I recently had the opportunity to put a system into production backed by CockroachDB. While I'm a huge fan of PostgreSQL, I wanted something that provided better out of the box support for high availability. Cockroach

Admittedly this should be classified in a duhhh category of knowledge, but... I recently wrote code that used the useful atomic.Value type to support hot reloading a configuration. In doing so, I introduced a goroutine (and memory) leak. The bug was 100% my fault, and didn't have anything to do with atomic.Value other than the fact that it's the type of issue you'll most likely run into when swapp

update, 2017: The book might be a couple years old, but it's still relevant. Nothing fundamental or outwardly major has changed in Go (the team has promised a stable API until the next major version). The big changes have been with the tooling, compiler and runtime as well as enhancing the standard library (like supporting HTTP/2). The Little Go Book is a free introduction to Google's Go programmi

Learning promises is an interesting process. Like many tools, there are common pitfalls to get stuck on. What makes promises somewhat unique is that it tends to be obvious that you're doing it wrong. Why? Promises are designed to solve a clear and well-understood problem: nested callbacks. As you start to use them however, you're code isn't that different. Obviously there's something you don't gro

The worst kept secret about unit testing in general, and TDD specifically, is that it's primarily a design activity with future correctness as a side effect. Unit tests don't uncover all design problems, but they are effective with respect to cohesion and coupling issues and the rather significant principals that relate to these. One thing I've noticed from programmers who've spent most of their l

Like most, I've always appreciated a software package that lets me hot-reload the configuration without having to restart. Nginx immediately comes to mind, as does Postgresql (not for all settings, but most). This is something I've never done; so I was pretty happy when the opportunity presented itself. I'm not sure how anyone else does this, but it's pretty basic stuff. When you get past the mean

Over the last few days, we've been writing a custom Redis command in C. The command, xdiff, is tailored to a specific use-case: diff'ing a set from a sorted set with an offset and count. A reasonable question is: why not just write it in Lua? Keeping in mind the dangers of such synthetic benchmarks, I decided to compare the C implementation to one written in Lua. The full C implementation can be s

When you first start using Redis you probably see it with a fairly narrow perspective. Maybe you're thinking of it for caching, or you are looking to its sets to maintain a unique list, like tags. The more you use it, the more you find it useful. Up until now, I've always used Redis to implement specific features (or parts of a feature). I've used it for ranking, real time statistics, simple queue

Although DuckDuckGo's success is based more on ideology than technology, you'd have to be a pretty arrogant technologist to not appreciate and be impressed with what this small team (for a long time, 1 person) has accomplished. And while DuckDuckGo teaches us a number of valuable lessons (about business, and privacy), to me, the most important, is that good programmers should be measured by what t

Let's keep this short. Too few websites log JavaScript errors. Let's build a simple system to track client-side errors. First, we'll create a logError method in JavaScript: function logError(details) { $.ajax({ type: 'POST', url: 'http://mydomain.com/api/1/errors', data: JSON.stringify({context: navigator.userAgent, details: details}), contentType: 'application/json; charset=utf-8' }); } This assu

Back when I first started playing with node.js, there was one thing that always made me uncomfortable. Embarrassingly, I'm talking about module.exports. I say embarrassingly because it's such a fundamental part of node.js and it's quite simple. In fact, looking back, I have no idea what my hang up was...I just remember being fuzzy on it. Assuming I'm not the only one who's had to take a second, an

update, 2017: The book is many years old, but still relevant. Redis has evolved a lot, but most of that has been in the form of internal improvements, new advanced features (like lua scripting) and awesome new data types. The best way to learn Redis is still to start by understanding the fundamentals presented in this book. PDF version The epub version is now available There are also Russian and I

I'm in the process of rolling out a feature which will let developers see some basic usage statistics on their games via mogade.com. The first phase was to make it so data could be collected, the next phase is to build the reporting UI. Of course, there's a phase in the middle which is to transform our data from raw statistics to actual reportable information. Since we are using mongodb we are doi

Yesterday I talked about the work I was doing in improving the performance around mogade's ranking functionality. Basically, we denormalized our data and leaned on Redis for its built-in sorted set data structure. When you're working closely with code, trying to improve specific aspects of it, all types of smaller things jump out at you trying to get your attention. Today I wanted to run a some be

Practical NoSQL - Solving a Real Problem with MongoDB and Redis When I wrote The Little MongoDB Book (hey, it's free) I presented the point of view that, broadly speaking, NoSQL was about expanding our toolset with respect to data storage. In addition to new tools, NoSQL is also about viewing, and storing, data with an open mind and using new modeling techniques (if not new, than at least newly ac

The book is available as a pdb and epub A couple weeks ago I released mongly. The feedback has been great, but I've noticed that a lot of people still have some fundamental questions about MongoDB. Questions like, where does it fit and how do you model your data? I initially thought about writing a couple blog posts, but I felt that a short ebook might be a better format. I hope you like it and th