Находки в опенсорсе

​​Generate color scheme from photos and use them in #css.

Upload your image and our tool will generate the right palettes for you.
Best with TailwindCSS.

https://palette-generators.vercel.app/

#html #css

Scan git repos for secrets using regex and entropy 🔑

Gitleaks is a SAST tool for detecting hardcoded secrets like passwords, api keys, and tokens in git repos. Gitleaks aims to be the easy-to-use, all-in-one solution for finding secrets, past or present, in your code.

Features:
- Scans for commited secrets
- Scans for uncommitted secrets as part of shifting security left
- Available Github Action
- Gitlab and Github API support which allows scans of whole organizations, users, and pull/merge requests
- Custom rules via toml configuration
- High performance using #go and go-git
- JSON and CSV reporting
- Private repo scans using key or password based authentication

https://github.com/zricethezav/gitleaks

​​handcalcs: #python calculations in Jupyter, as though you wrote them by hand.

handcalcs is a library to render Python calculation code automatically in Latex, but in a manner that mimics how one might format their calculation if it were written with a pencil: write the symbolic formula, followed by numeric substitutions, and then the result.

Because handcalcs shows the numeric substitution, the calculations become significantly easier to check and verify by hand.

https://github.com/connorferster/handcalcs

Collection of #ts type challenges with online judge.

High quality types can help with projects' maintainability and avoiding bugs. There are a bunch of awesome type utilities libraries may boosting your works on types, like ts-toolbelt, utility-types, SimplyTyped, etc. We took a lot of inspiration from.

This project is aim to make you better understand how the type system works, writing your own utilities, or just having fun with the challenges. We are also trying to form a community that you can ask and answer questions you have faced in realworld - they may become part the challenges as well!

Challenges start with very simple ones and go to complex tasks.

https://github.com/type-challenges/type-challenges

​​Interactive prompts made simple. Build a prompt like stacking blocks.

Customize prompts in your #python CLI tool. Extensive support for formatting, colors, background colors, styling, and etc. Also supports emojis!

https://github.com/bchao1/bullet

​​DearPyGui: A GPU Accelerated #python GUI Framework

Dear PyGui is a simple to use (but powerful) Python GUI framework. DearPyGui provides a wrapping of DearImGui that provides a hybrid of a traditional retained mode GUI and Dear ImGui's immediate mode paradigm.

Dear PyGui is fundamentally different than other Python GUI frameworks. Under the hood, DearPyGui uses the immediate mode paradigm allowing for extremely dynamic interfaces. DearPyGui does not use native widgets, but instead draws the widgets using your computer's GPU. DearPyGui is currently supported on the following platforms: macos, linux, windows.

https://github.com/hoffstadt/DearPyGui

Written in #cpp

​​Litmus helps Kubernetes SREs and developers practice chaos engineering in a Kubernetes native way.

Litmus is a toolset to do cloud-native chaos engineering. Litmus provides tools to orchestrate chaos on #k8s to help SREs find weaknesses in their deployments. SREs use Litmus to run chaos experiments initially in the staging environment and eventually in production to find bugs, vulnerabilities. Fixing the weaknesses leads to increased resilience of the system.

Litmus takes a cloud-native approach to create, manage and monitor chaos. Chaos is orchestrated using the following Kubernetes Custom Resource Definitions (CRDs):
- ChaosEngine: A resource to link a Kubernetes application or Kubernetes node to a ChaosExperiment. ChaosEngine is watched by Litmus' Chaos-Operator which then invokes Chaos-Experiments
- ChaosExperiment: A resource to group the configuration parameters of a chaos experiment. ChaosExperiment CRs are created by the operator when experiments are invoked by ChaosEngine.
- ChaosResult: A resource to hold the results of a chaos-experiment. The Chaos-exporter reads the results and exports the metrics into a configured Prometheus server.

Chaos experiments are hosted on hub.litmuschaos.io. It is a central hub where the application developers or vendors share their chaos experiments so that their users can use them to increase the resilience of the applications in production.

