If you spend time working in the terminal, whether for work or
leisure, a lot of the commands you type often have a dependency on
other recent commands, might be repetitive actions, or be very
similar to other commands previously run. Gaining mastery over your
shell history is a great way to be more productive in the terminal.
I’m going to share some tips which improve my speed while using the
shell to perform common sysadmin tasks, or file manipulation.
As a moderator of the Rust
subreddit, I regularly happen upon
posts about developers’ attempts to transpose their respective
language paradigms to Rust, with mixed results and varying degrees
In this guide, I’ll describe some of the issues developers encounter
when transposing other language paradigms to Rust and propose some
alternative solutions to help you work around Rust’s limitations.
In my previous post, I wrote about system fonts and their advantages
over web fonts. I encouraged a ‘system fonts first’ approach,
arguing that, compared to system fonts, web fonts (a) can negatively
impact performance, (b) use more data, and (c) increase your site’s
energy consumption. But a web without web fonts would be a far less
interesting one — maybe by using web fonts a little more responsibly
we can get all their benefits, while minimising the disadvantages.
I enjoy working with distributed systems, and I also enjoy working
with embedded devices and single-board computers, so I thought it
would be fun to combine these interests and build a Kubernetes
cluster using some Raspberry Pi computers. This seemed like a
low-cost way to have an always-on cluster that can be used to learn
more about Kubernetes, and distributed computing in general.
Whenever I mention that I don't use Interface Builder, Storyboards
or Auto Layout, developers, especially newer developers, ask me how
it's even possible to write UIKit apps like that. So many iOS
tutorials dump you straight into Interface Builder and
constraint-building, and while that does have benefits at the
mid-to-high-end, like with localization and right-to-left languages,
it's still a fairly sharp learning curve and mental overhead that
leaves many beginners not really understanding what is going on
under the hood. It's no wonder that SwiftUI seems so refreshing and
easy to use, in comparison.
Garbage collection is considered one of the more shark-infested
waters of programming, but in this post, I’ll give you a nice kiddie
pool to paddle around in. (There may still be sharks in it, but at
least it will be shallower.)
When we started Goliath, no one on the team knew Go beyond the
experiments we ran to validate that Go would be a better choice for
us than our other options. Today, all of our backend and full-stack
engineers write Go, and our incremental delivery of Goliath has
vaulted us over a big milestone: More than 500,000 lines of Go now
running in production. This seemed like a good point to reflect on
Let's face facts. Git is not fun. Git is not friendly. No. It's just
infuriatingly useful, so we're stuck with it. But what if you could
make git more friendly? More convenient? Would that make your day a
little less stressful?
OpenZFS stands out in its snapshot design, providing powerful and
easy-to-use tools for managing snapshots. Snapshots complement a
backup strategy, as they are instantaneous and don’t require a
backup window. Since snapshots are atomic, they are not affected by
other processes and you don’t have to stop any running applications
before taking a snapshot.
Django is an MTV framework. Instead of MVC (Model, Views,
Controller), it uses Model, Template, and View. The View is a Python
function that takes a Web request and returns a Web response (in
MVC, this would be a Controller). But the heart of your application
is the Model.
In fact the root problem here isn't about Go specifically. This is a
general problem that you can encounter in any language, and in fact,
even beyond. When you lie to your code, there will be
Golang is the lifeblood of thousands of Uber’s back-end services,
running on millions of CPU cores. Understanding our CPU bottlenecks
is critical, both for reducing service latencies and also for making
our compute fleet efficient. The scale at which Uber operates
demands in-depth insights into codes and microarchitectural
Actors offer data isolation within a type in such way that the code
you write cannot create data races. In other words, thread-safety is
built into the type system. Similarly to how mutability is - you
simply cannot compile code that mutates immutable data.
We are happy to announce that the third edition of the Rust
language, Rust 2021, is scheduled for release in October. Rust 2021
contains a number of small changes that are nonetheless expected to
make a significant improvement to how Rust feels in practice.
In terms of simplicity, Alpine Linux is unpeered. Alpine is the only
Linux distribution that fits in my head. The pieces from which it is
built from are simple, easily understood, and few in number, and I
can usually predict how it will behave in production. The software
choices, such as musl libc, are highly appreciated in this respect
as well, lending a greater degree of simplicity to the system as a
Have you heard “legacy code” as the reason when something went wrong
in a software project? Understanding legacy code is crucial because
it occurs in every project sooner or later. We use the term loosely
to describe old code that we don’t like but what is legacy code
really and even more importantly how can we avoid it?
I spend a lot of my time at work writing Go services that talk to
other Go services over HTTP. Much of the time, everything works as
expected, but every now and then a situation arises where I’m
struggling to understand why my program is receiving a specific
value. Is my request not being built correctly? Am I not properly
deserializing the response? Logging can be helpful, but sometimes I
really just want to look at the HTTP traffic between services.