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