Opensource Findings
4.81K subscribers
2 photos
716 links
Links and concise reviews on open-source tools, news, and talks about language-design, trends and fundamentals. Write-only.

If you like this project, you can sponsor it directly: https://github.com/sponsors/wemake-services
Download Telegram
to view and join the conversation
​​Flowistry is a VSCode extension that helps you understand #rust programs with program analysis.

Flowistry uses dataflow analysis and pointer analysis to analyze Rust programs at a deeper level than just types can offer (e.g. as you can already find in rust-analyzer).

Flowistry has five commands:
- Flowistry: Backward Highlight: given a selected variable, this command highlights the backward slice of the variable.
- Flowistry: Backward Select: same as above, but this puts the slice in your selection rather than highlighting it.
- Flowistry: Forward Highlight and Flowistry: Forward Select: same as above, but for forward slices than backward slices.
- Flowistry: Effects: given your cursor is within a particular function, this command opens the effects panel for that function.

https://github.com/willcrichton/flowistry
​​Resource monitor that shows usage and stats for processor, memory, disks, network and processes.

C++ version and continuation of bashtop and bpytop.

Features:
- Easy to use, with a game inspired menu system.
- Full mouse support, all buttons with a highlighted key is clickable and mouse scroll works in process list and menu boxes.
- Fast and responsive UI with UP, DOWN keys process selection.
- Function for showing detailed stats for selected process.
- Ability to filter processes.
- Easy switching between sorting options.
- Tree view of processes.
- Send any signal to selected process.
- UI menu for changing all config file options.
- Auto scaling graph for network usage.
- Shows IO activity and speeds for disks
- Battery meter
- Selectable symbols for the graphs
- Custom presets

https://github.com/aristocratos/btop
​​Seed is a #rust front-end framework for creating fast and reliable web apps with an Elm-like architecture.

Seed allows you to develop the front-end with all the benefits of Rust, meaning speed, safety, and too many more things to count.

The Seed templating system uses a macro syntax that makes Rustaceans feel right at home. This means linting, formatting, and commenting will work, and it's all in Rust. This is opposed to a JSX-like syntax that relies on IDE extensions to improve the developer experience.

Seed has a batteries-included approach. This means less time writing boilerplate and less time installing dependencies.

Features
- completely written in Rust, including the templating system (e.g. div! macro).
- built-in state management that is based on the Elm architecture.
- a batteries-included approach with a focus on developer experience.
- clear and extensive documentation for Rust beginners and pros alike.
- WebAssembly.

https://github.com/seed-rs/seed
​​Astro is a fresh but familiar approach to building websites. Astro combines decades of proven performance best practices with the DX improvements of the component-oriented era. Use your favorite JavaScript framework and automatically ship the bare-minimum amount of JavaScriptβ€”by default.

Most of the JS based JAMStack solutions you know do let you produce optimized, pre-generated HTML files, but as they're usually based on a UI framework, there's a core JS Framework runtime - React for Gatsby, Vue for Gridsome, Angular for Scully, that always ships! It's part of the core experience and is expected to be always needed. Even if you have pages that might not need any interactivity or behavioral code, the runtime gets downloaded and interpreted. It's a precious time wasted, on a non-essential job, from a static page perspective.

So, why do we prefer a #js based SSG solution in the first place?

- Mostly probably because of one of the following reasons -
- Hand-crafting is hard
- Interactivity is almost always required (or we think it is)
- Familiarity with a UI Framework is a top priority
- A familiar tooling, DX, quick/instant feedback loop go a long way, in making tech X a better choice than tech Y
- A rich ecosystem, CMS integrations(like Gatsby) greatly simplify the content authoring pipeline
- The JS/Non-JS tools you knew are wickedly fast, but only produce static HTML (Eleventy, Hugo, etc.) by default. You manage browser-side behaviour the conventional way.

Wouldn't it be good if you can still build SSG sites, without giving up on many of the above benefits(except the ecosystem probably for now) - interactivity, tooling, familiar UI framework, DX, while being more mindful towards the site, and every page served?. No/Less JS by default, and all the client-side JS, loaded precisely when necessary - with the framework itself exposing constructs to orchestrate the JS load and initialization behavior in a fine-tuned way.

If you like how this sounds, Astro is for you!

https://github.com/snowpackjs/astro
​​cheat allows you to create and view interactive cheatsheets on the command-line. It was designed to help remind unix system administrators of options for commands that they use frequently, but not frequently enough to remember.

https://github.com/cheat/cheat

#go #shell
⚑️Breaking news!

PostgreSQL 14 Released!

