​​Elixir v1.11 released

Over the last releases, the #elixir team has been focusing on the compiler, both in terms of catching more mistakes at compilation time and making it faster. Elixir v1.11 has made excellent progress on both fronts. This release also includes many other goodies, such as tighter Erlang integration, support for more guard expressions, built-in datetime formatting, and other calendar enhancements.

During this period, we have also started publishing a series of production cases on our website, featuring Elixir’s usage at Brex, Farmbot, and Heroku, with many more cases coming soon.

Features:
- Tighter #erlang integration
- Compiler checks: application boundaries
- Compiler checks: data constructors
- Compilation time improvements
- config/runtime.exs and mix app.config
- And many others!

https://elixir-lang.org/blog/2020/10/06/elixir-v1-11-0-released/

​​concise commandline monitoring for containers.

Top-like interface for container metrics. ctop comes with built-in support for Docker and runC. As well as a single container view for inspecting a specific container.

Connectors for other container and cluster systems are planned for future releases.

https://github.com/bcicen/ctop

#go #devops #docker

​​HTTPie—aitch-tee-tee-pie—is a user-friendly command-line HTTP client for the API era. It comes with JSON support, syntax highlighting, persistent sessions, wget-like downloads, plugins, and more.

HTTPie is designed for painless debugging and interaction with APIs, HTTP servers, and web services, which it accomplishes by:

- Built-in JSON support
- Colorized and formatted terminal output
- Sensible defaults
- Persistent sessions
- Forms and file uploads
- HTTPS, proxies, and authentication support
- Support for arbitrary request data and headers
- Wget-like downloads
- Extensions API
- Expressive and intuitive syntax
- Linux, macOS, and Windows support
- All that & more in 2 simple commands: http + https

https://httpie.org/

#python

​​Machine Learning models should play by the rules, literally. Natural Intelligence is still a pretty good idea.

Back in the old days, it was common to write rule-based systems.
Nowadays, it's much more fashionable to use machine learning instead.

We started wondering if we might have lost something in this transition. Sure, machine learning covers a lot of ground but it is also capable of making bad decision. We've also reached a stage of hype that folks forget that many classification problems can be handled by natural intelligence too.

This package contains scikit-learn compatible tools that should make it easier to construct and benchmark rule based systems that are designed by humans. You can also use it in combination with ML models.

This tool allows you to draw over your datasets. These drawings can later be converted to models or to preprocessing tools.

https://koaning.github.io/human-learn/

#python #ds

​​Public release of the TransCoder research project https://arxiv.org/pdf/2006.03511.pdf

Pytorch original implementation of TransCoder in Unsupervised Translation of Programming Languages.

https://github.com/facebookresearch/TransCoder

⚡Breaking news!

Webpack 5 is released!

webpack 4 was released in February 2018. Since then we shipped a lot of features without breaking changes. We know that people dislike major changes with breaking changes. Especially with webpack, which people usually only touch twice a year, and the remaining time it "just works". But shipping features without breaking changes also has a cost: We can't do major API or architectural improvements.

So from time to time, there is a point where the difficulties pile up and we are forced to do breaking changes to not mess everything up. That's the time for a new major version. So webpack 5 contains these architectural improvements and the features that where not possible to implement without them.

The major version was also the chance to revise some of the defaults and to align with proposals and specifications that come up in the meantime.

So today (2020-10-10) webpack 5.0.0 is released, but this doesn't mean it's done, bugfree or even feature-complete. As with webpack 4 we continue development by fixing problems and adding features. In the next days there will probably a lot bugfixes. Features will come later.

This release focus on the following:
- Improve build performance with Persistent Caching.
- Improve Long Term Caching with better algorithms and defaults.
- Improve bundle size with better Tree Shaking and Code Generation.
- Improve compatibility with the web platform.
- Clean up internal structures that were left in a weird state while implementing features in v4 without introducing any breaking changes.
- Prepare for future features by introducing breaking changes now, allowing us to stay on v5 for as long as possible.

https://webpack.js.org/blog/2020-10-10-webpack-5-release/

However, webpack@5 raised a lot of discussions because of its breaking changes.
See this article (from Sindre Sorhus) for example: https://blog.sindresorhus.com/webpack-5-headache-b6ac24973bf1

​​Run macOS software on Linux!

Darling is a translation layer that lets you run macOS software on Linux.
Features:

