Working as a Software Developer, there are always new tools and frameworks coming out that can completely change your workflows – for the better (or worse?).
Source: 5 Linux Utilities to Improve Your Programming Workflow in 2022, an article by Rishabh Rawat.
I often find async Rust to be misunderstood. Conversations around "why async" often focus on performance 1 - a topic which is highly dependent on workloads, and results with people wholly talking past each other. While performance is not a bad reason to choose async Rust, we often we only notice performance when we experience a lack of it. So I want to instead on which features async Rust provides which aren't present in non-async Rust. Though we'll talk a bit about performance too at the end of this post.
Source: Why Async Rust, an article by Yoshua Wuyts.
The OpenBSD packet filter PF was introduced a little more than 20 years ago as part of OpenBSD 3.0. We'll take a short tour of PF features and tools that I have enjoyed using.
Source: A Few of My Favorite Things About The OpenBSD Packet Filter Tools, an article by Peter N. M. Hansteen.
In 1983, Acorn Computers needed a CPU. So 10 people built one.
Source: A history of ARM, part 1: Building the first chip, an article by Jeremy Reimer.
Learn how to use Nmap, to scan and analyze your network, to find network vulnerabilities. Perform Version and OS detection easily and find open ports.
Source: Learn Nmap to find your first Network Vulnerability.
Kubernetes is a colossal beast. You need to understand many different concepts before it starts being useful. When everything is set up, you’ll probably want to expose some pods to the outside of the cluster. Kubernetes provides different ways to do it: I’ll describe them in this post.
Source: Back to basics: accessing Kubernetes pods, an article by Nicolas Fränkel.
The WHOIS protocol is one of the older internet protocols around. It's infuriatingly simple, by and large considered obsolete, and the data provided by it unpredictable, unreliable, incomplete, and, of course, still one of the corner stones of internet operations. In other words, it's the kind of thing I like to waste my time on trying to understand.
Source: WHOIS: Fragile, unparseable, obsolete... and universally relied upon, an article by Jan Schaumann.
A line of code containing 6+ pieces of information should be simplified.
Source: Want cleaner code? Use the rule of six, an article by David Amos.
Every Python developer is familiar with the
selfargument, which is present in every* method declaration of every class. We all know how to use it, but do you really know what it is, why it's there and how it works under the hood?
Source: What is Python's "self" Argument, Anyway?, an article by Martin Heinz.
If you specify both the day of month and the day of week field, then cron will run the command when either of the fields match. In other words, there’s a logical OR relationship between the two fields.
Source: Schedule Cronjob for the First Monday of Every Month, the Funky Way, an article by Pēteris Caune.
The OpenBSD virtual machine daemon works pretty well with Linux VMs nowadays. This was time for me to see if I could replace the Synology Docker service with some Docker host provided by vmd(8).
Source: Running a Docker Host under OpenBSD using vmd(8), an article by Joel Carnat.
There's a question that always comes up when people pick up the Rust programming language: why are there two string types? Why is there
String, and&str?My Declarative Memory Management article answers the question partially, but there is a lot more to say about it, so let's run a few experiments and see if we can conjure up a thorough defense of Rust's approach over, say, C's.
Source: Working with strings in Rust.
Today, a co-worker who started working at the company recently asked
me what was preferred: use base or use parent. He preferred the
latter, and so did I. I linked to an article by Mark Gardner:
Multiple ways to inheritance in
Perl
which also recommends use parent over use base.
The Rust team is happy to announce a new version of Rust, 1.64.0. Rust is a programming language empowering everyone to build reliable and efficient software.
Source: Announcing Rust 1.64.0.
Postgres is an awesome database for a lot of reasons, put simply it's a really feature rich, powerful, and reliable database. One of those rich areas is the many built-in functions in Postgres.
Source: Fun With Postgres Functions, an article by Craig Kerstiens.
So you have a Jupyter Notebook with
pyproject.tomlandpoetry.lockfiles, and you want to productionise it? You’ll just need a Linux or macOS machine.
Source: Reproducible Jupyter Notebook with Nix, an article by Victor Engmark.
FreeBSD has a very stable and well thought out init and services system called rc(8).
This is a guide to declarative nirvana: describing the desired end state of an entire production pipeline (building, provisioning, deploying, and everything in between) in code, and then materializing it with a single command. We achieve this by integrating two tools: Terraform and Nix.
Source: A Comprehensive Guide to End-to-End-Declarative Deployment with Terraform and Nix, an article by Jonas Carpay.
The fast proliferation of Kubernetes has meant that many more organizations are running Kubernetes without the personnel or the money to secure it properly. And yes, that includes you, "person who is primarily a developer, but deployed an GKE cluster 6 months ago while following the CIS benchmarks and hasn't looked at it since, thinking it's super secure because it's 'managed' by Google". Hopefully this collection of tips will help you out!
Source: Under-documented Kubernetes Security Tips, an article by Mac Chaffee.
We can use Make and a couple of short shell scripts to implement file content-based caching and read/write that cache to remote storage, such as S3. The demo repository contains a version using minio for ease of demonstration.
Source: Content based change detection with Make, an article by Andy Dote.
redframes (rectangular data frames) is a data manipulation library for ML and visualization. It is fully interoperable with pandas, compatible with scikit-learn, and works great with matplotlib!
redframes prioritizes syntax over flexibility and scope. And minimizes the number-of-googles-per-lines-of-code™ so that you can focus on the work that matters most.
Source: redframes, an article by Max Humber.
At Crunchy we talk a lot about memory, shared buffers, and cache hit ratios. Even our new playground tutorials can help users learn about memory usage. The gist of many of those conversations is that you want to have most of your frequently accessed data in the memory pool closest to the database, the shared buffer cache.
There's a lot more to the data flow of an application using Postgres than that. There could be application-level poolers and Redis caches in front of the database. Even on the database server, data exists at multiple layers, including the kernel and various on-disk caches. So for those of you that like to know the whole story, this post pulls together the full data flow for Postgres reads and writes, stem-to-stern.
Source: Postgres Data Flow, an article by David Christensen.
One aspect of Haskell that many new users find difficult to get a handle on is operators. Unlike many other languages, Haskell gives a lot of flexibility to developers to define custom operators. This can lead to shorter, more elegant code in many cases.
Source: Operator Glossary.
Grids help designers create cohesive layouts, allowing end users to easily scan and use interfaces. A good grid adapts to various screen sizes and orientations, ensuring consistency across platforms.
Source: Using Grids in Interface Designs, an article by Kelley Gordon.
When developing some python code and testing it in IPython, I love the
autoreloadfeature of IPython. When enabled it will reload imported modules automatically. So you will always use the newest version of your code. It even patches modifications on class methods into existing class instances. To enable it first load it with%load_ext autoreload, then enable it with%autoreload 2– See the documentation for explanations of the options and how to autoreload only selected imports.
Source: Shorter Hacks 16 IPython Autoreload, an article by Michael F. Schönitzer.
Here is another shot at distributed tracing in Rust. I saw multiple articles online but sadly none gave me the necessary tips to make distributed tracing work in my context.
What I wanted to achieve was to get a complete trace starting from the API request to the database across multiple services communicating through AMQP.
This article will guide you through every steps required to instrument your application.
Distributed Tracing in Rust, an article by Romain Lebran.
Podman Desktop is an open-source GUI application for managing containers on Linux, macOS, and Windows.
Historically, developers have been using Docker Desktop for graphical management of containers. This worked for those who had Docker Daemon and Docker CLI installed. However, for those who used Podman daemon-less tool, although there were a few Podman frontends like Pods, Podman desktop companion, and Cockpit, there was no official application. This is not the case anymore. Enter Podman Desktop!
Source: Manage containers on Fedora Linux with Podman Desktop, an article by Mehdi Haghgoo.
Rust is in a pretty good place; it is getting more and more popular, has more and more contributors, and is used in some pretty significant places. However, it is a time of flux and change, and transitioning from a research project then a new, rapidly changing language to a popular, established project is a difficult change.
Here, I want to describe what I think are the ten biggest challenges for Rust for now and the next few years. I have some ideas for solutions, but they are all big, difficult questions with no simple answer, so the real solutions will all take iteration, energy, and creativity. My focus is on the core project; there are many challenges for the community and ecosystem (e.g., how to make GUIs with Rust, or how to get more crates to 1.0) which I think must be primarily solved by the community.
Source: Ten challenges for Rust, an article by Nick Cameron.
Billions of people carry cameras in their pockets and use them to document their lives. Yet, despite the democratization of the hardware, the knowledge of photographic techniques remains elusive. Countless books, webpages, and YouTube videos purport to offer advice, but tend to dwell on topics of little consequence - such as shopping for gear or memorizing made-up rules of composition that seldom make for a good shot.
I'm not a pro, but I dabbled in photography for more than two decades - and after making countless mistakes, I have gotten fairly good. This page is an impassioned contrarian take on what it takes to snap great photos, along with a set of simple experiments that can be repeated at home.
Source: Photography for geeks, an article by Michal Zalewski.
Just like metadata is data about data, metaprogramming is writing programs that manipulate programs. It's a common perception that metaprograms are the programs that generate other programs. But the paradigm is even broader. All of the programs designed to read, analyze, transform, or modify themselves are examples of metaprogramming.
Source: Metaprogramming in Python, an article by Satwik Kansal.
Zerolog is a high-performance, zero-allocation Go logging library. It provides structured logging capabilities for latency-sensitive applications where garbage collection is undesirable. You can use in a completely zero-allocation manner such that after the logger object is initialized, no further objects will be allocated on the heap, thus preventing the garbage collector from being triggered.
This tutorial will explain how to install, set up, and use the Zerolog logger in a Go application. We'll start by going through its API and all the options it provides, and show how to customize them in various ways. Finally, we'll describe how to use it in a typical web application so you can get a good idea of how to adopt it in your projects.
Next time you just need to get a value out of a deeply-nested
JSONobject, trylens-aeson. I think you’ll be glad you did.
Source: Easy JSON in Haskell, an article by Drew Olson.
detailsA lot of chatter around the ol’
<details>and<summary>elements lately! I saw Lea Verou recently tweet an observation about the element’s display behavior and that sorta splintered into more observations and usage notes from folks, including a revived discussion on whether<summary>should be allowed to contain interactive elements or not.There are a lot of dots to connect and I’ll do my best here to do exactly that.
Source: More Details on
details, an
article by Geoff Graham.
Think that web form has got your number? If you used input type="number", you may be surprised to find that it doesn't.
Source: Why the number input is the worst input, an article by Jared Toporek.
Python is, in a lot of ways, a very rich language. After years of using it, I still regularly discover new parts of the ecosystem, even in the standard library. In particular, there are a few modules which are not very well-known, but can be very useful in some situations. Today I discovered
dbma persistent key/value store.
Source: TIL—Python has a built-in persistent key-value store.
I’ll make the case for one practice that works very well operationally: deploying small units of code to production on a regular basis. I think that your deploys should be measured in dozens of lines of code rather than hundreds. You’ll find that taking this as a fixed point requires only relatively simple uses of revision control.
Source: Ship Small Diffs, an article by Dan McKinley.
Once, Sancia Grado was just a thief with a grudge and a rare talent. Then she learned how to use that talent, and beat the great merchant houses of Tevanne at their own game. With Clef and Berenice, she even saw off an immortal hierophant - but the war they're fighting now is one they know they can't win.
This time, they're not facing robber-baron elites or an immortal hierophant, but an entity whose intelligence is spread over half the globe: a ghost in the machine using the magic of scriving to possess and control not just objects, but human minds.
Despite all their efforts their enemy marches on, implacable, unstoppable - and it's closing in on its true prize: an ancient doorway that leads to the centre of creation itself.
Sancia and her friends glimpse a last desperate opportunity to stop this unbeatable foe - but to do so, they'll have to unlock the centuries-old mystery of scriving's origins and pull off the most daring heist they've ever attempted.
And as if that weren't enough, their adversary might just have a spy in their ranks - and a last trick up its sleeve . . .
In the evening I started in Locklands, book 3 in The Founders Trilogy by Robert Jackson Bennett.
Swift 5.7 is now officially released! Swift 5.7 includes major additions to the language and standard library, enhancements to the compiler for a better developer experience, improvements to tools in the Swift ecosystem including SourceKit-LSP and the Swift Package Manager, refined Windows support, and more.
Source: Swift 5.7 Released!, an article by Holly Borla.
I knew CSS blend modes could create some cool effects, but even so, a CodePen I saw recently left me shocked at what they’re capable of.
Source: The Power of CSS Blend Modes, an article by Scott Vandehey.
A while ago, after what now seems like eternity of flirting with Haskell articles and papers, I finally crossed the boundary between theory and practice and downloaded a Haskell compiler. I decided to do a field evaluation of the language by two means. I was going to solve a problem in a domain that Haskell is known to excel at followed by a real world problem1 that hasn't had much exploration in Haskell2. Picking the problems was easy. There's a lot of folklore that suggests Haskell is great for building compilers and interpreters so I didn't have to think long to a pick a problem that would be self contained, reasonably short, and fun - writing an interpreter of a Lisp dialect. For the second test case I decided to go with a web application - plenty of people are writing them for money and there hasn't been much Haskell-related work done in this area.
Source: Writing A Lisp Interpreter In Haskell, an article by Slava Akhmechet.
Most software developers are familiar with object-relational mapping (ORM), a coding technique that creates an abstraction layer between object-oriented programming languages and databases. But despite its value, ORM isn’t ideal in all situations – particularly when programmers make wrong assumptions about its use. We debunk several such mistaken beliefs so that you can use ORM the right way.
Source: 3 Common Misconceptions About Object-relational Mapping, an article by Will Johnston.
In this post, we'll dive deep into Log Structured Merge Tree aka LSM Tree: the data structure underlying many highly scalable NoSQL distributed key-value type databases such as Amazon's DynamoDB, Cassandra and ScyllaDB. These databases by design are known to support write rates far more than what traditional relational databases can offer. We'll see how LSM Tree enables them to allow the write speeds that they claim, as well as how they facilitate reads.
Source: What is a LSM Tree, an article by Rahul Sharma.
Go is one of the programming languages I love the most. It allows a very fast execution time (unlike Python) without affecting negatively the developer experience (unlike C), and is strongly typed (unlike TS where you can lie to the compiler). But it has some flaws, and nil interfaces are a tricky one I have to address.
Source: Go Traps - nil interfaces, an article by Ewen Quimerc'h.