​​Numl (nude elements) unity of design and code.

Your code is your design system.
Markup language to create modern high-quality interfaces with any look.

Features:
- A single language to describe styles and behaviour of your app
- Numl is not bound to the framework and is based on modern web standards, and also uses code generation techniques, which allows you to use the most advanced technologies and practices, as well as update them, updating the design system, rather than rewriting your entire codebase
- Numl can be integrated with vue.js, react, angular, and svelte
- With Numl you will be able to create high-quality web interfaces with the power of a small team of frontend engineers with the middle level of expertise

https://numl.design/

#js #css

​​Homebrew, but with #docker images.

Whalebrew creates aliases for Docker images so you can run them as if they were native commands. It's like Homebrew, but with Docker images.

Docker works well for packaging up development environments, but there are lots of tools that aren't tied to a particular project: awscli for managing your AWS account, ffmpeg for converting video, wget for downloading files, and so on. Whalebrew makes those things work with Docker, too.

https://github.com/whalebrew/whalebrew

#macos #devops

​​Λrrow is a library for Typed Functional Programming in #kotlin.

Arrow aims to provide a lingua franca of interfaces and abstractions across Kotlin libraries. For this, it includes the most popular data types, type classes and abstractions such as Option, Either, IO, Functor, Applicative, Monad to empower users to write pure FP apps and libraries built atop higher order abstractions.

Arrow is a family of different projects, including:

- Arrow Fx is a next-generation Typed FP Effects Library that makes effectful and polymorphic programming first class in Kotlin, and acts as an extension to the Kotlin native suspend system.
- Arrow Optics offers an Optics DSL to compose different Optics while improving ease of use and readability. To avoid boilerplate, Arrow will generate this property-like DSL using @optics annotation.
- Λrrow Meta is a meta-programming library that cooperates with the Kotlin compiler in all its phases, bringing its full power to the community.

https://arrow-kt.io

​​Unsynchronize asyncio by using an ambient event loop in a separate #python thread.

- Mark all async functions with @unsync. May also mark regular functions to execute in a separate thread.
- - All @unsync functions, async or not, return an Unfuture

- All Futures must be Unfutures which includes the result of an @unsync function call, or wrapping Unfuture(asyncio.Future) or Unfuture(concurrent.Future). Unfuture combines the behavior of asyncio.Future and concurrent.Future:
- - Unfuture.setvalue is threadsafe unlike asyncio.Future
- - Unfuture instances can be awaited, even if made from concurrent.Future
- - Unfuture.result() is a blocking operation except in unsync.loop/unsync.thread where it behaves like asyncio.Future.result and will throw an exception if the future is not done

- Functions will execute in different contexts:
- -@unsync async functions will execute in an event loop in unsync.thread
- - @unsync regular functions will execute in unsync.threadexecutor, a ThreadPoolExecutor
- - @unsync(cpubound=True) regular functions will execute in unsync.processexecutor, a ProcessPoolExecutor

https://github.com/alex-sherman/unsync

​​A cross-platform, customizable science fiction terminal emulator with advanced monitoring & touchscreen support.

Heavily inspired from the TRON Legacy movie effects (especially the Board Room sequence), the eDEX-UI project was originally meant to be "DEX-UI with less « art » and more « distributable software »". While keeping a futuristic look and feel, it strives to maintain a certain level of functionality and to be usable in real-life scenarios, with the larger goal of bringing science-fiction UXs to the mainstream.

It might or might not be a joke taken too seriously.

Features:
- Fully featured terminal emulator with tabs, colors, mouse events, and support for curses and curses-like applications.
- Real-time system (CPU, RAM, swap, processes) and network (GeoIP, active connections, transfer rates) monitoring.
- Full support for touch-enabled displays, including an on-screen keyboard.
- Directory viewer that follows the CWD (current working directory) of the terminal.
- Advanced customization using themes, on-screen keyboard layouts, CSS injections.
- Optional sound effects made by a talented sound designer for maximum hollywood hacking vibe.

https://github.com/GitSquared/edex-ui

#js

​​Fundoc - the right way to generate documentation.

A business feature in your project may be implemented in separated files and even in different technologies. Fundoc can merge all descriptions about business features and put in appropriate files.

Fundoc's main goals:
- Allow you to keep all your documentation along with your code. Separating documentation from code makes it harder to support.
- Use same versioning tools for your documentation as for your code. All versions of your documentation should match versions of source code otherwise we can't trust this documentation.
- A documentation generator should allow you to write your doc-fragments in different kinds of files like source code files (Rust, C++, TypeScript, Java, JavaScript, Ruby, Python, etc), specification files (Alloy, TLA+, etc), stylesheet files (CSS, SCSS, QT Stylesheets, etc), configs (JSON, TOML, YAML, etc).