- Fast: Darling runs macOS software directly without using a hardware emulator.
- Free: Like Linux, Darling is free and open-source software. It is developed openly on GitHub and distributed under the GNU GPL license version 3.
- Compatible: Darling implements a complete Darwin environment. Mach, dyld, launchd — everything you'd expect.
- Easy to use: Darling does most of the setup for you. Sit back and enjoy using your favorite software.
- Native: We aim to fully integrate apps running under Darling into the Linux desktop experience by making them look, feel and behave just like native Linux apps.

https://www.darlinghq.org/

​​List of Microservice API Patterns.

Our Microservice API Patterns (MAP) capture proven solutions to design problems commonly encountered when specifying, implementing and maintaining message-based APIs.

MAP focusses on message representations – the payloads exchanged when APIs are called. These payloads vary in their structure as API endpoints and their operations have different architectural responsibilities. The chosen representation structures strongly influence the design time and runtime qualities of an API. The evolution of API specifications and their implementations has to be governed.

https://microservice-api-patterns.org/

​​Inertia.js: the modern monolith. Build single-page apps, without building an API.

Inertia.js lets you quickly build modern single-page React, Vue and Svelte apps using classic server-side routing and controllers.

Inertia is a new approach to building classic server-driven web apps. We call it the modern monolith.

Inertia allows you to create fully client-side rendered, single-page apps, without much of the complexity that comes with modern SPAs. It does this by leveraging existing server-side frameworks.

Inertia has no client-side routing, nor does it require an API. Simply build controllers and page views like you've always done!

