Michael Mayr DerMitch

Postgres structure - 3 tables, each has 1 text column named "id"

psql (14.10 (Homebrew))
Type "help" for help.

[LOCAL] mydatabase=# select * from test1;
 id
----
(0 rows)

PostgreSQL is Enough

Background and Cron Jobs

macOS Internals

Understand your Mac and iPhone more deeply by tracing the evolution of Mac OS X from prelease to Swift. John Siracusa delivers the details.

Starting Points

How to use this gist

You've got two main options:

CUSTOM GAME ENGINES: A Small Study

WARNING: Article moved to separate repo to allow users contributions: https://github.com/raysan5/custom_game_engines

A couple of weeks ago I played (and finished) A Plague Tale, a game by Asobo Studio. I was really captivated by the game, not only by the beautiful graphics but also by the story and the locations in the game. I decided to investigate a bit about the game tech and I was surprised to see it was developed with a custom engine by a relatively small studio. I know there are some companies using custom engines but it's very difficult to find a detailed market study with that kind of information curated and updated. So this article.

Nowadays lots of companies choose engines like [Unreal](https:

How many warnings should your JavaScript app have?

JavaScript warnings are these messages being displayed in yellow or red in your JavaScript console or terminal. They make no sense at all in general but they are a good indication of the health of your app. The points below will give you a general idea of how many warnings you should expect in your app:

0 warnings: the app is not working at all
5 warnings: app is probably starting but crashing soon after - try to find why it crashes. You'd think you could read the warnings to learn why it doesn't work, but that's not what warnings are for.
50 warnings: That's the soft spot - most likely everything's running smoothly

Async/Await - The challenges besides syntax - Cancellation

This is the second article in a series of articles around Rusts new async/await feature. The first article about interfaces can be found here.

In this part of the series we want to a look at a mechanism which behaves very different in Rust than in all other languages which feature async/await support. This mechanism is Cancellation.

React

Ant Design - https://ant.design/
Atlaskit by Atlassian - https://atlaskit.atlassian.com/
Base Web by Uber - https://baseweb.design/
Blueprint by Palantir - https://blueprintjs.com/
Carbon by IBM - https://www.carbondesignsystem.com/
Elastic UI by Elastic - https://elastic.github.io/eui/
Evergreen by Segment - https://evergreen.segment.com/

See imgur / linked pastebin and github mirror for 1-8 → 1-8 balancers. Creator: raynquist, github mirror linked in Balancers Illustrated: 1 through 8 balancers explained, imgur album linked in Balancer Book Update (Summer 2019)

The official documentation is in the [sd_notify(3)][1] manual page.

Very short summary:

Change your systemd service to Type=notify.
Your daemon will receive an environment variable NOTIFY_SOCKET, which contains a path to an AF_UNIX socket.
(If the first path byte is @, this means an "abstract" socket, and you should change the 1st byte to 0x00 before using.)
The protocol consists of sending datagrams containing textual (UTF-8) status messages.
Each message contains newline-separated KEY=value parameters.
When the daemon is ready, it must send READY=1, and systemd will transition the service from "starting" to "running".

	Just a quick test of squashfs compression ratio using different settings.

	I am looking for relatively good and fast compression, that also is quick to decompress.
	I don't care about ultimate end size exactly tho.

	Input (a Debian testing live build with 6240 installed packages):

	$ sudo du -bs ./chroot
	26566785410 ./chroot # 26.6GB
	$