​​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:

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 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

​​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

​​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

​​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.

​​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

​​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

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

​​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

​​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/

​​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

​​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

​​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

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

​​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

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

​​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

​​Effector: The state manager.

Effector is an effective multi-store state manager for #js apps (#react/React Native/#vue/Node.js), that allows you to manage data in complex applications without the risk of inflating the monolithic central store, with clear control flow, good type support and high capacity API. Effector supports both #ts and Flow type annotations out of the box.

Effector follows five basic principles:
- Application stores should be as light as possible - the idea of adding a store for specific needs should not be frightening or damaging to the developer.
- Application stores should be freely combined - data that the application needs can be statically distributed, showing how it will be converted in runtime.
- Autonomy from controversial concepts - no decorators, no need to use classes or proxies - this is not required to control the state of the application and therefore the api library uses only functions and plain js objects
- Predictability and clarity of API - a small number of basic principles are reused in different cases, reducing the user's workload and increasing recognition. For example, if you know how .watch works for events, you already know how .watch works for stores.
- The application is built from simple elements - space and way to take any required business logic out of the view, maximizing the simplicity of the components.

https://github.com/zerobias/effector

​​Chrome plugin to search the information available on a webpage using natural language instead of an exact string match.

Search the information available on a webpage using natural language instead of an exact string match. Uses MobileBERT fine-tuned on SQuAD via TensorFlowJS to search for answers and mark relevant elements on the web page.

https://github.com/model-zoo/shift-ctrl-f

​​Beautiful colour gradients for design and code.

uiGradients is a community contributed collection of beautiful multi-color #css gradients. This is an effort to give back to the community, by the community. Hopefully this will help you draw inspiration and serve as a resource for picking gradients for your own projects.

https://uigradients.com