https://github.com/litmuschaos/litmus

#docker #devops #ts #go

​​The modern #css in #js styling library: near-zero runtime, server-side rendering, multi-variant support, and a best-in-class developer experience.

Features:
- Performant: Stitches avoids unnecessary prop interpolations at runtime, making it significantly more performant than other styling libraries.
- Lightweight: Both @stitches/core and @stitches/react libraries combined weigh in at around 6.5kb gzipped.
- Server-Side Rendering: Stitches supports cross-browser server-side rendering, even for responsive styles and variants.
- Variants: Variants are a first-class citizen of Stitches, so you can design composable component APIs which are typed automatically.
- Theming: Define multiple themes with CSS variables, then expose them to any part of your app.
- Developer experience: With a fully-typed API, token-aware properties, and custom utils, Stitches provides a fun and intuitive DX.
- Critical Path CSS: Stitches only injects the styles which are actually used, so your users don't download unnecessary CSS.
- Specificity. No more specificity issues due to the atomic output. Even extended components (via the as prop) won't contain duplicate CSS properties.
- Polymorphic as prop: Included in Components returned from the styled function.
- Easy overrides: Stitches provides a css prop, which allows style overrides to be applied in the consumption layer.

https://stitches.dev/

​​New functional language focused on good developer experience.

A user from Quora asked:

> Why isn't functional programming that popular even though it's so beneficial?

One of the top answer says:

> The user experiences of functional programming languages sucks.

No doubt, this is a sad but true story for most functional programming (FP) languages. I personally thought that FP languages like Haskell offers a very unified and pure programming concepts (i.e. everything are functions, and functions and compose well, etc). However, Haskell syntax is a mess (take a look at the grammar), there are a lot of edge cases (e.g. weird indentation rules). Of course this problem is not only limited to Haskell, similar problems can also be found in other FP languages like Erlang, F#, OCaml etc. Thus, I believe that these are also the primal reason that most people felt FP languages are hard.

> I wanted more people to adopt FP.

That is what I wished for, therefore I'm motivated to create a language called Keli (named after my girlfriend), which hopes to an FP language with good user experience (UX).

In the following section, I will describe the UX problems of FP languages and how they are solved in other programming languages.

https://keli-language.gitbook.io/doc/

Written in #haskell

Howdy provides Windows Hello™ style authentication for Linux. Use your built-in IR emitters and camera in combination with facial recognition to prove who you are.

Using the central authentication system (PAM), this works everywhere you would otherwise need your password: Login, lock screen, sudo, su, etc.

Howdy is currently available and packaged for Debian/Ubuntu, Arch Linux, Fedora and openSUSE. If you’re interested in packaging Howdy for your distro, don’t hesitate to open an issue.

https://github.com/boltgolt/howdy

#python

​​Futuristic Sci-Fi and Cyberpunk graphical user interface framework for web apps

Arwes is a web framework to build user interfaces for web applications based on futuristic science fiction and cyberpunk styles, animations, and sound effects. The concepts behind are opinionated and try to inspire advanced space technology and alien influence. It is built on top of #react, JSS, Anime, and Howler.

https://github.com/arwes/arwes

#js #css #html

​​Gitpod is an open-source #k8s application providing fully-baked, collaborative development environments in your browser - powered by VS Code.

Tightly integrated with GitLab, GitHub, and Bitbucket, Gitpod automatically and continuously prebuilds dev environments for all your branches. As a result, team members can instantly start coding with fresh, ephemeral and fully-compiled dev environments - no matter if you are building a new feature, want to fix a bug or do a code review.

Features:
- Dev environment as code
- Prebuilt dev environments - automatically prepare environments on every Git push
- Professional developer experience in a browser tab (VS Code Extensions, full Linux terminals)
- Integrated Docker build
- GitLab, GitHub, and Bitbucket integration
- Integrated code reviews
- Snapshots - Snapshot any state of your dev environment and let others create clones
- Collaboration - Invite team members to your environments
- Gitpod CLI to automate your experience

