Crosstyan crosstyan

Arch Linux ARM 64 on Raspberry Pi 3 B+ With Full Disk Encryption And SSH Unlock: 2018 Edition

There are multiple ways to get a full disk encrypted arch linux system on raspberry. In this tutorial, we will install a 64-bit arch linux armv8 system, using dropbear as ssh server for remote pre-boot unlocking of the root filesystem. However, it will still be possible to unlock and use the pi as usual, with a keyboard and monitor. We will also create an unencrypted partition in the installation process, usable as a rescue system.

Differences to the 32-bit arch linux arm version:

probably better performance
can run 64-bit software
comes without the proprietary video-driver blobs

Installing .NET Core on Linux ARM64

The following intructions can be used to install .NET Core on Linux ARM64.

Pro tip: Check out .NET Core Docker files to determine the exact instructions for installing .NET Core builds, for example .NET Core 3.1 ARM32 SDK Dockerfile.

Installing .NET Core Globally

The following instructions install the latest .NET Core globally. It isn't required to do that, but it provides the best experience.

Software Transactional Memory in C++: pure functional approach (Tutorial)

In this article I’ll tell you about my pure functional library for Software Transactional Memory (STM) that I’ve built in C++. I adopted some advanced functional programming concepts that make it composable and convenient to use. Its implementation is rather small and robust, which differentiates the library from competitors. Let’s discuss what STM is and how to use it.

Intro
Links
Software Transactional Memory
STM basics
Composable transactions
Dining Philosophers: The task

The PATH is an important concept when working on the command line. It's a list of directories that tell your operating system where to look for programs, so that you can just write script instead of /home/me/bin/script or C:\Users\Me\bin\script. But different operating systems have different ways to add a new directory to it:

Windows

The first step depends which version of Windows you're using:

If you're using Windows 8 or 10, press the Windows key, then search for and

	/*
	* Self-Explanatory Protocol Buffer Lang Guide
	*/


	/*
	* Why Protocol Buffers?
	* Protocol buffers are Google's language-neutral, platform-neutral, extensible mechanism for serializing structured data – think XML, but smaller, faster, and simpler.
	* You define how you want your data to be structured once, then you can use special generated source code to easily write and read your structured data to and from a variety of data streams and using a variety of languages.
	* Protocol Buffers are Schema Of Messages. They are language agnostic.

	#include <sstream>
	#include <iostream>
	#include <iomanip>

	std::string uint8_to_hex_string(const uint8_t *v, const size_t s) {
	std::stringstream ss;

	ss << std::hex << std::setfill('0');

	for (int i = 0; i < s; i++) {

	(ns byte
	"My own take on byte conversion. `(byte)` doesn't work with unsigneds
	within clojure, and signed values don't work well within
	clojurescript. Includes additional bitwise functions for working
	specifically with bytes.")



	(defn signed
	"Signed byte that works between clojure and clojurescript.

	#!/usr/bin/env python3

	# let's say you have a C++ project in Nix that you want to work on with CLion so that the Nix dependencies are available
	# put this script in your project directory
	# then, in Settings -> Build, Execution, Deployment -> Toolchains set CMake to this script
	# if you need any extra nix-shell arguments, add them to the invocation at the bottom

	import os
	import sys
	import shlex

	import redis
	import cv2
	import numpy as np
	import time
	import io
	from PIL import Image

	r = redis.StrictRedis.from_url('redis://:[email protected]:6379/1')
	img_path ="image"

	{
	"configurations": [
	{
	"environments": [
	{
	"MINGW64_ROOT": "C:\\msys64\\mingw64",
	"BIN_ROOT": "${env.MINGW64_ROOT}\\bin",
	"FLAVOR": "x86_64-w64-mingw32",
	"TOOLSET_VERSION": "7.3.0",
	"INCLUDE": "${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION};${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION}\\tr1;${env.MINGW64_ROOT}\\include\\c++\\${env.TOOLSET_VERSION}\\${env.FLAVOR}",