#photography #ship

#bird #photography #nature #sky #blue

I've created a simple model and animation and blender and exported these in the GLTF format. In my "game engine" I've implemented a GLTF parser from scratch and added an animation system to the rendering. I'll assume your are familiar with the basic concept of joint/bone based animation and linear algebra for gamedev.

Parsing GLTF

In my implementation, I've only cared about the binary file format .glb of the GLTF standard. In this format, meta and binary data are stored in the same file, which I find more convenient for my use case. Alternatively the data can also be split into the meta data .gltf file and (multiple) binary files .bin.

The meta data in GLTF is stored in a JSON format. The format specifies different object types which are hierarchically organized in scenes as nodes. References between objects are generally given as indexes into the corresponding object array within the JSON data.

Most objects will eventually reference to accessor objects. These describe in which format and where in the binary data values are stored.

Reading Meshes

I won't go into too much detail about loading meshes from GLTF, as this isn't the focus of this article. Meshes have a list of primitives which define the geometry. Each primitive has a set of attributes, which are accessor indexes for different attributes of vertices, e.g. position and normal data. Additionally, the primitive object has an indices attribute which points to another accessor. The indices data indexes into the arrays of the attributes, defining the triangle structure.

For animated meshes it's important to load the JOINTS_0 and WEIGHTS_0 attributes. The joints data has to be stored as a 4D integer vector and the weights as 4D floating point vector. The data will be used at the very end in the vertex shader to apply the joint transformations to the vertices.

Important to note here is that a mesh might have additional JOINTS_n and WEIGHTS_n attributes. This will occur when a single vertex is influenced by more than 4 joints.

Reading Animation Data

For animations two object types are important; skins and animations.

Skins

Skins define the skeleton used in our animation. The two attributes we're interested in are joints and inverseBindMatrices.

The joints array holds indexes referring to node objects. These are the bones of the skeleton. The hierarchy has to be read from the nodes, which have children attributes.

The inverseBindMatrices attribute is an index to an accessor. This accessor locates an array of 4x4 matrices in the binary data. The array must have at least as many matrices as there are joints in the skin object. These matrices will be needed later to apply the animation to our model

Animations

Animations define the transformations which are applied to the skin. They have two arrays of child objects which define the transformations; channels and samplers. The channels map attributes of joints to samplers.

The example below says, that the sampler 0 describes the translation part of the animation for joint 2. Each joint can have a channel for each different transforms: translation, rotation and scale. (There is also "weights" but I've ignored this as it only applies to morph targets)

{
    "sampler":0,
    "target":{
        "node":2,
        "path":"translation"
    }
},

The samplers have three attributes; input, interpolation and output. Input and output are again indexes to accessors, which point to arrays of equal length. The input values are time stamps in the animation, while the output are the values at the corresponding time stamp. The type of the output differs based on the transformation, while the input is always a scalar. The interpolation defines how values between sample points should be interpolated.

Gathering all Data

In my implementation I've first transformed the data read from the sample into these structs. An AnimationPoint holds the corresponding input and output values. An AnimationSequence is a vector for points + the interpolation method. An AnimationSet gathers all sequences for the different transformations of a single joint.

pub struct AnimationPoint<T> {
    pub input: f32,
    pub output: T,
}

pub struct AnimationSequence<T> {
    pub points: Vec<AnimationPoint<T>>,
    pub interpolation: GltfSamplerInterpolation,
}

pub struct AnimationSet {
    pub translation: AnimationSequence<Vec3>,
    pub rotation: AnimationSequence<Vec4>,
    pub scale: AnimationSequence<Vec3>,
    pub weights: AnimationSequence<f32>,
}

A Joint holds it's own animation data, the inverse bind matrix and the indexes of its children. The child association is important later on to calculate the transformation matrices. The child indexes here are not the values read from the JSON data but the position of the joint in the animation struct.

The Animation just holds a vector of joints and stores the index of the root joint. The common root of the skeleton has to be determined by the implementation itself and is not stored in the GLTF data. However the standard states that the joints of a skin must have a common root.

pub struct Joint {
    set: AnimationSet,
    inverse_bind_mat: Mat4,
    children: Vec<usize>,
}

pub struct Animation {
    joints: Vec<Joint>,
    common_root: usize,
}

Calculating the Joint transformation

Now that we have gathered all data required, we can finally do the animation itself. For this we need to calculate a transformation matrix for each joint.

This part took me the longest time. I still had a vague idea what had to happen from university (10+ years ago) but it still took me multiple sessions to find all errors and missing calculations in my implementation. Lisyarus blog post was a great resource as well as the Vulkan example by Sascha Willems.

I'm still not very familiar with the terminology but hopefully this explanation will help :). Each joint has a local matrix which is defined by its translation, rotation and scale at given point in time. These values have to be read and interpolated from the animation sequence. The values are then transformed into 4x4 matrix and multiplied in this exact order to retrieve the local matrix.

Joint(N, t) = Translation(N, t) * Rotation(N, t) * Scale(N, t)

Next we have to include the hierarchy into our transformations. Each local matrix only describes how a vertex is transformed in the reference frame of the joint. But joints themselves are also move be their parents (when the arm moves the hand is also moved). These transformations also need to be applied to our vertices. Therefore we need to traverse the hierarchy and apply each local matrix of a parent to its children. This has to happen recursively, such that each joint "includes" all transformation from the root to itself.

This can be achieved by traversing the tree starting at the common root. For each child we simply multiply the local matrix with the matrix of the parent in the correct order. By starting at the root we guarantee that the matrix of the parent joint already includes all previous matrices.

Joint(N, t) = Parent(N, t) * Joint(N, t)

let mut queue = VecDeque::new();
queue.push_back(self.common_root);
while let Some(parent) = queue.pop_front() {
    for child in self.joints[parent].children.iter() {
        joint_mats[*child] = joint_mats[parent] * joint_mats[*child];
        queue.push_back(*child);
    }
}

Finally we have to include the inverse bind matrix, again at the correct place. I still don't understand 100% how this matrix functions, but it brings the vertex into the correct reference frame before the joint transformations are applied.

Joint(N, t) = Joint(N, t) * InverseBindMatrix(N) 

After this step we have a set of matrices which can be sent of to the GPU to be used in our vertex shader.

Applying the Animation

Now that the hard part is done, we just have to apply the animation to each vertex in the vertex shader. I've passed the calculated joint matrices via a read-only storage buffer (I'm using wgpu for rendering).

Each vertex has a vec4<u32> of joints indexes and corresponding weights as vec4<f32>. To arrive at the final matrix for a joint look up the correct joint matrices and calculated the weighted sum.

    var ani_matrix = model.weights[0] * joint_positions[model.joints[0]] +
            model.weights[1] * joint_positions[model.joints[1]] +
            model.weights[2] * joint_positions[model.joints[2]] +
            model.weights[3] * joint_positions[model.joints[3]];

    out.world_pos = model_matrix * ani_matrix * vec4<f32>(model.position, 1.0);

Happy Animation?

If you did everything correctly you should now be able to enjoy your glorious animations. Otherwise the model will be a distorted mess and you are sent onto an adventure to look for subtle bugs in any of these steps. Here are some of the errors I had to fix before my animations looked right:

• Mixing Joint index and Node index numbers when building the hierarchy
• Multiplying translation, rotation and scale in the wrong order
• Loading matrices from the GLTF binary as row-major instead of column-major
• An error in the translation matrix, I've but the translation values into the last row instead of the last column.
• Not adding the inverse bind matrix
• Adding the inverse bind matrix between each step of the hierarchy
• Not using the hierarchy at all
• Errors in sampling from the animation sequence

#gamedev #animation #rust #gltf #3d

#photography #nature

• 3D Modell: Cardholder-Body.3mf
• FreeCAD: Cardholder.FCStd

#3dprinting

#bird #photography

Ingredients

• 200g Dinkelvollkornmehl
• 200g Weizenmehl 550
• 150g Sonnenblumenkerne
• 50g Müsli
• 15g Salz
• ¼ Würfel Hefe

Instructions

Ein einfaches Kastenbrot mit Sonnenblumenkernen. Das Rezept ist sehr flexibel. Gehzeiten können verlängert werden, wenn der Teig im Kühlschrank geht. Wenn es schnell gehen muss kann auch mehr Hefe benutzt werden. Ebenso können die Sonnenblumenkerne durch andere Saaten ausgetauscht werden.

Vorteig

• 200g Dinkelvollkornmehl
• 15g Salz
• ¼ Würfel Hefe

Saaten

• 150g Sonnenblumenkerne
• 50g Müsli
• 150g Wasser

Teig

• Vorteig
• Saaten
• 200g Weizenmehl 550
• 60g Wasser

Zubereitung

• Mehl, Hefe und Wasser mit einer Gabel verrühren und in einer zweiten Schüssel Saaten mit Wasser bedecken
• Vorteig und Saaten etwa 2 Stunden gehen lassen
• Vorteig, Saaten, Weizenmehl und 60g Wasser zu einem weichen Tag kneten. Wassermenge gegebenenfalls anpassen.
• Teig über mindestens 2 Stunden gehen lassen und dabei 3 mal falten. Kann auch über Nacht im Kühlschrank gehen.
• Laib formen und in eine Backform geben (falls nötig Form mit Backpapier auslegen oder einfetten)
• Teig zwei weitere Stunden gehen lassen (oder über Nacht im Kühlschrank). Das Volumen sollte sich for dem Backen etwa verdoppelt haben.
• Laib einschneiden und mit etwas Wasser bespritzen
• 80 Minuten bei 180°C backen ohne vorheizen
• Brot aus der Form nehmen und weitere 15 Minuten backen

#brot #backen #dinkel #weizen

Dateien:

• Weihnachtaufhaenger.FCStd
• Weihnachtaufhaenger.3mf

#3dprint #model #freecad

#photography #train

Taken at the RTM Musuem in #Ouddorp

#photography #wind #sea

#photography #netherlands #sea #water

#photography #netherlands

#photography #hand #bnw

In JavaScript we can access the WASM memory through a DataView object.

  WebAssembly.instantiateStreaming(fetch("lib.wasm"), {}).then(
            (obj) => {
				const dv = new DataView(obj.instance.exports.memory.buffer)
				//...
			}

The DataView object allows us to read and write data to the memory. To pass a string to a WASM function we first have to encoded it to bytes and then write these bytes into the memory buffer. setUint8 sets the i-th byte of the memory buffer to the provided value.

	// encode string in "program" as utf8 and write to WASM memory
	let utf8Encode = new TextEncoder();
	const p_data = utf8Encode.encode(program);
	for (let i = 0; i < p_data.length; i++) {
		dv.setUint8(i, p_data[i])
	}

The byte position of the written data serves as the "pointer" to the data, that we have to pass to the WASM function call. As the data was written to the start of the memory it will be 0 in this case.

The function we want to call has this signature (in zig). The example is taken from the chromahack code also used in this article about writing WASM libraries in zig

render_point_2(program: [*]const u8, len: usize, result: [*]f32) void

As we can only pass pointers, not strings directly, we also have to pass the length of our string. Otherwise the called function doesn't knowns how much data has to be read from the linear memory.

The called function calculates a RGB color value. The values are written to the provided result location, therefore we also have to provide a pointer for the result in the call. The first two parameters define the string we pass into the function, start location 0 and length of p_data.length. The third parameter is the result location. This is set to p_data.length as this is the first unused location in our memory, directly after the string.

obj.instance.exports.render_point_2(0, p_data.length, p_data.length);

After the function call we have to retrieve the data from the memory. In this case we know that the function will always write 3 floating point values. Otherwise the function would also need to return the length of the result.

The data is again retrieved throught the DataView object via the getFloat32 function. Note that the address is given as a byte offset and therefore has to be increased by 4 each time (byte size of a float). The second parameter defines the endianness of the read data.

const r = dv.getFloat32(p_data.length + 0, true);
const g = dv.getFloat32(p_data.length + 4, true);
const b = dv.getFloat32(p_data.length + 8, true);

#dev #wasm #js #webdev

For my chromahack project I've used zig to implement the language. To integrate this into an interactive web app I had to compile it to WASM.

Function Definition

The original function I wanted to export as WASM has this signature:

pub fn render_point(program: []const u8, t: f32, x: f32, y: f32) [3]f32

This was a problem as the WASM target does not support the types []const u8 and [3]f32 as function parameter/return type. Therefore I've created a new function (creatively called render_point_2) to wrap my original implementation:

export fn render_point_2(program: [*]const u8, len: usize, t: f32, x: f32, y: f32, result: [*]f32) void {
    const r = render_point(program[0..len], t, x, y);
    result[0] = r[0];
    result[1] = r[1];
    result[2] = r[2];
}

The program is now passed as a pointer to an array + its length. The function no longer has a return value, but writes the result to a provided array address. The caller has to ensure that the array can store 3 floating point values.

Also note the export keyword. I've missed this and spent an hour wondering why my WASM file had no exported function.

Building WASM

To build the WASM file you can either use the zig build-exe command or integrate it into your build.zig file.

The command zig build-exe src/root.zig -target wasm32-freestanding -fno-entry -rdynamic -OReleaseFast will create the WASM file in your project folder.

To build the WASM file via zig build add the following block to your builg.zig file. This will create the file in zig-out/bin. (based on this gist from trasstaloch )

const wasm = b.addExecutable(.{
	.name = "lib",
	.root_source_file = b.path("src/root.zig"),
	.target = b.resolveTargetQuery(std.Target.Query.parse(
		.{ .arch_os_abi = "wasm32-freestanding" },
	) catch unreachable),
	.optimize = optimize,
});
wasm.entry = .disabled;
wasm.rdynamic = true;
b.installArtifact(wasm);

It is also possible to copy further assets into the output directoy, such as your HTML and JavaScript files.

// copy web stuff
b.installBinFile("index.html", "index.html");
b.installBinFile("assets/favicon.png", "favicon.png");

#zig #dev #wasm

I've created a small programming languages I've been thinking about for a long time. I wanted a programming language that would interpret any string as a valid program and create some visual result out of that. The inspiration was the hacker movie aesthetics, typing furiously on their laptops and bright, colorful patterns flashing over screens.

Design

The language is implemented as a stack based machine. Each character is interpreted as an operation on this stack. For example, a take the top two items from the stack, adds them up and puts the result back. Unassigned symbols are simply ignored.

The stack is initiated with the x and y coordinates of a pixel in an image. (I also put a time value, which is always zero, onto the stack as I want to extend the system for animations in the future).

The program is then executed for each pixel in an [512x512] image. When the program stops (this is guaranteed through the language), the top three items of the stack are interpreted as RGB values.

Implementation

The implementation of the languages itself is rather simple, as it's only a large switch-case statement. As I wasn't sure how fast the interpreter would run when implemented JavaScript I've decided to built it in zig.

The zig program is split into a library and executable. The executable simply wraps the library by invoking the render_point function for each pixel in an image and saving the result to disk.

Usage via the command line was rather tedious. Therefore I've compiled the library to WASM to integrate it into an web app to allow for an interactive workflow.

As rendering a long program might take a few seconds I've split the rendering process into chunks to avoid blocking the UI. Randomizing the order of chunks added a nice hackeresque feel to the process.

To create the layout of the website I used Claude, as this was a part of the process I was not interested in. Everything else is organic, hand-crafted artisanal code.

Conclusion and Future

This was a fun project, which could be implemented within a few programming session. I've struggled a bit generating the WASM file. The zig documentation on this topic is rather slim and many examples are outdated. However, this was the first time I've worked with WASM and in the end it was a simple solution.

In the future I want to implement the animation feature of the language. For this I will also have to increase the performance. I want to try WebGL and SIMD for this. Another interesting topic might be to generate programs through algorithms. I think genetic algorithms could work well with this language as it can be mutated and crossed without concern for validity.

Web Version: https://chromahack.rerere.org/

Source Code: https://codeberg.org/h4kor/chromahack

#dev #chromahack #language #visual

#photography #bird #nature

Sony A6400 with Tamron 18-300mm

Ingredients

• 200g Udon Nudeln
• 4 EL Sojasauce
• 1 EL Reisessig
• 1 EL Agavendicksaft
• 2 TL Speisestärke
• Gemüse und Sojaschnetzel
• 1 Stück Ingwer (optional)
• 1 Knoblauchzehe (optional)

Instructions

Dieses Rezept koche ich zur Zeit sehr häufig in meiner Mittagspause. Es ist schnell und einfach und lässt sich endlos variieren.

• Gemüse länglich, mundgerecht schneiden. Sojaschnetzel aufkochen und abgießen.
• Ingwer und Knoblauch fein hacken
• Sojasauce, Reisessig, Agavendicksaft mit 200ml Wasser verrühren
• Udonnudel nach Packung kochen
• Sojaschnetzel und Gemüse anbraten. Zutaten je nach Garzeit später hinzugeben.
• Ingwer und Knoblauch 1 Minute mit anbraten und mit Sauce ablöschen
• Speisestärke in etwas Wasser auflösen und unterrühren
• fertige Nudeln abgießen und zur Sauce hinzufügen

Beliebte Gemüse Kombination

• Sojaschnetzel und TK Erbsen
• Sojaschnetzel und Zucchini
• Möhren und TK Erbsen
• Paprika und Zwiebeln

#rezept #schnell #vegan

Chatkontrolle

Da fast alle gängigen Messenger inzwischen Ende zu Ende verschlüsselt kommunizieren haben Sicherheitsbehörden es schwer Chats zu überwachen. Da auch die Betreiber der Chatprogramme keinen Einblick haben ist die einzige verbleibende Möglichkeit zu Überwachung das abfangen der Nachrichten auf dem Gerät der Nutzer. Dies benötigt zur Zeit den Einsatz eines "Staatstrojaners".

Da der Trojanereinsatz ein schwerer und kostspieliger Eingriff ist, versucht die Politik immer wieder eine Alternative zu schaffen. Der letzte Angriff war die sogenannten Chatkontrolle. Unter dem Vorwand der Kindesmissbrauchsbekämpfung sollen Chatanbieter gezwungen werden Chats nach dokumentiertem Kindesmissbrauch zu durchsuchen.

Technisch bedeuten diese Versuche, dass die Ende-zu-Ende Verschlüssung entweder entfernt oder umgangen werden muss. Anbieter könnten die Verschlüsselung anpassen um Daten auf ihren Servern zu analysieren oder alternative über einen zweiten Kanal zur Analyse ausspielen.

KI Tools

Im aktuellen GenAI Hype wird in derzeit in jede App ein "KI Funktion" eingebaut die nicht bei drei auf den Bäumen ist. Die Giganten Google and Microsoft gehen direkt einen Schritt weiter und bauen die KI direkt in ihre Betriebssystem ein.

Bei Microsoft heißt das "Feature" Recall und ist standardmäßig Teil von Windows 11. Recall macht alle 30 Sekunden einen Screenshot und speichert diesen in einer Datenbank. Die KI kann diese Datenbank durchsuchen und dem Nutzer so helfen Sachen wiederzufinden. Die Verarbeitung geschieht laut Microsoft ausschliesslich lokal auf dem eigenen Rechner.

Google integriert zur Zeit ihr KI System Gemini tief in das Android Betriebssystem. Es soll es der Benutzerin ermöglichen die KI über alle Apps hinweg zu benutzen. Ohne das die App selbst KI Funktionen implementiert. Dies bedeutet jedoch auch, dass Gemini auf die Daten in allen Apps zugreifen kann. Da die Daten "in der Cloud" verarbeitet werden, erlangt Google somit Zugriff auf Chats und Daten die vorher privat waren.

(Mit Apples Plänen habe ich mich nicht auseinander gesetzt, aber auch hier wird im AI Game mitgespielt)

Die Entwicklung von KI Modellen benötigt massiv Daten. Aktuelle Modelle haben bereits alle frei zugänglichen Quellen leer gesaugt und benötigen Nachschub. Auch wenn die Systeme zur Zeit nicht genutzt werden um Trainingsdaten zu generieren, ist es nicht abwegig, dass sich dies schnell ändern wird. Im Wettkampf um die besten Modelle werden immer mehr Daten benötigt. Und Daten die Nutzerverhalten abbilden sind nicht erst im aktuellen KI Hype wertvoll geworden.

Auch OpenAI will Daten durch einen eigenen Browser Daten sammeln. Meta hatte noch nie ein augeprägtes Verständnis für Datenschutz und sammelt mit Facebook und Instagram fleißig mit.

Nur ein Schritt fehlt

Die Infrastruktur die man zum sammeln von KI Trainingsdaten und zur Überwachung ala Chatkontrolle benötigt unterscheidet sich nur in wenigen Details. In beiden Fällen benötigt man Funktionen die auf den Geräten der Nutzer Daten sammeln. Diese Daten müssen dann ausgeleitet werden um sie auf den eigenen Servern zu verarbeiten. Der Unterschied zwischen KI und Chatkontrolle ist am Ende nur was man mit diesen Daten machen will.

Die Chatkontrolle ist zum Glück vorest gescheitert, aber die Tech-Konzerne bauen zur Zeit Infrastruktur die sich leicht anpassen lassen kann um diese umzusetzen. Recall kann die Screenshots nebenbei auch auf potenziell illegale Inhalte untersuchen und melden. Bei Gemini werden die Daten direkt von Google verarbeitet und neben der AI kann auch noch ein zweites System Analysen durchführen.

Die so entstehenden Daten-Silos werden auch ein begehrtes Ziel für die Sicherheitsbehörden werden. Da die Infrastruktur beim nächsten Versuch eine Überwachung einzuführen quasi schon existiert, wird die Abwehr diese Begehren deutlich schwieriger werden.

#politik #ki #überwachung #datenschutz

You don't need to parse the data from the Wikipedia page, it is also available in Wikidata. However the data is not (always?) the same as in Wikipedia. For the example below the latest album was not linked yet (fixed now).

Example for Rise Against

SELECT ?album ?performerLabel ?albumLabel ?publication_date WHERE {
  VALUES ?performer {
      wd:Q246352
    }
   ?album wdt:P175 ?performer .
   ?album wdt:P31 wd:Q482994 .
   ?album wdt:P577 ?publication_date
   SERVICE wikibase:label { bd:serviceParam wikibase:language "en". }
}

I think the origin, or popularity, of services such as LinkTree is the artificial limitations of links in social networks. Instagram does not allow links in post and you can only have a single link in your profile. This makes it hard to promote a song or to link to multiple other channels.

Other platforms, such as LinkedIn, are suspected to limit the reach of articles if they include several links. Therefore people use an indirection through a router to keep links to a minimal.

I've started the journey by binge-watching the CMU Intro to Database Systems lectures. Andy Pavlo is an amazing lecturer, and I can only recommend this series to anyone wanting to understand DB systems or being nostalgic about their time at university.

My goal was to build a DB that could:

• store time series identified by an ID
• query and transform these series using a simple query language
• be accessible over the network

Core Structure

I've started my journey by figuring out to work with pages. This finally resulted in the following overall architecture for the core of my database.

A page directory serves as the central component handling pages in memory. Any other part of the system will retrieve and interact with pages through this directory. The directory itself is only responsible for pages in memory. Whenever it needs to persist or read pages from disk, it will use the File Manager.

The file manager is the single structure interfacing with the file system. Its only responsibility is to persist pages to disk and retrieve them again later on. Because to the layout of files I've chosen it knows some details about the database implementation, but could be refactored to be completely agnostic of the database using it.

The main user of the page directory is the B+Tree implementation. Series in the database system are represented by B+Trees. Other systems will instantiate B+Tree instances for each series they interact with. The tree structure loads necessary data from the series pages via the page directory.

Pages

Pages are the core entities of database systems. As databases have to deal with (much) more data than will fit into memory data has to be read and written to disk frequently. Therefore, all persistent data is structured into pages. In essence, pages are just data blocks of a specified size. These can be moved between disk and memory without transformations.

In my system, the start of each page is used as a page header. The header specifies what kind of data is stored in the page. Additionally, it has a version number for future use and a CRC hash to detect data corruption. The body of a page is just a block of data, which structure depends on its type. The interpretation of the body is controlled by the user of the page.

As pages are transferred between disk and memory, it is important to have exact control over their layout. Regular struct have no guarantees on the layout of fields in memory and have additional padding bytes between fields for alignment. Therefore, I used packed struct for all page definitions.

The size of a page is controlled by a comptime variable PAGE_SIZE. Thanks to zig's comptime feature, all related sizes and offsets can be derived from this and compile time. I can also derive capacity of the B+Tree branches and leaves (see below) from this. Therefore, I can simply adjust the page size, and all other parts will adjust accordingly.

/// total size of pages in bytes
pub const PAGE_SIZE: usize = 4 * 1024;
/// size of page header in bytes
pub const PAGE_HEADER_SIZE: usize = @bitSizeOf(PageHeader) / 8;
/// size of page data section in byters
pub const PAGE_DATA_SIZE: usize = PAGE_SIZE - PAGE_HEADER_SIZE;

One limitation I ran into is that zig does not (yet) allow arrays in packed structs . Because of this limitation, I had to define an integer type of the correct size to specify the body of the page, instead of simply using [BODY_SIZE]u8. Another alternative would have been @Vector(BODY_SIZE, u8) (as found in the issue), but this felt more wrong.

pub const PageHeader = packed struct {
    type: PAGE_TYPE,
    version: u8,
    crc: u32 = 0,
};

pub const PageData = @Type(.{ 
	.int = .{
		.signedness = .unsigned,
		.bits = PAGE_DATA_SIZE * 8
	}
});

pub const Page = packed struct {
    header: PageHeader,
    // data is only used as a blob of data, and not directly used
    data: PageData,
}

File Structure

After implementing my page structure, I had to think about how to organize them on disk. I've decided to store each series created in the database as an individual file. Pages within a file/series are identified by there position within the file. Thereby, it was easy to get any page for a particular series by the file name. An additional hope was that this would keep the related data close in the filesystem, improving performance, but I never tested this hypothesis.

This structure means that pages have two IDs; a local and a global ID. The local ID is the page's position within a series file. The global ID is the concatenation of series ID and the local page ID. The first page (local ID 0) of each file is a series header page. This page keeps information about the series. At the moment it only stores the ID of the root pages for the B+Tree.

Page Directory

The page directory is responsible for holding and managing pages in memory. On initialization, it allocates a fixed number of slots which can hold pages. Thereby, no memory has to be allocated when a new page is loaded from disk and the footprint of the directory is static. For each slot a PageHandle handle is created. These handles track usage of the slot; which pages is currently loaded, whether it has been modified or if it is currently in use.

The interface for the using systems is rather simple. Pages can be requested by there ID, either in read or write mode. The page directory transparently loads them from disk, through the file manager, and provides the corresponding page handle to the caller. Once the page is no longer needed the page handle is "returned" to the directory.

Eventually, during the runtime of the system, enough pages will have been loaded that all pages are occupied. At this point, a currently unused page has to be evicted. Each page handle has a used flag, which is set whenever anyone uses the page. When the directory looks for a free slot it iterates over the slots and skips any slot with a raised used flag and unsets it. Once it encounters a slot with an unset flag which is currently not locked the pages is replaced. This approach approximates "least recently used", but is much faster than a full implementation.

Modified pages are not directly saved to disk when they are freed by a writing user. Instead they are kept dirty in the directory and only written to disk when the page has to be evicted. To prevent data loss, I've added a background worker with cycles through all slots to persist dirty pages if they are currently not in use. (A lesson learnt after losing a few weeks of data which was never persists.)

B+Tree

I chose to represent series as B+Trees, a.k.a. the best data structure in computer science. In contrast to other time series databases, which often use LSM trees I chose to use B+Tree as it keeps the data ordered at every point in time. This makes traversal of the series data simple and (hopefully) fast.

B+Trees consist of branch and leaf nodes. Branch nodes keep a list of references to their children. Between two child references the branch keeps a threshold values. The referenced child between two threshold values will only hold values between these values. The rules by which the tree is transformed when values are added or removed keep it balanced, where a leaf nodes are at the same depth. This allows lookup of values within a few steps through the tree.

In my database the leaf nodes store tuples of (timestamp, value) in order. Additionally they hold a reference to their next sibling. This allows fast traversal of the leaf nodes when scanning over a time period.

Next Part: Query Language

#db #database #tsdb #dragondb #zig #dev

Ingredients

• 600g Dinkelvollkornmehl
• 200g Sonnenblumkerne
• 100g Basis-Müsli
• 6g Hefe
• 15g Salz
• 720g Wasser

Instructions

Das Rezept ist eine vereinfachte Variation von Dinkelvollkornbrot mit Nüssen. Die Saaten können nach belieben angepasst werden.

Vorteig

• 300g Dinkelvollkornmehl
• 300g Wasser
• 15g Salz

Saaten

• 200g Sonnenblumkerne
• 100g Basismüsli
• 300g Wasser

Hauptteig

• Vorteig
• Saaten
• 300g Dinkelvollkornmehl
• 120g Wasser
• 6g Hefe

Zubereitung

• Vorteig und Saaten in zwei Schüsseln ansetzten und mindestens 2 Stunden gehen lassen
• Alle Zutaten in einer großen Schlüssel verkneten bis homogen
• Hauptteig 2 Stunden gehen lassen und 3 mal dehnen und falten
• Hauptteig falten und zu Laib formen und in eine Brotform geben. Form gegebenfalls mit Backpapier auslegen oder einfetten.
• Form mit Alufolie oder Klarsichfolie abdecken
• Mindestens 12 Stunden im Kühlschrank gehen lassen. Teig sollte sich etwa im Volumen verdoppeln.
• Ofen nicht vorheizen. Brot einschneiden und für 90 Minuten bei 180°C Ober-/Unterhitze backen.
• Brot aus Form nehmen und weitere 10 Minuten ohne Form backen

#brot #dinkel #backen

Ingredients

• 550g Weizenmehl 550
• 430g Wasser
• 20g Olivenöl
• 15g Salz
• 10g Frische Hefe (oder 1/2 Packung Trockenhefe)

Instructions

Schnelles Ciabatta das ich spontan zum grillen gebacken habe. Mengen basieren auf Plötzblog: Ciabatta mit Sauerteig.

• Hefe in Wasser auflösen
• Alle Zutaten mischen und kurz kneten
• In einer Schüssel gehen lassen und alle 30 Minuten dehnen und falten bis sich das Volumen verdoppelt hat
• Ofen auf 250°C vorheizen
• Teig auf einer gemehlten Fläche teilen und zu zwei Laiben formen
• 15-20 Minuten backen

#brot #backen

Read this as it's from the same author as Blindsight. Has some intriguing elements, but came not close to other novels of Peter Watts i read.

Cannot recommend this enough! This is one of the novels I often have to think of and read multiple times.

#scifi

Absolutely agree. There are many books I rated 5/5 because. I enjoyed them and would definitely recommend them to anyone asking. But then their are books which changed my way of thinking or world perspective. They need their own rating. A "this goes up to eleven!".

#photography #bird #nature

#photography #bird #nature

#photography #tree

#bird #photography

#bird #photography

#bird #photography

#bird #photography

#bird #photography #nature

#bird #photography #nature

One of my favorite science fiction books. It plays in a world shortly before and after the AI singularity. I don't know how to describe it in a review without spoiling the journey, but I found many parallel to technologies and trends which should only emerge years after the publication of Accelerando.

#scifi #ai

Punkte zeigen einzelne Erhebungen, die Linie ist der Durchschnitt der letzten 14 Befragungen. Die Daten aller Institute wurde genutzt. Bei der "Gesellschaft für Markt- und Sozialforschung" habe ich die Sonstigen und BSW verworfen, da diese zusammen in einer Spalte aufgelistet wurden.

#politik #dataviz #btw25 #data

#bird #photography #nature

Mit der anstehenden Wahl wurde es Zeit die neuen Programme einzupflegen. Derzeit sind die meisten Programme nur Entwürfe, lediglich die Union hat schon ein fertiges Wahlprogramm.

Ein kleine Anleitung findet ihr hier: https://blog.libove.org/posts/wahlprogramme/

Der Source Code ist auf GitHub verfügbar: https://github.com/H4kor/wahlprogramme

#vegan Rouladen mit Rotkohl und Knödeln

Ingredients

• 4 Tofuhack
• 1 große Zucchini
• 3 Paprika
• 4 Zwiebeln
• 8 Knoblauchzehen
• 3 Lorbeerblätter
• 4 Dosen Tomatenstücke
• 4 TL Paprikapulver
• 2 TL Kreuzkümmel (gemahlen)
• 2 TL Oregano
• 1 TL Zwiebelpulver
• 1 TL gemahlener Pfeffer
• 2 EL Tomatenmark
• 1 Liter Gemüsebrühe
• 500 g Vollkorn Langkornreis
• 3 Dosen Kidney Bohnen

Instructions

"Chili" sin Carne Rezept für große Mengen zum einfrieren.

• Zucchini, Paprika und Zwiebeln würfeln
• Knoblauch hacken
• Gewürze mischen
• Tofuhack in Öl anbraten
• Gemüse hinzufügen und ein paar Minuten mit anbraten
• Gewürze und Tomatenmark kurz mit anbraten
• Mit Gemüsebrühe ablöschen und Tomatenstücke hinzufügen
• Kidney Bohnen und Reis hinzufügen
• ~40 Minuten köcheln lassen bis Reis gar ist. Wasser hinzufügen falls nötig

#vegan #chili

Main Features:

• Lists and Tags now have RSS Feeds.
• Nicer 404 Pages

For development I took the time to setup the "end-to-end" tests using go test instead of the previous pytest setup. This vastly simplifies testing and its much quicker.

To test #ActivityPub functionality I use a small mock server, which content can be controlled during testing.

#owlblogs

I've had #IndieAuth implemented in the "v1" of my blog, but only used it for the the #IndieWeb wiki. Did not yet bother to reimplement in v2.

For my DungeonPlanner project I wanted to use custom icons for the tool buttons. Unfortunately the documentation for this is rather slim. As an additional constraint, the image data should be embedded in the binary as I like to compile and ship a single binary file (as long as this is possible).

The nearest approach I could find was to create buttons with downloaded images. The snippet is for GTK3 so it had to be adjusted for GTK4, but it contained the right function names to know what to search for :).

