​​terminus: A terminal for a more modern age!

Terminus is a highly configurable terminal emulator for Windows, macOS and Linux

- Integrated SSH client and connection manager
- Theming and color schemes
- Fully configurable shortcuts
- Split panes
- Remembers your tabs
- PowerShell (and PS Core), WSL, Git-Bash, Cygwin, Cmder and CMD support
- Direct file transfer from/to SSH sessions via Zmodem
- Full Unicode support including double-width characters
- Doesn't choke on fast-flowing outputs
- Proper shell experience on Windows including tab completion (via Clink)

https://github.com/Eugeny/terminus

#ts

​​dbmate: A lightweight, framework-agnostic database migration tool.

Dbmate is a database migration tool, to keep your database schema in sync across multiple developers and your production servers.

It is a standalone command line tool, which can be used with #go, Node.js, Python, Ruby, PHP, or any other language or framework you are using to write database-backed applications. This is especially helpful if you are writing many services in different languages, and want to maintain some sanity with consistent development tools.

Features:

- Supports MySQL, PostgreSQL, and SQLite.
- Uses plain SQL for writing schema migrations.
- Migrations are timestamp-versioned, to avoid version number conflicts with multiple developers.
- Migrations are run atomically inside a transaction.
- Supports creating and dropping databases (handy in development or test).
- Supports saving a schema.sql file to easily diff schema changes in git.
- Database connection URL is definied using an environment variable or specified on the command line.
- Built-in support for reading environment variables from your .env file.
- Easy to distribute, single self-contained binary.

https://github.com/amacneil/dbmate

​​This is choose, a human-friendly and fast alternative to cut and (sometimes) awk written in #rust

Features:
- terse field selection syntax similar to Python's list slices
- negative indexing from end of line
- optional start/end index
- zero-indexed
- reverse ranges
- slightly faster than cut for sufficiently long inputs, much faster than awk
- regular expression field separators using Rust's regex syntax

https://github.com/theryangeary/choose

​​Store your #js configs in one place and share between projects without any pain.

With sharec you can share and management configuration across projects, keep your code up to date and start new projects in one command.

https://github.com/lamartire/sharec

​​A data-first #rust-native UI design toolkit.

Its main goal is to offer a polished user experience. There are many factors to this goal, including performance, a rich palette of interactions (hence a widget library to support them), and playing well with the native platform.

https://github.com/xi-editor/druid

It basically turns this code https://github.com/xi-editor/druid/blob/master/druid/examples/calc.rs into this layout:

​​Nicene is a collection of extra Credo checks for linting #elixir code.

https://github.com/sketch-hq/nicene

​​Stop pasting company secrets into random websites!

It doesn't take a lot of text to tell you what Boop is. But here is a substantial amount of text anyway. It's a place for you to paste plain text and transform it if need be. It's what some of you use TextEdit, or maybe Notes, or maybe a blank unsaved .html file because that's what your editor defaults to when pressing ⌘+N and it's easier to do that than pick the proper file type, right? It's not like you needed syntax highlighting anyway.

Feature:
- Bring your own scripts
- Native AF
- Powered by Javascript
- Free and open source

https://github.com/IvanMathy/Boop

#swift

​​Newt DB, the amphibious database.

- In #python: enjoy the ease of working with your data as ordinary objects in memory.
- Data are moved in and out of memory as needed, so databases can be as large as needed.
- In Postgres: index and search your data using PostgreSQL, from within your application and externally.
- Within your application, search results may be returned as application objects, or as data, depending on your needs.
- Transactional and built on mature technology for reliability.

http://www.newtdb.org/en/latest/

​​Layer Cake is a graphics framework for #svelte.

It uses the measurements of your target div and your data extents to create scales that stay synced on layout changes. Use these scales to organize multiple, mostly-reusable Svelte components, whether they be SVG, HTML, Canvas or WebGL. Since they all share the same coordinate space, you can build your graphic one layer at a time.

https://layercake.graphics/

#js

​​Build reactive applications with the #ruby on Rails tooling you already know and love.

You just discovered an exciting new way to build modern, reactive, real-time apps with Ruby on Rails. StimulusReflex eliminates the complexity imposed by full-stack frontend frameworks. And, it's fast.

Inspired by #elixir's LiveView feature.

https://github.com/hopsoft/stimulus_reflex

Personal opinion: one can better use Elixir and Phoenix if LiveView is required.

​​#haskell STatic ANalyser

Stan is a command-line tool for analysing Haskell projects and outputting discovered vulnerabilities in a helpful way with possible solutions for detected problems. Stan is searching for not only performance or error-prone code pieces, but it also can help with establishing and applying best-practices from the whole Haskell ecosystem.

Although Haskell is a statically typed language, not all properties can be encoded in types. Even though GHC is quite a powerful compiler, it tries to be library-agnostic and provide only language-specific suggestions, while Stan uses the knowledge about the current state of the ecosystem and commonly used libraries.

You will find Stan helpful if you enjoy writing in Haskell, but want more guarantees from your code, not provided by the Haskell type system or GHC.