https://github.com/daynin/fundoc

#docops #rust

​​Query #git repositories with SQL. Uses SQLite virtual tables and go-git.

gitqlite is a tool for running SQL queries on git repositories. It implements SQLite virtual tables and uses go-git. It's meant for ad-hoc querying of git repositories on disk through a common interface (SQL), as an alternative to patching together various shell commands.

https://github.com/augmentable-dev/gitqlite

#go

​​mailgo: a new concept of mailto and tel links.

Instead of only triggering the default email or phone apps when selecting a mailto or tel link on your website, “mailgo” provides a modal with more options such as “Open in Gmail”, “Open in Outlook”, etc.

This will extra functionality will be less important on mobile now that Apple is letting us change our default clients in iOS 14 (so that the default app would already be set to Gmail, for example), but you may find it helpful for your users anyhow. 4.96 KB cheap.

https://mailgo.dev/

#js #html

​​Voila turns Jupyter notebooks into standalone web applications.

Unlike the usual HTML converted notebooks, each user connecting to the Voila tornado application gets a dedicated Jupyter kernel which can execute the callbacks to changes in Jupyter interactive widgets.

- By default, Voila disallows execute requests from the front-end, preventing execution of arbitrary code.
- By default, Voila runs with the strip_source option, which strips out the input cells from the rendered notebook.

https://github.com/voila-dashboards/voila

#python

​​Tabler Icons: 558 Fully customizable free SVG icons.

https://tablericons.com

#css #html

​​Flipping how we define typography in #css.

Features:
- It uses font metadata to crop space from text nodes above capital letters and below the baseline.
- It adjusts font-size so that the height of capital letters is a multiple of your grid.

https://seek-oss.github.io/capsize/

#html

​​Jargon from the functional programming world in simple terms!

Have you ever wondered what monads and functors are? This project has answers!
There are examples in #python #js #scala and #rust

You will learn that numbers, strings and lists are monoids, and what morphisms are.

https://github.com/hemanth/functional-programming-jargon

​​#python interpreter written in #rust

CPython is the common implementation of Python. We love C, but we love Rust a little more... that's why we're working on a RustPython, a Python implementation written in Rust. We are doing it for fun, to learn about writing interpreters, and to have a useful, usable and embeddable implementation of Python in Rust.

Goals:
- Full Python-3 environment entirely in Rust (not CPython bindings) with a clean implementation, without compatiblity hacks
- Fast, reliable and secure implementation of Python that can be used with Rust
- It also support WASM out of the box, demo: https://rustpython.github.io/demo/

https://github.com/RustPython/RustPython

Shelly: a programming language for drawing.

Drawing is done by issuing instructions to a turtle, which draws lines and shapes as it moves, using various colors and styles. The code is executing instantly, as you type.

It resonates with me:
1. All Russian schools used Turtles to teach programming. I remember this little guy 🐢
2. I can't draw! With regular tools at least

https://shelly.dev/

​​UVU is an extremely fast and lightweight test runner for Node.js and the browser: Ultimate Velocity, Unleashed

Features:
- Super lightweight
- Extremely performant
- Individually executable test files
- Supports async/await tests
- Supports native ES Modules
- Browser-Compatible
- Familiar API

https://github.com/lukeed/uvu

#js

​​The tiny framework for building hypertext applications.

Features:
- Do more with less—We have minimized the concepts you need to learn to get stuff done. Views, actions, effects, and subscriptions are all pretty easy to get to grips with and work together seamlessly
- Write what, not how—With a declarative API that's easy to read and fun to write, Hyperapp is the best way to build purely functional, feature-rich, browser-based apps in #js
- Smaller than a favicon—1 kB, give or take. Hyperapp is an ultra-lightweight Virtual DOM, highly-optimized diff algorithm, and state management library obsessed with minimalism

https://github.com/jorgebucaran/hyperapp

​​⚡Breaking news!

#svelte now officially supports #ts!

TypeScript support in Svelte has been possible for a long time, but you had to mix a lot of disparate tools together and each project ran independently. Today, nearly all of these tools live under the Svelte organization and are maintained by a set of people who take responsibility over the whole pipeline and have common goals.

When we say that Svelte now supports TypeScript, we mean a few different things:
- You can use TypeScript inside your <script> blocks — just add the lang="ts" attribute
- Components with TypeScript can be type-checked with the svelte-check command
- You get autocompletion hints and type-checking as you're writing components, even in expressions inside markup
- TypeScript files understand the Svelte component API — no more red squiggles when you import a .svelte file into a .ts module

