| 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 |

| D3 |

| 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 |

| Subtyping |

| 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 |

| Education |

| 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? |

| 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 |

| Self-management |

| 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 |

| MiniTeX |

| 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 |

| WYSIWYG |

| 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 |

| SteamOS |

| What is this? |