Inertia isn't a framework, nor is it a replacement to your existing server-side or client-side frameworks. Rather, it's designed to work with them. Think of Inertia as glue that connects the two. Inertia does this via adapters. We currently have three official client-side adapters (#react, #vue, and #svelte) and two server-side adapters (Laravel and Rails).

https://inertiajs.com/

#js

​​Intuitive find & replace CLI (sed alternative) written in #rust

Why use it over any existing tools?

- Painless regular expressions. sd uses regex syntax that you already know from JavaScript and Python. Forget about dealing with quirks of sed or awk - get productive immediately.
- String-literal mode. Non-regex find & replace. No more backslashes or remembering which characters are special and need to be escaped.
- Easy to read, easy to write. Find & replace expressions are split up, which makes them easy to read and write. No more messing with unclosed and escaped slashes.
- Smart, common-sense defaults. Defaults follow common sense and are tailored for typical daily use.

Personal opinion: I had used sed a lot in the past. And I hate it. This looks like a good alternative.

https://github.com/chmln/sd

​​Flake8 plugin to find commented out or dead #python code

Part of our wemake-python-styleguide project. But, you can install it independently!

https://github.com/sobolevn/flake8-eradicate

​​A blazingly fast static web server in a single binary you can set up with zero code - written in #rust.

Features:
- Single binary with no dependencies and everything built-in.
- Blazingly fast! It's built on top of Actix, one of the fastest web frameworks in the world and of course, written in Rust.
- Everything in a single config file - everything you need to setup is in the binserve.json, just change it, run it!
- Epic Portability - just carry the binary around and all you have to change is the host and port in the binserve.json.
- Easiest Routing - you just have to enter the route and the static file to respond in the binserve.json to add a route entry!
- Handlebars template engine - renders every static file with Handlebars on the first run improving performance!
- Template Variables in one place - that too in the one and only config file!
- Secure by design - runs security validation checks on the first run and will only run the server once configuration is confirmed secure! (See Security)
- Config & Static File Assistance - just running it will create the configuration file and the static directory boilerplate for you!
- Supports Any Static Files - just give any static file of your choice to routes and response will match it's Content-Type.
- Straightforward Directory Structure - static files falls under the static directory, you can even change that! And images, css, and js falls under the assets directory which should all be created for you in the first run itself!
- Custom Error Page Support - you can design your own fancy error pages!
- Actix Logging Middleware - Logging is powered directly from Actix.

https://github.com/mufeedvh/binserve

​​A powerful little #go TUI framework

The fun, functional and stateful way to build terminal apps. A Go framework based on The #elm Architecture. Bubble Tea is well-suited for simple and complex terminal applications, either inline, full-window, or a mix of both.

Bubble Tea is in use in production and includes a number of features and performance optimizations we’ve added along the way. Among those is a standard framerate-based renderer, a renderer for high-performance scrollable regions which works alongside the main renderer, and mouse support.

https://github.com/charmbracelet/bubbletea

​​Boundary enables identity-based access management for dynamic infrastructure.

Boundary provides simple and secure access to hosts and services.

Traditional approaches like SSH bastion hosts or VPNs require distributing and managing credentials, configuring network controls like firewalls, and exposing the private network. Boundary provides a secure way to access hosts and critical systems without having to manage credentials or expose your network, and is entirely open source.

Boundary is designed to be straightforward to understand, highly scalable, and resilient. It can run in clouds, on-prem, secure enclaves and more, and does not require an agent to be installed on every end host.

Unlike firewalls, Boundary performs per-access authentication and authorization checks, allowing for much higher level mappings of users to services or hosts than at network layers. Although complementary to secrets managers (like HashiCorp's own Vault), Boundary fills a different niche, allowing the credential that is eventually used to be hidden entirely from the user.

- Authenticate with any trusted identity provider you are already using. No need to distribute new credentials and manage them.
- Authorize access based on logical roles and services, instead of physical IP addresses. Manage dynamic infrastructure and integrate service registries so hosts and service catalogs are kept up-to-date.
- Automate credential injection to securely access services and hosts with HashiCorp Vault. Reduce risk of leaking credentials with dynamic secrets and just-in-time credentials.

https://github.com/hashicorp/boundary

#go

​​Secure and fast microVMs for serverless computing.

Firecracker is an open source virtualization technology that is purpose-built for creating and managing secure, multi-tenant container and function-based services.

Firecracker enables you to deploy workloads in lightweight virtual machines, called microVMs, which provide enhanced security and workload isolation over traditional VMs, while enabling the speed and resource efficiency of containers. Firecracker was developed at Amazon Web Services to improve the customer experience of services like AWS Lambda and AWS Fargate .

Firecracker is a virtual machine monitor (VMM) that uses the Linux Kernel-based Virtual Machine (KVM) to create and manage microVMs. Firecracker has a minimalist design. It excludes unnecessary devices and guest functionality to reduce the memory footprint and attack surface area of each microVM. This improves security, decreases the startup time, and increases hardware utilization. Firecracker currently supports Intel CPUs, with AMD and Arm support in developer preview.

Firecracker is integrated with Kata Containers , Open Nebula , UniK , Weave FireKube (via Weave Ignite ), and containerd via firecracker-containerd It's also used by fly.io . Firecracker can run Linux and OSv guests.

https://github.com/firecracker-microvm/firecracker

#rust #devops

​​Monorepo vs. polyrepo: architecture for source code management (SCM) version control systems (VCS)

Monorepo means using one repository that contains many projects, and polyrepo means using a repository per project. This page discusses the similarities and differences, and has advice and opinions on both.

https://github.com/joelparkerhenderson/monorepo_vs_polyrepo

#devops

​​Gravity is not a force.

Under general relativity, gravity is not a force. Instead it is a distortion of spacetime. Objects in free-fall move along geodesics (straight lines) in spacetime, as seen in the inertial frame of reference on the right. When standing on Earth we experience a frame of reference that is accelerating upwards, causing objects in free-fall to move along parabolas, as seen on the left.

In this system there is only one space dimension, shown on the vertical axis and labeled in meters. The time dimension is the horizontal axis and labeled in seconds. The gravitational field is constant within the area of interest.

Use this demo to see and feel this!

https://timhutton.github.io/GravityIsNotAForce/

#js

> How to make CPython faster.

> We want to speed up CPython by a factor of 5 over the next four releases.
> See the plan for how this can be done.
> Making CPython faster by this amount will require funding. Relying on the goodwill and spare time of the core developers is not sufficient.

This includes JIT and other awesome features for #python

https://github.com/markshannon/faster-cpython

We need this!

​​Implementation of a simple programming language for beginners.

The primary goal of Neon is to find out whether a useful programming language can avoid some of the common pitfalls that beginners frequently encounter in other languages. Some of these common errors avoided by design are:

- Floating point errors due to binary floating point
- Writing if (x = 0) when if (x == 0) is intended
- Null pointer exceptions
- Unintended empty loop with while (condition);
- Forgetting to use the return value of a function

Personal opinion: very interesting take on this topic. I hope that we will have more beginner-friendly (or even beginner-only) languages in the future.

https://github.com/ghewgill/neon-lang

#cpp

> When learning Object Oriented Design in a school setting, the discussion usually goes something like this:

> “This is a picture of a dog. What things can a dog do? Bark, eat, run, walk, these are its methods. What are some things that describe a dog? It is soft, brown, has 4 legs. These are its properties”

> “Purely behavioural code should be kept at a minimum at the boundaries of your domain layer, mostly to interface with the richer world of Nouns.”

> I like to refer to this object modelling advice as “Find the Nouns”, and it is wrong

This article describes a very different approach to OOP.
I wrote a similar article not so long ago: https://sobolevn.me/2019/03/enforcing-srp