Lautaro Emanuel emlautarom1

In the last years I've been asked multiple times about the comparison between raylib and SDL libraries. Unfortunately, my experience with SDL was quite limited so I couldn't provide a good comparison. In the last two years I've learned about SDL and used it to teach at University so I feel that now I can provide a good comparison between both.

Hope it helps future users to better understand this two libraries internals and functionality.

Get path of remote socket: execute on remote host

emacs --batch --execute "(progn
        (require 'server)
        (princ (expand-file-name \"remote\" server-socket-dir)
               #'external-debugging-output))"

Get path of local socket: execute on local host
```
emacs --batch --execute "(progn
    
```

A case for CancellationTokens

Background

The Rust async working group is currently actively discusing on ways to improve async/await. Niko Matsakis documented the main goals and ideas in the async vision document.

As part of the improved async ecosytem, users should be able to make use of

Program Analysis, a Big Happy Family

The idea behind program analysis is simple, right? You just want to know stuff about your program before it runs, usually because you don't want unexpected problems to arise (those are better in movies.) Then why looking at Wikipedia gives you headaches? Just so many approaches, tools, languages 🤯

In this article I would like to give a glimpse of an overarching approach to program analysis, based on ideas from abstract interpretation. My goal is not to pinpoint a specific technique, but rather show how they have common core concepts, the differences being due mostly to algorithmic challenges. In other words, static analysis have a shared goal, but it's a challenge to make them precise and performant.

Code is meant to be executed by a computer. Take the following very simple function:

fun cantulupe(x) = {

Optics By Example Cheat Sheets

The following are appendices from Optics By Example, a comprehensive guide to optics from beginner to advanced! If you like the content below, there's plenty more where that came from; pick up the book!

Operators
Composition Guide
Substitution Guide
Optical Constarints and Types

	#!/usr/bin/env bash
	# cc - Claude Code wrapper with session naming
	# Usage:
	# cc Start a new Claude Code session
	# cc n <name> Start a new session with a name
	# cc ls List sessions (current project)
	# cc ls -a List sessions across all projects
	# cc r <name\|index> Resume a session by name or index
	# cc rn <index> <name> Rename a session
	# cc rm <name\|index> Delete a session

	#!/usr/bin/python

	import argparse
	import os
	import shlex
	import sys
	import tempfile
	import yaml

	config = yaml.full_load(open(os.path.expanduser("~/.config/sandbox.yml")))

	RAR registration data
	WinRAR
	Unlimited Company License
	UID=4b914fb772c8376bf571
	6412212250f5711ad072cf351cfa39e2851192daf8a362681bbb1d
	cd48da1d14d995f0bbf960fce6cb5ffde62890079861be57638717
	7131ced835ed65cc743d9777f2ea71a8e32c7e593cf66794343565
	b41bcf56929486b8bcdac33d50ecf773996052598f1f556defffbd
	982fbe71e93df6b6346c37a3890f3c7edc65d7f5455470d13d1190
	6e6fb824bcf25f155547b5fc41901ad58c0992f570be1cf5608ba9

	{-# LANGUAGE DataKinds #-}

	-- \| My database API.

	module DBAPI where

	import Data.Defaults

	data ConnSpec p = ConnSpec
	{ username :: !(Required p String)

	{-# LANGUAGE GeneralisedNewtypeDeriving #-}

	module Data where

	type UserName = String

	data DataResult = DataResult String
	deriving (Eq, Show)

	class Monad m => Cache m where