PostgreSQL 14 brings a variety of features that help developers and administrators deploy their data-backed applications. PostgreSQL continues to add innovations on complex data types, including more convenient access for JSON and support for noncontiguous ranges of data. This latest release adds to PostgreSQL's trend on improving high performance and distributed data workloads, with advances in connection concurrency, high-write workloads, query parallelism and logical replication.

Features:
- JSON Conveniences and Multiranges: SELECT ('{ "postgres": { "release": 14 }}'::jsonb)['postgres']['release']; now works.
- Performance Improvements for Heavy Workloads
- Enhancements for Distributed Workloads
- Administration and Observability
- SQL Performance, Conformance, and Convenience

https://www.postgresql.org/about/news/postgresql-14-released-2318/
​​Interactive Redis: A Terminal Client for Redis with AutoCompletion and Syntax Highlighting.

IRedis is a terminal client for redis with auto-completion and syntax highlighting. IRedis lets you type Redis commands smoothly, and displays results in a user-friendly format.

IRedis is an alternative for redis-cli. In most cases, IRedis behaves exactly the same as redis-cli. Besides, it is safer to use IRedis on production servers than redis-cli: IRedis will prevent accidentally running dangerous commands, like KEYS *

Has many other awesome features!

https://github.com/laixintao/iredis

#python
⏲ Periodic reminder.

You can support this project (and all other open-source projects I am working on):
- Monetarily on GitHub Sponsors: https://github.com/sponsors/wemake-services
- Morally by following me on GitHub: https://github.com/sobolevn

This helps me to find and post quality content here and stay ad-free (sorry, crypto startups, not today).
⚑️ Breaking news!

Python3.10 was released several hours ago (not so breaking news, right?). One of the main new features is pattern matching.

Today, I am releasing dry-python/[email protected] with full pattern matching support. Here's an example of how you can use it together with Result type:

from returns.result import Failure, Success, safe

@safe
def div(first_number: int, second_number: int) -> int:
return first_number // second_number

match div(1, 0):
# Matches if the result stored inside `Success` is `10`
case Success(10):
print('Result is "10"')

# Matches any `Success` instance and binds its value to the `value` variable
case Success(value):
print('Result is "{0}"'.format(value))

# Matches if the result stored inside `Failure` is `ZeroDivisionError`
case Failure(ZeroDivisionError):
print('"ZeroDivisionError" was raised')

# Matches any `Failure` instance
case Failure(_):
print('The division was a failure')


Cool, isn't it? Today Python made one more giant step for better functional programming support. And no doubt, that dry-python is the first one to officially support it.

Check out our:
- Docs: https://returns.readthedocs.io/en/latest/pages/result.html#pattern-matching
- Release notes: https://github.com/dry-python/returns/releases/tag/0.17.0
- Python3.10 release notes: https://docs.python.org/3.10/whatsnew/3.10.html

Soon we will be adding pattern matching support for mypy as well. So, it would be type checked correctly.

Big day for #python!
​​Prevent Kubernetes misconfigurations from reaching production (again 😀 )! Datree is a CLI tool to ensure K8s manifests and Helm charts follow best practices as well as your organization’s policies.

It’s far more effective than manual processes, such as sending an email to a slew of developers, begging them to set various limits, which likely falls on deaf ears because developers are already overwhelmed.

The CLI integration provides a policy enforcement solution for Kubernetes to run automatic checks on every code change for rule violations and misconfigurations. When rule violations are found, Datree produces an alert which guides the developer to fix the issue inside the CI process β€” or even earlier as a pre-commit hook β€” while explaining the reason behind the rule.

Right now, there are 30 battle-tested rules for you to choose from.

https://github.com/datreeio/datree

#k8s #devops #go
​​kbar is a simple plug-n-play React component to add a fast, portable, and extensible command+k interface to your site.

Command+k interfaces are used to create a web experience where any type of action users would be able to do via clicking can be done through a command menu.

With macOS's Spotlight and Linear's command+k experience in mind, kbar aims to be a simple abstraction to add a fast and extensible command+k menu to your site.

Features:
- Built in animations and fully customizable components
- Keyboard navigation support; e.g. ctrl n / ctrl p for the navigation wizards
- Keyboard shortcuts support for registering keystrokes to specific actions; e.g. hit t for Twitter
- Nested actions enable creation of rich navigation experiences; e.g. hit backspace to navigate to the previous action
- A simple data structure which enables anyone to easily build their own custom components

https://github.com/timc1/kbar

#react #js #ts
​​Open-source platform that brings an Airtable experience for your database and allows you to build any automation or cloud functions for your product.

Manage Firestore data in a spreadsheet-like UI, write Cloud Functions effortlessly in the browser, and connect to your favorite third party platforms such as SendGrid, Twilio, Algolia, Slack and more.

