Kreijstal

Setting Up Git with Nginx for Anonymous HTTP Access

This guide explains how to configure a Git repository to be served anonymously over HTTP using Nginx and git-http-backend. This setup allows users to clone and fetch repositories without authentication, and optionally push if configured. It’s ideal for public repositories or simple internal use cases.

Prerequisites

• A Linux server with:
  • Git installed (sudo apt install git)
  • Nginx installed (sudo apt install nginx)
  • fcgiwrap installed (sudo apt install fcgiwrap) to bridge Nginx and git-http-backend

Kreijstal

;; I want to build a package phase by phase, how hard can it be?
(use-modules (guix store)
             (guix derivations)
             (guix packages) ; Ensure this module is imported
             (guix build-system gnu)
             (guix build utils)
             (gnu packages wine)
             (guix build gnu-build-system)
             (guix download) ; Import the download module
             (guix base16)   ; Import the base16 module for hash conversion

Kreijstal

Overview

BSPrak is a custom setup for using QEMU through the GNU Guix package manager. This repository contains scripts and configurations to manage a custom QEMU build along with other essential tools.

Enter the Development Environment: Use guix shell to enter a shell with all necessary dependencies:

guix shell -m manifest.scm

Kreijstal

/*
 * Bitwise rotate a 32-bit number to the left.
 */
function ROTL(num, cnt)
{
  return (num << cnt) | (num >>> (32 - cnt));
}

/*
 * These functions implement the basic operation for each round of the

Kreijstal

VERILATOR = verilator
IVERILOG = iverilog
VVP = vvp

# Detect operating system
ifeq ($(OS),Windows_NT)
    DETECTED_OS := Windows
else
    DETECTED_OS := $(shell uname -s)
endif

Kreijstal

/* Copyright 2018 ETH Zurich and University of Bologna.
 * Copyright and related rights are licensed under the Solderpad Hardware
 * License, Version 0.51 (the “License”); you may not use this file except in
 * compliance with the License.  You may obtain a copy of the License at
 * http://solderpad.org/licenses/SHL-0.51. Unless required by applicable law
 * or agreed to in writing, software, hardware and materials distributed under
 * this License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR
 * CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *

Kreijstal

Introduction to Part III

A type system is, roughly, a mechanism for classifying the expressions of a language. Type systems for programming languages, sequential and concurrent, are useful for several reasons, most notably:

(1) to detect programming errors statically (2) to extract information that is useful for reasoning about the behaviour of programs (3) to improve the efficiency of code generated by a compiler (4) to make programs easier to understand.

Types are an important part of the theory and of the pragmatics of the $\pi$-calculus, and they are one of the most important differences between $\pi$-calculus and CCS-like languages. Many of the type systems that have been studied for the $\pi$-calculus were suggested by well-known type systems for sequential languages, especially $\lambda$-calculi. In addition, however, type systems specific to processes have been proposed, for instance for preventing certain forms of interference among processes or certain forms of deadlock.

Kreijstal

function Result(tag, value) {
  this.tag = tag;
  this.value = value;
}


Result.ok = function(value) {
  return new Result("ok", value);
};

Kreijstal

(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
(function (global){(function (){
'use strict';

var possibleNames = require('possible-typed-array-names');

var g = typeof globalThis === 'undefined' ? global : globalThis;

/** @type {import('.')} */
module.exports = function availableTypedArrays() {

Kreijstal

import typing as tp
import operator

# Defining the basic parser structure
ParserP = tp.Callable[[str], tp.Tuple[tp.Any, str]]

# Defining the ParserError for exception handling
class ParserError(Exception):
    def __init__(self, msg, content):
        super().__init__(f"{msg}: {content}")