https://svelte.dev/blog/svelte-and-typescript

​​cdk8s is a software development framework for defining Kubernetes applications and reusable abstractions using familiar programming languages and rich object-oriented APIs. cdk8s generates pure Kubernetes YAML - you can use cdk8s to define applications for any Kubernetes cluster running anywhere.

cdk8s apps are programs written in one of the supported programming languages. They are structured as a tree of constructs.

The root of the tree is an App construct. Within an app, users define any number of charts (classes that extend the Chart class). Each chart is synthesized into a separate Kubernetes manifest file. Charts are, in turn, composed of any number of constructs, and eventually from resources, which represent any Kubernetes resource, such as Pod, Service, Deployment, ReplicaSet, etc.

cdk8s apps only define Kubernetes applications, they don't actually apply them to the cluster. When an app is executed, it synthesizes all the charts defined within the app into the dist directory, and then those charts can be applied to any Kubernetes cluster using kubectl apply -f dist/chart.k8s.yaml or a GitOps tool like Flux.

https://github.com/awslabs/cdk8s

#ts #python #devops

​​The Machine Learning Toolkit for Kubernetes

The Kubeflow project is dedicated to making deployments of machine learning (ML) workflows on Kubernetes simple, portable and scalable. Our goal is not to recreate other services, but to provide a straightforward way to deploy best-of-breed open-source systems for ML to diverse infrastructures. Anywhere you are running Kubernetes, you should be able to run Kubeflow.

Features:
- Kubeflow includes services to create and manage interactive Jupyter notebooks.
- Kubeflow provides a custom TensorFlow training job operator that you can use to train your ML model.
- Kubeflow supports a TensorFlow Serving container to export trained TensorFlow models to Kubernetes.
- Kubeflow Pipelines is a comprehensive solution for deploying and managing end-to-end ML workflows.
- Our development plans extend beyond TensorFlow. We're working hard to extend the support of PyTorch, Apache MXNet, MPI, XGBoost, Chainer, and more. We also integrate with Istio and Ambassador for ingress, Nuclio as a fast multi-purpose serverless framework, and Pachyderm for managing your data science pipelines.

https://www.kubeflow.org/

#devops #ds

​​A #rust crate to offer compile-time assistance for working with unsafe code.

Sometimes functions or methods have preconditions that cannot be ensured in the type system and cannot be guarded against at runtime. The most prominent example of functions like that are unsafe functions. When used correctly, unsafe functions are used to "declare the existence of contracts the compiler can't check". These contracts are the preconditions for the function call. Failing to uphold them usually results in a violation of memory safety and undefined behavior.

Currently the most used scheme for dealing with these preconditions on unsafe functions is to mention them in the Safety section of the function's documentation. Programmers using the function then have to check what they have to ensure to call the function correctly. The programmer that uses the function may then leave a comment next to the function, describing why the call is safe (why the preconditions hold).

This approach is even advertised by the compiler (as of 1.44.1) when using an unsafe function outside of an unsafe block.

This library works by allowing programmers to specify preconditions on functions they write in a unified format. Those preconditions are then transformed into an additional function argument. Callers of the function then specify the same preconditions at the call site, along with a reason why they believe the precondition is upheld. If the preconditions don't match or are not specified, the function will have invalid arguments and the code will not compile.

https://github.com/aticu/pre

Introducing Domain-Oriented Microservice Architecture

Recently there has been substantial discussion around the downsides of service oriented architectures and microservice architectures in particular. While only a few years ago, many people readily adopted microservice architectures due to the numerous benefits they provide such as flexibility in the form of independent deployments, clear ownership, improvements in system stability, and better separation of concerns, in recent years people have begun to decry microservices for their tendency to greatly increase complexity, sometimes making even trivial features difficult to build.

As Uber has grown to around 2,200 critical microservices, we experienced these tradeoffs first hand. Over the last two years, Uber has attempted to reduce microservice complexity while still maintaining the benefits of a microservice architecture. With this blog post we hope to introduce our generalized approach to microservice architectures, which we refer to as “Domain-Oriented Microservice Architecture” (DOMA).

While it’s been popular in recent years to criticize microservice architectures because of these downsides, few people have advocated an outright rejection of microservice architectures. The operational benefits are too important, and it seems that there are no, or limited, alternatives. Our goal with DOMA is to provide a way forward for organizations that want to reduce overall system complexity while maintaining the flexibility associated with microservice architectures.

This piece explains DOMA, the concerns that led to the adoption of this architecture for Uber, its benefits for platform and product teams, and, finally, some advice for teams who want to adopt this architecture.

#architecture #ddd