This is the final code I ended up with:

let button = Button::new();
let bytes = include_bytes!("../../assets/icons/add_chamber.png");
let g_bytes = glib::Bytes::from(&bytes.to_vec());
let stream = MemoryInputStream::from_bytes(&g_bytes);
let pixbuf = Pixbuf::from_stream(&stream, Cancellable::NONE).unwrap();
let texture = Texture::for_pixbuf(&pixbuf);
let image = Image::from_paintable(Some(&texture));
button.set_child(Some(&image));

We start by creating a button. Instead of using the ButtonBuilder as you would normally do, I'm just creating an "empty" button. It should be possible to still use the builder, as we are just replacing the child content at the end.

let button = Button::new();

Next we need to load our image data. As I want my images to be embedded in the binary I use the include_bytes! macro. The raw bytes are then turned into a glib:Bytes struct and finally into a MemoryInputStream. The stream is needed to parse the image data.

let bytes = include_bytes!("../../assets/icons/add_chamber.png");
let g_bytes = glib::Bytes::from(&bytes.to_vec());
let stream = MemoryInputStream::from_bytes(&g_bytes);

The next goal is to create an Image object containing our embedded image. With GTK 4.6 we could still use Image::from_pixbuf but this will be deprecated in GTK 4.12. Instead we have to do an extra step and create a Texture and use Image::from_paintable. The texture can simply be created from a Pixbuf, which is created by using the Pixbuf::from_stream function

let pixbuf = Pixbuf::from_stream(&stream, Cancellable::NONE).unwrap();
let texture = Texture::for_pixbuf(&pixbuf);
let image = Image::from_paintable(Some(&texture));

Finally we can set the child of our button to the image and our icon button is done. The same approach also works for ToggleButton.

button.set_child(Some(&image));

#gtk #gtk4 #rust #gtkrs

It's all about data

The performance ("intelligence") of large language models (LLMs) mainly depends on the scale of its training data and the size of the model [1]. To create a better LLM you need to increase its size, and train it on more data. The architecture and configuration of an LLM can almost be neglected in comparison.

However, the intelligence of a model does not grow linearly with its size [1]. There is a diminishing return on increasing the size of LLMs. If you increase the size of model and training set by 10x, you will only get an increase in performance as the previous 10x increase accomplished. This explains why vast amounts of data are required to effectively train large language model.

ChatGPT 3 was trained on 500 billion tokens [2]. There are no official numbers (that I could find) on how much data was used to train ChatGPT 4, but rumors in the AI community state that it was trained on 13 trillion tokens. With this numbers the performance step from 3 to 4 took an 26x increase in data.

The estimation for the size of publicly available, de duplicated data is 320 trillion tokens [4]. This is 24.6x more data than ChatGPT4 was (likely) trained on. If these numbers are correct, the performance of LLMs will only increase as much as it increased from ChatGPT3 to ChatGPT4 before we ran out of data.

I doubt that this will be enough to reach AGI level intelligence.

Poisoned Data

Now you might say "we produce more data every day, models can get better in the future". We could just wait some decades, train new models from time to time and see a gradual increase in performance. And one day we suddenly have an AGI. But the release of ChatGPT created a problem. It poisoned any data collected after November 30, 2022.

The release of ChatGPT was the wet dream of every spammer, bot operator, troll and wannabe influencer. Suddenly you could create seemingly high quality content, indistinguishable from human written text, at virtually zero cost. Ever since the internet gets filled with LLM generated content. And this is a problem for all future trainings.

Models that are trained on their own generations (or data created by other models) start to forget, there performance declines [3]. Therefore you have to avoid training on AI generated content, otherwise the increase in data may decrease your performance. As it is virtually impossible to clean a dataset from AI generated text, any data collected after Nov. 2022 should be avoided. Maybe you can still use a few more months or years of data, but at some point more data will hurt the model more than it helps.

The publicly available data that we got now is all we will get to train an AGI. If we need more data it will have to collected at an exorbitant price to ensure it's not poisoned by AI generated data.

We reached a dead end

The size of current training sets and potentially available data shows that we will not reach AGI levels with the current state of the art approaches. Due to data poisoning we will not get substantially more usable data. Thereby AGI is (currently) not achievable. Opening pandora's box of accessible generative AI may killed our chance of creating an artificial general intelligence.

If we want to build an AGI we will have to do it with the data we have now.

#AI #AGI #LLM #GenAI

Ingredients

• 100 g Udon Nudeln
• Handvoll Sojaschnetzel
• 1 kleine Zucchini
• 1 kleine Karotte
• 1 EL Szechuan Pfeffer
• 1 Knoblauchzehe
• 1 cm Ingwer
• 1 EL schwarze Bohnenpaste
• 1 EL Sojasauce
• 1 EL Agavendicksaft
• 200 ml Wasser

Instructions

Dieses Rezept war ein bisschen frei Schnauze, ist aber wirklich gut geworden. Die Mengen sind im nachhinein geschätzt, also abschmecken und gegebenfalls anpassen.

• Sojaschnetzeln kochen
• Knoblauch und Ingwer fein hacken
• Alle Gewürze und Wasser mischen
• Karotten und Zucchini in dünne Scheiben schneiden
• Nudeln nach Packung kochen
• Sojaschnetzel anbraten
• Zucchini und Karotten für 2 Minuten mitanbraten
• Mit Gewürzmischung ablöschen
• Sauce reduzieren und Nudeln unterheben

#vegan #nudeln #udon #zucchini #karotten #szechuan #szechuanpfeffer

Spells

• Level 0 Spells
• Level 1 Spells
• Level 2 Spells
• Level 3 Spells
• Level 4 Spells
• Level 5 Spells
• Level 6 Spells
• Level 7 Spells
• Level 8 Spells
• Level 9 Spells

Magic Items

Armor

• Uncommon Armor
• Rare Armor
• Very Rare Armor
• Legendary Armor

Rings

• Uncommon Ring
• Rare Ring
• Very Rare Ring
• Legendary Ring

Rods

• Uncommon Rod
• Rare Rod
• Very Rare Rod
• Legendary Rod

Staves

• Uncommon Staff
• Rare Staff
• Very Rare Staff
• Only one Legendary Staff: Staff of the Magi

Weapons

• Uncommon Magic Weapon
• Rare Magic Weapon
• Very Rare Magic Weapon
• Legendary Magic Weapon

Wondrous Items

• Uncommon Wondrous Item
• Rare Wondrous Item
• Very Rare Wondrous Item
• Legendary Wondrous Item

Generators

• Random Potion Shop
• Random Scrolls Shop

Gamemaster Guide Tables

• Magic Item Table G

#DnD #5e #random #generator #tabletop

Ingredients

• 250g Nudeln
• 200g TK Erbsen
• 200ml vegane Sahne
• 1 Zwiebel
• 1 Knoblauchzehe
• 50g Hefeflocken
• 1 EL Olivenöl
• 1 EL Tomatenmark
• 1 TL Paprikapulver
• 1 TL Oregano
• Salz und Pfeffer

Instructions

Ein einfaches und schnelles Nudelgericht ideal für Kleinkinder. Schmeckt gut mit veganem Parmesan.

• Zwiebel würfeln und Knoblauch fein hacken
• Nudeln kochen
• Zwiebeln und Knoblauch in Olivenöl glasig anbraten
• Tomatenmark für 2-3 Minuten mitanbraten
• Erbsen, Hefeflocken und Gewürze hinzugeben, kurz mit anbraten
• Sahne und 100ml Wasser hinzugeben und gut verrühren
• Sauce unter gelegentlichem Rühren aufkochen
• Nudeln abgießen und alles gut durchmischen
• Mit Salz und Pfeffer abschmecken

#vegan #rezept #nudeln #erbsen

Ingredients

• 500g Fusilli Nudeln
• 250g Cherry Tomaten
• 125g Rucola
• 1 Glas veganes grünes Pesto
• 2 EL Agavendicksaft
• 2 EL Senf, mittelscharf
• 50g veganer Parmesan (optional)

Instructions

Die vegane Version meines Lieblings-Nudelsalats.

• Nudeln kochen und abkühlen lassen oder mit kalten Wasser abkühlen
• Rucola waschen und abtropfen lassen
• Tomaten halbieren oder vierteln
• Nudeln, Tomaten, Pesto, Agavendicksaft und Senf vermischen
• Mit veganem Parmesan abschmecken (optional)
• Rucola untermischen

#vegan #rezept #nudelsalat #einfach

As tags are also part of microformats2, I wanted to mark the hashtags accordingly. This is currently not possible with the hashtag extension.

I've extended this to allow adding arbitrary attributes to the link tag (Related Pull Request). Until this is merged into the main repository I'll use my own version, which can be done by adding a replace directive to the go.mod

replace go.abhg.dev/goldmark/hashtag => github.com/H4kor/goldmark-hashtag v0.0.0-20240619193802-bec327f5be38

#go #dev #owlblogs #markdown #indieweb

#emsflower #turtle #photography

A nice and simple solution to add comments to your blog.

I've decided to go the bit more complicated route and added #ActivityPub support to my blog directly. Any interaction will show up below the posts. However this requires a backend and will not work with a static site generator.

Thumbnails use the same file format as their parent files assuming the user already chose the best format for their images. The thumbnails are created with a width of 620px, equal to the content width of the blogs main body. If the image is already small enough the image data is simply copied.

The URL of a thumbnail can simply be generated by replacing /media/ with /thumbnail/.

I will still write some tests and see if any errors occur on my blog before merging this feature into the main branch.

#dev #blog

One reason against storing binary blobs in relational databases often stated is read performance, but I didn't find any benchmarks supporting this claim. Therefore I built a small test setup to see the difference between serving binary files out of a SQLite database vs serving from the file system directly.

As my blog is written in Go, I created the a simple server similar to my blog. It uses sqlx and go-sqlite3 for the database handling and net/http for the static file server

package main

import (
	"log"
	"net/http"

	"github.com/jmoiron/sqlx"
	_ "github.com/mattn/go-sqlite3"
)

type sqlBinaryFile struct {
	Data []byte `db:"data"`
}

type sqlHandler struct {
	Db *sqlx.DB
}

func (h *sqlHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	id := r.PathValue("filename")
	var sqlFile sqlBinaryFile
	h.Db.Get(&sqlFile, "SELECT data FROM files WHERE id = ?", id)
	w.Write(sqlFile.Data)
}

func main() {

	db := sqlx.MustOpen("sqlite3", "files.db")
	sql := &sqlHandler{Db: db}

	fs := http.StripPrefix("/dir/", http.FileServer(http.Dir("./static")))
	http.Handle("/dir/", fs)
	http.Handle("/sqlite/{filename}", sql)

	log.Print("Listening on :3000...")
	err := http.ListenAndServe(":3000", nil)
	if err != nil {
		log.Fatal(err)
	}
}

As a test set I created 2000 files between 200kb and 4MB in size using a simple python script:

import os
import random

for i in range(2000):
    os.system(f"head -c {(random.randint(200, 4000))}K </dev/urandom > static/{i:05d}.bin")

