We’re programmers, so writing code is what we do, is it not ? As the
title suggests, our job is a bit more complicated than stroking keys
on a keyboard in front of a screen all day. If you go beyond
programming languages, and frameworks and processes, beyond test
suites and sprints and Jira tickets, you will always find a problem
that needs to be solved.
I would say that we, as programmers, are, first and foremost,
problem solvers. We take a problem that someone else has and, using
all the tools at our disposal, produce a solution.
Recently I've been taking a look at replacements for common command
line tools (and coreutils) - ls, cat, find, grep, etc. Turns out,
people have been rewriting a lot of them in Rust
Most of today’s popular CI services support running jobs in
arbitrary Docker containers. In this post, I’ll describe why Docker
is such a great fit for CI and how it can be made even better with
custom images.
After 6PM I gave a mealworm, Tenebrio molitor, to my Brachypelma
smithi. This was the first time it accepted food since I bought
it. It
molted recently, which
might have been the reason it didn't accept food on earlier occasions
as it was in pre-molt.
Brachypelma smithi eating a mealworm, Tenebrio molitor.
In the above photo you can see a few grains of sand on its carapace
which ended up there after the tarantula's struggle with the mealworm.
I was recently looking at the source of a wxPython-based GUI
application, about 45.5KLOC in size, not counting the libraries used
(e.g. Twisted). The code was written by Java developers who are
relatively new to Python, and it suffers from some performance
issues (like a 30-second startup time). In examining the code, I
found that they had done lots of things that make sense in Java, but
which suck terribly in Python. Not because “Python is slower than
Java”, but because there are easier ways to accomplish the same
goals in Python, that wouldn’t even be possible in Java.
So, the sad thing is that these poor folks worked much, much harder
than they needed to, in order to produce much more code than they
needed to write, that then performs much more slowly than the
equivalent idiomatic Python would.
I’ve been writing a lot of Python recently. As a relative newcomer
to the language, it continues to impress me with its versatility and
“quality of life” features. I’m not surprised that it’s been
gaining so much popularity among
developers as of late.
Two such features I’ve discovered recently are the permutations
and combinations functions of Python’s
itertools
module. The module is basically a set of convenience functions to
produce iterators to suit various needs.
Beginners seem to ask this question when they are feeling daunted by
the challenge before them. Maybe they are hoping for a helpful
answer, but it seems like most answers will just be a jumping off
point for feeling bad about their own progress.
Everyone learns differently. They learn from different sources, at
different paces. Suppose you ask this question and someone answers
“one month”? Will you feel bad about yourself because you’ve been at
it for six weeks? Suppose they say, “ten years”? Now what do you
think?
On this day last year I
wrote the first blog post for Plurrrr. And from that day on I managed
to write a post every single day. It hasn't been easy always, but most
of the time it was rewarding to compose a post. Especially the ones
with photos.
The software to create a blog like this named tumblelog is available als
open source. Just clone the
GitHub repository and read
the instructions in the
README.md. If
you have any questions, feel free to contact
me. Happy blogging!
This article is about how pipes are implemented the Unix kernel. I
was a little disappointed that a recent article titled “How do Unix
pipes
work?”
was not about the internals, and curious enough to go digging in
some old sources to try to answer the question.
But, this concept is actually a pretty straightforward journaling
exercise. In your decision journal (it can be anything from a
Google
Document
to a cheap notebook to even a Trello board), you simply chronicle
your bigger decisions and record how you felt when you made them.
As an article for Farnam
Street recommends, when
you’re faced with a large decision, use your journal to document the
following:
The choice you’ve made
What you expect to happen as a result of that choice
Data encryption at rest is a must-have for any modern Internet
company. Many companies, however, don't encrypt their disks, because
they fear the potential performance penalty caused by encryption
overhead.
Ever considered setting up and running your very own git server?
It’s actually quite easy! In this post, I’ll outline the steps I
took to set up my own so that you can
give it a try yourself.
In December 2018, KrebsOnSecurity looked at how dozens of
U.S. political campaigns, cities and towns had paid a shady company
called Web Listings Inc. after receiving what looked like a
bill for search engine optimization (SEO)
service
rendered on behalf of their domain names. The story concluded that
this dubious service had been scamming people and companies for more
than a decade, and promised a Part II to explore who was behind Web
Listings. What follows are some clues that point to a very
convincing answer to that question.
Working on many projects across multiple identities can be difficult
to manage. This is a procedure for leveraging git aliases to set an
identity at the project level for any project with support for
GPG-based commit signing.
There are a lot of good programming languages in the world. There
are even multiple that fit Rust's broad description, and place in
the ecosystem. This is a very good place, with real problems to
solve. I'm not convinced that Rust is necessarily technically
superior to its nearest neighbors, but there are some things it
seems to do particularly well.
Radio buttons and checkboxes have long been components that cause
users confusion. These components are often used in the same
context, but look completely different. Designers and developers
know the difference, but that’s because they learned it through
their work. What about users who were never taught the difference?
