thomasdarimont

package demo.cont;

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.util.function.Consumer;

public final class Continuation {

    private final Object delegate;

bowbahdoe

import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;

public final class Continuation {
    final Object impl;

    static final Class<?> IMPL_CLASS;
    static final MethodHandle NEW;
    static final MethodHandle YIELD;

andrewrk

const std = @import("std");

pub fn build(b: *std.Build) void {
    // Standard target options allows the person running `zig build` to choose
    // what target to build for. Here we do not override the defaults, which
    // means any target is allowed, and the default is native. Other options
    // for restricting supported target set are available.
    const target = b.standardTargetOptions(.{});

    // Standard optimization options allow the person running `zig build` to select

belm0

// C++ MCAS implementation, based on "Efficient Multi-word Compare and Swap"
// (https://arxiv.org/pdf/2008.02527.pdf)
//
// TODO: API header
// TODO: reclamation.  Currently the implementation leaks descriptor records
//      and leaves them in place indefinitely.  Short list of options:
//          1) reuse thread-local descriptors (https://arxiv.org/pdf/1708.01797.pdf)
//          2) use "record manager" abstraction and plugins (DEBRA, etc.)
//             (https://bitbucket.org/trbot86/implementations/src/master/cpp/debra)
// TODO: generalization:  32-bit support, user-defined word size and

belm0

Structured concurrency and Lua (part 1)

John Belmonte, 2022-Sep

I've started writing a toy structured concurrency implementation for the Lua programming language. Some motivations:

• use it as a simple introduction to structured concurrency from the perspective of Lua (this article)
• learn the fundamental properties of structured concurrency and how to implement them
• share code that could become the starting point for a real Lua library and framework

So what is structured concurrency? For now, I'll just say that it's a programming paradigm that makes managing concurrency (arguably the hardest problem of computer science) an order of magnitude easier in many contexts. It achieves this in ways that seem subtle to us—clearly so, since its utility didn't reach critical mass until around 2018[^sc_birth] (just as control structures like functions, if, and while weren't introduced to languages until long after the first compu

eatonphil

# th30z@u1310:[Desktop]$ psql -h localhost -p 55432
# Password: 
# psql (9.1.10, server 0.0.0)
# WARNING: psql version 9.1, server version 0.0.
#          Some psql features might not work.
# Type "help" for help.
# 
# th30z=> select foo;
#  a | b 
# ---+---

s5bug

// Author: Aly Cerruti
// Please follow along in Scastie, so you can see the output of statements:
//   https://scastie.scala-lang.org/CLmK5tLuRd6rxXuEnba0rQ

// A Category
trait Category[
  // A collection of objects
  Obj <: AnyKind,
  // A constraint on those objects (Scala lacks dependent typing, so i.e. `Val = [A] =>> Monoid[A]` makes the category of Monoids)
  Val[_ <: Obj],

shawwn

Twitter thread: https://twitter.com/theshawwn/status/1456925974919004165
Hacker News thread: https://news.ycombinator.com/item?id=29128998

November 6, 2021

How does JAX allocate memory on a TPU?

jnp.device_put(1) is deceptively simple to write in JAX. But on a TPU, what actually happens? How does a tensor containing the value 1 actually get onto a TPU?

Turns out, the answer is "C++", and a lot of it.

ess7

#define WIN32_LEAN_AND_MEAN
#include <windows.h>

#include <reaper_plugin.h>
#include <ns-eel.h>

/*
 * If you actually try this, the JS effect that uses the new function should not be the first one loaded,
 * otherwise you will get an "undefined 'myadd'" error.
 * Workarounds: recompile/reset or add any JS effect before this

joe-warren

{
    "problemMatcher": [
        {
            "owner": "hlint",
            "severity": "warning",
            "pattern": [
                {
                    "regexp": "^([^:]*\\/)([^:/]*):(\\d+)(-\\d+)?:(\\d+)(-\\d+)?: (Warning|Error): (.*)$",
                    "fromPath": 1,
                    "file": 2,