The SQLite database was created with this script:

import os
import sqlite3

os.remove("files.db")
con = sqlite3.connect("files.db")
cur = con.cursor()

cur.execute("CREATE TABLE files( id VARCHAR(255) PRIMARY KEY, data BLOB NOT NULL )")

for f in os.listdir("static"):
    print(f)
    data = open("static/" + f, "rb").read()
    cur.execute("INSERT INTO files(id, data) VALUES (?, ?)", (f, data))

con.commit()

To benchmark the server I created two files listing all file URLs (one for sqlite, one fot filesystem) and used siege to run the benchmark with this configuration.

siege -f urls_sqlite.txt -c 1 -b --time=10s -j

The test was executed on my laptop:

• CPU: Intel(R) Core(TM) i7-8565U CPU @ 1.80GHz
• CPU max MHz: 4600,0000
• Memory: 16 GB

I ran the test with different concurrency and plotted the results:

For a low throughput system (such as my blog) the difference between SQLite and the filesystem is small enough to not care about. The possible throughput (transaction/second) of the filesystem is ~2.3 times higher. The response time grows slower with increased concurrency.

For the time being I will stick with my SQLite solution. Once my blog gets really popular I can easily change the implementation of the binary repository.

#hosting #sqlite #go #benchmark #server

How many lightbulbs can I control with a single CPU?

Black and white profile picture of an alpaca. Its hair partially covers its eyes.

#photography

This looks great! I've been playing with the idea of creating a search engine for a while now. Maybe this will help to overcome my procrastination :D

• Possibility to follow/subscribe to all published entries ActivityPub (e.g. on Mastodon)
• Likes, announces (aka boosts) and replies are tracked on posts (example post with interactions)
• Replies to websites supporting ActivityPub will mention the author.
• Support for hashtags as implemented by Mastodon

Feel free to check out version 0.2.0. Feedback is always appreciated :)

Shot at #Emsflower.

#Bird #Colorful #Photography

Shot at #Emsflower

Shot during day trip to #Emsflower

Shot during day trip to #Emsflower

Ingredients

• 1 Brokkoli
• 1 handvoll Sojaschnetzel
• 1 EL Erdnussmus
• 1 EL Erdnussöl (oder anderes Öl)
• 6 EL Sojasauce
• 1 EL Ajvar
• 1 EL Agavendicksaft
• 2 Zehen Knoblauch
• 1 Daumen breit Ingwer
• Reis oder Udon Nudeln

Instructions

Eine einfache, vegane und nicht scharfe Erdnusssauce. Ich habe das klassische Sambal Oelek (oder Chilisauce) mit Ajvar ausgetauscht, um das Gericht für Kinder anzupassen.

Ich benutze die Sojaschnetzel von Vantastic als Fleischersatz. Alternativ kann auch fester Tofu gepresst und in Stärke gewendet benutzt werden. Oder einfach ganz weglassen, funktioniert trotzdem :).

Serviert wird das Gericht entweder mit Reis oder Udon Nudeln.

Eine wichtige Lektion die ich gelernt habe: wenn die Sauce zu dünn wird nicht mit Stärke andicken. Die Stärke zieht sämtlichen Geschmack aus der Sauce.

• Sojaschnetzel in Wasser mit 1 EL Sojasauce kurz aufkochen und ziehen lassen
• Brokkoli in mundgerecht Stücke zerschneiden
• Knoblauch und Ingwer fein hacken
• Erdmussmuß, Sojasauce, Ajvar, Agavendicksaft und ~150ml Wasser mischen und abschmecken
• Sojaschnetzel abgießen, abwaschen und goldbraun anbraten
• Knoblauch, Ingwer und Brokkoli hinzufügen und 1-2 Minuten mit anbraten
• mit einem Schuss Wasser ablöschen, ~2 Minuten Brokkoli garen lassen
• Erdnusssauce hinzufügen und ~5 Minuten köcheln lassen
• Mit Reis oder Udon Nudeln servieren

#vegan #rezept #erdnuss #brokkoli

If you like to try out owl-blogs or even contribute to the project, the main location of the code is now on GitHub.

H4kor/owl-blogs

Ein Rotkehlchen sitzt auf einer verzierten Stange

A frog sitting in a pond and croaking

In the future this can be done using the relative color feature coming to CSS, but this isn't yet widely supported.

    --primary: hsl(170, 66%, 28%);
    --secondary: hsl(from var(--primary) calc(h + 180) s l);

I figured out that you can achieve the same effect using the color-mix. This is already supported by all major browsers.

    --primary: hsl(170, 66%, 28%);
    --secondary: color-mix(in hsl longer hue, var(--primary), var(--primary) 50%);

The command mixes the primary color with itself in the HSL color space. Additionally it is specified that it should use the longer pass along the hue axis. As this will always be the 360° path, a mix of 50% will end up at the 180° complementary color to the primary color. The saturation and lightness will stay the same.

This allows for fast testing of colors using the developer console:

This can also be used to create other color palettes by changing the percentage accordingly.

First Look

My data source was a bunch of CSV files, which I combined into a single DataFrame, including latitude and longitude columns. I've used geopandas to plot this data for a first visualization. The DataFrame can be turned into a GeoDataFrame to create geometry information from the longitude and latitude columns. It's important to specify the right coordinate reference system (CRS) of your data.

With this conversion the data can be plotted using the plot function of geopandas

df = load_my_dataframe(...)
gdf = gpd.GeoDataFrame(
    df, geometry=gpd.points_from_xy(df["Longitude"], df["Latitude"]), crs="EPSG:4326"
)
ax = gdf.plot(
    column="ValueToVisualize",
)

Adding Boundaries

The shape of Germany is already recognizable, but some more context would be beneficial. For this reason I've added the borders of the German states to the plot. The shape files of all European countries can be downloaded from eurostat in various formats. I've used the "Polygon (RG)" version and the .shp format. The files contain the borders on different levels (country, state and regional borders). With a few lines the borders can be added to the plot.

border_file = "NUTS_RG_01M_2021_3035.shp/NUTS_RG_01M_2021_3035.shp"
eu_gdf = gpd.read_file(border_file)
eu_gdf.crs = "EPSG:3035"
gdf_de = eu_gdf[(eu_gdf.CNTR_CODE == "DE") & (eu_gdf.LEVL_CODE == 1)]
gdf_de.to_crs("EPSG:4326").boundary.plot(ax=ax, color="black")

Filling the Map

Using points to visualize this data is not the best approach. Instead I want to fill the entire map where each pixel is colored according to the nearest data point. This can be achieved by computing a Voronoi Diagram, where each data point is turned into a face. I've tried to use the geoplot library to compute the voronoi diagram, but it got stuck on my data. Luckily scipy also has a voronoi implementation, but it's a bit more work to use.

# create a box around all data
min_lat = df["Latitude"].min() - 1
max_lat = df["Latitude"].max() + 1
min_lon = df["Longitude"].min() - 1
max_lon = df["Longitude"].max() + 1
boundarycoords = np.array(
    [
        [min_lat, min_lon],
        [min_lat, max_lon],
        [max_lat, min_lon],
        [max_lat, max_lon],
    ]
)
# convert our data point coordinates to a numpy array
coords = df[["Latitude", "Longitude"]].to_numpy()
all_coords = np.concatenate((coords, boundarycoords))
# compute voronoi
vor = scipy.spatial.Voronoi(points=all_coords)
# construct geometry from voronoi
polygons = [
    shapely.geometry.Polygon(vor.vertices[vor.regions[line]])
    for line in vor.point_region
    if -1 not in vor.regions[line]
]
voronois = gpd.GeoDataFrame(geometry=gpd.GeoSeries(polygons), crs="EPSG:4326")
# create dataframe
gdf = gpd.GeoDataFrame(
    df.reset_index(),
    geometry=voronois.geometry,
    crs="EPSG:4326",
)

# plot borders
gdf_de.to_crs("EPSG:4326").boundary.plot(ax=ax, color="black")
# clip geometry to inside of map
clip = eu_gdf[(eu_gdf.CNTR_CODE == "DE") & (eu_gdf.LEVL_CODE == 0)]
gdf = gdf.clip(clip.to_crs("EPSG:4326"))
# plot data
gdf.plot(
    ax=ax,
    column="Monatsgradtage",
    cmap="Blues",
    legend=True,
)

Making it beautiful

The plot is almost done, I only want to clean it up a bit. As the axis don't serve any purpose here, I removed them. Additionally I've added a title and a small text to the bottom to include the source in the graphic.

ax.set_title(f"Heizgradtage 2020", fontsize=20)
ax.axis("off")
ax.text(
    0.01,
    0.01,
    "Quelle: https://www.dwd.de/DE/leistungen/gtz_kostenfrei/gtz_kostenfrei.html\nVisualisierung: Niko Abeler CC-BY-SA 4.0",
    ha="left",
    va="top",
    transform=ax.transAxes,
    alpha=0.5,
    fontsize=8,
)

Als Beispiel: Ein Tag mit konstanter Temperatur von 5°C ergibt 10 Heizgradtage ((15°C-5°C) * 1 Tag). Ein Monat mit 10°C ergibt 300 Heizgradtage ((15°C-5°C) * 30 Tage)

Die Visualisierung zeigt die Heizgradtage der Jahre 2010 - 2023 in Deutschland. Je kälter (mehr Heizgradtage) es in einer Region ist, desto dunkler wird diese dargestellt. Die Visualisierung basiert auf den Daten des DWD.

Parallel zu den Heizgradtagen gibt es auch die Kühlgradstunden. Hier werden die Stunden über einem Schwellwert (hier 18°C) gezählt. Eine Stunde mit 30°C ergibt somit 12 Kühlgradstunden. In dieser Visualisierung werden heiße Regionen in dunklerot dargestellt.

The service is currently hosted on games.rerere.org and provides three games:

• Rock Paper Scissors
• Tic-Tac-Toe
• Bunkers, an artillery game

The games can be played by mentioning the service and and your opponent in a note. I've mainly tested these with Mastodon but they should also work with other fediverse apps.

I want to release the source code soon, but it still needs some clean up, documentation and testing to be useful to anyone. The server is written in go and if you want to build something similar I've used these libraries to help with the ActivityPub implementation:

• go-ap/activitypub
• go-ap/jsonld
• go-fed/httpsig

// truncated for simplicity
type Entry interface {
	ID() string
	Content() EntryContent
	PublishedAt() *time.Time
	Title() string
	SetID(id string)
	SetPublishedAt(publishedAt *time.Time)
}

One problem with this is, that I have to implement these functions for each type of entry. Many of these implementation will be identical leading to a high degree of code duplication. To avoid this I've created an EntryBase, which implements sensible defaults.

type EntryBase struct {
	id          string
	publishedAt *time.Time
}

func (e *EntryBase) ID() string {
	return e.id
}

func (e *EntryBase) PublishedAt() *time.Time {
	return e.publishedAt
}

func (e *EntryBase) SetID(id string) {
	e.id = id
}

func (e *EntryBase) SetPublishedAt(publishedAt *time.Time) {
	e.publishedAt = publishedAt
}

With this "base class" the specific implementations only have to implement functions which differ between entry types.

type Article struct {
	EntryBase
	meta ArticleMetaData
}

type ArticleMetaData struct {
	Title   string
	Content string
}


func (e *Article) Title() string {
	return e.meta.Title
}

func (e *Article) Content() model.EntryContent {
    // render content from markdown	
}

Ingredients

• 250g Risotto Reis
• 1 Glas Kichererbsen
• 400g Champignons
• 2 kleine Zwiebel
• 2 Knoblauchzehen
• 25g getrocknete Pilze
• 300ml Gemüsebrühe
• ½ Dose Kokosmilch
• 1 EL Sojasoße
• 1 EL Balsamico Essig
• Thymian und Pfeffer

Instructions

• Getrocknete Pilze in 300 ml Wasser einweichen (~30 min). Aus Wasser nehmen und grob hacken. Wasser aufbewahren!
• Pilze in Würfel schneiden und in Olivenöl goldbraun anbraten. Anschließen aus der Pfanne nehmen und beiseite Stellen.
• Zwiebel und Knoblauch fein gehackt bei mittlerer Hitze leicht braun anbraten.
• Reis und getrocknete Pilze hinzufügen und 1-2 Minuten mit anbraten. Mit Pilzewasser ablöschen.
• Pilze und Kichererbsen hinzufügen.
• Mischung aus Gemüsebrühe, Sojasoße, Essig und Thymian portionsweise hinzugeben.
• Solange kochen und Flüssigkeit hinzufügen bis Reis fast gar ist.
• Kokosmilch und Pfeffer hinzufügen. Für etwa 5 Minuten kochen bis gewünschte Konsistenz erreicht ist.

#vegan #kichererbsen #pilze #rezept

To create a menu bar in GTK4 we need a MenuModel, from which the bar is created. The MenuModel can be derived from a Menu object. Menu objects can have sub menues and and MenuItems as children, buidling a tree structure which represents the entire menu of the application.

Let's start at the end of our menu definition, by defining the root of the menu tree. The root should only have sub menues as children.

let menu = Menu::new();
menu.insert_submenu(0, Some("File"), &file_menu);
menu.insert_submenu(1, Some("Edit"), &edit_menu);
let menu_model: MenuModel = menu.into();

This is our root menu and derived model. The first parameter determines the ordering of the menu entries. The second parameter defines the name displayed in the menu bar and the last parameter is a reference to another Menu object. In this example menu has two children "File" and "Edit" which are further menus we have to define.

The resulting menu bar will look similar to this:

The menus are Menu objects. To add selectable entries, MenuItems are inserted. The first parameter defines the ordering within the menu. I tend to leave gaps in my ordering to allow insertions later, without changing all order numbers. The MenuItem takes two (optional) strings as parameters. The first string is the string shown in the menu. and the latter references an action. This action is executed if the menu item is selected.

let file_menu = Menu::new();
file_menu.insert_item(0, &MenuItem::new(Some("New Dungeon"), Some("file.new")));
file_menu.insert_item(5, &MenuItem::new(Some("Open ..."), Some("file.open")));
file_menu.insert_item(10, &MenuItem::new(Some("Save ..."), Some("file.save")));

The resulting menu looks similar to this:

(Note that the shown shortcuts are automatically added when an accelarator is defined for the action).

To define the effect of selecting a menu item, actions have to be added to the window. I insert actions into action groups to organize them by their main menu. This code defines two actions in the "file" action group; "file.new" and "file.open". The name of the action group is defined when the group is added to the window.

let file_actions = SimpleActionGroup::new();

let action_file_new = ActionEntry::builder("new")
    .activate(
        move |_group: &SimpleActionGroup, _, _| {
            // Define behavior here
        },
    )
    .build();

let action_file_open = ActionEntry::builder("open")
    .activate(
        move |_group: &SimpleActionGroup, _, _| {
            // Define behavior here
        },
    )
    .build();

file_actions.add_action_entries([
    action_file_new,
    action_file_open,
]);

window.insert_action_group("file", Some(&file_actions));

For further organization of menu entries, sub menues can be used. This uses the same method as used on the root menu.

edit_menu.insert_submenu(20, Some("Change Mode"), &mode_menu);

This results in a sub menu similar to this

After defining the menu and deriving the MenuModel a PopoverMenuBar can be created and added to the application window. This can be achieved by wrapping the content of the window in another box and adding the menu bar to this box.

let menubar = PopoverMenuBar::from_model(Some(&menu_model));

let window_box = gtk::Box::builder()
    .orientation(gtk::Orientation::Vertical)
    .build();
window_box.append(&menubar);
window_box.append(&main_box);

// Create a window
let window = ApplicationWindow::builder()
    .application(app)
    .child(&window_box)
    ...
    .build():

The full code used in these examples can be found in the DungeonPlanner Source Code

#rust #gtk #gtk4 #gtkrs

(All texts are generated with ChatGPT)

• Dungeon PDF: ThievesHideout.pdf
• Dungeon File: ThievesHideout.dungeon

DungeonPlanner is a small and simple tool I use to create and plan dungeons for tabletop games. It is game system agnostic and should be applicable to most tabletop games.

Feedback is appreciated as always :)

Mouse Position

The mouse position can be obtained by using an EventControllerMotion. This is added to the DrawingArea.

let pos_controller = EventControllerMotion::new();
pos_controller.connect_motion(move |_con, x, y| {
    ...
});
drawing_area.add_controller(pos_controller);

Mouse Clicks

For each mouse button you want to "observe" a GestureClick is created and added to the DrawingArea.

let gesture_click = GestureClick::builder()
    .button(GDK_BUTTON_PRIMARY as u32)
    .build();

gesture_click.connect_pressed(move |_, _, _, _| {
    // create to mouse click
});
drawing_area.add_controller(gesture_click);

let control_key = gtk::EventControllerKey::new();

control_key.connect_key_pressed(move |_, key, _, _| {
    match key {
        gdk::Key::Right => { ... },
        gdk::Key::Left => { ... },
        gdk::Key::Up => { ... },
        gdk::Key::Down => { ... },
        _ => (),
    }
    glib::Propagation::Proceed
});
window.add_controller(control_key);

Ingredients

• 200g Cashews
• 60g Hefeflocken
• 1 TL Knoblauchpulver
• 1 TL Salz

Instructions

Alle Zutaten in einen Standmixer geben und solange zerkleinern bisam ein feines Pulver hat. Sobald die richtige Konsistenz erreicht ist, "fließt" der Parmesan nicht mehr richtig beim mixen und leicht klumpig wird.

#vegan

As the set didn't include any screws I've decided to print some for her. The screws are compatible with the wrench and screwdriver of the "klein Bosch Work-Box". The holes of the block are loose enough to easily screw in the bolts.

I've used Blender to create these. For my first try I've created my own screw using the "Screw" modifier applied to a triangle. This worked okay, but the resulting screw was too loose and would just slip into the hole. For the next try I used the plugin "Bolt Factory" to create the screw part and only kept my previously designed head.

Things I've learned:

• A 6-vertices circle with 18mm circumference is not the same as a 18mm screw head. The "18mm" refers to the distance between to edges, not two vertices.
• 3D printed screw holes need a lot more "room". Simply scaling by the X and Y axis worked for my "triangle screw" but not the generated screw. Instead I had to thicken and thin the bands of the screw.

All files can be used under the CC-BY 4.0 License.

• Blender File
• Screw STL
• 1-Hole Block
• 5-Hole Block

I generally try to avoid database specific feature for as long as possible in my projects. Ideally I'm able to use SQLite in local development and automated testing and only start using Postgres in the testing and production environment. This works great with abstraction layers such as SQLAlchemy and Django and allows me to postpone the decision for a specific database system for as long as possible. As a nice bonus it keeps the testing setup very simple as I can simple use an in memory SQLite.

The growing memory requirements were the point where I had to choose a specific database. As I use PostgreSQL virtually always in production systems I looked into the options it provided to optimize my queries.

The main problems where cause by the episode data, a ~9 GB table with +11 million rows. I already had indexes in place but the queries for the audio properties of podcasts still took +1 minute per plot. This meant that "live" queries where no longer possible and I needed a solution to store (partial) results.

I've chosen to use materialized views as they are a great fit for my problems. The data presented on the page doesn't have to be updated with every newly analyzed audio file. It is sufficient to get an update once per day (even once per week would be fine). The transformations required can easily be done in SQL.

Materialized views behave almost like a regular table, but you cannot directly create or update rows in the table. Instead the content is created from an SQL statement, executed once on creation or upon refreshing the view.

Creating a materialized view is simple:

create materialized view pub_hist 
select date(publishing_date), count(*)
from episode e
group by date(publishing_date)

This command executes the selection query and stores the result in the view pub_hist. Afterwards you can simply query from this view:

select *
from pub_hist
where "date" < now()

Other than normal views the content of the materialized view is not updated automatically. Instead you have to trigger a refresh, which will reevaluate the defined query and store the result:

REFRESH MATERIALIZED VIEW pub_hist;

To refresh the views I simply run a daily (celery) job, which calls the refresh command for all views.

Ingredients

• 1 Dose Tomatenstücke
• 2 Knoblauchzehen
• 1 EL Olivenöl
• Oregano
• Thymian
• Salz und Zucker
• Optional: 1/2 Chili (getrocknet oder frisch)

Instructions

• Knoblauch schälen und grob hacken
• Auf mittlerer Hitze in einem kleinen Topf Olivenöl und Knoblauch erhitzen
• Unter ständigem rühren den Knoblauch im Öl 2-3 Minuten garen. Der Knoblauch darf nicht braun werden
  • Chilis ebenfalls mitgaren falls gewollt
• Tomatenstücke dazugeben und zum köcheln bringen
• Kräuter und eine Prise Salz und Zucker hinzugeben
• Herd auf niedrige Hitze drehen und mit halb aufgelegtem Deckel für 20-30 Minuten einköcheln lassen
• Mit dem Pürierstab zur gewollten Konsistenz zerkleinern
• Heiß in ein verschließbarers Glas füllen, kann mindestens eine Woche im Kühlschrank gelagert werden

Rezept für Pizzateig

Ingredients

• 3-4 EL Passata
• 1/2 EL Olivenöl
• 1 TL Oregano
• Prise Salz
• Prise Zucker

Instructions

All Zutaten zusammengeben, gut mischen und direkt auf die Pizza. So einfach!

Wer mag kann auch noch etwas Knoblauchpulver geben. Für eine pikante Soße einfach ein bisschen Chili aus der Mühle dazu.

Ingredients

• 400 g carrots
• Juice of a lemon
• 175 ml sunflower oil
• 400 g flour
• Pack of baking soda
• 2 Packs of vanilla sugar
• 200 g sugar
• 100 g chopped almonds
• 1/2 table spoon cinnamon
• 2 cm ginger
• pinch of salt
• powdered sugar and lime juice

Instructions

• Preheat your oven to 165°C
• Grate the carrots and ginger and mix it with the oil and lemon juice
• Mix all dry ingredients (flour, sugar, almonds, baking soda, vanilla sugar, cinnamon and salt) in another bowl.
• Add the mixed dry ingredients to the carrots and mix everything thoroughly.
• Fill everything in your cake pan and bake at 165°C for 60 minutes
• Mix powdered sugar and lime juice to a viscous liquid and spread if over the finished cake

#vegan #cake

Ingredients

• 1 Aubergine (eggplant)
• 3 spring onions
• 1 small onion
• 150 ml water
• 1 table spoon soy sauce
• 1 table spoon rice vinegar
• 1 tea spoon curry paste
• 2 tea spoons sugar
• 1/2 tea spoon salt
• 1-2 cm of ginger root
• 3 cloves of garlic
• 1 table spoon starch
• peanut oil
• rice