https://github.com/gitpod-io/gitpod

#ts #go #devops

​​Fully automated python fuzzer built to test if code actually is production ready in seconds.

#python allows you to do pretty much whatever you want. This is a good thing for the most part however it creates the opportunity for unexpected events to occur. One of battletested's strongest assets is its ability to show you all of those possibilities so there are no surprises. In a way, it surpasses learning about the behavior of code by reading docstrings because all behaviors are recorded during a fuzz.

https://github.com/CodyKochmann/battle_tested

For example, the image below shows just how much is brought to light about a piece of code without needing to read a textbook's worth of documentation (which almost never exists) just to learn about the full behavior of a single function.

​​High-confidence browser testing.

This is like QuickCheck, but for E2E tests.

Features:

- Reduce testing effort: Generate thousands of test cases instead of writing them manually. Lower the maintenance burden of your browser testing by writing concise specifications with looser coupling to your implementation.
- Find complex bugs: Quickstrom simulates complex and unexpected user behavior using generative random testing. When the specification is violated, Quickstrom finds a minimal failing example.
- Understand your system: Focus on specifying your system, not on writing test cases. A specification lets you run Quickstrom, but can also increase your team's understanding of the system.
- Adopt gradually: Quickstrom works with any web application that renders DOM elements. Start simple, and gradually refine your specification to increase coverage and confidence.


https://github.com/quickstrom/quickstrom

#haskell

​​Simple tool to evolve PostgreSQL schema easily. PostgreSQL migrations made easy!

PGmigrate has the following key-features:
- Transactional and nontransactional migrations: you can enjoy whole power of PostgreSQL DDL
- Callbacks: you can run some DDL on specific steps of migration process (e.g. drop some code before executing migrations, and create it back after migrations were applied)
- Online migrations: you can execute series of transactional migrations and callbacks in a single transaction (so, if something goes wrong simple ROLLBACK will bring you in consistent state)

https://github.com/yandex/pgmigrate

#python

​​A terminal-based presentation tool with colors and effects.

Present your stuff without leaving your terminal!

Personal opinion: this might be a really cool thing for live-coding sessions for people using vim/emacs. The context switch would be minimal.

https://github.com/vinayak-mehta/present

#python

Ever wanted to work with async functions in #python the same way you do in #js?

Me neither! But, today I had a use-case for it to try. Features:
- Ultra-performant Promise implementation in Python
- It is a super set of Promises/A+ designed to have readable code
- Familiar API
- Works with async / await
- Has partial typing support
- Works on multiple python versions

https://github.com/syrusakbary/promise

​​A tool to help migrate #js code quickly and conveniently to #ts.

ts-migrate is intended to accelerate the TypeScript migration process. The resulting code will pass the build, but a followup is required to improve type safety. There will be lots of // @ts-expect-error, and any that will need to be fixed over time. In general, it is a lot nicer than starting from scratch.

ts-migrate is designed as a set of plugins so that it can be pretty customizable for different use-cases. Potentially, more plugins can be added for addressing things like improvements of type quality or libraries-related things (like prop-types in React).

https://github.com/airbnb/ts-migrate

We have examples of the three categories of plugins:

- example-plugin-jscodeshift simply reverses the names of all identifiers.
- example-plugin-text will add a console.log before each return statement.
- example-plugin-ts is a simple TypeScript AST-based plugin, which shows how we can add simple types to the JavaScript code with the usage of TypeScript compiler API.

Produces:

Great channel from one of my friends 👍

Python libraries to make your code readable, reliable and maintainable

An experienced programmer understands perfectly well that a developer spends most of his time reading code and therefore treats the process of writing code with the deepest trepidation (and sometimes with fanaticism). To write quality and maintainable code, you need to take the time to write tests and integrate QA tools. There is a whole technique aimed at test-driven development (TDD) and I will not devote this article to the topic of testing as such. Tests are absolutely necessary and there is nothing to discuss. In this article, we are going to talk about tools that help you write quality Python code.

#python, #testing, #libraries, #blog, #QA, #isaak