I was recognised as a Github Star! https://stars.github.com/profiles/sobolevn/

This is very important to me because I spend like 50% of my overall time on Github.
It also brings a lot of extra motivation to continue my free community work I do (like this telegram channel).

If you want to share this moment with me and say "thank you" - click "Follow" button here: https://github.com/sobolevn

Let's build more awesome tools together!

​​Flow-based visual scripting for #python.

Ryven is a flow-based visual scripting environment for Python for creating diagram-like representations of your Python scripts. It provides you with a simple system to create new nodes executing any Python code. It might come in handy as a tool for exploration, too, once users created a lot more nodes. Convenient use cases include IoT, data processing and data manipulation, generally visualizing algorithms, Raspberry Pi, and basically any web API.

Features:
- Simple concept, intuitive UI
- Create clear and good looking flows
- Any Python code can be put into a node, no limits!
- Easy process of creating new nodes
- There are data and execution connections but pure dataflows are possible
- Stylus support
- Live source code manipulation
- It is free

https://ryven.org/

​​Fuzzy Finder in #rust!

Half of our life is spent on navigation: files, lines, commands, etc. You need skim! It is a general fuzzy finder that saves you time. skim provides a single executable: sk. Basically anywhere you would want to use grep, try sk instead.

https://github.com/lotabout/skim

The Open Architecture Playbook. Use it to create better and faster (IT)Architectures. OSS Tools, templates and more for solving IT problems using real open architecture tools that work!

Smart people have been thinking on how to create IT architectures as long as there has been computers. Ideas come and go, however creating a good architectures can still be complex and time consuming. Especially when you try to invent the wheel for yourself. With this interactive playbook you can create your IT architecture better and faster. The focus of this architecture playbook is in on:

1. Knowledge reuse. Why reinvent the wheel again? It is far and more fun to create a better wheel for your organisation or IT project instead! Focus on the hard complex context specific issues. Use good open tools and knowledge for the easy 80%!
2. Easier creation of architecture documents and deliverables. This playbook has an extensive list of all open tools available for creating your IT architecture or design. Using these open tools will speed up the process of creating your architecture deliverables and reduce your risks.
3. Quality improvement. By making use of content parts provided for various architecture deliverables you will lower your business risks. Complex business IT projects will fail. Now and in future. But if you make use of proven methods and tools developed from decades of IT architecture scientific research you will lower the risk for your project. Architecture will help to make your projects more successful in terms of costs, speed and profitability.

https://nocomplexity.com/documents/arplaybook/index.html

​​Erlang/Elixir NIFs in Nim

Nimler is a library for authoring #erlang and #elixir NIFs in the #nim programming language. It has mostly complete bindings for the Erlang NIF API and some accessories for making writing NIFs easier, including idiomatic functions for converting between Erlang terms and Nim types, and simplifications for using resource objects.

Mostly, Nimler is a minimal, zero-dependency wrapper for Erlang NIF API.

https://github.com/wltsmrz/nimler

​​Prevent cloud misconfigurations during build-time for Terraform, Cloudformation, Kubernetes, Serverless framework and other infrastructure-as-code-languages with Checkov (Чехов).

Checkov is a static code analysis tool for infrastructure-as-code.

It scans cloud infrastructure provisioned using Terraform, Cloudformation, Kubernetes, Serverless or ARM Templates and detects security and compliance misconfigurations.

Features:
- Over 400 built-in policies cover security and compliance best practices for AWS, Azure and Google Cloud.
- Scans Terraform, CloudFormation and Kubernetes, Serverless framework and ARM template files.
- Detects AWS credentials in EC2 Userdata, Lambda environment variables and Terraform providers.
- Evaluates Terraform Provider settings to regulate the creation, management, and updates of IaaS, PaaS or SaaS managed through Terraform.
- Policies support evaluation of variables to their optional default value.
- Supports in-line suppression of accepted risks or false-positives to reduce recurring scan failures. Also supports global skip from using CLI.
- Output currently available as CLI, JSON, JUnit XML and github markdown and link to remediation guides.

https://github.com/bridgecrewio/checkov

#python #devops #k8s

​​Command-line DNS #rust client

Dogs can look up!