Instructions

• Cut aubergine into large, long pieces (~4 cm long, ~2 cm thick)
• Chop ginger and garlic, cut spring onions and onions into thin rings
• Mix water, soy sauce, rice vinegar, sugar and salt
• Mix starch with a small amount of water.
• Fry in oil until golden brown. Press with spatula to release water
• Put aubergine pieces aside and add new oil into the pan
• Fry curry paste, garlic, ginger, green onions and onions for a short time
• Add mixed water and aubergine pieces to the pan and cook everything for 2 minutes
• Add starch to thicken the sauce
• Serve with rice

Ingredients

• 1 Onion
• 1 Garlic
• 1 cm fresh ginger root
• 1 Carrot
• 3 table spoons Coconut oil
• 1,5 table spoons red curry paste
• 300 g Beluga lentils
• 1 can tomatos (chunky or whole)
• 1 can Coconut milk
• 550 ml vegetable stock
• 1 sweet potato
• 2 table spoons lime juice
• Salt and pepper

Instructions

Origin: https://www.rewe.de/rezepte/veganes-beluga-linsen-curry/

• Peel and chop the onions, garlic, ginger root and carrots.
• Fry for 2 minutes. Add curry and lentils and fry for a short time
• Add Tomatos, coconut milk and 200 ml vegetable stock.
• Cook for 10 minutes and peel the sweet potato
• Add sweet potato and cook for 20 minutes. Add vegetable stock periodically
• Add lime juice. Season with salt and pepper.

Ingredients

• 350g 550 Mehl
• 200ml Wasser
• 10ml Olivenöl
• 5g Salz
• ~5g frische Hefe

Instructions

Vorbereitung

• Mehl und Salz in einer Schüssel mischen
• Hefe in Wasser auflösen und zum Mehl geben, Olivenöl hinzufügen
• Mit einer Gabel die Flüssigkeit untermischen
• Sobald man mit der Gabel nicht mehr weiterkommt per Hand kneten bis ein homogener Teig entsteht
• 30 Minuten bei Raumtemperatur ruhen lassen und nocheinmal kurz kneten
• 1-3 Tage im Kühlschrank lagern, einmal täglich falten.

Backen

• Teig in Portionen teilen, 275g für eine Pizza 550g für ein Blech
• Kurz kneten um einen runden Teigballen zu formen
• Mit einem Schuss Olivenöl in einer Schüssel 2-3 Stunden ruhen lassen
• Teig per Hand strecken, nicht ausrollen, und belegen
• Pizza ca. 8-10 Minuten (Blech 15-20 Minuten) bei 250°C backen.

There are two common methods to count visitors: extract the number from server logs or using an analytics software with an HTML snippet. Both approaches have limitations which will result in distorted numbers.

Using analytics snippets tends to result in an underestimation of visitor counts. A significant portion of internet users have an AdBlocker, leading to their exclusion from the count. Additionally, certain users might disable JavaScript or refrain from loading resources from external domains, further contributing to the under counting issue.

On the other hand, relying solely on server logs tends to overstate the number of visitors. This is because a significant portion of server logs comprises entries generated by bots and crawlers, which should ideally be filtered out to arrive at an accurate visitor count. Yet, many bots attempt to conceal their identity, making this filtering process challenging. Furthermore, some legitimate visitors might be counted multiple times, for example when they switch networks and acquire new IP addresses.

The true number of visitors will lie somewhere between the value produced by your analytics snippet and a number calculated from server logs. Unfortunately there is no way to retrieve the "true" number of visitors.

In conclusion: There is no true visitor number, it always depends on how you count and your definition of a visitor.

Podcast de facto Standard

For the information about tag usage, I used defusedxml and written some basic validators to check that the tags included are also valid according to there specification.

The audio analysis is done using ffmpeg and ffprobe. I only extract basic features provided by these tools.

I hope this information is helpful to the podcasting community and people building their own podcasting system.

My next step will most likely be POSSE as I often post photo to multiple sites manually.

I started by building small test print using Blender, to test if the ESP8266 could be mounted on small pins. Luckily I took this step, as I mismeasured the spacing of the pins, which could be easily fixed at this stage. Additionally the print showed that my printer was stringing a lot, which I fixed by changing the retraction settings.

The next step was to design the case. For this I simply added 1mm thick walls around the mounting. Using boolean functions I've added holes for the USB port and the reset button. Additionally I've added a lid to the case, which was simply placed on a 0.5mm lip in the case.

The design revealed some issues, which I fixed in the next iteration. The holes in the lid were too small and the printer was having trouble printing them. The USB port cutout had to be moved and increased slightly. Additionally the box was to small to fit the ESP8266 and the DHT22 and I added 1cm to the height of the box. These changes led to the second design.

I used this design for a day, which revealed another issue. The sensor was reporting too high temperatures, by about 3 degrees Celsius. This was caused by the fact that the DHT22 sensor was too close to the ESP8266. I had to separate the two components by increasing the size of the box and adding a separation wall.

As I had to redesign the case anyway, I also redesigned the lid. I changed the design of the holes from cubes to octagons. The lid is now held in place by protusions which fit into holes in the case. I added additional holes to the case, where the DHT22 sensor would be located.

The case still has some potential for improvement, but I'm happy with the current design for now.

The files for the case can be found below and can be used under the CC BY-SA 4.0 license.

• Blender file: case.blend
• STL files:
  • Case case.stl
  • Lid lid.stl

This was the first 3D print I did, to test the printed. The result is great, stringing being the only issue. I will now try out different retraction settings to reduce stringing.

I baked pizza for dinner. My daughter got her own piece with tomatoes.

Ingredients

• 600g Dinkelvollkornmehl
• 150g Hafermilch
• 150g Walnüsse
• 150g Haselnüsse
• 30g Leinsamen
• 70g Basismüsli
• 6g Hefe
• Sonnenblumkerne

Instructions

Das Rezept basiert auf dem Dinkelvollkornbrot mit Buttermilch von Plötzblog und ist eine vegane Anpassung. Die Saaten können variiert werden, benutzt einfach was ihr da habt und mögt.

Vorteig

• 300g Dinkelvollkornmehl
• 150g Hafermilch
• 150g Wasser
• 15g Salz

Saaten

• 150g Walnüsse
• 150g Haselnüsse
• 30g Leinsamen
• 70g Basismüsli
• 400g Wasser

Hautteig

• 300g Dinkelvollkornmehl
• 110g Wasser
• 6g Hefe
• Vorteig und Saaten
• Sonnenblumkerne zum rollen

Zubereitung

• Vorteig und Saaten mindestens 2 Stunden ruhen lassen.

• Hauptteig per Hand kneten bis homogen.

• Hauptteig 2 Stunden gehen lassen und währenddessen 3 mal falten

• In Sonnenblumkerne rollen und in gefettete Backform geben.

• Mindestens 12 Stunden in Kühlschrank gehen lassen, Volumen sollte sich etwas verdoppeln. Ansonsten vor dem backen bei Raumtemperatur weiter gehen lassen.

• Vor dem Backen befeuchten und bei 180°C Ober-/Unterhitze für 90 Minuten backen.

• Anschließend 10 Minuten ohne Form backen.

Ingredients

• ½ großen Blumenkohl
• 4-6 Kartoffeln
• 100ml Hafermilch
• 1TL Paprikapulver
• 1/2TL Korianderpulver
• Weizenmehl (550)
• Paniermehl
• Rosmarin
• Olivenöl
• Salz und Pfeffer

Instructions

Blumenkohl-Wings

• Blumenkohl in mungerechte Stücke zerlegen
• Paprikapulver, Koriander, Salz und Pfeffer mischen
• Mit Mehl andicken bis man einen dicken Backteig hat
• Blumenkohl in Teig und Paniermehl wenden und auf Backblech legen
• Mit Olivenöl beträufeln

Kartoffeln

• Kartoffeln schälen und in Würfel oder Wedges schneiden
• Mit Salz, Rosmarin und Olivenöl mischen und auf das Blech geben

Alles bei 190° für 30-40 Minuten backen.

Artists on Artstation started to post "No AI" images

AIs (still) rely on vast amounts of training data. To build improved models, larger and larger datasets are required. Models will have to be retrained periodically to include new concepts in the model. Image generators have to be updated to be adjusted to the ever shifting taste of the humans using them. Text generators have to learn the latest memes to stay relevant.

The explosive popularity of AI generated content will lead to new challenges when building new datasets. I see two ways how the progress on these generative models can be slowed down or even stopped entirely by their own popularity.

Self Poisoning

The datasets used for this a generally created by scraping the required data from the internet. This means everything posted to Reddit, Twitter and the rest of the internet is collected, cleaned and prepared for training AIs. The cleaning part will become harder and harder with each new iteration of generative models, as you want to avoid content created by the AI in your training set.

An AI system trained on data created by the system itself will not become better, as the information in the data is already known by the system. If the data used are valid examples, this might just waste computation time while training data model. But any poor examples will degrade the performance of the resulting model.

If a considerable portion of the training data comprises examples created by a previous version of a generative model, the next model will learn to recreate the style and errors of the previous model.

Adversarial Poisoning

A lot of artists hate generative models, especially for their ability to mimic the style of individual artists. This has led some to hide their artworks, because they don’t want to provide even more data to these systems. If the concerns of artists are ignored, some might try to sabotage the systems which steal their art style.

A common technique for using Stable Diffusion is to give a prompt like “A cat sitting on a bench, by Artist X”. For artists with a large portfolio, this creates results which, on a first glance, could have been created by these artists. As datasets are generated automatically, it might be possible to introduce adversarial examples into the training data which destroy such prompts.

Artists might publish decoy “artworks” on their feeds. These decoys would be easily recognisable by humans, but scraping systems would include them in the training sets. If an artist has more decoys than real artworks associated with their name, the AI system will mimic the style of the decoy.

Artworks can be published with surrounding noise. Instead of just publishing an image, the image might be extended by random frames. The descriptions could be extended by additional nonsense descriptions.

All these countermeasures can be circumvented, but this will be expensive. For general models, trained on massive data models, such cleaning measures will most likely be too expensive. However, fine tuning a model only requires a relatively small training set. Cleaning such a dataset for a single artist will be a simple task. The poisoning will only be a minor inconvenience for people creating such specialized models.

alias vv=". venv/bin/activate"
alias djs="python manage.py shell"
alias djr="python manage.py runserver"
alias djmm="python manage.py makemigrations"
alias djmi="python manage.py migrate"

Extended the editor to allow replies. Still have to add a scraper to fill in the title of the referenced page automatically.

Up until now I wrote all my articles either directly on the server or on my PC. For this I use a convoluted system, partially working on the server, partially on my PC with git and ssh in between. As this process is tedious it keeps me from writing short updates.

The online editor is still every limited but I will extend it as needed. Additionally I've adjusted some of the internal structure of the blog to allow for different types of post. This will allow me to also write short notes, which will not show up in the main feed.

My own algorithm turned out to be quiet slow when compared to networkx. For this reason I also reimplemented the networkx algorithm, but with multithreading support. The most important feature for me was the ability to load the graph from a binary file. While networkx used to much data while ingesting the graph data, I can effortlessly write it to file and load it in graph_force.

At the moment this library fulfils my needs, but with publishing I commit to maintaining it. Maybe this is useful to someone else.

Creative usage of web assembly as a "universal" binary, running on every machine. I'm currently using both Rust and Go. Will keeps this in mind if I ever want to combine them :)

I've scraped the tweets of all (known) accounts and created a website to browse all community tweets. I tried to assign the tweets to episodes based on the airing dates. With the current acquisition of Twitter by Musk and the following "turbulences" it might be a good idea to check the project again to see if more data can be preserved. It would be a shame if this piece of my favorite show disappeared forever.

The source and prepared datasets can be found on GitHub.

The show also add a homepage for the fictional community college. Sadly the website is no longer available but it's in the internet archive. Sadly the videos of the A/V Department did not survive.

Because I still want to visualize this graph, I've decided to write my on graph layouting program. For the first implementation I followed the slides of a lecture at KIT. This gave me some janky but promising results, as I was able to load my graph and an iteration only required ~10 seconds. To validate my implementation I created a debug graph, consisting of 2000 nodes with 4 clusters of different sizes.

After this first implementation I took pen and paper and thought about the problem a bit. This lead to an improved version, with a simpler model leading to faster execution times and quicker convergence.

Embedding the mastodon instances graph, is still challenging. The algorithm creates oscillation in the graph, which I suspect are introduced by one (or multiple) large cliques. I will post an update soon.

Update:

Bonus image of the florentine families graph:

For my first steps I used requests. As this was too slow, with many servers not responding, I switched to aiohttp to run multiple concurrent requests.

I used a many loop which started new request tasks and waited for these tasks to finish. Whenever a request task finished I wrote the result in an SQLite database for later analyses and started another request task. This achieved a good throughput and crawled the "entire" mastodon world in a few hours.

I might add a cleaned up version of the script in the future.

Things I learned:

• first time seriously working with asyncio and aiohttp in python.
• asyncio.wait returns a done and pending. I used this to process done requests and afterwards replaced my tasks list with the pending return value.
• sqlite does not work well with asyncio. This is why stored the results in the main loop.
• I found it easiest to catch all error in my request function and return a tuple with an success indicator (return result, success) instead of allowing raised errors in the the async task.

If you want to implement IndieAuth yourself I recommend using the living standard document directly. I've started using the wiki page as reference and later realised that it was outdated (the outdated content has been removed in the meantime). IndieAuth is basically OAuth2 with a few additions and conventions. If you are already familiar with OAuth2 you probably not have many problems implementing this. My (first) implementation can be found in this pull request.

Before I continue with Micropub, I have to do some refactoring as the code is still a bit rough around the edges.

Things I learned while implementing IndieAuth:

• CSRF does not require server state. You can use the Double Submit Cookie
• Learned how PKCE works and that it is rather simple.
• Got a deeper understanding of OAuth2 in general. Previously I always used server and client libraries (as any responsible developer should!)

For this guide I will assume that we have a yaml format like this:

title: "How to parse YAML dates"
date: 17-10-2022

The corresponding definition in Go looks like this:

type Data struct {
	Title   string    `yaml:"title"`
	Date    time.Time `yaml:"date"`
}

When we try to unmarshal the above yaml it will result in an error: parsing time "17-10-2022" as "2006-01-02T15:04:05Z07:00": cannot parse "0-2022" as "2006". To support this format the unmarshal behavior of the Data struct has to be overwritten.

func (d *Data) UnmarshalYAML(unmarshal func(interface{}) error) error {
	type T struct {
		Title string `yaml:"title"`
	}
	type S struct {
		Date string `yaml:"date"`
	}

	// parse non-time fields
	var t T
	if err := unmarshal(&t); err != nil {
		return err
	}
	d.Title = t.Title

	// parse time field
	var s S

	if err := unmarshal(&s); err != nil {
		return err
	}

	possibleFormats := []string{
		"02-01-2006",
		time.Layout,
		time.ANSIC,
	}
	var found_time bool = false
	for _, format := range possibleFormats {
		if t, err := time.Parse(format, s.Date); err == nil {
			d.Date = t
			found_time = true
			break
		}
	}

	if !found_time {
		return fmt.Errorf("could not parse date: %s", s.Date)
	}

	return nil
}

Let's break this down.

func (d *Data) UnmarshalYAML(unmarshal func(interface{}) error) error {

In order to control the unmarhalling of a yaml file, we have to provide an UnmarshalYAML function for the struct. This function is passed an unmarshal function which can be used to parse arbitrary structs. We will use this function multiple times to retrieve different parts of the yaml file.

	type T struct {
		Title string `yaml:"title"`
	}
	type S struct {
		Date string `yaml:"date"`
	}

Next we separate our Data struct into two parts; one for everything we just want to keep as it is and one for the date field. Note that the date field is using string as its type, as we want to do the time parsing ourselves.

	// parse non-time fields
	var t T
	if err := unmarshal(&t); err != nil {
		return err
	}
	d.Title = t.Title

For all fields that we want to keep untouched, we just have to call the unmarshal function and, if no error occured, copy the data to our data struct. To parse the date we start similarily, by getting the time string.

	// parse time field
	var s S

	if err := unmarshal(&s); err != nil {
		return err
	}

Aftwards the function loops over all formats that we want to support and check if the string matches any format. The list of possible formats can be extended. I kept it short in this example. You can find the full list I use at the bottom of the tutorial.

	possibleFormats := []string{
		"02-01-2006",
		time.Layout,
		time.ANSIC,
	}
	var found_time bool = false
	for _, format := range possibleFormats {
		if t, err := time.Parse(format, s.Date); err == nil {
			d.Date = t
			found_time = true
			break
		}
	}

Finally, we check if any format matched.

	if !found_time {
		return fmt.Errorf("could not parse date: %s", s.Date)
	}

	return nil

Now our Data struct will accept any time format we add to the possibleFormats list. This is the full list I currently use in my blog software, the latest code can be found in the owl-blogs project.

	possibleFormats := []string{
		"2006-01-02",
		time.Layout,
		time.ANSIC,
		time.UnixDate,
		time.RubyDate,
		time.RFC822,
		time.RFC822Z,
		time.RFC850,
		time.RFC1123,
		time.RFC1123Z,
		time.RFC3339,
		time.RFC3339Nano,
		time.Stamp,
		time.StampMilli,
		time.StampMicro,
		time.StampNano,
	}

reply:
  url: "https://borghal.blog/note/2022/09/11/194932/"

Hope this works for your webmention implementation :)

Leveling up my IndieWeb game

My markup is still a bit rough and minimal. I guess you could use the name in my h-card, but I definitely should add the author to the h-entry.

Leveling up my IndieWeb game

I'm currently in the same process. I've just retrieved and sent my first webmentions two weeks ago. I really like the way you integrated the mentions into you blog, my implementation is still very basic in that regard.

Micropub is also high on my list, after attending the Homebrew Website Club this week, as I'm still missing a convenient and fast method to create new post. Especially shorter once, like replies to post.

The problem: most of the top answers you find on Google and StackOverflow are wrong. They will break in the presence of , or " in the data. Additionally all I found are vulnerable to CSV injections.

Usage:

• yourData is the data you want to convert to CSV.
• In data you have to change two things
  • Change the array to list all headers you want to be included in your CSV
  • Change the value lookups in the body to match the headers.
• csvStr will be the finished CSV content. You can use this to construct a download for the user.

Snippet:

const yourData = [
	{value_a: 12, value_b: "some data"},
	{value_a: null, value_b: "no data"},
]