Stan is a configurable CLI tool. Besides the main feature of analysing Haskell projects statically, Stan has a list of features that make it unique, easy to use and flexible to configure:

- Pretty analysis results, including both HTML and terminal reports
- Suggestions and possible solutions for fixing the existing problems
- Analysing not only Haskell source code, but also information from the .cabal files
- Flexible runtime configuration via TOML and CLI

https://github.com/kowainik/stan

​​One more cross-platform GUI library for #rust, but this one is inspired by #elm

Features:
- Simple, easy-to-use, batteries-included API
- Type-safe, reactive programming model
- Cross-platform support (Windows, macOS, Linux, and the Web)
- Responsive layout
- Built-in widgets (including text inputs, scrollables, and more!)
- Custom widget support (create your own!)
- Debug overlay with performance metrics
- First-class support for async actions (use futures!)
- Modular ecosystem split into reusable parts

https://github.com/hecrj/iced

​​Zig is a general-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.

Features:
- Small, simple language
- Performance and Safety: Choose Two
- Zig competes with C instead of depending on it
- Order independent top level declarations
- Optional type instead of null pointers
- Manual memory management
- A fresh take on error handling
- Compile-time reflection and compile-time code execution
- Agnostic of blocking vs async I/O. Zig avoids function colors

https://ziglang.org/

​​A pure functional language for type-level programming in #rust

At its core, Tyrade supports recursive enum types (kinds, technically) and pure recursive functions.

https://github.com/willcrichton/tyrade

Tyrade is a proof-of-concept language showing how Rust traits enable a general purpose type-level programming model. Its goal is to show that type-level programming is possible for useful tasks (not writing Turing machines), and programs can be written in a reasonable way. Here's what the language looks like:

​​Helpful #elixir assertions for ExUnit

There are three things this library offers:

- Concise, expressive assertions for common types of tests
- Flexibility through composition
- Exceptional error messages

https://github.com/devonestes/assertions

​​Terminal disk space navigator written in #rust

Given a path on your hard-drive (which could also be the root path, eg. /). diskonaut scans it and maps it to memory so that you could explore its contents (even while still scanning!).

Once completed, you can navigate through subfolders, getting a visual treemap representation of what's taking up your disk space. You can even delete files or folders and diskonaut will track how much space you've freed up in this session.

https://github.com/imsnif/diskonaut

​​Blazing fast linter for #js and #ts written in #rust

This crate powers deno lint, but is not #deno specific and can be used to write linters for Node as well.

https://github.com/denoland/deno_lint

Blazing fast, see comparison with ESLint:

A Terraform module for hosting your own runner for CI/CD on Digital Ocean to run jobs in your GitHub Actions workflows.

Doact is a Terraform module to automate the deployment and hosting process of your own runners on Digital Ocean cloud to run jobs in your GitHub Actions workflows. It makes it easy to automate all your software workflows, now with world-class CI/CD. Build, test, and deploy your code right from GitHub.

Doact sets up a self-hosted runner on the cloud. Self-hosted runners offer more control of hardware, operating system, and software tools than GitHub-hosted runners provide. With self-hosted runners, you can choose to create a custom hardware configuration with more processing power or memory to run larger jobs, install software available on your local network, and choose an operating system not offered by GitHub-hosted runners.

https://github.com/itsksaurabh/doact

#devops #hcl

​​Today I want to talk about our #django template: https://github.com/wemake-services/wemake-django-template

It is the strictest and the most advanced django project template there is.
Features:

- Always up-to-date with the help of dependabot
- Supports latest python3.7+
- poetry for managing dependencies
- mypy and django-stubs for static typing
- pytest and hypothesis for unit tests
- flake8 and wemake-python-styleguide for linting
- docker for development, testing, and production
- sphinx for documentation
- Gitlab CI with full build, test, and deploy pipeline configured by default
- Caddy with https and http/2 turned on by default
- Great docs

And many more! Featured products built with it:

- Backend for https://apps.apple.com/app/apple-store/id1506209462

My close friend made an app that helps you find new cool and interesting facts every day. No ads, 100% free. They parse multiple sources to get just the pure content without any noise.

- Internal services for https://github.com/roskomsvoboda a company who tracks different law-related incidents in the Russian internet

- And more than 590 public projects on github: https://github.com/search?q=wemake-django-template&type=Code

- Our own private projects for the largest Russian corporations
- Are you using it too? Drop me a line privately or add your company in this list: https://github.com/wemake-services/wemake-django-template/wiki/Who-is-using-this-template

Totally worth it! #python

Toml sorting library. Simple autoformatter and linter.

Features:

- Sort tables and Arrays of Tables (AoT)
- Option to sort non-tables / non-AoT's, or not
- Preserve inline comments
- Option to preserve top-level document comments, or not
- Standardize whitespace and indentation

https://github.com/pappasam/toml-sort

#python

> The only people entitled to say how open source 'ought' to work are people who run projects, and the scope of their entitlement extends only to their own projects.

> Just because someone open sources something does not imply they owe the world a change in their status, focus and effort, e.g. from inventor to community manager.

A very good piece from Rich Hickey (#clojure author) about how open-source really works vs how users of open-source think it works.

#rant