fogti

#!/usr/bin/env python3

import html.parser
import requests

known = ["/", "/faq.html", "//alternativlos.org/", "impressum.html"]

class OnlyLinks(html.parser.HTMLParser):
    def handle_starttag(self, tag, attrs):
        if tag == 'li':

fogti

polymake, bistellar

env

• https://polymake.org/doku.php/start
• https://metacpan.org/dist/App-perlbrew/view/script/perlbrew

# it is obv. not necessary to install bliss or nauty system-wide (compiling polymake against them didn't work in my tests)
emerge -av dev-libs/stb dev-perl/App-perlbrew sci-libs/{cddlib,lrslib,soplex} sci-mathematics/{flint,normaliz,singular}

fogti

interface HiProfunctor (0 p : (0 xt : Type) -> (xt -> Type) -> Type) where
    dimap : (a, b : Type) -> (c : b -> Type) -> (d : (a -> Type))
         -> (ab : (a -> b)) -> ((y : a) -> c (ab y) -> d y)
         -> p b c -> p a d

data DepFun : (0 xt : Type) -> (xt -> Type) -> Type where
    DF : (0 xt : Type) -> (yt : xt -> Type) -> ((x : xt) -> yt x) -> DepFun xt yt

HiProfunctor DepFun where
    dimap a b c d ab acd (DF _ _ bc) = DF a d (\av : a => acd av (bc (ab av)))

fogti

//! Abstract Syntax Tree for yanais source code

const std = @import("std");
const assert = std.debug.assert;
const testing = std.testing;
const Allocator = std.mem.Allocator;

nodes: NodeList.Slice,
extra_data: []const u8,

fogti

(*
  what language features do we want?

  * free tagged unions
  * dependent types
*)

mod Example {

pub tag True;

fogti

const std = @import("std");
const Allocator = std.mem.Allocator;

pub fn BasicBlock(comptime Stmt: type, comptime Cond: type) type {
  return struct {
    // entry points
    labels: std.ArrayList([]const u8),
    entp_cnt: usize,

    // exit points

fogti

{ buildPythonPackage
, lib
, pytestCheckHook
, runCommandNoCC
, xorg
}:

pvl:

let

fogti

let nixOp = nixBlti.nixOp;
let nixBltiRT = nixBlti.initRtDep(nixRt);
let nixInScope = nixBlti.mkScopeWith();
return async (nixBound) => {
  nixBound = await nixBound;
  let nix__lib = nixOp._lambdaA2chk(nixBound, "lib");
  return (async (nixInScope) =>
    (async (nixInScope) =>
      (async (nixInScope) =>
        nixBlti.PLazy.from(async () => {

fogti

distributed build without single points of failure

problem statement

If we want to distribute a build across several build nodes, and want to avoid a "single point of failure", what needs to be considered?

motivation

• distribute the build across several build nodes, because some packages take extremely long to build

fogti

use prelude::{Service, Box};
pub struct State;

impl State {
    pub fn new() -> Box<dyn Service> {
        Box::new(Self)
    }
}

impl Service for State {