Boxbase - Index

Bayesian rule: better decision making
The AI Expectation Gap: Why We Demand More from Artificial Intelligence than Human Intelligence
The Enchanted Grove
Cinder.AI and the Battle of Copyright
Mastering AI Prompting Techniques
Navigating AI-Generated Content: Legal & Ethical Insights
Misuse more likely
Syntax in big-step normalisation paper
Relational Parsing, part 0, recognizer
Leibniz equality
Currying of functors
Facts and fiction amalgated
The Facist Factory
Plan 9 on epaper (SPI driver)
Minimality is for the audience rather than the author
"Porting" of kapow to Plan 9
Unix hater's handbook stinks
Regular languages as types (Rady)
Return to Plan 9
For people who are in favor of DMCA on youtube-dl
A reason to iterate your writing (writing advice)
I got automated summaries
Experiences after installing Haskell language server
Don't clone that GUI (how about this instead?)
GPL or not?
Medi Madelen Gwosdz' OOP take
The internals of this blog need an update
Should Purescript's Partial instead be called Unsafe?
Bartosz Milewski's neat defunctionalization talk
How to offend a skilled blog author with your blogwriting
I just removed Google Analytics from this website
Review of "Simple Essence of Algebraic Subtyping"
How a Haskell programmer wrote a tris in Purescript
Case against OOP is understated, not overstated
About the author of this blog
Tutorial: Transparent interfaces in Haskell
Can you Church-encode a stream?
On how I write (recognizing skimming)
Build systems are logic programming languages (à la Carte paper discussion)
Highlights on Kovács' NbE STLC thesis
How to read code: the next generation
Hierarchical Free Monads: Myopic alternative to Tagless Final
Partial evaluation with expansion and contraction
This is not a monad tutorial
Linear continuations and classical linear logic
Typechecking for justified nets
Optimal reduction with sausages
Continuations for normalising sum types
Understand IO Monad and implement it yourself in Haskell
Hereditary substitutions
Typechecking for Classical Linear Logic sequents
The categorical abstract machine Mk.2
Game semantics & cartesian closed categories
Adjoint functors & normalization
Dependent types and pullbacks
Typechecking & parametric polymorphism in cartesian closed categories
Adjoint functors visualized
Inverted representation of dependent types
Adjoint functors
Geometric algebra (duals) (cont)
Interpreting geometric algebra
Shifting functors: Alternative for numerical towers?
Things to say about typescript
Sugar prevents weight loss
Preparing wordprocessing-format dogfood
Granularizing "Not P" for error messages
"Structure of interaction" interesting paper
Elm experiences
Implemented linear abstract machine
Geometry of interaction and optimal reduction
Quadratic equation solution (it's actually a nice trick)
Sketch of a language
Error correcting Earley parsing
Merging of Lisp with Lisp with types
Invertible lexical analysis & Regular expressions
Ideas on word processing
Error correction in LR parsing
Layout sensitive LR(1) algorithm analysis
How to write your own LR(1) parsing tables (and generate them)
Flaws in structured programming
Idris2 & Vim channels & Vim plugin development
Implicit arguments can trip you
Grabbag of Idris tricks
Earley parsing in Idris: WellFounded (Part 2)
Earley parsing in Idris (Part 1)
Idris review
Dependent and linear typing on representing hardware memory
Explaining lambda calculus to a front-end web developer
Writing STLC Evaluator to explore into structure of proof assistants
Bidirectional typechecking with dependent typing
Learning about pure type systems
Chu construction on linear logic
Exploration into categorical abstract machines
Concatenative calculus corresponding to linear logic
Ensuring correctness of my logic programming implementations
Modeling tower of hanoi in linear logic
Sequents as a computational medium
Focusing proofs, explanation
From open deduction into interaction nets
Exploring normalisation of Linear Logic
Logic and recursion
Miscellaneous thoughts & Answers to previous post's quiz
Grow past dynamic/static typing debate
Computation with truth tables and linear logic
Explaining formal proofs
Health & Obesity hypotheses
Small typechecking fragment for concurrent linear expression types
Study into exact real arithmetic Pt. 2
Study into exact real arithmetic
Contradiction in divide by zero
How to stop/help progress
RISC-V can be fun if they don't mess it up
Dialogical logic resolution algorithm with sound negation
Dialogical logic programming
Null references was a mistake, but what's the take-away?
Does Law of the excluded middle collapse constructivity?
The things you're going to ask with UE4 VR
Blueprints as a programming language
Toward typing of the concurrent expression language
2019: Resurgence of logic programming
SKS church booleans Part 2: atomic flows
SKS system church booleans
Deep inference combinators
Deep inference
Session types and computability logic
A peek inside llprover's innards
Modeling of Chess in Prolog
Tool configuring (and an old word processor)
Concurrent linear expression language
BCI combinators & Linear logic
Interaction and Concurrency
Extending Pratt parser with layout sensitivity
Horn-clauses as imperative program representation
Can we solve dynamic memory management?
Bad things I have to say about ML/Haskell
How many languages am I going to write?
Illative combinatory logic
Short explanation of unum type 3 (posit) arithmetic
Dissecting Zebra Puzzle (Puzzle building)
Japanese abacus and binary arithmetic
What are constraint handling rules and why fuss about them?
Into Logic Programming
Coercive subtyping extension to MLsub type inference
Indexed multidimensional arrays
APL, ignored wisdom under plain sight
Horn Clause -based VM and Frontend for Lever 0.10.0
Towards general-purpose logic programming
Retrieving strongly connected components without an additional pass
Operator chart minification problem
Minimal (34MB) LLVM build with C API
Why programming is hard? Because data and code are inextricable
Modules and coeffects
How do I structure my programming projects
A new runtime for Lever 0.10.0
Two big MLsub hacks I made (that do not work)
Dynamic-static typing
Extensible type promotion for subtyping arithmetic
Typeclasses (and MLsub)
Generalize/Instantiate/Fixpoint/Traits for MLsub
Global variables inside modules
Types and Indeterminates
An another MLsub study
Hindley-Milner type system/Algorithm W study
Types have tremendous information density
Expression problem assesment
Finishing study of Axiom to Aldor
Studying Axiom with a Context-Free Grammar
Static typing increases the need to refactor
AXIOM - A computer algebra system
Reviewing "Computer Networking" by Kurose and Ross
Layout parsing with context-free grammars
Happy extra rare new year
Internet has sunk into garbage
Holiday rush
Beginning with Plan 9
The upcoming visit to Plan 9
What made old games better?
The Fragmented Worklist
How should the addition -expression behave?
Multiple Dispatch Problems
Value range analysis papers
MLsub subtyping in SSA IR
In Defense of Details
GPU computing through SPIR-V
Bug-free programming, what could we do for it?
Not taking risks isn't risk aversion
Starting videoblogging
Lever upgrade: Weakened multimethods
PC from 2020 will boot faster than Commodore C64
Nothing to write about today
Vulkan WSI, Oculus and SDL2
Lever 0.8.0 retrospective
Usecases of diff when porting code
The waltz with ninjas toward portable Ninja build systems
Application of Fortune's algorithm on triangulation
Easy text rendering with Vulkan
Naive Bayesian detects spam that a man wont
Exploring language design
What programming language should a beginner learn in 2017 - 20XX?
Lever's translator
Game programming patterns
Detour into an esoteric moded keyboard layout
A dynamically typed register allocator
Differenciable protobuf, snowflake method
Optimizing Lever PNG loading
Polynomial long division
Webassembly is friendship
Start of abstract interpretation in Lever
Hashing, comparison and equality, questions for readers
Lever documentation came online
Texopic and slow-paced problem solving
Vulkan API is liberating the graphics from the desktop
Mesh topology and differential geometry
We don't understand each other
How Lever can help with WebGPU development
Syntax is the last thing you should design
Documentation principles
Problems in coming up with good streaming primitives
Lever's libuv integration
Lever console had to be homebrew
Journeys of Lever
The first time & visual cues
Oculus touch controllers are your VR hands
Programming and creativity random thoughts
Appreciation for syntax and plain text
On correctness and incorrectness
Advice for Arduino programming
Mobile, copper and fiber comparison
Texopic typesetting language
Eve language review
Right recursion at Marpa parser
The story of a failed archival utility
A WebAssembly study
Thoughts on critical reading
"Perfect product" and other folksman entrepreneur advice
Why Fiber?
Marketing studies
Lever JSON decoding/encoding
Finicky C preprocessing and parsing details
Concurrency in Javascript
Javascript continent and the callback pyramids of hell
Writing good and detailed documentation
The keyboard design was a failure
Lever standalone compiler
Ultimate 3D keyboard progress report
Did my first 3D-Design in VR
Wasteland 2
Expectations of game design
VR is going to succeed
Oculus Rift
Keyswitch connector 3d-print madness!
Delta robot status update
The missing piece of Desktop Linux & Linux VR
Robot electronics
Progressive learning and arduino
Windows Fatigue
Software complexity
3D printing impressions
Waiting for Rift
How to get high perf graphics with a dynamic language
I can't draw a flower
Vulkan API Overview: Pipeline barriers
Vulkan API Overview: Rendering primitives
Vulkan API Overview
Analytical view to trigonometry
Rasterizing versus painting
Lever rendering to Oculus Rift
Oculus Rift on Lever
Chart parser solves the solved problem again
Waiting for Oculus Rift CV1
Dota 2: Know your enemy in the internet
Lever's Eventloop
Introducing Lever Programming Language
Music Theory
Steam Controller Review
Ergodox keyboard
Fundamental piece of my compiler
Designing Portal levels is harder than playing them through
How can I get away with dynamic typing?
Mnemonics for bezier curves
Learn differential geometry in sympy (it's a CAS)
How I arrived from Lelux Mk.2 to Pytci
Working on Lelux Mark II
Linux namespaces lets you pretend you are a root
Inspired from Clay Sculpting
Quick Relational Database App Setup Guide for Dummies
Does a blogger blog if no one reads him?
Virtual reality
Game Mechanics Taxonomy
My Ludum Dare 2015 -entry
Javascript Promises: Language Smells
PeacefulForest Aftermath: Motivation
Blogwriter benefits from composition skills
Improving productivity with worklists
Indies vs. Gamers entry: PeacefulForest
Boid Behaviors
Reactive Programming Study
Better Web Language
Pyllisp grammar (and parser) slow but flexible
Marpa: Parsing Revolution
Compiler In Plain Python: Register Allocation
Elm Language Bonsai
Compiler in Plain Python: Instruction Select
MenuetOS Programmer Review
CEK Abstract Machine
LR & GLL Parsers Study
The Vanishing Pixel (Hardware Upgrade)
Optimizing RPython JIT for Pyllisp
Pyllisp FFI Uses Generated JSON Headers
Pyllisp Syntax
SSA Construction
Python to SPIR-V Translation
User Interface Parsing
Bottom-up Editing In Tree Structures
Context Free Grammar as a Schema
REPL in a Projectional Editor
Document Schema in Textended
Bottom-up Top-down dissonance
Why Would Somebody Program Treepython Instead of Python
Textended Updates & Layout Engine Details
Textended Update 2
Textended Update
The First Textended Editor Release
Minimum Viable Editor
Further Challenges in Generating C Bindings
Differential Geometry and Spiro Spline Interpolation
Euler Spirals, Curves, Spiro
Challenges in Parsing C to Get Bindings
Wavepot Milestone #1
Pong Running in RPython Interpreter on MIPS32
Pypy Threw My Projects Bottom-Up
Interactive Programming
Visual Programming Perhaps Inevitable
Unjustified Abstractions, Premature Abstractions
Introducing Solid Lisp
Large Programming Projects and their Organization
TeX Study
GCW 0 Arrived
Readability of a Computer Program
Back to Visual Programming and Structure Editors
Simulating Lightning on a Computer
Compiling with Continuation Passing Style
Back to Lisp
VBA Badness Explained with Car Analogies
About The Author of This Blog
LR(1) parsers
Description of the Simplex Algorithm
Finalizers, GC, greenlets and the grue
To understand C programs, study their data structures
Why radians are used everywhere in programming?
What is Hard?
Mesh Modelling Thoughts
Deployment Tools
Virtual Machine Design
Object System
Thoughts on Writing a Compiler
JIT FFI Experiment
Gamification cuts both ways in stackoverflow
SELF Just-In-Time compiler optimizations
Syntax for a programming language
Visual Programming
Mill CPU Architecture Overview
Javascript Needs Module Loaders
Midi Proxy
How Unity3D Sucks?
Code Layout for Readability
SteamOS Install
Dynamic typing is good
Microsoft Should Ditch The Windows
Python in SteamOS
What is this?