​​Introducing you misspell-fixer-action. It is a #github action that will fix your typos and grammar errors in both source code and documentation.

And then send you a pull request with the fixes it made! It is an auto-formatter, but for natural languages.

https://github.com/sobolevn/misspell-fixer-action

Here's an example:

MeiliSearch is a powerful, fast, open-source, easy to use, and deploy search engine. The search and indexation are fully customizable and handles features like typo-tolerance, filters, and synonyms.

https://github.com/meilisearch/MeiliSearch

#rust

​​K9s provides a terminal UI to interact with your Kubernetes clusters. The aim of this project is to make it easier to navigate, observe and manage your applications in the wild. K9s continually watches Kubernetes for changes and offers subsequent commands to interact with your observed resources.

https://github.com/derailed/k9s

#go #k8s #devops

This plugin adds cargo add, cargo rm, and cargo update commands to #rust projects. Something I personally really miss.

https://github.com/killercup/cargo-edit

#rust

An operating system designed for hosting containers written in #rust

Bottlerocket focuses on security and maintainability, providing a reliable, consistent, and safe platform for container-based workloads. The base operating system has just what you need to run containers reliably, and is built with standard open-source components. Bottlerocket-specific additions focus on reliable updates and on the API. Instead of making configuration changes manually, you can change settings with an API call, and these changes are automatically migrated through updates.

Some notable features include:

- API access for configuring your system, with secure out-of-band access methods when you need them.
- Updates based on partition flips, for fast and reliable system updates.
- Modeled configuration that's automatically migrated through updates.
- Security as a top priority.

https://github.com/bottlerocket-os/bottlerocket

#devops

> I remember how careful I was the first time I opened a GitHub pull request. I read, re-read and triple-checked every one my comments before posting. It felt scary publishing my thoughts online because I was afraid people would judge me or misinterpret me.

> I enjoy working on open source just as much today as when I started. In this post I want to share some principles I try to follow to avoid unproductive discussions and invest my focus on what matters the most. Some of these dos and don'ts might be useful for maintainers, some for contributors. Whatever your role in open source, I hope you find some useful tips.

Dos and don'ts in open source: https://geirsson.com/open-source.html

​​ExplainShell - a command-line contextual visualizer.

https://explainshell.com

#shell

​​A visual debugger for Jupyter!

https://blog.jupyter.org/a-visual-debugger-for-jupyter-914e61716559

#python

Interesting take on margin:

> We should ban margin from our components. Hear me out. Margin breaks component encapsulation. A well-built component should not affect anything outside itself. Margin makes reusability harder. Good components are usable in any context or layout.

#css #rant

> You’re creating a patient registration flow and your user is partway through the form wizard and needs more information on how to find and fill out their “insurance certificate number” in order to continue. Some users need to know what this means. Others need to know where to find it (hint: it’s on another piece of paper).

> You’ve come to a crossroads. Do you interrupt the flow? Add a page? A modal? How do you decide what to do?

This article offers a decision making framework: what component you should use and when.

#css

​​aiometer is a #python 3.7+ concurrency scheduling library compatible with asyncio and trio and inspired by Trimeter. It makes it easier to execute lots of tasks concurrently while controlling concurrency limits (i.e. applying backpressure) and collecting results in a predictable manner.

https://github.com/florimondmanca/aiometer

Integrating new code quality tools into existing legacy is always hard.

Here's a good article about integrating RuboCop into existing #ruby code.

We are also working on adding a single command integration of wemake-python-styleguide into an existing #python legacy. Currently it is a WIP, but you can already read about it here: https://github.com/wemake-services/wemake-python-styleguide/pull/1276/files#diff-a767531552fe775f5be950388425b154R28

More tools and articles about this to come!

​​Install and run #python applications in isolated environments with pipx.

It's roughly similar to npx from #js ecosystem.

https://github.com/pipxproject/pipx

​​Summoner is a tool for scaffolding fully configured batteries-included production-level #haskell projects.

Do you want to create a library that is to be uploaded to Hackage/Stackage, that builds with both Cabal and Stack and supports the latest three major GHC versions? Or are you building a production application which uses a custom prelude and has CI with GitHub Actions or Travis Linux and AppVeyors Windows checks? Maybe do you want to play with your idea in a single module without introducing the whole complexity of the Haskell projects? Summoner can help you do all that with minimal effort from you - it can even upload the project to GitHub if you wish!

By the way, Summoner operates as either CLI or TUI application, so you can choose what you are more comfortable with and install only the required one.

https://github.com/kowainik/summoner

​​NimbleParsec is a simple and fast library for text-based parser #elixir combinators.

Combinators are built during runtime and compiled into multiple clauses with binary matching. This provides the following benefits:

- Performance: since it compiles to binary matching, it leverages many Erlang VM optimizations to generate extremely fast parser code with low memory usage
- Composable: this library does not rely on macros for building and composing parsers, therefore they are fully composable. The only macros are defparsec/3 and defparsecp/3 which emit the compiled clauses with binary matching
- No runtime dependency: after compilation, the generated parser clauses have no runtime dependency on NimbleParsec. This opens up the possibility to compile parsers and do not impose a dependency on users of your library
- No footprints: NimbleParsec only needs to be imported in your modules. There is no need for use NimbleParsec, leaving no footprints on your modules

The goal of this library is to focus on a set of primitives for writing efficient parser combinators. The composition aspect means you should be able to use those primitives to implement higher level combinators.

https://github.com/dashbitco/nimble_parsec

​​Browsh is a fully-modern text-based browser. It renders anything that a modern browser can; HTML5, CSS3, JS, video and even WebGL. Its main purpose is to be run on a remote server and accessed via SSH/Mosh or the in-browser HTML service in order to significantly reduce bandwidth and thus both increase browsing speeds and decrease bandwidth costs.

https://www.brow.sh/

#shell #js #go

​​Save disk space by cleaning unneeded files from software projects.

It will identify the disk space savings you would get from deleting temporary/unnecessary files from project directories, such as target from Cargo projects and node_modules from Node projects.

https://github.com/tbillington/kondo

#rust

Not all duplicated code should be removed. This is one of the most important parts of the DRY principle to understand.

This article shares some great examples!

> “Don’t Repeat Yourself” was never about code. It’s about knowledge. It’s about cohesion. If two pieces of code represent the exact same knowledge, they will always change together. Having to change them both is risky: you might forget one of them. On the other hand, if two identical pieces of code represent different knowledge, they will change independently. De-duplicating them introduces risk, because changing the knowledge for one object, might accidentally change it for the other object.

> Looking at the reasons for change, is a very powerful modelling heuristic.

Very emotial post about the current state of software communities and their reactions to new things. This particular post is focused on monads as this new concept people are confused about.

I personally feel this too. Awesome read!

P.S. It also features dry-python/returns as a good example of how things should be done to sell new concepts to users: https://github.com/dry-python/returns

​​kubectx is a utility to manage and switch between kubectl(1) contexts.

kubens is a utility to switch between Kubernetes namespaces.

https://github.com/ahmetb/kubectx

#devops #go

> Please don’t write your documentation in Markdown. Please. I’m begging you.

> Markdown is tolerable for short documentation, like a readme.md. Past that, it’s the wrong tool for the job.

A very good #rant about markdown issues. Provides several solutions as well.

#docops