dog is a command-line DNS client, like dig. It has colourful output, understands normal command-line argument syntax, supports the DNS-over-TLS and DNS-over-HTTPS protocols, and can emit JSON.

https://github.com/ogham/dog

​​Free/Libre Open Source Software Binaries of VSCode

Microsoft’s vscode source code is open source (MIT-licensed), but the product available for download (Visual Studio Code) is licensed under this not-FLOSS license and contains telemetry/tracking. According to this comment from a Visual Studio Code maintainer:

> When we Microsoft build Visual Studio Code, we do exactly this. We clone the vscode repository, we lay down a customized product.json that has Microsoft specific functionality (telemetry, gallery, logo, etc.), and then produce a build that we release under our license.

> When you clone and build from the vscode repo, none of these endpoints are configured in the default product.json. Therefore, you generate a “clean” build, without the Microsoft customizations, which is by default licensed under the MIT license

The VSCodium project exists so that you don’t have to download+build from source. This project includes special build scripts that clone Microsoft’s vscode repo, run the build commands, and upload the resulting binaries for you to GitHub releases. These binaries are licensed under the MIT license. Telemetry is disabled.

https://vscodium.com/

​​Keep an eye on your #docker image size and prevent it from growing too big!

Limit your docker image size with a simple CLI command. Perfect to be used inside your CI process.

Also available as a Github Action.

https://github.com/wemake-services/docker-image-size-limit

#python

​​k0s - Zero Friction Kubernetes

k0s is an all-inclusive Kubernetes distribution with all the required bells and whistles preconfigured to make building a Kubernetes clusters a matter of just copying an executable to every host and running it.

Key Features:
- Packaged as a single static binary
- Self-hosted, isolated control plane
- Variety of storage backends: etcd, SQLite, MySQL (or any compatible), PostgreSQL
- Elastic control-plane
- Vanilla upstream Kubernetes
- Supports custom container runtimes (containerd is the default)
- Supports custom Container Network Interface (CNI) plugins (calico is the default)
- Supports x86-64 and arm64

Quickstart:

curl -sSLf get.k0s.sh | sh
k0s server --enable-worker

https://github.com/k0sproject/k0s

#k8s #devops #go

​​A privacy-first, open-source platform for knowledge sharing and management.

A local-first, non-linear, outliner notebook for organizing and sharing your personal knowledge base. Use it to organize your todo list, to write your journals, or to record your unique life.

The server will never store or analyze your private notes. Your data are plain text files and we currently support both Markdown and Emacs Org mode (more to be added soon). In the unlikely event that the website is down or cannot be maintained, your data is, and will always be yours.

https://github.com/logseq/logseq

#clojure #docops

​​List of the best fonts for coding with live preview!

Features:
- Live preview of all fonts with your code samples
- Select specific fonts to compare
- Choose editor themes
- Choose your language for syntax highlights

https://devfonts.gafi.dev/

​​Fast and simple Node #js version manager, built in #rust

Features:
- Cross-platform support (Mac, Windows, Linux)
- Single file, easy installation, instant startup
- Built with speed in mind
- Works with .node-version and .nvmrc files

https://github.com/Schniz/fnm

⚡Breaking news!

#php 8 is released!

Features:
- Union Types
- Named Arguments
- Match Expressions
- Attributes
- Constructor Property Promotion
- Nullsafe Operator
- Weak Maps
- Just In Time Compilation

https://www.php.net/archive/2020.php#2020-11-26-3

​​Upptime is the open-source uptime monitor and status page, powered entirely by GitHub Actions and Issues.

Features:
GitHub Actions is used as an uptime monitor
Every 5 minutes, a workflow visits your website to make sure it's up
Response time is recorded every 6 hours and committed to git
Graphs of response time are generated every day
GitHub Issues are used for incident reports
An issue is opened if an endpoint is down
People from your team are assigned to the issue
Incidents reports are posted as issue comments
Issues are locked so non-members cannot comment on them
Issues are closed automatically when your site comes back up
Slack notifications are sent on updates
GitHub Pages are used for the status website
A simple, beautiful, and accessible PWA is generated
Built with Svelte and Sapper
Fetches data from this repository using the GitHub API

https://github.com/upptime/upptime

​​Clearly is a real time monitor for your celery tasks and workers. Clearly see and debug your celery cluster in real time!

