Krzysztof Leśniak serpent7776

Mike's x86-64 Assembly (ASM) Notes

Assembling Binary Machine Code

Operating `Modes`:

These determine the assumed/default size of instruction operands, and restricts which opcodes are available, and how they are used.

Modern operating systems, booted inside Real mode,

THIS GIST WAS MOVED TO TERMSTANDARD/COLORS REPOSITORY.

PLEASE ASK YOUR QUESTIONS OR ADD ANY SUGGESTIONS AS A REPOSITORY ISSUES OR PULL REQUESTS INSTEAD!

Please consider using http://lygia.xyz instead of copy/pasting this functions. It expand suport for voronoi, voronoise, fbm, noise, worley, noise, derivatives and much more, through simple file dependencies. Take a look to https://github.com/patriciogonzalezvivo/lygia/tree/main/generative

Generic 1,2,3 Noise

float rand(float n){return fract(sin(n) * 43758.5453123);}

float noise(float p){
	float fl = floor(p);
  float fc = fract(p);

Getting your OPML file from youtube

Go to youtube
Go to Subscriptions
Scroll down to bottom and press the Export Subscriptions button
Download the file

or

Just press THIS (should work)

Falsehoods programmers believe about time

This is a compiled list of falsehoods programmers tend to believe about working with time.

Don't re-invent a date time library yourself. If you think you understand everything about time, you're probably doing it wrong.

Falsehoods

There are always 24 hours in a day.
February is always 28 days long.
Any 24-hour period will always begin and end in the same day (or week, or month).

Shell Process Groups and the behaviour of CTRL+C and `kill`

Shells create process groups when running commands. This is true regardless of synchronous or asynchronous commmands.

Unix processes are not automatically supervisory processes (unlike Erlang). This extends Unix shells as well.

However things like pipe groups and terminal TTY shortcuts (CTRL+C) obscure this fact.

Why COW was deemed ungood for std::string.

COW, short for copy on write, is a way to implement mutable strings so that creating strings and logically copying strings, is reduced to almost nothing; conceptually they become free operations like no-ops.

Basic idea: to share a data buffer among string instances, and only make a copy for a specific instance (the copy on write) when that instance's data is modified. The general cost of this is only an extra indirection for accessing the value of a string, so a COW implementation is highly desirable. And so the original C++ standard, C++98, and its correction C++03, had special support for COW implementations, and e.g. the g++ compiler's std::string implementations used COW.

So why was that support dropped in C++11?

In particular, would the same reason or reasons apply to a reference counted immutable string value class?

	#!/bin/sh

	##############################################################################
	# This code known is distributed under the following terms:
	#
	# Copyright (c) 2013 Isaac (.ike) Levy <[email protected]>.
	# All rights reserved.
	#
	# Redistribution and use in source and binary forms, with or without
	# modification, are permitted provided that the following conditions

	create table deps_saved_ddl
	(
	deps_id serial primary key,
	deps_view_schema varchar(255),
	deps_view_name varchar(255),
	deps_ddl_to_run text
	);

	create or replace function deps_save_and_drop_dependencies(p_view_schema varchar, p_view_name varchar) returns void as
	$$

	const I = x => x
	const K = x => y => x
	const A = f => x => f (x)
	const T = x => f => f (x)
	const W = f => x => f (x) (x)
	const C = f => y => x => f (x) (y)
	const B = f => g => x => f (g (x))
	const S = f => g => x => f (x) (g (x))
	const S_ = f => g => x => f (g (x)) (x)
	const S2 = f => g => h => x => f (g (x)) (h (x))