PostgreSQL 13 Released!

PostgreSQL 13 includes significant improvements to its indexing and lookup system that benefit large databases, including space savings and performance gains for indexes, faster response times for queries that use aggregates or partitions, better query planning when using enhanced statistics, and more.

Along with highly requested features like parallelized vacuuming and incremental sorting, PostgreSQL 13 provides a better data management experience for workloads big and small, with optimizations for daily administration, more conveniences for application developers, and security enhancements.

Changelog: https://www.postgresql.org/about/news/2077/

​​A SQL database implemented purely in TypeScript type annotations.

This means that it operates solely on #ts types - you define a "database" (just a type annotation) and then query it using some more type annotations.

It supports a subset of #sql, including SELECT (with conditions and joins), INSERT, UPDATE and DELETE statements.

Personal opinion: crazy and super cool!

https://github.com/codemix/ts-sql

​​An #erlang backend to the OCaml compiler.

So, you can write OCaml and get Erlang bytecode!
You can get the best of two worlds: OCaml's type system and Erlang's awesome virtual machine.

As you can tell, this is highly experimental. But, lack of typing in Erlang is a very hot topic. There are several competing solutions at the moment. See our #gleam posts for more information.

https://github.com/AbstractMachinesLab/caramel

​​Completely unstyled, fully accessible UI components, designed to integrate beautifully with Tailwind CSS.

Supports both #vue and #react. Svelte support will be added soon.
It will be a really interesting project!

https://headlessui.dev/

Automatic HTTPS for any #go program: fully-managed TLS certificate issuance and renewal.

Easy and Powerful TLS Automation. The same library used by the Caddy Web Server.

Caddy's automagic TLS features—now for your own Go programs—in one powerful and easy-to-use library! CertMagic is the most mature, robust, and capable ACME client integration for Go... and perhaps ever.

With CertMagic, you can add one line to your Go application to serve securely over TLS, without ever having to touch certificates.

certmagic.HTTPS([]string{"example.com"}, mux)

That line of code will serve your HTTP router mux over HTTPS, complete with HTTP->HTTPS redirects. It obtains and renews the TLS certificates. It staples OCSP responses for greater privacy and security. As long as your domain name points to your server, CertMagic will keep its connections secure.

Compared to other ACME client libraries for Go, only CertMagic supports the full suite of ACME features, and no other library matches CertMagic's maturity and reliability.

https://github.com/caddyserver/certmagic

#devops

Hacktoberfest will start tomorrow! 🎃

Support open source and pick a limited edition T-shirt or plant a tree.

To earn your Hacktoberfest tee or tree reward, you must register and make four valid pull requests (PRs) between October 1-31 (in any time zone). PRs can be made to any public repo on GitHub, not only the ones with issues labeled Hacktoberfest. If a maintainer reports your pull request as spam or behavior not in line with the project’s code of conduct, you will be ineligible to participate. This year, the first 70,000 participants who successfully complete the challenge will be eligible to receive a prize.

https://hacktoberfest.digitalocean.com

But, that's not it! There are other companies who offer extra swag:

https://github.com/crweiner/hacktoberfest-swag-list

Don't know where to start? I've got you covered!
1. You can contribute to the most advanced typed library in Python's ecosystem: https://github.com/dry-python/returns/issues?q=is%3Aissue+is%3Aopen+label%3Ahacktoberfest
2. Or to the strictest Python linter out there: https://github.com/wemake-services/wemake-python-styleguide/issues?q=is%3Aissue+is%3Aopen+label%3AHacktoberfest

Happy Hactoberfest!

​​Disk Usage/Free Utility (Linux, BSD & macOS)

Features:
- User-friendly, colorful output
- Adjusts to your terminal's width
- Sort the results according to your needs
- Groups & filters devices
- Can conveniently output JSON

https://github.com/muesli/duf

#go #devops

​​visx | visualization components for #react

visx is a collection of reusable low-level visualization components. visx combines the power of d3 to generate your visualization with the benefits of react for updating the DOM.

https://github.com/airbnb/visx

#ts

​​Build automation for the post-container era. It's like Makefile and Dockerfile had a baby.

Earthly is a build automation tool for the post-container era. It allows you to execute all your builds in containers. This makes them self-contained, reproducible, portable and parallel. You can use Earthly to create Docker images and artifacts (eg binaries, packages, arbitrary files).

