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

fs-err is a drop-in replacement for #rust std::fs that provides more helpful messages on errors. Extra information includes which operations was attmpted and any involved paths.

The error message that Rust gives you isn't very useful: The system cannot find the file specified. (os error 2)

...but if we use fs-err instead, our error contains more actionable information:

 to open file `does not exist.txt`
    caused by: The system cannot find the file specified. (os error 2)

https://github.com/andrewhickman/fs-err

​​Performance analysis toolkit for #csharp

Perfolizer is a collection of useful algorithms for performance analysis. You can use it as a NuGet package or via a command-line tool.

Perfolizer is used as a statistical engine for BenchmarkDotNet (the most popular .NET library for benchmarking).

https://github.com/AndreyAkinshin/perfolizer

Great read about #scala's ZLayer from ZIO.

Nice and very useful concept that can be ported to many other languages.

https://zio.dev/docs/howto/howto_use_layers

​​Napkin is a tool to "write" sequence diagrams effectively as #python code.

https://github.com/pinetr2e/napkin

This code:

def distributed_control(c):
    user = c.object('User')
    order = c.object('Order')
    orderLine = c.object('OrderLine')
    product = c.object('Product')
    customer = c.object('Customer')

    with user:
        with order.calculatePrice():
            with orderLine.calculatePrice():
                product.getPrice('quantity:number')
                with customer.getDiscountedValue(order):
                    order.getBaseValue().ret('value')
                    c.ret('discountedValue')

Will result in:

Turn real code (Github Gist)
into faux code (SVG image)

http://knutsynstad.com/fauxcode/

#js

​​#k8s #devops #go

Local Kubernetes development with no stress.

Tilt helps you develop your microservices locally. Run tilt up to start working on your services in a complete dev environment configured for your team.

Tilt watches your files for edits, automatically builds your container images, and applies any changes to bring your environment up-to-date in real-time. Think docker build && kubectl apply or docker-compose up.

https://github.com/windmilleng/tilt

​​#k8s #devops #go

arkade (ark for short) provides a clean CLI with strongly-typed flags to install charts and apps to your cluster in one command.

Gone are the days of contending with dozens of README files just to get the right version of #helm and to install a chart with sane defaults.

https://github.com/alexellis/arkade

​​#k8s #devops #go

Skaffold is a command line tool that facilitates continuous development for Kubernetes applications. You can iterate on your application source code locally then deploy to local or remote Kubernetes clusters. Skaffold handles the workflow for building, pushing and deploying your application. It also provides building blocks and describe customizations for a CI/CD pipeline.

https://github.com/GoogleContainerTools/skaffold

> You will aquire knowledge on how to build software in a purely functional manner, you will leverage a particular kind of algebraic effects called environmental effects in order to structure your code in a better way enabling you to test each individual component in an isolated way and making your modules reusable and composable.

> We are not cheating, neither using magic tricks! By leveraging functional programming principles we have developed a set of libraries that enrich the fp-ts ecosystem with the functionalities that you may find in a library like ZIO in the Scala ecosystem.

> The latest development in the core TypeScript language allow us to take environment usage even further compared to what ZIO can achieve, namely TypeScript has a very good support for intersection types and this makes environment usage wonderful.

https://arnaldimichael.gitbook.io/matechs-effect/

#ts #scala

> Approachable ideas and best practices to help engineering teams apply the principles of functional programming to high-level design and architecture.

> Many articles on functional programming, or FP, focus on low-level coding practices (such as avoiding side effects) and FP-specific patterns (such as the dreaded monad). They don’t, however, touch on high-level design and architecture. Yet FP principles can be applied at larger scales. In fact, many popular frameworks and architectural styles, from serverless on the backend to Redux/Elm-style frameworks on the frontend, have their roots in functional programming.

> When used appropriately, FP principles can reduce complexity while increasing the testability and maintainability of an application. This is functional architecture.

​​Build complete frontend features, even if your API doesn't exist.

Mirage #js is an API mocking library that lets you build, test and share a complete working #js application without having to rely on any backend services.

https://miragejs.com/

> In recent years, many language ecosystems have developed automatic code formatters to reduce the mental overhead of code readers and therefore to share code more easily. These tools work by ensuring that all code written in the same language looks the same. Some examples of these tools include gofmt for Go or mix format for Elixir. The Erlang community was lacking a tool like this, so we created a rebar3 plugin just to automatically format code.

> In this article we’ll discuss the history of the Erlang parsing and formatting tools, the challenges of developing a formatter and the resulting tool that we created. Learn how you can use it and customize it to your needs.

#erlang

> My honeymoon with the #go language is extremely over.

> This article is going to have a different tone from what I've been posting the past year - it's a proper #rant. And I always feel bad writing those, because, inevitably, it discusses things a lot of people have been working very hard on.

> If you're already heavily invested in Go, you probably shouldn't read this, it'll probably just twist the knife. If you work on Go, you definitely shouldn't read this. I've been suffering Go's idiosyncracies in relative silence for too long, there's a few things I really need to get off my chest.

Run #python in #wasm!

https://webassembly.sh/?run-command=python

​​Director is a simple and rapid framework used to manage tasks and build workflows using Celery.

The objective is to make Celery easier to use by providing:

- a WebUI to track the tasks states,
- an API and a CLI to manage and execute the workflows,
- a YAML syntax used to combine tasks into workflows,
- the ability to periodically launch a whole workflow,
- and many others.

https://github.com/ovh/celery-director

#python

I forgot to add reactions to the previous post! You know what to do.

#fail

​​A commandline tool + #python library to glitchify images and even make GIFs out of them! Featuring 10 different levels of glitching intensity! The algorithm used to create glitched images is a slightly modifed version of the popular ImageGlitcher tool's algorithm, so you can expect the glitched images to look really cool!

https://github.com/TotallyNotChase/glitch-this

​​⚡Breaking news!

Rome is finally released!

https://github.com/facebookexperimental/rome

It is still highly experimental and stuff, but you can have a look at the source code and try it.

#ts #js

​​#ts has Turing-complete type system. It means that you can write any program with just types.

Here's an amazing example:

> This project attempts to push TypeScript's type system to its limits by actually implementing various functions and algorithms, purely on top of the type system.

> Every implementation includes comments describing in detail what's going on. Some functions and algorithms use creative (and sometimes not officially supported) solutions to overcome some limitations of the type system.

https://github.com/ronami/meta-typing

​​⚡Breaking news!

Introducing Hanami::API: It's a minimal, extremely fast, lightweight Ruby framework for HTTP APIs.

http://hanamirb.org/blog/2020/02/26/introducing-hanami-api.html

#ruby