> While I do like flower, to me it's not been totally up to the task (pun intended :).
Why is that? flower needs page refreshes, filters only one task type at a time, displays results as plain strings without any formatting or syntax highlighting, and on top of that also truncates them!

> And clearly is actually real time, has multiple simultaneous filters, a beautiful syntax highlighting system, an advanced formating system that shows parameters, results and tracebacks just as an ipython would, has complete un-truncated results and is very easy to use! Also you can install it very easily with a docker image!

> It's great to actually see in a totally real time way what's going on in your celery workers! So it's very nice for inspecting, debugging, and even demonstrating your company async-superpowers (put clearly on a big screen TV showing all tasks of your production environment)!

> Clearly is composed of a server, which collects real time events from the celery cluster, generates missing states, and streams filtered data to connected clients; and a client, which you use to send filter commands and display both real time and stored data. They communicate with each other via gRPC and ProtocolBuffers.

https://github.com/rsalmei/clearly

#python

​​REST API for any Postgres database.

Using PostgREST is an alternative to manual CRUD programming. Custom API servers suffer problems. Writing business logic often duplicates, ignores or hobbles database structure. Object-relational mapping is a leaky abstraction leading to slow imperative code. The PostgREST philosophy establishes a single declarative source of truth: the data itself.

Declarative Programming: It’s easier to ask PostgreSQL to join data for you and let its query planner figure out the details than to loop through rows yourself. It’s easier to assign permissions to db objects than to add guards in controllers. (This is especially true for cascading permissions in data dependencies.) It’s easier to set constraints than to litter code with sanity checks.

Leak-proof Abstraction: There is no ORM involved. Creating new views happens in SQL with known performance implications. A database administrator can now create an API from scratch with no custom programming.

https://github.com/PostgREST/postgrest

#haskell

​​The tiny all-in-one development tool for modern web apps.

All the features you'd expect and more, from development to production:
- No "entry points" or "pages" to configure - just <script type=module src=anything.js>
- import "packages" from npm without installation
- Smart bundling and caching for npm dependencies
- Hot reloading for modules, Preact components and CSS
- Lightning-fast JSX support that you can debug in the browser
- Import CSS files and CSS Modules (*.module.css)
- Static file serving with hot reloading of CSS and images
- Highly optimized Rollup-based production output (wmr build)
- Crawls and pre-renders your app's pages to static HTML at build time
- Built-in HTTP2 support in both development and production (wmr serve --http2)
- Supports Rollup plugins, even in development where Rollup isn't used

https://github.com/preactjs/wmr

#js

​​Type-safe, compiled Jinja-like templates for #rust

Askama implements a template rendering engine based on Jinja. It generates Rust code from your templates at compile time based on a user-defined struct to hold the template's context.

Feature highlights:
- Construct templates using a familiar, easy-to-use syntax
- Template code is compiled into your crate for optimal performance
- Benefit from the safety provided by Rust's type system
- Optional built-in support for Actix, Gotham, Iron, Rocket, tide, and warp web frameworks
- Debugging features to assist you in template development
- Templates must be valid UTF-8 and produce UTF-8 when rendered
- Works on stable Rust

https://github.com/djc/askama

​​Beartype is an open-source pure #python PEP-compliant O(1) constant-time runtime type checker emphasizing efficiency, portability, and thrilling puns.

Beartype brings Rust inspired zero-cost abstractions into the lawless world of dynamically-typed pure Python.

Beartype is portably implemented in Python 3, continuously stress-tested via GitHub Actions + tox + pytest, and permissively distributed under the MIT license. Beartype has no runtime dependencies, only one test-time dependency, and supports all Python 3.x releases still in active development.

https://github.com/beartype/beartype

An incremental parsing system for programming tools written in #rust

Tree-sitter is a parser generator tool and an incremental parsing library. It can build a concrete syntax tree for a source file and efficiently update the syntax tree as the source file is edited.

Tree-sitter aims to be:
- General enough to parse any programming language
- Fast enough to parse on every keystroke in a text editor
- Robust enough to provide useful results even in the presence of syntax errors
- Dependency-free so that the runtime library (which is written in pure C) can be embedded in any application

https://github.com/tree-sitter/tree-sitter