const escape = (str) => {
	// handle empty cell
	if(str == null || str == '') return '""'
	// ensure string
	str = `${str}`
	// prevent CSV Injection https://owasp.org/www-community/attacks/CSV_Injection
	const forbidden = new Set(["=", "+", "-", "@", "\t", "\n", "\r"])
	if (forbidden.has(str[0])) {
		str = `'${str}`
	}
	// escape double quotes
	str = str.replace(/"/g, '""')
	return `"${str}"`
};

const data = [
	// header
	[
		"Header A",
		"Header B",
	].map(escape),
	// body
	...yourData.map(
		row => [
			row["value_a"],
			row["value_b"],
		].map(escape)
	)
]
const csvStr = data.map(x => x.join(",")).join("\n")

console.log(csvStr);

What is CSV

The naive assumption about CSV (comma separated values) is just appending data with commas as separators in between. This works in some special cases, but for general data this scheme will quickly break. When you have data which includes commas it will break your CSV.

In  [1, 2, 'hello, world']
CSV 1,2,hello, world
Out [1, 2, 'hello', ' world']

To avoid this quotes are used. Either all or only the values where it is needed are put into quotes. The reader will ignore all commas if they are inside quotes. This way we can represent data that includes commas.

In  [1, 2, 'hello, world']
CSV "1","2","3","hello, world"
Out [1, 2, 'hello, world']

But this only shifts the problem. What happens if our quote character is used in our data?

In  [1, 2, 'hello", John," what?']
CSV "1","2","3","hello", John," what?"
Out [1, 2, 'hello', ' John', ' what?']

To avoid this an escape character is used. The escape character is placed in front of every quote char, which is part of the data. This indicates to the reader that the following quote is part of the data. The most common format of CSV uses the quotechar itself as the escapechar. Every " in the data is simply doubled to "".

In  [1, 2, 'hello", John", what?']
CSV "1","2","3","hello"", John"", what?"
Out [1, 2, 'hello", John", what?']

The combination of "separator", "quotechar" and "escapechar" allows us to encode arbitrary data as CSV, without breaking the format of our data. In principle anything can be chosen for these three characters. One common variation is to use a semicolon (;) as the separator. If a tab (\t) is used, the files are called "TSV" (Tab separated values).

  app:
    logging:
      options:
        max-size: "10m"
        max-file: "3"

• Contributions:
  • Pull Request on rsyslog documentation got accepted: Use option.stdsql instead of option.sql in examples
  • Two pull request on opawg/user-agents accepted: 117, 118
• Created a mascot for owl-blogs using DALL-E 2
  • Prompt: "Logo for a blogging app with an owl as a mascot"
  • Tried a few variations of the prompt until I found a logo I liked
  • Opened the result in Inkscape and traced the mascot
  • Result can be found here
• RSS requires the pubDate to be specified in RFC822. When using the Go time format time.RFC822 , the rss validator will complain. Using time.RFC1123Z (RFC1123 updates RFC822) will yield accepted dates.
• Found a notepad notepad with a built in unit calculator
• Postgres in your Browser and Tutorials
• Swapped the blog from hugo to my own tool \o/

user_comment = get_object_or_404(
    self.user.comments,
    pk=self.kwargs["comment_pk"],
)

Ingredients

• 800g Gnocchi
• 1 Brokkoli
• 1 Dose Tomatenstück
• 1 Becher veganes Creme Fraiche
• 1 Zwiebel
• 1-2 Knoblauchzehen
• Veganer Reibekäs
• Olivenö
• Oregano
• Thymian
• Salz und Pfeffer
• Optional: Paniermehl und Leinensamen

Instructions

Ein schneller veganer Auflauf mit Gnocchi und Brokkoli. Kann eingefroren oder backfertig im Kühlschrank gelagert werden, für Tage wenn man keine Lust hat zu kochen.

• Wasser in Topf zum Kochen bringen und Gnocchi nach Packung kochen
• Brokkoli in mundgerechte Stücke schneiden
• Zwiebel und Knoblauch hacken
• Zwiebel in Öl anbraten bis sie anfangen Farbe zu bekommen
• Brokkoli und Knoblauch hinzufügen und kurz mit anbraten
• Mit Tomaten ablöschen und Dose mit etwas Wasser ausspülen und mit hinzugeben
• Für ein paar Minuten aufkochen, dann Creme Fraiche hinzufügen
• Nach Geschmack würzen
• Fertige Gnocchis in die Pfanne geben und alles gut vermischen
• In Auflaufform geben und mit Käse bedecken
• Optional etwas Paniermehl und Leinensamen über den Käse sträuen, für einer knusprigere Kruste
• für ca. 20 Minuten bei 200°C backen

First, move your AppImage to a suitable location. One option is to create a new directory for all your apps (e.g. an "Applications" directory in your home folder). I prefer to store them in .local/bin, as this folder is added to the $PATH variable. This allows you to use the app anywhere by calling it in a terminal. For GUI apps you most likely want to start them from the start menu of your desktop environment. For most apps, this can be achieved by following these steps.

1. Open the App
2. In a terminal call mount and look for the application name. You can use grep to filter the output. (mount | grep MyApp)
3. Open the location in your file manager. In the directory you should find:
   • an icon. This can be a PNG in the main folder. In my case (Obsidian) the icons where stored in usr/share/icons/hicolor
   • a "desktop configuration file". It's content should look similar to this:

   [Desktop Entry]
   Name=Obsidian
   Exec=AppRun --no-sandbox %U
   Terminal=false
   Type=Application
   Icon=obsidian
   StartupWMClass=obsidian
   X-AppImage-Version=0.13.19
   Comment=Obsidian
   MimeType=x-scheme-handler/obsidian;
   Categories=Office;
   

4. Copy the icon into .local/share/icons. If you find a hicolor folder in the app directory, copy the entire folder over. (use Ctrl+H to show hidden files)
5. Copy the desktop configuration file into the .local/share/applications/ directory in your home folder.
6. Edit the copied desktop file.
   • Replace the app name in the Exec= (and TryExec=) statement with the full path to the AppImage. In the example file above: Exec=~/.local/bin/MyApp

Source Code: https://github.com/H4kor/rordle

Crate: https://crates.io/crates/rordle

How To Play:

• Meet up with friends, co-workers or people you would like to know better in a video call (or in person once the pandemic ends).
• Create a new game and share the link with all players.
• At the top of the Page you can enter new fun facts about you, for example: “As a child I owned 10 chickens”.
• Wait until some facts are in the pool. The number of facts is shown in the sidebar.
• With “Next Facts” you can show change the fact shown to all players. Discuss in the group from whom the fact might be.
• You can set your choice in the sidebar by clicking on a name.
• Once everybody has set their choice, the submitter (or game creator) can reveal the author of the fact.
• Talk about the fun fact.
• Repeat until no more facts are available.

Data Sources

GPU Prices

For GPU prices I used the german website https://geizhals.de. The website shows the prices of items over a time frame of six months. The data of the plots is delivered as JSON and can be easily scraped. I scraped the pricing data for the four current-gen NVIDIA graphics cards (RTX 3060 - 3090). As multiple manufacturers sell the same graphics card chips, I averaged the prices per chip.

Crypto Currency Prices

I used Yahoo! Finance as my source for the crypto currency prices. You can download the historic data as CSV.

Evaluation

For a first impression, I’ve added the bitcoin price to the plot of GPU prices. To normalize the prices, I divided each time series value by the first price observed. Squinting at this plot, you can already see that the overall trend in prices roughly line up.

For a more accurate analysis, I looked at the correlation factors and created corresponding scatter plots. Each dot in the plots represents one day. The Y-axis shows the price of the GPU at that day and the X-axis the price of the crypto currency. If prices correlated perfectly, all dots would lie on a diagonal line.

For the RTX 3060, there is only a weak correlation between prices. The correlation between RTX 3060 and ETH prices is not significant and has to be discarded. Keep in mind that the 3060 was just released on 26 of February, so we have less pricing data compared to the other GPUs. For the other cards, we see higher correlation factors. Whenever the price of one rose, the other rose too. The effect is strongest for the RTX 3090 and is visible in Bitcoin and Ethereum.

This analysis still has a flaw, as it does not correct for the overall trend in the price development. Prices change over time because of factors affecting all products. For example, inflation will rise all prices over longer observations. This creates a false correlation if you compare prices over a long time frame. To correct for this, the overall trend has to be removed from the data. I used a linear regression to remove the trend.

With the trend removed, the measured correlation between the prices is weaker, as expected, as we removed a linear factor from the data. The data still shows a correlation between crypto currency and GPU prices. The correlation is stronger for Bitcoin than for Ethereum.

To test the validity of these correlations, I did the same analysis for CPU from AMD and Intel. I used the prices of the generations; Ryzen 5000 and i-11000. The AMD prices show no correlation with the crypto currency prices (p-value below 0.05). For Intel chips, we can observe a slight correlation. This gives me more confidence that the correlation is real for GPUs.

Conclusion

We can see a correlation between GPU prices and the value of crypto currencies, but correlation does not mean causation. A causation is plausible in this case. Miners earn a lot of money with their businesses and can predict how much they will earn on average with each graphics card. As long as their earnings are high enough, it is profitable for miners to buy cards at higher prices. Bitcoin miners rarely use GPUs anymore, but ASICs. The production of ASICs may add more price pressure on silicon and chip production. I don't have any data on the amount of production capacity being used by ASICs, so I don't know how much pressure they produce.

Why is this a problem? There is nothing inherent to blockchains that demands such a high dependence on computing hardware. The resources spent by miners only serves as a mechanism to increase the cost of changing data in the blockchain. This cost serves as a mechanism to secure blockchain. Other mechanism for securing blockchains exist and successfully used (see Proof of Stake). Proof of Work creates external costs (environmental impact, higher electricity prices, GPU scarcity) to benefit a small group of miners.

Download the raw data and notebook.

#cryptocurrency #gpu #analysis

Do gamers want this? Ask any gamer about pay-to-win, or in-game purchases, and you got your answer.

Alternative Financing

What are the alternatives? Let’s imagine the manifestation of another ideology: Communism.

Everybody pays as much as they can spare to game developers. The game developers use this money to pay artists and developers, which create the content of the former NFTs. Every player can use these new skins and items, no matter how much they paid. There is no special treatment for paying more. Your sole motivation for paying is liking the games and wanting to see it grow.

This is certainly better than NFTs, but still does not enhance the game. A game where you cannot progress or achieve anything is boring. So let’s mix in meritocracy.

We still finance the content as above, however it’s not given to the players directly. Instead, the items/skins are tied to achievements in the game in a deterministic way. Want that new sword skin? Win 100 fights in the Arena of Doom. This gives players a goal and rewards skill in the game.

I think these two principles create a system which most gamers will like. You don’t have to pay for new skins/items, but you can still brag about your new skin because everyone knows how hard it is to obtain. This would also be an improvement over the current system of micro transactions and in-game purchases.

Now you may ask: “But what about sharing items between games? That’s the whole reason for using blockchain and NFT.”

Decentralization and Ownership

Blockchain will not solve the problem of sharing items between games.

Tracking ownership is the smallest of problems. The more hard questions are: How do you translate item stats from one game to the other? How do you exchange assets in a unified way? How do you convince large publishers to open up their ecosystems?

So here is my solution: Federation.

First, we need to find a common way to connect game account with each other. An established method is OAuth2. This would allow players to connect accounts of different games. Once connected, your game can retrieve the list of items a player unlocked in the other game.

Another possibility, and a more decentralized method, is the Solid Project, where your data is stored in a place you control. This would have the added benefit that your game assets still exist when the publisher of the stops maintaining the game.

Additionally to authentication, we need an API to exchange information about the in-game assets between games. The API needs to present items in a standardized way, which is still flexible enough to cover “all” items in games. One possibility would be to use RDF and define a standard vocabulary for game items. RDF uses three-part structure to describe properties of subjects. With in-game items, this would be equivalent to: “sword is green”, “sword has +3 strength”. By defining a standard vocabulary (e.g. how to represent colors), games could easily translate from the common description to in-game attributes.

You might also want to include assets in the API. Again, we need heavy standardized representation (e.g. glTF or obj for 3D assets, PNG for images, ...). These assets would mostly only serve as references for designers to create their own assets. Games are art pieces, and it is almost impossible to share assets between them in an automated way.

Once our authentication flows and APIs are defined, we can integrate them into games. This still requires work from artists and programmers. The game developers decide which game they want to support for exchanging items with. Connecting two shooters is easier than connecting a fantasy RPG to a sci-fi strategy game. Using the assets API the designers change or recreate the assets to be used in their game and adjust the stats to be balanced. When the players connect their game accounts, the information about ownership is exchanged, and the modified items awarded to the player.

Most games will probably only support game connections with similar settings where the translation is straightforward. But over time, more and more games will build connections between varying genres. At this point the true power of a federated system starts.

The connections of games build a graph. This allows you to support many game connections without explicitly connecting them. A player earns an item in Game A. This item is translated to another item in Game B. If your game supports a connection to Game B, it can automatically supports all items which are also supported by Game B. This way, your game will automatically accept more and more items from different games without more work for the designers.

Conclusion

I think this creates a system that is beneficial to all participants. New games will use connection to popular, similar games to attract players to their game. Players that get a bit tired of a game can swap to new games and take (some) of their assets over. Large publishers might use this system to cross promote their games.

A rotating christmas reaves in a snow landscape. The center of the reave has a portal leading to a mystical building.

• Music: Scott Holmes Music - This is Christmas CC BY-NC 4.0
• Tavern in Portal: Medieval House 007 - Blacksmith CC-0
• Blend File: xmas.blend (without Tavern)

#render #blender #xmas

This is fully procedurally created solar panel material. Borders, wires and colors can be easily adjusted.

You can use this assets under the CC BY 4.0 License.

Solar Panel Material

#blender #texture #solar

Configuring the RabbitMQ Server

For the configuration of the RabbitMQ server we will use a rabbitmq.conf and a definitions.json. I stored these files in a rabbitmq folder to keep my project folder structure clean. This setup is derived from sudos answer on StackOverflow

The rabbitmq.conf deactivates the default guest user and tells RabbitMQ to load the definition file.

loopback_users.guest = false
management.load_definitions = /etc/rabbitmq/definitions.json

In the definition file we can define our users, vhosts and permissions.

{
 "rabbit_version": "3.9",
 "users": [
  {
   "name": "local_jobs",
   "password_hash": ">>>HASH<<<",
   "hashing_algorithm": "rabbit_password_hashing_sha256",
   "tags": ""
  },
  {
   "name": "adminuser",
   "password_hash": ">>>HASH<<<",
   "hashing_algorithm": "rabbit_password_hashing_sha256",
   "tags": "administrator"
  }
 ],
 "vhosts": [
  {
   "name": "\/"
  },
 ],
 "permissions": [
  {
   "user": "local_jobs",
   "vhost": "\/",
   "configure": ".*",
   "write": ".*",
   "read": ".*"
  }
 ],
 "parameters": [],
 "policies": [],
 "queues": [],
 "exchanges": [],
 "bindings": []
}

To add the configurations to the RabbitMQ server they are added via the volumes options in the docker-compose.yml

  rabbitmq:
    hostname: rabbitmq
    image: rabbitmq:3.9-management
    command: rabbitmq-server
    ports:
      - "5672:5672"
      - "15672:15672"
    volumes:
      - ./rabbitmq/rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf:ro
      - ./rabbitmq/definitions.json:/etc/rabbitmq/definitions.json:ro

Generating Password Hashs

In order to generate the password hashs I used the python script by Todd Lyons on StackOverflow

#!/usr/bin/env python3

# rabbitMQ password hashing algo as laid out in:
# http://lists.rabbitmq.com/pipermail/rabbitmq-discuss/2011-May/012765.html

from __future__ import print_function
import base64
import os
import hashlib
import struct
import sys

# This is the password we wish to encode
password = sys.argv[1]

# 1.Generate a random 32 bit salt:
# This will generate 32 bits of random data:
salt = os.urandom(4)

# 2.Concatenate that with the UTF-8 representation of the plaintext password
tmp0 = salt + password.encode('utf-8')

# 3. Take the SHA256 hash and get the bytes back
tmp1 = hashlib.sha256(tmp0).digest()

# 4. Concatenate the salt again:
salted_hash = salt + tmp1

# 5. convert to base64 encoding:
pass_hash = base64.b64encode(salted_hash)

print(pass_hash.decode("utf-8"))

Die Suche ermöglicht es mehrere Begriffe in Relation zueinander darzustellen.

• Begriffe werden durch Kommas getrennt (z.B. Klima,Wirtschaft)
• Begriffe können durch Pluszeichen addiert werden (z.B. Klima+Umwelt)
• Um nach einem exakte Begriff zu suchen kann dieser in Anführungszeichen gesetzt werden (z.B. "Klima")

Contains:

• Tesla Cybertruck by PolyDucky is licensed under Creative Commons Attribution.

In the last months I've spent a lot of my time researching and thinking about the ecological impact of blockchain. Bitcoin and Ethereum, the two most popular blockchain technologies, have a vast power consumption. The power consumption is not inherent to blockchain technologies, but a result of the way these blockchains are secured.

The network of computers running Bitcoin and Ethereum establish trust by making changes to the blockchain expensive. This is achieved by requiring to solve a puzzle whenever you want to append something to the chain. Miners (people who solve these puzzles) have to spend money on hardware and electricity to solve the puzzles. The difficulty of the puzzle is adjusted automatically with the number (and power) of computers trying to solve the puzzle. Without adjusting the difficulty, changes would become inexpensive and the blockchain would become vulnerable. This method of securing a blockchain is called "Proof of Work" (PoW).

There are other methods to establish trust in a blockchain network, like Proof of Stake (PoS), which require far less energy. I want to focus on Proof of Work as this is the system which currently secures the most value in the crypto currency space.

It's hard to calculate the real power consumption of a blockchain. Estimates are mostly concerned with the current hash rate (how many tries to solve the puzzle are executed each second) and the efficiency of the used hardware. It is almost impossible to know how efficient the hardware used is which leads to large ranges in the estimation. As of writing Bitcoins energy usage probably lies somewhere between 43 TWh and 477 TWh per year. In the following I will not concern myself with the efficiency of the hardware. Instead I try to derive the energy consumption of any blockchain (using PoW) from the value of the coins and how much miners are paid in block rewards.

Why miners mine

The reason why miners do their job of building and operating mining pools is simple: they want to earn money. For each block that is found by a miner she earns some coins.

There are generally two ways miners are rewarded for their work:

First the miner can create some new coins for each found block. The block rewards can change over time, for example bitcoin started with 50 BTC per block and the reward is lowered gradually until, eventually, no new coins are added to the blockchain. This mechanism is used to create the initial pool of coins and to incentivise mining while very little transaction fees are available.

When the block reward is diminished over time transaction fees play an important role to incentivise mining. When you create a transaction to be added to the blockchain a transaction fee can be added. This fee is given to the miner who created the block containing the transaction. Once no more coins are generated out of thin air the transaction fees have to pay the bills of the miners.

The block reward gives us an upper limit of the expenses of all miners. If 10 BTC are earned on average per block, all miners combined can at most spent 10 BTC to create a new block. If more resources were spent on creating a block over a longer period of time miners would go bankrupt.

Why efficiency does not matter

Miners have two main costs: hardware and electricity, everything else is overhead. In order to be profitable they constantly try to minimize the price per computed hash. The number of blocks generated by a miner is directly proportional to the percent of the global hash rate the miner controls. A miner holding 1% of the global hash rate will be able to create 1% of the blocks. As hardware gets more efficient, in terms of hashes per energy usage, miners will upgrade their hardware to minimize their cost and to secure more blocks. When other miners upgrade their hardware too the advantage of a single miner is diminished as the improved hash rate is lost when everybody increases their hash rate. This leads to a cycle of constant upgrade to stay ahead of the curve. The upgrade cycle only leads to a higher global hash rate but does not lower the power consumption of the networks as a whole as miners only try to secure a bigger piece of the block reward cake.

If you look at mining from above, ignoring the single miner, you see a collective that constantly buys more efficient hardware but somehow manages not to reduce its power consumption. Instead the power consumption of the collective is dictated by the rewards themself.

Higher rewards for mining, either by coins becoming more valuable or more fees being paid, lead to investments into mining equipment. Existing miners buy more machines and new people start mining. This leads to a higher energy consumption of the mining collective.

Any mining reward not used for new hardware (or kept as profit) will be used to buy energy to run the machines.

How much energy will be used

This gives us four factors that control the energy usage of all miners.

• Block Reward: How much money can be earned by creating a block (Coin/Block)
• Exchange Rate: What is the value of a coin ($/Coin)
• Proportional Energy Costs: Which portion of the mining rewards is used for electricity (%)
• Electricity Price: How much does an average miner pay for a kilowatt-hour ($/kWh)

The used energy of the network per block can be computed as:

([Block Reward] * [Exchange Rate] * [Proportional Energy Costs]) / [Energy Price]
 = [Energy Usage per Block]

Abstracting away blocks and exchange rates this could be simplified to:

a * [Daily Rewards] / [Energy Price] = [Daily Energy Usage]

where a is the proportion of the rewards used for energy

Blockchain Energy Usage Calculator

(The calculation assumes that a new block is generated every 10 minutes)

Conclusion

The energy consumption of a PoW blockchain is proportional to the value a miner can earn per block. If the value of the reward doubles, either by higher fees or higher coin values, the energy consumption will double eventually. Similarly the power consumption will rise if the price of energy drops.

A widely used blockchain, which potentially could replace fiat currencies, would have a high transaction amount leading to a large pool of fees to be collected by miners. This would eventually lead to a corresponding energy consumption.

https://h4kor.github.io/end-of-covid/

You can select countries at the bottom of the page. Feedback, feature requests or improvements can be submitted on GitHub

Das Ergebnis kann hier gefunden werden: https://aachen-bussgelder-k3fasuseya-ey.a.run.app/

(Das Repository: https://github.com/h4kor/aachen-bussgelder)

I'm working on a small game with a procedural map. As the whole game is set in a labyrinth-like building I've decided to use tile maps. The map generation algorithm produces a 2D matrix with 0s and 1s. A 1 indicates that the tile is walkable while a 0 represents an impassable field.

In a simple 2D setting this could be represented by using a floor sprite for each 1 and a wall sprite for each 0. However, this isn't very appealing. Instead the visual representation of a tile should be depended on its neighborhood.

Each tile can have one of 256 (2^8) configurations. These configurations can be reduced to 41 by considering rotations as one configuration. As multiple configurations need the same wall layout we will only need 15 tiles to render the tile map.

My first approach to implement the rendering was to use shit ton of if statements. The approach tested for all configurations to find the needed piece and rotation. A few shortcuts prevented that I had to test for all 256 configurations but it was still too much. After implementing this approach for 4 tile pieces I gave up.

My next idea was to represent the knowledge of which piece and rotation is required for each configuration in a lookup map. This approach is similar to marching cubes where you need a lookup map to know how to construct the faces of a cube. After writing down 30 entries of the lookup map I came up with the following idea (which I will call "Tile Strings").

Instead of checking for all 256 configurations, we only look at a 2x2 section of the neighborhood.

We start with the 2x2 patch in the upper left corner and determine the character it represents. This character represents whether the left side of the tile needs a wall, a corner or needs to be empty.

The 2x2 patch is than rotated around the center to determine the characters for the other sides. After the full rotation we have a 4 character string representing the configuration of the center tile, for example "WCCE". This is our tile string.

Example code for a single 2x2 check (written in GDScript):

if cell(p + Vector3(-1, 0, 0)):
    if cell(p + Vector3(0, 0, -1)) and not cell(p + Vector3(-1, 0, -1)):
        tile_str += "C"
    else:
        tile_str += "E"
else:
    tile_str += "W"

With the calculated tile string we can start to search for a suitable sprite or model in a library (our library should consist of 15 assets named by their tile string). We still have to manipulate the tile string and determine the rotation, as we most likely only want to create 15 assets.

As the tile string represents a unique configuration we only have to rotate it (at most 3 times) to find a fitting configuration in our library. We start by checking if the tile string already fits an element in our library. If this is the case we can just use it! If no element fits we rotate by 90 degrees, by moving the last character of the string to the front, "WCCE" is transformed to "EWCC". The number of rotations are counted. We do this at most 3 times. If you didn't find a fitting element after 3 rotations your library is not yet complete. Once the rotated element fits, it can be inserted into our scene with the determined rotation.

Example code for finding an element in the library (written in GDScript):

var rotation = 0
for i in range(4):
    if tile_str in library:
        add_part(position, rotation, tile_str)
        break
    rotation += 90
    cfg_str = cfg_str[3] + cfg_str[0] + cfg_str[1] + cfg_str[2]

Your library does not have to be limited to 15 elements. Maybe corridors running north-south should have a different design than east-west corridors. Just add a new element with the corresponding tile string to your library.

This approach only requires a few lines of code. There is probably a lot of potential for improvement but it works perfectly for my use case. The process of developing this once again showed me that it is worthwhile to take a step back and think about your problem. The first two approaches showed me properties of the problem and implementing them (partially) deepened my knowledge, which ultimately led to the "Tile String" algorithm.

Ingredients

• 175 g 550 Mehl
• 100 ml lauwarmes Wasser
• Prise Salz
• 5 g Hefe
• Vegane Crème fraîe
• Rauchsalz
• Knoblauchpulver
• Pfeffer
• 1 rote Zwiebel
• 6 Champignons

Instructions

• Teigzutaten zu einem glatten Teig kneten
• Teig im Kühlschrank mindestens 24 Stunden gehen lassen. Alle 24 Stunden Teig durch kurzes kneten entlüften.
• 30-60 Minuten vor dem backen zwei Teigbälle a 100-150 g formen und warm gehen lassen und Backofen auf 300°C vorheizen
• Teig sanft zu möglichste dünnen Fladen formen
• Fladen mit Crème fraîche bestreichen und mit nach belieben würzen
• Zwiebeln in dünne Ringe schneiden und Champignons würfeln und Fladen belegen
• ca 5 Minuten bei 300°C backen

einwohner = 83_000_000
tote_pro_tag = 800
prozent_tote_pro_tag = tote_pro_tag / einwohner
print(f"{prozent_tote_pro_tag * 100:.4f}%\tder Bevölkerung stirbt pro Tag")
print(f"{prozent_tote_pro_tag * 100 * 7:.4f}%\tder Bevölkerung stirbt pro Woche")
print(f"{prozent_tote_pro_tag * 100 * 30:.4f}%\tder Bevölkerung stirbt pro Monat")
print(f"{prozent_tote_pro_tag * 100 * 365:.4f}%\tder Bevölkerung stirbt pro Jahr")

0.0010%	der Bevölkerung stirbt pro Tag
0.0067%	der Bevölkerung stirbt pro Woche
0.0289%	der Bevölkerung stirbt pro Monat
0.3518%	der Bevölkerung stirbt pro Jahr

Das ganze in Prozenten auszudrücken macht es nicht viel besser. Wie sieht es also aus wenn wir die COVID-19 Sterblichkeit auf andere Situationen übertragen?

Wie riskant wäre es zu fliegen?

fluggaeste_deutschland = 227_000_000 # Quelle: https://de.statista.com/themen/1060/flugpassagiere/
tote_fluggaeste_pro_tag = prozent_tote_pro_tag * fluggaeste_deutschland
print(f"{int(tote_fluggaeste_pro_tag)} Menschen würden täglich beim fliegen sterben")
print(f"{int(tote_fluggaeste_pro_tag * 7)} Menschen würden wöchentlich beim fliegen sterben")
print(f"{int(tote_fluggaeste_pro_tag * 30)} Menschen würden monatlich beim fliegen sterben")

2187 Menschen würden täglich beim fliegen sterben
15315 Menschen würden wöchentlich beim fliegen sterben
65638 Menschen würden monatlich beim fliegen sterben

Wie viele Flugzeuge müssten dafür abstürzen?

passagiere_pro_maschine = 101 # Quelle: https://de.statista.com/statistik/daten/studie/327019/umfrage/passagiere-je-flugzeug-deutsche-flughaefen/
fluege = fluggaeste_deutschland / passagiere_pro_maschine / 365
abstuerze = tote_fluggaeste_pro_tag / passagiere_pro_maschine
print(f"{abstuerze:.0f} von {fluege:.0f} Flugzeugen würden täglich abstürzen")

22 von 6158 Flugzeugen würden täglich abstürzen

Wie sieht es mit dem Schienenverkehr aus?

zuggaeste_deutschland = 2_600_000_000 # https://de.statista.com/statistik/daten/studie/13626/umfrage/reisende-im-schienenpersonenverkehr-der-db-ag/
tote_zuggaeste_pro_tag = prozent_tote_pro_tag * zuggaeste_deutschland
print(f"{int(tote_zuggaeste_pro_tag)} Menschen würden täglich bei Zugfahrten sterben")
print(f"{int(tote_zuggaeste_pro_tag * 7)} Menschen würden wöchentlich bei Zugfahrten sterben")
print(f"{int(tote_zuggaeste_pro_tag * 30)} Menschen würden monatlich bei Zugfahrten sterben")

25060 Menschen würden täglich bei Zugfahrten sterben
175421 Menschen würden wöchentlich bei Zugfahrten sterben
751807 Menschen würden monatlich bei Zugfahrten sterben

Wie viele Zugunglücke wären es pro Tag?

kapazitaet = 468 # Intercity 2 https://de.wikipedia.org/wiki/Intercity_2_(Deutsche_Bahn)
zuege = zuggaeste_deutschland / kapazitaet / 365
ungluecke = tote_zuggaeste_pro_tag / kapazitaet
print(f"{ungluecke:.0f} von {zuege:.0f} Zügen würden täglich verunglücken")

54 von 15221 Zügen würden täglich verunglücken

Fazit

Es ist schrecklich wie viele Menschen gerade an COVID-19 sterben. Wenn man diese Werte in Relation setzt wird einem das Ausmaß erst richtig bewusst. Niemand von uns würde in einen Zug oder Flugzeug steigen wenn es genau so gefährlich wäre wie es gerade in dieser Pandemie ist.

As the guide was written for django 1.6 some minor changes were necessary when working with newer versions (I've used django 3.1.4).

Setup for migration

Steps 1 + 2 work as described in the guide above. A new database is created and added to the settings.py.

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'dbname',
        'USER': 'dbuser',
        'PASSWORD': 'dbpass',
        'HOST': 'mysql.example.com',
        'PORT': '',
    },
    'postgresql': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'dbname',
        'USER': 'dbuser',
        'PASSWORD': 'dbpass',
        'HOST': 'postgresql.example.com',
        'PORT': '',
    }
}