Features:
- Powerful spreadsheet interface for Firestore
- Supercharge your database with cloud functions and ready made extension: use APIs or NPM modules
- Rich and flexible data fields: more that 30 different types
- Collaborate with your team

https://github.com/rowyio/rowy

#ts
​​The backlash to modern front end development is gaining steam, with good reason: single-page apps have ruined the web. Can we rescue it without going backwards? In this talk, Rich Harris presents a way to do just that. Rich Harris is a graphics editor at the New York Times, where he builds JavaScript apps to help explain the news. He is also the creator of Rollup, the JavaScript module bundler, and Svelte, the front end framework.

What’s wrong with Single-Page apps? There are a lot of critiques. A non-exhaustive list of terrible things about single-page apps include:
You’ll need a bloated JavaScript framework and performance will suffer
It comes with complex tooling and is less resilient, since it won’t work without JavaScript
It will be buggy and accessibility issues

JavaScript failing is a fact of life. So what’s a developer to do? SPAs solve problems to the traditional approach, but are still problematic. Rich presents a new framework for thinking about how we can get the best of both the MPA and SPA worlds: transitional apps.

What’s a transitional app? Transitional apps samples elements from both traditional and modern architecture. The term is borrowed from interior design’s framing of β€œtransitional design.” Transitional apps are, like multi-page apps, server-side rendered for fast initial loads, resilient since they work without JS by default, and provide a consistent experience with accessibility features built in. But like a single-page application, they also have a single codebase, fast navigation, persistent elements, and client-side state management.

Learn more about transitional apps, and how to get the best of both worlds in Rich’s talk.

#js #svelte
​​SQLFluff is a dialect-flexible and configurable SQL linter. Designed with ELT applications in mind, SQLFluff also works with Jinja templating and dbt. SQLFluff will auto-fix most linting errors, allowing you to focus your time on what matters.

Although SQL is reasonably consistent in its implementations, there are several different dialects available with variations of syntax and grammar. SQLFluff currently supports the following SQL dialects (though perhaps not in full):
- ANSI SQL - this is the base version and on occasion may not strictly follow the ANSI/ISO SQL definition
- BigQuery
- Exasol
- Hive
- MySQL
- PostgreSQL (aka Postgres)
- Snowflake
- SQLite
- Teradata
- Transact-SQL (aka T-SQL)

https://github.com/sqlfluff/sqlfluff

#python
​​A #rust graphical tool to visualize binary data.

It colorizes bytes according to different rules and renders them as pixels in a rectangular grid. This allows users to identify interesting parts in large files and to reveal image-like regions.

The program allows you to control various parameters like the offset into the file, the stride, the width of the rectangular grid as well as the way in which (groups of) bytes are colorized.

https://github.com/sharkdp/binocle
​​Kubegres is a #k8s operator allowing to deploy one or many clusters of postgresql instances and manage databases replication, failover and backup.

Features:
- It can manage one or many clusters of Postgres instances. Each cluster of Postgres instances is created using a YAML of "kind: Kubegres". Each cluster is self-contained and is identified by its unique name and namespace.
- It creates a cluster of PostgreSql servers with Streaming Replication enabled: it creates a Primary PostgreSql pod and a number of Replica PostgreSql pods and replicates primary's database in real-time to Replica pods.
- It manages fail-over: if a Primary PostgreSql crashes, it automatically promotes a Replica PostgreSql as a Primary.
- It has a data backup option allowing to dump PostgreSql data regularly in a given volume.
- It provides a very simple YAML with properties specialised for PostgreSql.

https://github.com/reactive-tech/kubegres

#go #devops
​​KubeLinter is a static analysis tool that checks Kubernetes YAML files and Helm charts to ensure the applications represented in them adhere to best practices.

KubeLinter runs sensible default checks, designed to give you useful information about your Kubernetes YAML files and Helm charts. This is to help teams check early and often for security misconfigurations and DevOps best practices. Some common examples of these include running containers as a non-root user, enforcing least privilege, and storing sensitive information only in secrets.

KubeLinter is configurable, so you can enable and disable checks, as well as create your own custom checks, depending on the policies you want to follow within your organization.

When a lint check fails, KubeLinter reports recommendations for how to resolve any potential issues and returns a non-zero exit code.

https://github.com/stackrox/kube-linter

#go #k8s #devops
​​High-performance load testing tool, written in #go.

Features:
- Protocol Agnostic - Currently supporting HTTP, HTTPS, HTTP/2. Other protocols are on the way.
- Scenario-Based - Create your flow in a JSON file. Without a line of code!
- Different Load Types - Test your system's limits across different load types.

https://github.com/ddosify/ddosify