Earthly is meant to be used both on your development machine and in CI. It can run on top of popular CI systems (like Jenkins, Circle, GitHub Actions). It is typically the layer between language-specific tooling (like maven, gradle, npm, pip, go build) and the CI build spec.

Features:
- Reproduce CI failures
- Builds that run the same for everyone
- From zero to working build in minutes
- Build anything via containers - build images or standalone artifacts (binaries, packages, arbitrary files)
- Programming language agnostic - allows use of language-specific build tooling
- Reproducible builds - does not depend on user's local installation. Runs the same locally, as in CI
- Parallelism that just works - builds in parallel without special considerations the user has to make
- Mono-repo friendly - ability to split the build definitions across a vast directory hierarchy
- Multi-repo friendly - ability to import builds or artifacts from other repositories

https://github.com/earthly/earthly

#docker #devops #go

Example:

# Earthfile
FROM golang:1.13-alpine3.11
RUN apk --update --no-cache add git
WORKDIR /go-example

all:
  BUILD +lint
  BUILD +docker

build:
  COPY main.go .
  RUN go build -o build/go-example main.go
  SAVE ARTIFACT build/go-example AS LOCAL build/go-example

lint:
  RUN go get golang.org/x/lint/golint
  COPY main.go .
  RUN golint -set_exit_status ./...

docker:
  COPY +build/go-example .
  ENTRYPOINT ["/go-example/go-example"]
  SAVE IMAGE go-example:latest

Output:

​​The minimal, blazing-fast, and infinitely customizable prompt for any shell! Written in #rust

Features:
- Fast: it's fast – really really fast! 🚀
- Customizable: configure every aspect of your prompt.
- Universal: works on any shell, on any operating system.
- Intelligent: shows relevant information at a glance.
- Feature rich: support for all your favorite tools.
- Easy: quick to install – start using it in minutes.

https://github.com/starship/starship

​​A simple terminal UI for git commands, written in Go with the gocui library.

Rant time: You've heard it before, git is powerful, but what good is that power when everything is so damn hard to do? Interactive rebasing requires you to edit a goddamn TODO file in your editor? Are you kidding me? To stage part of a file you need to use a command line program to step through each hunk and if a hunk can't be split down any further but contains code you don't want to stage, you have to edit an arcane patch file by hand? Are you KIDDING me?! Sometimes you get asked to stash your changes when switching branches only to realise that after you switch and unstash that there weren't even any conflicts and it would have been fine to just checkout the branch directly? YOU HAVE GOT TO BE KIDDING ME!

If you're a mere mortal like me and you're tired of hearing how powerful git is when in your daily life it's a powerful pain in your ass, lazygit might be for you.

https://github.com/jesseduffield/lazygit

#go

This is not a drill: we have a new markup language!

nestedtext: Human readable and writable data interchange format.

NestedText is a file format for holding data that is to be entered, edited, or viewed by people. It allows data to be organized into a nested collection of dictionaries, lists, and strings. In this way it is similar to JSON and YAML, but without the complexity and risk of YAML and without the syntactic clutter of JSON. NestedText is both simple and natural. Only a small number of concepts and rules must be kept in mind when creating it. It is easily created, modified, or viewed with a text editor and easily understood and used by both programmers and non-programmers.

NestedText is convenient for configuration files, address books, account information and the like.

https://github.com/KenKundert/nestedtext

Example:

    name: Katheryn McDaniel
    address:
        > 138 Almond Street
        > Topika, Kansas 20697
    phone:
        cell: 1-210-555-5297
        home: 1-210-555-8470
            # Katheryn prefers that we always call her on her cell phone.
    email: KateMcD@aol.com
    additional roles:
        - board member

​​A simple encoding of higher-kinded types in TypeScript.

TypeScript doesn't directly support higher-kinded types yet, but various attempts have been made to simulate them (see related work at the bottom). This project presents a new, greatly simplified approach to encoding HKTs using the power of conditional types.

The idea is that, although we can't truly abstract over a type constructor type T<A> = ..., we can abstract over the result T<_> of applying it to a special placeholder type . Then, if we can somehow substitute all instances of within a type, we effectively have the ability to "apply" T at arbitrary types. That is, we can abstract over T! And it turns out we can define a substitution operator $<T, S> which does just that.

https://github.com/pelotom/hkts

#ts

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