Apply migrations to new database

python manage.py migrate --database=postgresql

syncdb is no longer available in newer django versions and was replaced by migrate. The flag --no-initial-data is no longer available and I didn't find a substitution.

Clean Up the new database

Some migrations will create initial data in your database. This will probably create conflicts, as we are migrating existing data into this database. I did this step by hand, but the command python manage.py sqlflush --database=postgresql will give you the SQL query to do it automatically.

Copy data to new database

In order to copy the data we use dumpdata and loaddata.

When dumping the data it is important to use the flag --natural-foreign, otherwise the import process cannot import data with foreign keys.

python manage.py dumpdata --all --natural-foreign > dump.json

The dumped data can be loaded into the new database. This process can take a long time. Ensure that your machine executing this command is as close as possible to the database, ideally running on the same machine. First, I started this command on my local machine. After 30 minutes I decided that it took too long and uploaded the dump to the server running the database, which finished the command in about a minute. My dump file was only 16 MB big.

python manage.py loaddata dump.json --database=postgresql

Adjust config

Now all data is available in the new database. Just adjust the settings to use the postgresql as the default database.

Rendering of a portal with two light orbs orbiting above. Leafs fly away from the portal.

Music: Remix of Monomyth – The Spaces Between - Scott Buckly CC-BY 4.0

nafluh'e Chaugnar Faugn ch'.

H̸a̶s̶t̷u̷r̶o̸r̷ ̸i̸l̵y̴a̴a̴ ̸g̵o̷f̵'̴n̸n̶o̷g̸ ̵s̸h̵u̸g̷g̷ ̶p̴h̴'̴u̴h̸'̸e̵ ̵t̵h̴r̶o̶d̸ ̷a̶t̷h̶g̸

v̷͈̓u̸͍̓l̴̝͌g̶̮͠t̷̜͆m̴̗̿ ̷̪̈k̵̮͑ň̷̤'̶͍̊a̵̝̽ ̸̫̐ṇ̵̊a̸͈̅f̸̘̊l̶̺͠ó̴̢r̷̂ͅȓ̴̨'̸̡̓è̷̹,̸̘̈́

c̷̹͝ȋ̶̟l̴̨̈́y̸̨̽ạ̴̊â̴͇ ̴̙̂c̸̭͋h̵̲̓'̸͎͗ ̷͕́s̸̲̾ḧ̴̢́ů̶͈g̸̈́͜g̴̢̅o̴̧̔ṱ̴͆h̸̪̃ ̶̹̆h̴̲̊ủ̷̙p̸͇̒a̵̪͆d̵̲͗g̷̖̊h̸̳̋ ̷̖̊ń̸̥a̴̖͌f̷̦͝l̶̯̊'̵̞̃f̷̳̒h̸̢͋á̴͜l̵͕̐m̴̳͑a̶̢̾ ̸̘̈́e̵̯̎b̶͍͝u̵̮͘n̸̻̎m̵̺̃ả̴̝o̷̩͊r̸̨͝

b̷̼̏ṵ̷͋g̶̥̈ ̶̧͂'̸̭̉b̴̮͛ṱ̶͘h̵̬́n̵̝̊ḵ̸̄ǫ̶̛t̷̛̳h̶̹̿ ̸́͜H̴̜̿a̴̛̲s̴̡̓t̶̢̚u̶̢͆r̶̦̔ ̴̰̃f̸͍͘h̸̖̄t̵̛̹a̶̯̽g̸̮͠n̷͓͒ ̶͇̾s̴̖̄ḩ̴͆a̵͔̔g̷͗ͅg̵͕͠.̷̰̆

Blood Ring

Music: Remix of THE OLD ONES - Scott Buckly CC-BY 4.0

Quelle: https://wahlen.regioit.de/1/km2020/05334002/html5/Kreistagswahl_NRW_78_Uebersicht_stbz.html

        

This is my pizza recipe for an easy to prepare lunch. It takes 15 minutes to prepare the dough. I typically prepare enough dough for 4 servings. The dough can be stored for several days and improves each day ;).

Preparing the pizza takes around 10 minutes.

Ingredients

Dough (per serving):

• 175g wheat flour (all purpose / 550)
• 100g water
• 5g salt
• 5g olive oil
• ~5g yeast

Toppings

• Passata
• Olive Oil
• Salt and pepper
• (Chili, optional)
• Oregano
• vegan cheese (I use Simply V)
• whatever you like on a pizza!

Preparation

• Mix your flour and salt
• Dissolve your yeast in the water
• Add water and oil to the dry ingredients and mix everything
• Once all liquid is absorbed start kneading the dough until you reach an even consistency
• Put your dough in the fridge overnight

Cooking

In the morning take 275g of your dough out of the fridge. Fold or knead it shortly to create a round ball. Put the ball into a bowl and cover it.

After 1-3 hours fold the dough once. Be careful to keep the air building up!

Preheat your oven to 250°C (20-30 minutes before your lunch).

Put the dough ball on a floured surface and carefully push and pull it into shape. Be gentle and keep as much air as possible inside the dough! Put the pizza dough on your baking sheet.

Coat the pizza lightly with olive oil. Add 3-5 tablespoon passata and spread it evenly. You don't need a lot of sauce, only cover the dough lightly.

Season the sauce with salt, pepper and oregano (I also add chili). Add your ingredients and cheese.

Bake the pizza for 10 minutes.

Paul Graham comes to the conclusion that wealth taxes have "dramatic effects" and that "even a .5% wealth tax would start to keep founders away from a state or country that imposed it."

I think this conclusion is wrong. His model assumes that the earned money just lies on a big pile and is not used for 60 years. A more reasonable model would include interest being earn with the money. For this I will use an extended model:

(growth * (1-wealth_tax)^years

If we assume a reasonable return of investment of 2% per year the number shifts dramatically. Instead of "losing" 25% at 0.5% wealth tax you end up with 242% of your original value after 60 years. Even a wealth tax of 3% would only half your wealth.

Paul Graham's article also misses to mention that a wealth tax only affect people with ALOT of money. Elizabeth Warren's "Ultra-Millionaire Tax" would only tax assets over $50 million. Once you are affected by a wealth tax you have enough money to live a luxurious life (and your children will probably never have to work to live). Most startup founders never reach this amount of wealth.

As this tax only targets the super rich let's look at the effect this tax would have on Jeff Bezos (data source: Wikipedia):

Even a high wealth tax of 5% leaves Bezos the majority of his wealth. If Bezos stopped earning new wealth in 2018 he could bequeath $30 billion to his children in 2080 with a 2% wealth tax. With a 5% wealth tax his children would still inherit over $4 billion!

The questions I'm asking myself when thinking about a wealth tax are the following:

• Should a person have virtually unlimited resources for the rest of her life, just because she had a clever idea in her 20s?
• Should children have virtually unlimited resources for the rest of their lives, just because one of their parents had a clever idea in her 20s?
• Should grandchildren have virtually unlimited resources for the rest of their lives, just because one of their grandparents had a clever idea in her 20s?

Um zu überprüfen wie mit der Senkung umgegangen wird habe ich kurz nach der Ankündigung angefangen Preisdaten zu sammeln. Hierfür habe ich die Webseiten von 10 deutschen Unternehmen stichprobenartig beobachtet. Dabei wurde täglich der Preis aller gelisteten Artikel gespeichert (max 25000 Artikel pro Unternehmen). Beobachtet habe ich die Unternehmen:

• Aldi Nord
• Aldi Süd
• BMW
• Kaufland
• Hornbach
• Media Markt
• Obi
• Netto
• Avocado Store
• Whisky.de

Ich hätte gerne noch mehr Unternehmen beobachtet, jedoch ließen sich viele Webseiten nicht reibungslos auswerten. Insgesamt habe ich 3.228.617 Preise von 368.452 Produkten erfasst (Stand: 03.07.20).

Auswertung

Als leichter Einstieg in die Auswertung dient die Preisentwicklung bei BMW. Die Preise bleiben konstant bis zum 2. Juli (da ich die Daten nachts erhoben habe kann es durchaus sein das die Preise schon am 1. Juli gesenkt wurden) und sinken dann um etwa 3% ab. Hier wurde die Mehrwertsteuersenkung direkt an den Kunden weitergegeben.

An diesem Graphen lässt sich die Visualisierung leicht erklären. Für jeden Artikel berechene ich täglich den "relativen Preis". Dafür gucke ich mir die Preise eines Artikels über den gesamten Beobachtungszeitraum an und nehme an das der "normale" Preis der am häufigsten vorkommende Preis ist. Dann werden alle Preise durch diesen normalen Preis geteilt um den relativen Preis zu bekommen. Auf diese weise lassen sich die Preise normieren, was Auswertung und Visualisierung deutlich vereinfachen.

Etwas spannender wird das ganze schon bei Aldi Nord.

Hier kann man sehen das die Preise immer wieder abweichen. Die schwachen Linien ober und unterhalb der Hauptlinie zeigen Preisänderungen. Zu Beginn der Beobachtung sieht man Rabattaktionen in denen wenige Artikel günstiger sind als normalerweise. Das erste interessante Ereignis gibt es am 21.6. Hier werden viele Artikel ca. 3% teurer. Am 27.6 fallen all diese Artikel wieder auf ihr normales Niveau zurück und gleichzeitig werden andere Artikel ca. 3% billiger. Mit Beginn der der Mehrwertsteuersenkung werden die meisten Artikel wieder teurer und nur wenige bleiben um 3% reduziert.

Auf den ersten Blick sieht es so aus als würde Aldi Nord die Ersparnisse durch das Konjunkturpaket nicht an ihre Kunden weitergeben. Jedoch scheint sich Aldi Nord dafür entschieden zu haben nicht die Preise anzupassen, sonder einen Rabatt auf den Einkauf zu geben.

Ähnlich sieht es bei Aldi Süd aus. Hier gab es jedoch keine Preiserhöhung oder -senkung vor der Mehrwertsteuersenkung

Der Konkurrent Kaufland hat sich scheinbar entschieden die Preise selbst zu senken.

Wenige Artikel wurden zwei Wochen vor der Senkung teurer, aber ein ähnlicher (schwächerer) Effekt lässt sich am Anfang der Beobachtung erkennen. Eine Woche vor der Senkung hat Kaufland schrittweise angefangen die Preise anzupassen, jedoch sind nicht alle Preise gesenkt worden. Hier wäre eine detailliertere Analyse notwendig um zu sehen um welche und wieviel Artikel es sich handelt.

Deutlich chaotischer scheint es bei Netto zuzugehen.

Hier gibt es ständige Preisänderungen und Rabattaktionen die viele Artikel betreffen. Auch hier sieht man, dass ab dem 27.6 die Preise an die neue Mehrwertsteuer angepasst wurden. Auffällig hier sind die angehobenen Preise am 18.6 und die zum 27.6 immer dicker werdende Linie bei etwa 3%. Hier sollte noch etwas genauer nachgeguckt werden. Es könnte sein, dass hier Preise vor der Senkungen angehoben wurden.

Der Preisgraph für MediaMarkt sieht ähnlich chaotisch aus.

Hier lässt sich direkt die Preissenkung am 1.7 erkennen. Scheinbar wurden hier pauschal alle Preise gesenkt. Auf den ersten Blick lässt sich auch nicht erkennen, dass Preise vorher erhöht wurden.

Bei OBI wurden die Preise schon am 25.6 gesenkt. Was es mit dem "Zick-Zack" Muster auf sich hat weiß ich noch nicht, es könnte aber ein Artefakt meiner Erhebung oder Visualisierung sein.

Bei Hornbach wurden viele Preise gesenkt aber bei weitem nicht alle.

Bei Avocado Store handelt es sich um einen Marktplatz (ähnlich zu Amazon). Viele Anbieter können hier ihre Waren anbieten.

Einige Anbieter scheinen sich entschlossen zu haben die Preise zu senken. Auch hier zeigt sich ein leichtes "Zick-Zack" Muster (auch hier könnte es ein Artefakt meiner Erhebung oder Visualisierung sein). Hier wird interessant ob sich mit der Zeit mehr und mehr Anbieter entschließen die Senkung an den Kunden weiterzugeben. Ich weiß nicht wie viel Einfluss die Plattform selbst darauf hat.

Whisky.de habe ich als Beispiel für ein spezialisiertes, kleines Unternehmen mit in die Analyse aufgenommen. Hier zeigt sich bis jetzt keine Senkung der Preise.

Insgesamt lässt sich sehen das die Mehrwertsteuersenkung an den Verbraucher weitergeben wird. An einigen Stellen sieht es noch so aus als wäre es nicht überall der Fall, aber dies sind bis jetzt nur Hypothesen die weiter untersucht werden sollten! Ich werde meine Scraper vorerst weiter laufen lassen und tiefer in die Daten eintauchen.

console.rainbow = (s) => {
    const [cs, c] = s
        .split("")
        .map((c,i) => ['%c'+c, `color:hsl(${20*i%360}, 100%, 50%)`])
        .reduce((p, c) => [p[0] + c[0], p[1].concat(c[1])], ["", []])
  console.log(cs, ...c)
}
console.rainbow("Hello World!")

Kessler Bomb

Siege Weapon

Deployed in low orbits around hostile planets.

On deployment millions of projectiles are scatters in random orbits around the planet, taking out all satellites after a few hours. The shrapnels will make launches from the attacked planet impossible for several decades.

Primarily used to lock down planets with offensive capabilities.

Prohibited by the New Geneva Convention, due to the high collateral damage

Graphic by: Acadac

You start with "building a blog will take me 20 hours", then go to "OK actually I will need 10 hours for the data structure, 10 hours for a way to create posts and 10 hours for the actual website". For each of this estimations you will end up with more hours needed the further you break them down.

Breaking tasks down reveals more of the complexity of a task, leading to higher (hopefully more accurate) estimations.

• Open Postman and use the Import Button -> Paste Raw Text

• You can now execute the same request as done in the browser.
• Start modifying it and happy hacking.

#debug #web #postman

https://autotexture.libove.org/

Data distribution:

You can find the code for all plots here!

Bar Plot: Mean Values

Pros:

• Easy to create
• Simple to read
• Q3 – Q5 distinguishable

Cons:

• Hides a lot complexity
• Doesn't show spread
• Creates high confidence in shown values

Bar Plot: Mean values and Standard Deviation

Extension of first plot.

Pros:

• Still simple
• Introduces skepticism into shown data
• Hints at spread in data

Cons:

• Hides a lot complexity
• Still doesn't show distribution

Violin Plot

Pros:

• High Resolution
• Shows distribution of data

Cons:

• Harder to read
• Noisy on small sample sizes
• Shows data as being continuous

Vertical Histograms

Pros:

• High Resolution
• Shows distribution of data

Cons:

• Harder to read
• Shows data as being continuous

Scatter Plot

Pros:

• High Resolution
• Actually shows complete data
• Shows distribution of data

Cons:

• Hard to read
• Introduced noise and overdraw can distort data

Scaled Dots

Pros:

• High Resolution
• Shows distribution of data
• Shows data as discrete values

Cons:

• Visual distortion of proportions
• Humans can't easily compare circle sizes

Scaled Dots

Pros:

• Looks scientific
• Contains Median, Quantiles
• Shows outliers

Cons:

• Not designed for discrete data
• Doesn't show distribution correctly (e.g. Q4 + Q5)

#statistics #data #datascience #likert

I've used cross entropy as my loss of choice. On my training set the loss steadily decreased while the F1-Score improved. On the validation set the loss decreased shortly before increasing and leveling off around ~2, normally a clear sign for overfitting. However the F1-Score on the validation set kept rising and reached ~0.92, with similarly high presicion and recall.

As I never took a closer look at the relation between F1-Score and the cross-entropy loss, I've decided to do a quick simulation and plotted the results. The plots show the cross-entropy in relation to the F1-Score. On the first graph I varied the range in which the misses landed, while hits where always perfect. The graph shows that misses with a _confidence _create higher losses, even at high F1-Scores. In contrast the confidence of hits has a negligible influence on the loss as depicted in the second graph.

It seems likely that my network developed a high confidence in its prediction, only answering **** or 1, which provoked a high loss while still achieving reasonable high accuracy.

Ein einfaches Rezept für ein Kastenbrot aus Weizenmehl. Die Zusammensetzung der Saaten kann beliebig angepasst werden.

Vorteig:

• 250g Weizenmehl 550
• 250g Wasser
• 60g Anstellgut (TA200)

Saaten:

• 80g Sonnenblumkerne
• 40g Leinensamen
• 40g Haferflocken
• 160g heißes Wasser (ca. 90° C)

Hauptteig

• Vorteig
• Saaten
• 200g Weizenmehl 550
• 15g Salz
• 5g Hefe

Zutaten des Vorteigs gut vermengen und 12 Stunden bei Raumtemperatur gehen lassen

Saaten mischen und mit heißem Wasser übergießen. Mit eine Klarsichtfolie abdecken und ca. 1 Stunde ziehen lassen.

Alle Zutaten des Hauptteigs vermengen und per Hand zu einem weichen, leicht klebrigen Teig kneten.

Teig 90 Minuten gehen lassen und alle 30 Minuten in der Schüssel falten.

Teig auf einer bemehlten Arbeitsfläche formen und direkt in die Kastenform geben.

Für weitere 2 Stunden gehen lassen, bis sich das Volumen des Teigs etwa verdoppelt hat.

Vor dem backen den Brotteig längs einschneiden und gut befeuchten (z.B. mit einer Sprühflasche)

Den Ofen auf 250° C vorheizen und das Brot für 10 Minuten backen. Danach die Temperatur auf 200° C reduzieren und für weitere 35 Minuten backen. Das Brot aus dem Kasten nehmen und für weitere 10 Minuten auf einem Rost backen.

Update:

https://pathfinder.libove.org running on new server

https://tools.libove.org running on new server

Start with two layers, one for the dark sky and one for the stars. The dark sky is just uses a dark, blue color. The star layer contains a mixture of light colors. It is up to you how you create this layer. I painted the layer randomly with 3 colors and used the Smudge Tool to mix them. Make sure the star layer has an alpha layer.

To convert the randomly colored layer into stars the RGB Noise Filter is used, which can be found under Filters → Noise → RGB Noise …. Set up the filter as shown below. The Red, Green and Blue Noise is completely disabled and only the Alpha Noise is applied. If you do not see the Alpha slider of the filter make sure that the layer has an Alpha Channel.

After applying the filter for the first time the result does not look very promising. If you keep applying the filter repeatedly (using the Ctrl+F shortcut) the remaining color will get sparser and sparser. Keep doing this until you are satisfied with the density of the stars. The results should look like the example below.

Story

You want to go the final step with your loved one but damn it is expensive. Living on a small floating island there isn't much to earn money with, but you have to find a way before it is too late. Farm the little land you have to rack up the money you need.

Game Mechanics

The worth of objects changes with time. Most objects get more valuable over time, but only to a certain point. Once they exceeded this point the value deteriorates until they are completely worthless.

It is your job to find out how long processes have to run for an optimal outcome.

This requires keen observation and managing your time between different tasks.

Controls

• WASD and Arrow-Keys: Walk and Jump
• Spacebar: Use selected tool
• Mouse: Control build menu
• 1-8: Change Tool

Tools

• Hammer: Interact with most objects
• Wood: Plant trees
• Wheat: Plant Wheat
• Other: there might be hidden functionalities

Credits

Third Party Tools/Assets

• Godot Engine
• Gimp
• Music From Antti Luode

Sounds/Assets

• http://www.freesound.org/people/gruenebanane/sounds/241813/
• http://www.freesound.org/people/acebrian/sounds/380471/
• http://www.freesound.org/people/ryanharding95/sounds/272442/
• http://www.freesound.org/people/ryanconway/sounds/240801/
• http://www.freesound.org/people/deleted_user_877451/sounds/66113/
• http://www.freesound.org/people/vumseplutten1709/sounds/208829/
• http://www.freesound.org/people/jorge0000/sounds/361053/

Brot für das Wochenende musste her. Daher habe ich einen Teig angesetzt und mich von den Mengen am Neujahrsbrot orientiert. Ich habe dem Hauptteig noch etwas Hefe zugesetzt, da ich meinem Sauerteig noch nicht ganz vertraue. Herausgekommen ist ein schönes Brot mit einer großporigen Krume.

Sauerteig

• 105 g Weizenmehl 550
• 105 g Wasser (50°C)
• 7 g Anstellgut (mild geführt)

Autolyseteig

• 560 g Weizenmehl 550
• 355 g Wasser (55°C)

Hauptteig

• Sauerteig
• Autolyseteig
• 30 g Weizenmehl 550
• 16 g Salz
• 70 g Wasser (30°C)
• 0,3g Trokenhefe

Den Sauerteig ansetzen und ca. 12 Stunden bei Raumtemperatur reifen lassen.

Autolyseteig gut vermischen und 1 Stunde stehenlassen.

Alle Zutaten von Hand vermischen und 3 Stunden reifen lassen. Die ersten 2 Stunden 3 mal in der Schüssel falten.

Teig auf eine bemehlte Arbeitsfläche geben, in zwei Portionen teilen und schonend lang wirken.

1 Stunde im Gärkorb mit Schluss nach oben garen lassen.

Bei 250° C fallend auf 150° C mit Dampf für 30 Minuten backen.

Ich habe nun schon zum zweiten Mal das Nußdorfer Landbrot von Plötzblog gebacken und bin sehr zufrieden mit dem Rezept. Der Teig lässt sich etwas schwer per Hand kneten, was an dem Roggenanteil liegen dürfte.

Weizensauerteig

• 150 g Weizenmehl 1050
• 110 g Wasser
• 15 g Anstellgut

Vorteig

• 100 g Weizenmehl 1050
• 100 g Wasser
• 0,1 g Frischhefe

Hauptteig

• Sauerteig
• Vorteig
• 100 g Weizenmehl 1050
• 200 g Roggenmehl 1150
• 150 g Wasser
• 12 g Salz

Die Vorteig in ansetzen und etwa 20 Stunden bei Raumtemperatur reifen lassen.

Alle Zutaten vermengen und ca. 10 Minuten von Hand kneten. Der Teig sollte nur noch leicht an der Hand kleben.

2 Stunden zur Gare stellen und nach einer Stunde falten.

Teig zu einem länglichen Laib formen und in einen gut bemehlten Gärkorb geben. Ich habe den Teig leicht über eine bemehlte Arbeitsfläche gerollt um ihn in Form zu bringen.

Etwa 2 Stunden Gare im Gärkorb.

Statt das Brot zu stippen, habe ich es quer eingeschnitten.

Bei 250° C fallend auf 150° C mit Dampf für 40 Minuten backen. (Achtung mein Ofen verbrennt schnell das Brot, deswegen Temperaturen und Backzeit eher nach oben anpassen)

Das Rezept ist inspiriert von Kreolisches Rindfleisch – Curry mit Gemüse. Der Eintopf ist ideal für die kalten Jahreszeiten und lässt sich schnell zubereiten.

Zutaten:

• 500 g Schweine-Gulash
• 500 g Karotten
• 750 g Kartoffeln
• 500 ml Gemüsebrühe
• 3 Tomaten
• 3 Zwiebeln
• 4 Knoblauchzehen
• 1 Stück Ingwer
• 1 TL Kurkuma
• 1 TL Thymian
• Salz und Pfeffer
• Öl zum anbraten

Karotten und Kartoffeln schälen und ca 1 cm dicke Würfel schneiden. Zwiebeln fein würfeln, Knoblauch fein hacken und Ingwer zerreiben oder ebenfalls fein hacken. Tomaten würfeln.

Fleisch anbraten und mit Salz und Pfeffer würzen. Zwiebeln hinzugeben und mit anbraten. Tomaten, Ingwer und Knoblauch hinzugeben und kurz mit anbraten. Mit der Brühe ablöschen und Kartoffeln, Karotten und Gewürze hinzugeben.

Etwa 30 Minuten kochen bis Kartoffeln und Karotten gar sind.

Nach meinen ersten Versuchen mit Weizensauerteig Broten, wollte ich eine anderes Mehl versuchen und entschied mich für das Roggenvollkornbrot. Eigentlich hatte ich mir vorgenommen die Teigmenge zu halbieren, dies aber schon beim ansetzen des 1. Sauerteiges vergessen. Deswegen sind es direkt 3 Brote geworden. Das Rezept habe ich nur leicht verändert. Ich habe Weizen Anstellgut benutzt, da ich kein neues für diesen Versuch herstellen wollte. Der fertige Teig war sehr klebrig und ließ sich kaum verarbeiten, weswegen ich beim nächsten mal das Wasser des Hauptteigs weglassen würde. Die Backzeit habe ich auf 40-45 Minuten reduziert, da ich kleiner Brote gebacken habe. Außerdem hab ich fallend von 250° C auf 180° C gebacken, was meinem Backofen geschuldet ist.

Das Brot schmeckt leicht säuerlich und hat eine feine Porung.

Das Rezept gefällt mir sehr gut, da es sich gut in den Alltag integrieren lässt und keinen Dampf erfordert (den ich in meinem Ofen nur schlecht aufbauen kann). Ich habe den ersten Sauerteig abends angesetzt, den zweiten direkt am morgen zubereitet und konnte am Abend das Brot backen.

Erster Sauerteig

• 170 g Roggenvollkornmehl
• 170 g Wasser (warm)
• 17 g Anstellgut (Weizen)

Zweiter Sauerteig

• Erster Sauerteig
• 520 g Roggenvollkornmehl
• 520 g Wasser (warm)
• 18 g Salz

Hauptteig

• Zweiter Sauerteig
• 200 g Roggenvollkornmehl
• 110 g Wasser (warm)

Ersten Sauerteig vermischen und 12 Stunden ruhen lassen.

Zweiten Sauerteig vermischen und ~9 Stunden ruhen lassen.

Hauptteig vermischen, Wasser langsam einarbeiten bis Konsistenz stimmt, Laib formen und 90 Minuten im Gärkorb ruhen lassen.

Bei 250° C fallend auf 180° C backen. 500 g Brote für 40 Minuten backen, bei größeren Laiben die Backzeit anpassen.

Sauerteig (unverändert):

• 65 g Weizenmehl 550
• 80 g Wasser
• 6 g Anstellgut

Hauptteig

• Sauerteig
• 335 g Weizenmehl 550
• 40 g Weizenvollkornmehl
• 200 g Wasser
• 9 g Salz

Der Sauerteig hat 20 Stunden bei Raumtemperatur geruht.

Beim Hauptteig habe ich 10g Wasser weniger benutzt als im Orginalrezept. Außerdem habe ich die 30 g Roggenvollkornmehl gegen zusätzliche 30 g Weizenvollkornmehl ersetzt. Der Hauptteig ohne Salz wurde von Hand vermischt und 30 Minuten ruhen gelassen. Nach der Ruhe wurde das Salz hinzu gegeben und der Teig für 5 Minuten von Hand geknetet.

Die restlichen Garzeiten blieben unverändert, jedoch nur bei Raumtemperatur durchgeführt.

1 Stunde Gare, dann falten.

2 Stunde Gare, dann rund wirken.

15 Minuten Ruhe, dann Laib formen.

2,5 Stunden Gare im Gärkorb mit Schluss nach oben.

Zum Backen den Ofen eine halbe Stunde auf 250° C vorheizen. Für den Dampf habe ich eine Auflaufform mit Wasser in den Ofen gestellt. Das Brot wurde für 40 Minuten bei 250° C fallend auf 200° C gebacken. Nach 40 Minuten habe ich die Wasserschale entfernt und das Brot weitere 8 Minuten gebacken.

Geplante Änderungen für den nächsten Versuch:

• Einschnitt ändern (tiefer oder mehrere Schnitte?)
• Mehr Dampf. Wasser hatte nur leicht geköchelt.
• Temperatur stärker abfallen lassen. Brot sehr dunkel geworden.

Before the internet it was relatively easy to attribute an action or statement to an organisation, such as a political party or a state. Actions were attributable because evidence was impossible, or at least very hard, to forge (without leaving a trace). Statements made by an individual could be traced back as opinion were exchanged by direct contact.

This changed in the digital world. Data can be manipulated without leaving traces and left traces are hard to find and could also be created on purpose.

For this reason actions in the internet, such as hacking an organisation, can't be attributed to someone only based on the traces left in the process. Hard, physical proof is needed to do such an attribution.

Hacks are generally attributed to the Russian government at the moment. This attribution explains (some) features of found malware and traces. However a skilled hacker could have avoided such traces or planted them on purpose.

Statements made by an individual are often labeled as being left, right or liberal believes, but are just the interpretations and thoughts of a single person. Even if this person associates itself with a specific group doesn't make his statements general believes of such group. The association of an individual with a group got more fluid in the internet. One only has to claim being associated to be seen as voice of such group.

This error, where association is confused with attribution, can often be seen in today's debates. For example, feminists are viewed as crazy women who want to see men suffer because a few individuals with extreme viewpoints identify themselves as feminists. The political right is often set on one level with Nazis because, again, few individuals who call themselves "right" spread hatred against foreigners. The political left is confused with people that despise all authority or want to recreate the communism of the cold war.

In conclusion, our old techniques of attribution don't work any longer in the digital world. Actions can't be attributed and statements made by individuals only show their views, not general views of a group. This makes policital and social debates more complex, as organisations (movements/parties) can't be described by pointing on individual events or statements. Other techniques are required to pinpoint the general believes of a group.

• 500 g Chopped Tomatoes
• 100 ml Water
• 1 small Onion
• 1 Garlic Clove
• 1 Tsp Olive Oil
• 1/2 tsp Pepper
• 1 tsp Salt
• 1/4 tsp dried Chilis (Habaneros)
• 1 tsp Marjoram
• 1 tsp Oregano

Preparation:

Sear chopped onions and garlic for ~2 minutes in olive oil, until the garlic starts to turn brown.

Add tomatoes and water.

Let it simmer for 5 minutes and add all spices.

Mix everything up and let it simmer for ~30 minutes with a half closed lid.

Blend everything to a smooth sauce.

Conclusion:

Taste dominated by the hotness of the chili. Marjoram and Oregano barely noticeable. Pizza taste dictated by toppings and dough, sauce stays in background.

All textures are licensed under CC-BY 4.0

Ingredients for Simple Pizza Sauce for ~4 Pizzas:

• 1 Packet/Can Tomato Pieces
• **1 Tablespoon **Olive Oil
• 1 Teaspoon Salt
• 1-2 Teaspoon Oregano
• 1-2 chopped Garlic Gloves
• Pepper
• optionally Chili Powder or chopped Chilies

Add all ingredients into a pot and heat it until the sauce starts to cook. Leave the sauce simmering for approx. 30 minutes with the cover on but not closing the pot completely. The sauce is ready once most of the water is evaporated. If you don't like your sauce chunky use a mixer to create a smooth sauce.

Ingredients for 1 Pizza:

• 175 g Flour
• 100 ml Water
• ¼ Yeast Cube or  ½ Packet Dry Yeast
• 1 Tablespoon Olive Oil
• 1/2 Teaspoon Salt

Mix flour and salt and dissolve yeast in water. Add water and oil to the flour and knead it until the dough is smooth. Let the dough rest for at least 30 minutes, better overnight in the refrigerator.

Name: Blimmderox Rattlezak

Race: Gnome

Class: Wizard/11

Ability Scores {#ability-scores}

Raw: STR: 5 DEX: 14 CON: 15 INT: 20 WIS: 8 CHA: 13

Equipped: STR: 5 DEX: 16 CON: 15 INT: 26 WIS: 8 CHA: 13

(Point Buy 20: STR: 7 DEX: 14 CON: 13 INT: 18 WIS: 8 CHA: 11, +2 CON/CHA -2 STR Race Bonus, +2 INT from level 4+8)

Combat

Hit Points: 11D6 + 33

Initiative: 11

Reflex: 6 Fortitude: 5 Willpower: 6

Armor Class: 20 Touch: 16 Flat-footed: 17

CMB: 1 CMD: 14

Quaterstaff: Attacks: +2 Damage: 1d4-3 Crit: 20/x2

Ranged Attacks: Attacks: +8

Feats

(6 regular + 2 wizard bonus + Scribe Scroll)

• Scribe Scroll – Create magic scrolls
• Craft Wondrous Item – Create magic wondrous items
• Effortless Trickery – You can maintain concentration on one spell of the illusion school as a swift action.
• Spell Focus (Illusion) – +1 bonus on save DCs for one school
• Threatening Illusion – A threatening illusion spell causes one target to believe your illusion is a threat.
• Greater Spell Focus (Illusion) – +1 bonus on save DCs for one school
• Improved Initiative – +4 bonus on initiative checks
• Dazing Spell –  Daze creature with spell damage
• Improved Familiar – Gain a more powerful familiar

Traits

• Reactionary: You were bullied often as a child, but never quite developed an offensive response. Instead, you became adept at anticipating sudden attacks and reacting to danger quickly. You gain a +2 trait bonus on Initiative checks.
• Fidgety: +2 Initiative (can't find the English name, but it's from Gnomes of Golarion)

Illusion School {#illusion-school}

Forbidden Schools: Necromancy, Divination

Extended Illusions: Any illusion spell you cast with a duration of "concentration" lasts a number of additional rounds equal to 1/2 your wizard level after you stop maintaining concentration (minimum +1 round). At 20th level, you can make one illusion spell with a duration of "concentration" become permanent. You can have no more than one illusion made permanent in this way at one time. If you designate another illusion as permanent, the previous permanent illusion ends.

Blinding Ray: As a standard action you can fire a shimmering ray at any foe within 30 feet as a ranged touch attack. The ray causes creatures to be blindedfor 1 round. Creatures with more Hit Dice than your wizard level are dazzled for 1 round instead. You can use this ability a number of times per day equal to 3 + your Intelligence modifier.

Invisibility Field: At 8th level, you can make yourself invisible as a swift action for a number of rounds per day equal to your wizard level. These rounds do not need to be consecutive. This otherwise functions as greater invisibility.

Gnome Traits

• Small: Gnomes are Small creatures and gain a +1 size bonus to their AC, a +1 size bonus on attack rolls, a –1 penalty to their Combat Maneuver Bonus and Combat Maneuver Defense, and a +4 size bonus on Stealth checks.
• Slow Speed: Gnomes have a base speed of 20 feet.
• Low-Light Vision: Gnomes can see twice as far as humans in conditions of dim light.
• Illusion Resistance: Gnomes gain a +2 racial saving throw bonus against illusion spells and effects.
• Gnome Magic: Gnomes add +1 to the DC of any saving throws against illusion spells that they cast. Gnomes with Charisma scores of 11 or higher also gain the following spell-like abilities: 1/day—dancing lights, ghost sound, prestidigitation, and speak with animals. The caster level for these effects is equal to the gnome's level. The DC for these spells is equal to 10 + the spell's level + the gnome's Charisma modifier.
• Gift of Tongues: Gnomes love languages and learning about those they meet. Gnomes with this racial trait gain a +1 bonus on Bluff and Diplomacy checks, and they learn one additional language every time they put a rank in the Linguistics skill. This racial trait replaces defensive training and hatred.
• Obsessive: Gnomes receive a +2 racial bonus on a Craft or Profession skill of their choice.

Equipment

(82000 GP at level 10, crafting allows to spend up to 164000)

As this character is the result of multiple campaigns. It acquired gear worth 106800 gp, mainly by crafting the more expensive items.

• Headband of vast intelligence +6 (36000) – +6 Intelligence
• Hat of disguise (1800) – This apparently normal hat allows its wearer to alter her appearance as with a disguise self spell.
• Cloak of displacement, minor (24000) – This displacement works similar to the blur spell, granting a 20% miss chance on attacks against the wearer. It functions continually.
• Amulet of natural armor +1 (2000) – +1 Natural Armor
• Lenses of detection (3500) – These circular prisms let their wearer detect minute details, gaining a +5 competence bonus on Perception checks. It also aids in tracking, adding a +5 competence bonus on Survival checks when tracking.
• Snakeskin tunic (8000) – A snakeskin tunic is a tight, form-fitting shirt crafted from the scales of a giant snake. When worn, it grants a +1 armor bonus to AC, a +2 enhancement bonus to Dexterity, and a +2 resistance bonus on saving throws against poison.
• Bracers of armor +3 (9000) – +3 armor bonus
• Verdant boots (12000) – The wearer of these boots can, on command three times per day, cause her current square to sprout a thick canopy of fruit-bearing or otherwise edible plants. These plants count as difficult terrain and grant cover to any Medium or smaller creature within the square. They also provide enough food to sustain two Medium creatures for 1 full day. While the plants can grow on surfaces that would not normally support vegetation such as a wooden floor or cave stone, they cannot sprout on surfaces explicitly hostile to vegetation. The plants are usually of a sort common to the terrain or climate of the area in which they were produced. They disappear after 24 hours or when completely harvested, whichever comes first.
• Ring of sustenance (2500) – This ring continually provides its wearer with life-sustaining nourishment. The ring also refreshes the body and mind; its wearer only needs to sleep 2 hours per day to gain the benefit of 8 hours of sleep. This allows a spellcaster that requires rest to prepare spells to do so after only 2 hours, but does not allow a spellcaster to prepare spells more than once per day. The ring must be worn for a full week before it begins to work. If it is removed, the owner must wear it for another week to reattune it to himself.
• Ring of protection +2(8000) – his ring offers continual magical protection in the form of a deflection bonus of +2 AC
• Quaterstaff

Skills

(ranks only, 3 skills maxed by headband, 7 ranks per level)

Situational Bonus:

• +10 Disguise when using Hat of Disguise
• +2 resistance bonus on saving throws against poison
• +2 racial saving throw bonus against illusion spells and effects.

Spells

Level 1

• Alarm: Wards an area for 2 hours/level.
• Mage Armor: Gives subject +4 armor bonus.
• Unseen Servant: Invisible force obeys your commands.
• Shield: Invisible disc gives +4 to AC, blocks magic missiles.
• Mount: Summons riding horse for 2 hours/level.
• Sleep: Puts 4 HD of creatures into magical slumber.
• Color Spray: Knocks unconscious, blinds, and/or stuns weak creatures.
• Disguise Self: Changes your appearance.
• Silent Image: Creates minor illusion of your design.
• Erase: Mundane or magical writing vanishes.
• Expeditious Retreat: Your base speed increases by 30 ft.
• Feather Fall: Objects or creatures fall slowly.
• Chill Touch: One touch/level deals 1d6 damage and possibly 1 Str damage.
• Hypnotism: Fascinates 2d4 HD of creatures.
• Magic Missile: 1d4+1 damage; +1 missile per two levels above 1st (max 5).
• Grease: Makes 10-ft. square or one object slippery.
• Charm Person: Makes one person your friend.
• Ray of Enfeeblement: Ray causes 1d6 Str penalty + 1 per 2 levels.
• Vanish: As invisibility for 1 round/level (5 max).
• Obscuring Mist: Fog surrounds you.
• Protection from Evil: +2 to AC and saves, plus additional protection against selected alignment.
• Snapdragon Fireworks: Create 1 dragon firework/level.
• Floating Disk: Creates 3-ft.-diameter horizontal disk that holds 100 lbs./level.

Level 2

• Blindness/Deafness: Makes subject blinded or deafened.
• Minor Image: As silent image, plus some sound.
• Resist Energy: Ignores first 10 (or more) points of damage per attack from specified energy type.
• False Life: Gain 1d10 temporary hp + 1/level (max +10).
• Detect Thoughts: Allows "listening" to surface thoughts.
• Ghoul Touch: Paralyzes one subject, which exudes stench that makes those nearby sickened.
• Hypnotic Pattern: Fascinates 2d4 + level HD of creatures.
• Summon Monster II: Summons extraplanar creature to fight for you.
• Make Whole: Repairs an object.
• Fox's Cunning: Subject gains +4 to Int for 1 min./level.
• Levitate: Subject moves up and down at your direction.
• Scorching Ray: Ranged touch attack deals 4d6 fire damage, + 1 ray/four levels (max 3).
• Mirror Image: Creates decoy duplicates of you.
• Invisibility: Subject is invisible for 1 min./level or until it attacks.
• Spider Climb: Grants ability to walk on walls and ceilings.

Level 3

• Explosive Runes: Deals 6d6 damage when read.
• Phantom Steed: Magic horse appears for 1 hour/level.
• Illusory Script: Only select creatures can read text.
• Major Image: As silent image, plus sound, smell and thermal effects.
• Dispel Magic: Cancels one magical spell or effect.
• Loathsome Veil: Nauseates and/or sickens weak creatures.
• Protection from Energy: Absorbs 12 points/level of damage from one kind of energy.
• Displacement: Attacks miss subject 50% of the time.
• Vampiric Touch: Touch deals 1d6 damage per two levels; caster gains damage as temporary hp.
• Tiny Hut: Creates shelter for 10 creatures.
• Tongues: Speak and understand any language.

Level 4

• Dimension Door: Teleports you a short distance.
• Wall of Ice: Ice plane creates wall or hemisphere creates dome.
• Fire Trap: Opened object deals 1d4 damage + 1/level.
• Bestow Curse: –6 to an ability score; –4 on attack rolls, saves, and checks; or 50% chance of losing each action.
• Summon Monster IV: Summons extraplanar creature to fight for you.
• Shadow Conjuration: Mimics conjuration below 4th level, but only 20% real.
• Secure Shelter: Creates sturdy cottage.
• Phantasmal Killer: Fearsome illusion kills subject or deals 3d6 damage.
• Confusion: Subjects behave oddly for 1 round/level.
• Simulacrum, Lesser: Creates a double of a weak creature.

Level 5

• Mirage Arcana: As hallucinatory terrain, plus structures.
• Corrosive Consumption: Acidic patch damages an opponent.
• Cone of Cold: 1d6/level cold damage.
• Summon Monster V: Summons extraplanar creature to fight for you.
• Phantasmal Web: Catches subjects in illusory web.
• Wall of Sound: Sonic wall deflects and damages creatures.
• Shadow Evocation: Mimics evocation below 5th level, but only 20% real.
• Wall of Stone: Creates a stone wall that can be shaped.
• Teleport: Instantly transports you as far as 100 miles per level.
• Overland Flight: You fly at a speed of 40 ft. and can hustle over long distances.

Level 6

• Chain Lightning: 1d6/level damage and 1 secondary bolt/level.
• Shadow Walk: Step into shadow to travel rapidly.

Ghost Sound is a level 0 illusion spell available to bards, sorcerer and wizards. Gnome Magic allows gnomes to use Ghost Sound once per day as a spell like ability. It last 1 round per caster level and produces as much noise as 4 humans per caster level. The produced sound can be virtually anything.

The usage of Ghost Sound always depends on the situation. In combat it can be used to create a distraction, may allowing your allies to land attacks of opportunity or delaying actions of your enemies. Out of combat Ghost Sound can be used to support a lie or distract guards. I gathered some examples below.

In combat

This was one of the first times I successfully used Ghost Sound. My group fought a bunch of goblins in a cave. We were out numbered, the melee fighters were completely surrounded. As I had no higher spells left I used Ghost Sound to do something. Creating the sound of 16 charging Knights in the tunnel leading into the cavern, I were able to convince some goblins, that our back up troops arrived. Most of them tried to flee allowing the fighters to get the upper hand in the fight.

To use Ghost Sound in such a way, it is important to make it convincing. Firstly the source of the sound should not be directly visible to the target. Not even goblins will believe you, if you create the sound of an charging army on an empty plane. Secondly the produced sound should fit into the surrounding. If you are in a cave use the sound of giant insects, goblins and kobolds instead of bisons. The Bestiaries provide lists of monsters for every terrain type. At last choose sounds creating fear in your enemies. The descriptions of monsters often state their enemies or fears. You might can find something by knowledge rolls.

As a gnome you can use the metamagic feat Threatening Illusion to flank a foe. The targeted field is considered as threatening enemies. The feat raises the spell level by one but a threatening Ghost Sound is still a good choice for level one spells. The effect probably will only last one round, but your rogue will thank you.

In role playing

The real strength of Ghost Sound comes into play once combat is over. The spell can be used in almost any situation.

Causing distraction is probably the most common use of Ghost Sound. It begins at the towns gate by creating the sound of a brawl to distract the guards to avoid paying 2 silver coins per feet. When you reach the market distract a merchant with the sound of fighting chickens in his cages, to allow your rogue to acquire a splendid lunch. Whenever a NPC has to be distracted, Ghost Sound is a good first choice.

Ghost Sound can be used to support your statements or to alter the attitude of an NPC. If you want to convince a NPC that the group on the next table is plotting to kill him, we will be more likely to believe you if he hears constant mumbling. The guards might help you if the bandits scream about killing guards and taking their wives. General advise: let the target hear what he wants to hear in order to support your own needs.

Conclusion

As Ghost Sound is a level 0 spell it is tempting to use it all the time. However keep in mind that Ghost Sound is only as effective as your game masters allows it to be. At some point the GM will snap, if you repeat the same trick over and over again. My advise: only use Ghost Sound occasionally and describe it precisely. Also explain what effect you are looking for. You won't always get the wanted effect, but putting more effort in the descriptions makes it more likely.

Vashta Nerada (name origin) is a female half-elven rogue. She used to work as a courtesan but found people tend to pay more for the possessions of her clients than the clients for her services. Being a trained courtesan she has no problem to seduce victims and infiltrate mansions and strongholds. Her social skills and profession allow her to penetrate strong security measures and obtain objects of desire while the owner is fast asleep.

Name: Vashta Nerada

Race: Half-Elf

Class: Rogue/10

Ability Scores {#ability-scores}

Raw: STR: 10 DEX: 18 CON: 10 INT: 14 WIS: 10 CHA: 18

Equipped: STR: 10 DEX: 22 CON: 10 INT: 14 WIS: 10 CHA: 20

(Point Buy 25: STR: 10 DEX: 16 CON: 10 INT: 14 WIS: 10 CHA: 16, +2 DEX Race Bonus, +2 CHA from level 4+8)

Combat

Hit Points: 10D8

Initiative: 8

Reflex: 13 Fortitude: 3 Willpower: 3

Armor Class: 22 Touch: 16 Flat-footed: 16

CMB: 7 CMD: 23

Shortbow: Attacks: +16/+11 Damage: 1d6+2 Crit: 20/x3

Shortbow(30 feet): Attacks: +17/+12 Damage: 1d6+2 (+5d6 +5 bleed on Sneak Attack)  Crit: 20/x3

Dagger: Attacks: +14/+9 Damage: 1d4 (+5d6 +5 bleed on Sneak Attack)  Crit: 19-20/x2

Feats

(5 regular + 1 skill focus from race)

• Point-Blank Shot – +1 attack and damage on targets within 30 feet
• Precise Shot – No penalty for shooting into melee
• Weapon Finesse – Use DEX instead of STR on attack rolls with light weapons
• Weapon Focus(Short Bow) – +1 bonus on attack rolls with one weapon
• Skill Focus(Perception) – +3 bonus on one skill (+6 at 10 ranks)
• Skill Focus(Stealth) – +3 bonus on one skill (+6 at 10 ranks)

Rogue Talents

(4 Normal, 1 Advanced )

• Bleeding Attack: A rogue with this ability can cause living opponents to bleed by hitting them with a sneak attack.
• Fast Stealth: This ability allows a rogue to move at full speed using the Stealth skill without penalty.
• Trap Spotter: Whenever a rogue with this talent comes within 10 feet of a trap, she receives an immediate Perception skill check to notice the trap.
• Sniper's Eye: A rogue with this talent can apply her sneak attack damage on ranged attacks targeting foes within 30 feet that benefit from concealment.
• Stealthy Sniper: When a rogue with this talent uses the Stealth skill to snipe, she only suffers a –10 penalty on the Stealth check, instead of –20.

Traits

• Charming: Blessed with good looks, you've come to depend on the fact that others find you attractive. You gain a +1 trait bonus when you use Bluff or Diplomacy on a character that is (or could be) sexually attracted to you, and a +1 trait bonus to the save DC of any language-dependent spell you cast on such characters or creatures.
• Elven Reflexes: One of your parents was a member of a wild elven tribe, and you've inherited a portion of your elven parent's quick reflexes. You gain a +2 trait bonus on Initiative checks.

Equipment

(62000 GP at level 10)

• Darkwood Shortbow +2(8350)
• Dagger +1(2302)
• Mithral Chain Shirt +2(5300)
• Corset of the vishkanya (3000): As a free action, the wearer can compress herself to fit through tight spaces as though affected by a squeeze spell (Advanced Race Guide) for up to 10 rounds per day. While using the corset's magic, she gains a +5 bonus on Escape Artist checks.
• Cloak of Elvenkind (2500): +5 Stealth
• Eyes of the Eagle (2500): +5 Perception
• Vest of Escape (5200):  Hidden inside these are magic lockpicks that provide a +4 competence bonus on Disable Device checks. The vest also grants its wearer a +6 competence bonus on Escape Artist checks.
• Belt of incredible dexterity +4 (16000): +4 Dexterity
• Boots of the Winterland (2500): The wearer of these boots is able to travel across snow at her normal speed, leaving no tracks. (And more)
• Hat of Disguise (1800): This apparently normal hat allows its wearer to alter her appearance as with a disguise self spell.
• Headband of alluring charisma +2 (4000): +2 Charisma
• Mind sentinel medallion (3500): The medallion grants a continuous +2 resistance bonus on saves versus mind-affecting spells, spell-like abilities, and supernatural abilities.
• Sleeves of many garments (200): The wearer of these sleeves can, when she slips them on, choose to transform her current garments into any other nonmagical set of clothing.
• Apprentice's cheating gloves (2200): The wearer of these gloves can employ mage hand and prestidigitation at will.
• 2648 GP for other equipment and toys.

Skills

(ranks only, 11 ranks per level)

Situational Bonus:

• +10 Disguise when using Hat of Disguise
• +5 to find and disable traps (Trapfinding)
• +3 Reflex/AC vs traps (Trap Sense)
• +2 Resistance bonus versus mind-affecting spells, spell-like abilities, and supernatural abilities
• +1 Bluff/Diplomacy versus characters that are (or could be) sexually attracted to you (Charming)

Naive implementations of player movement use the axis of the coordinate system as directions. Left and Right correspond to the [1,0,0] direction and Up and Down to the[0,0,1] direction. This implementation is correct and usable as long as the camera is correctly aligned to this axis. If the camera is not aligned the movement directions no longer correspond to the perceived directions of the player (see image above). To correct this we have to extract the directions from the camera.

To compute our new directions we unproject three points from camera space to world space. Most framework/engine have built in functions to do this ( godot, opengl, unity ). We have to preform 3 unprojections for the points: (0,0), (1,0) and (0,1). By substracting the result of latter two from the former we obtain two 3D-Vectors that represent our new directions. To receive planar movement direction set the height value (mostly y) to zero and normalize the vectors.

Godot:

var p0 = cam.project_position(Vector2(0,0))
var pH = cam.project_position(Vector2(10,0))
var pV = cam.project_position(Vector2(0,10))

camH = pH - p0
camV = pV - p0
camH.y = 0
camV.y = 0
camH = camH.normalized()
camV = camV.normalized()

camH is the horizontal movement direction and camV the vertical. Instead of using the axis of the coordinate system ([1,0,0] and [0,0,1]) as movement directions, use camH for left/right movement and camV for up/down movement.

Low Poly Desert Arena

Pixel Art Terrain

This is my favorite salad. It's suitable for most occasions and can serve as a main or side dish. It takes around 20 minutes to prepare.

The ingredients (in a copyable fashion):

• 500 g Pasta
• 250 g Mini Tomatoes
• 250 g Mozzarella
• 125 g Arugula
• 100 g Green Pesto
• 2 Tablespoons Honey
• 2 Tablespoons Mustard
• 1 Handful Grinded Parmesan Cheese

Cook the pasta as described on the package (al dente). While the pasta is cooking you can cut the mozzarella and the tomatoes. I divide the tomatoes once or twice, depending on their size. The mozzarella is cut into pieces roughly the same size as the tomato pieces.

Add everything to the bowl, except the arugula! It takes a long time mix everything up if you add the arugula directly. Mix the ingredients until everything is coated than add the arugula and mix it again.

Cook

Preparing a Lavish Meal:

To prepare a Lavish Meal you need one pound of fresh ingredients per small or normal creature to feed. Additionally you need spices worth at least 1 gp. per person. It takes one hour to prepare the meal. If you want to feed more than 10 people it takes an additional hour per 10 people. You need a fire, or any other sufficient heat source, a pan and a pot.

Everyone eating a full Lavish Meal is healed. The amount of HP recovered depends on the Profession(Cooking) throw of the cook. A normal Lavish Meal heals 2 HP. You can only benefit from a Lavish Meal once per day.

The DC Profession(Cooking) to create a Lavish Meal is 20. For every 5 by which your check result exceeds the DC, the meal heals additional 2 hit points.

Woodcutter

Find Weak Spot:

You can analyse wooden objects, e.g. wooden doors, to find their weak spots to break them more easily. If you know the weak spot of an object the Strength DC to break it is lowered by one point. Additionally the objects hardness is lowered by one point.

It takes 1 minute to find a weak spot. You can use the bonus as long as you can see and access the found weak spot. Once you found one, you can describe it to other persons to allow them the same bonus. You have to stand next to the person, when she is breaking or attacking the object.

The DC Profession(Woodcutter) to find a weak spot is 20. For every 5 by which your check result exceeds the DC, the Strength DC to break the object and the hardness are lowered by an additional point.

Brewer

Splendid Drink

To prepare a Splendid Drink you need herbs worth at least 2 gp. per small or normal person. You can create at most 10 drinks with one Profession(Brewer) throw. It takes 30 minutes to prepare the drink. The drink has to cook for 4 hours before it is usable. You do not have to tend the drink while it is cooked. Splendid Drinks can be filled into flasks, waterskins or similar containers. A Splendid Drink has to be used 1 week after its creation or its effect is lost.

The DC Profession(Brewer) for brewing a Splendid Drink is 20. A Splendid Drink grants a +1 bonus to any skill check for 10 minutes. For every 5 by which your check result exceeds the DC Profession(Brewer), the drink grants an additional +1 bonus on skill checks. Tasks that take longer than 10 minutes, e.g. crafting, do not benefit from Splendid Drink. A Creature can only benefit from a Splendid Drink once per day.

Scribe

Prepare Letter of Recommendation

It takes 1 hour to create a Letter of Recommendation. You need parchment and ink worth at least 1 gp. and a quiet environment with a suitable surface to write on.

A Letter of Recommendation gives you a +2 bonus to one diplomacy throw against a merchant or an official instance, e.g. a mayor or town guard. The person the Letter of Recommendation is used against will keep it, regardless the result of the diplomacy throw. You can only use one Letter of Recommendation per diplomacy throw.

The DC Profession(Scribe) to create a Letter of Recommendation is 20. For every 5 by which your check result exceeds the DC, the diplomacy bonus granted by the Letter is increased by two points.

Driver

Spare Horses:

While driving a curt you can use Spare Horses to travel longer. You need to drive the cart or wagon the full 8 hours to uses be able to use Spare Horses. You can also use the skill when the cart is pulled by other animals than horses.

Spare Horses allows you to travel 1 hour longer before the horses get exhausted. The DC Profession(Driver) of Spare Horses is 20. For every 5 by which your check result exceeds the DC, you can travel an extra hour before your horses get exhausted.

Librarian

Support Research:

You can support an ally, including yourself, in his research. You need access to library or a book collection with at least 100 books. You have to support your ally for at least 1 hour. A person can only be supported once per knowledge check.

The DC Profession(Librarian) of Support Research is 20. A person you support in his research gains a +2 bonus on his knowledge check. For every 5 by which your check result exceeds the DC Profession(Librarian), the target gains an extra +2 bonus to its knowledge check.

Gambler

Test your Luck:

Your are used to risk everything for the chance of winning some coins. Even outside the tavern you can test your luck. By testing you luck you gain a luck points applicable to skill, attack and saving throws.

Test you luck is a move action. If success you gain luck points. You have to use the luck points in the next round or they are discarded. Luck points are applicable to skill, attack and saving throws. You have to apply the luck points before throwing the dice. You can split up you luck points, for example using 1 point for an attack roll and 1 point for a skill check.

The DC Profession (Gambler) of Test your luck is 20. If you succeed you gain one luck point. For every 5 by which your check result exceeds the DC Profession (Gambler), you gain an additional luck point. Once your fail the skill check profession (Gambler) you can't use Test your Luck for the rest of the day. Additionally your next skill, attack or saving throws is performed with a malus equal to the luck points you gained that day. You can't do a useless check to dismiss the malus.

When I plan a campaign, I separate the planning phase in two parts:

1. Planning the main story arc
2. Preparing for a session

Planning the main story arc

First figure out in which world you play want to play. Who are the big players? Kings, Gods, established heroes, etc. .

Create a small list of attributes for every important NPC. The list should contain their motives, morales, personality. The lists will help you to stay consistent and to act upon the PCs actions quickly.

As you won't be able to tell what will happen in the course of several sessions only make a rough plan of events that will happen.

Set up an initial list of events that will occur if the party of heroes would not exist. Example: the evil guy tries to summon an evil monster in roughly 10 days.

This timetable will give you a rough framework for your campaign, without rail-roading the story. After each session you should revisit the timetable and figure out how the actions of the heroes have changed the course of history. _Example: If the PCs killed a commander of the evil forces, the raid on a village in 2 weeks can't take place._This fixed timetable also means that the players can miss certain events if they are to slow or ignore a story plot. E. g. If the party needs four weeks to stop an event something else will happen without a chance for the PCs to intervene. With the timetable and rough descriptions of the event you got an overall story arc that is not written in stone and can be changed by the players.

Preparing for a session

When planning a session take a look at the timetable to see what is up next. Think through what can happen in the next bit of the story and possible actions of the PCs. You will never find all possible decisions, so don't even bother writing it down ;).

When you got a rough overview for the session, you can start to prepare.

Create groups of enemies fitting into the scene. Create local maps of villages, dungeons and other sites you want to use. Figure out how the enemies will behave.

Example: 2 groups of goblin guard the mage tower. On a small balcony hovers an all-seeing-eye warning the mages if it sees anything unusual. The door to the mages bedroom is trapped with Trap X. etc. .

If you have difficulties improvising, spend more time describing details of the sites the heroes visit. Have a lot of stuff ready you can use if needed.

At the end you should have a detailed description of the places the party will visit. From that point on the players decide. Listen to their actions and look up what could happen.

_

Example: They sneak through the fields -> give the goblins and the eye a perception throw and act upon it.

_

If you notice that it will get to boring, use the assets you created to add more into your world. Maybe 2 goblins decided to plunder the kitchen, and they notice the group.

Hopefully I gave you a rough idea how I plan my campaigns.

TL:DR

1. Have a rough story arc for the campaign.
2. Create detailed descriptions of sites and enemies for every session and only act upon the actions of the party

I took photos of the grass in my backyard to create a grass texture. The camera was held at shoulder height pointing down. I cropped the image into a 1:1 image. Try to keep the image as big as possible. Do not scale it into your desired dimension yet!

Make it tileable!

There are two methods to make the image tileable/seamless.

The easiest way to create a tileable texture is to use the "Make Seamless" tool (Filters->Map->Make Seamless).

If you aren't satisfied by the results of the Make Seamless filter you can also do it by hand.

Start by applying an x/2, y/2 offset by using the Layer->Transform->Offset tool.

This will offset the image in such a way that the opposite border match each other perfectly, but it only shifts the problem. You should notice that there are two lines, one horizontal, one vertical, were the image doesn't fit together. You can remove the visible borders in various ways, e.g. using the clone and blur tool.

Removing the midrange frequencies

At this point we cloud use the texture, but we will go one step further. The image still contains midrange frequencies, that we want to remove. The midrange frequencies will produce ugly tiling effects if the texture is repeated often.

Start by duplicating the seamless texture and apply a tileable blur (Filters->Blur->Tileable Blur) onto the duplicated version. Choose a high radius, roughly 10% of the images size. This will create a layer containing the mid and low frequencies.

To preserve the low frequencies create a new texture below the two existing. Use the Color Picker with a big radius to select an average color of the texture and fill the new texture with this color.

We now have one layer containing the mid and low frequencies, one containing the low frequencies and one containing all frequencies.

To create a layer containing the high frequencies set the mode of the blurred layer to "Grain extract" and move it above the original layer. By Merging these two layers you gain a new layer containing only the high frequencies. After merging set the mode of the resulting layer to "Grain merge" and merge the two remaining layers. This creates our final image containing the high and low frequencies but no mid frequencies.

Note: I scaled the images to save bandwidth

The content falls under the Open Game License (OGL).

Minor Items

• Lesser Minor Belt Item
• Greater Minor Belt Item
• Lesser Minor Body Item
• Greater Minor Body Item
• Lesser Minor Chest Item
• Greater Minor Chest Item
• Lesser Minor Eye Item
• Greater Minor Eye Item
• Lesser Minor Feet Item
• Greater Minor Feet Item
• Lesser Minor Hand Item
• Greater Minor Hand Item
• Lesser Minor Head Item
• Greater Minor Head Item
• Lesser Minor Headband Item
• Greater Minor Headband Item
• Lesser Minor Neck Item
• Greater Minor Neck Item
• Lesser Minor Shoulders Item
• Greater Minor Shoulders Item
• Lesser Minor Wrists Item
• Greater Minor Wrists Item
• Least Minor Slotless Item
• Lesser Minor Slotless Item
• Greater Minor Slotless Item

Random Item Type

• Lesser Minor Wondrous Item
• Greater Minor Wondrous Item

Medium Items

• Lesser Medium Belt Item
• Greater Medium Belt Item
• Lesser Medium Body Item
• Greater Medium Body Item
• Lesser Medium Chest Item
• Greater Medium Chest Item
• Lesser Medium Eye Item
• Greater Medium Eye Item
• Lesser Medium Feet Item
• Greater Medium Feet Item
• Lesser Medium Hand Item
• Greater Medium Hand Item
• Lesser Medium Head Item
• Greater Medium Head Item
• Lesser Medium Headband Item
• Greater Medium Headband Item
• Lesser Medium Neck Item
• Greater Medium Neck Item
• Lesser Medium Shoulders Item
• Greater Medium Shoulders Item
• Lesser Medium Wrists Item
• Greater Medium Wrists Item
• Lesser Medium Slotless Item
• Greater Medium Slotless Item

Random Item Type

• Lesser Medium Wondrous Item
• Greater Medium Wondrous Item

Major Items

• Lesser Major Belt Item
• Greater Major Belt Item
• Lesser Major Body Item
• Greater Major Body Item
• Lesser Major Chest Item
• Greater Major Chest Item
• Lesser Major Eye Item
• Greater Major Eye Item
• Lesser Major Feet Item
• Greater Major Feet Item
• Lesser Major Hand Item
• Greater Major Hand Item
• Lesser Major Head Item
• Greater Major Head Item
• Lesser Major Headband Item
• Greater Major Headband Item
• Lesser Major Neck Item
• Greater Major Neck Item
• Lesser Major Shoulders Item
• Greater Major Shoulders Item
• Lesser Major Wrists Item
• Greater Major Wrists Item
• Lesser Major Slotless Item
• Greater Major Slotless Item

Random Item Type

• Lesser Major Wondrous Item
• Greater Major Wondrous Item

I did this mainly out of comfort, as the old software only provided very basic features.

The old post will be transfered into this new set up eventually.