brunoanc

Screen sharing on Hyprland (Arch Linux)

Table of contents

• Screen sharing on Hyprland (Arch Linux)
  • Introduction
  • Install PipeWire and friends
  • Install xdg-desktop-portal and friends
    • Option #1: xdg-desktop-portal-hyprland (recommended)
    • Option #2: xdg-desktop-portal-wlr (not recommended)

• Remove other portal implementations

ordian

1. Make sure your rust application uses https://github.com/gnzlbg/jemallocator as the global memory allocator (when in doubt, grep jemallocator in your Cargo.lock).
2. Install jemalloc (we'll only need jeprof), dot, ps2pdf and libunwind on your system. Enable jemallocator's profiling feature (if jemallocator is an indirect dependency, one trick to do is to add a dependency jemallocator = { version = "*", features = ["profiling"] } to your app and let cargo select the || of features for you).
3. export _RJEM_MALLOC_CONF=prof:true,lg_prof_interval:32,lg_prof_sample:19. lg_prof_interval sets how often profile dump should be written to disk measured in allocated bytes. The value is passed as a power of two, which is 2^32 in our case, i.e. every 4 GiB of allocations of long-lived objects (see https://github.com/jemalloc/jemalloc/wiki/Use-Case%3A-Heap-Profiling). lg_prof_sample:19 tells jemalloc to take a profiling sample every 2^19 = 512 KiB.
4. Running your binary should produce a bun

Daenyth

import cats.Monad
import cats.effect.concurrent.{Ref, Semaphore}
import cats.effect.{Concurrent, Resource}
import cats.implicits._
import fs2.{Pipe, Stream}
import fs2.concurrent.{NoneTerminatedQueue, Queue}

/** Represents the ability to enqueue keyed items into a stream of queues that emits homogenous keyed streams.
  *

rusrushal13

Conferences

• Hydraconf

Summer School

• Summer school on practice and theory of Distributed Computing

Books

• Distributed Systems 3rd Edition by Maarten van Steen and Andrew S. Tanenbaum
• Data Intensive Applications by Martin Kleppmann

odersky

Principled Meta Programming for Scala

This note outlines a principled way to meta-programming in Scala. It tries to combine the best ideas from LMS and Scala macros in a minimalistic design.

• LMS: Types matter. Inputs, outputs and transformations should all be statically typed.

• Macros: Quotations are ultimately more easy to deal with than implicit-based type-lifting

• LMS: Some of the most interesting and powerful applications of meta-programming

SystemFw

object Example {
  import cats._, implicits._
  import cats.effect._
  import fs2._
  import scala.concurrent.ExecutionContext

  // start N streams concurrently, and stream their results in order
  // e.g. download a file from  a server in N parts concurrently, and stream it

  abstract class Channel[F[_], A] {

brson

Edit: This list is now maintained in the rust-anthology repo.

• Introduction
  • Understanding Over Guesswork
  • An Alternative Introduction to Rust
  • Rust and CSV Parsing
• Ownership
  • Where Rust Really Shines
  • Rust Means Never Having to Close a Socket
• The Problem with Single-threaded Shared Mutability

m-ou-se

# Download latest archlinux bootstrap package, see https://www.archlinux.org/download/
wget 'ftp://ftp.nluug.nl/pub/os/Linux/distr/archlinux/iso/latest/archlinux-bootstrap-*-x86_64.tar.gz'

# Make sure you'll have enough entropy for pacman-key later.
apt-get install haveged

# Install the arch bootstrap image in a tmpfs.
mount -t tmpfs none /mnt
cd /mnt
tar xvf ~/archlinux-bootstrap-*-x86_64.tar.gz --strip-components=1

retronym

indylambda: Putting invokedynamic to work for Scala

Java 8 introduced lambdas to the Java language. While the design choices differ in many regards from Scala's functions, the underlying mechanics used to represent Java lambdas is flexible enough to be used as a target for the Scala compiler.

Lambdas in Java

Java does not have canonical heirarchy of generic function types (ala scala.FunctionN), but instead allows a lambda to be used as a shorthand for an anonymous implementation of an Functional Interface

Here's an example of creating a predicate that closes over one value:

VictorLaskin

// List comprehension in C++11 in form of SQL-like syntax
// Example code from http://vitiy.info/cpp11-writing-list-comprehension-in-form-of-sql/
// Written by Victor Laskin (victor.laskin@gmail.com)

#include <iostream>
#include <functional>
#include <vector>
#include <future>
#include <algorithm>
using namespace std;