
Archives
Everything dumped in one place, just to ensure it’s linked somewhere for crawlers. It’s not really a useful list for human perusal.
- Highly inefficient invisible animations (CSS/Firefox/Chrome/React)
- High-Throughput Game Message Server with Python websockets
- What I look for while play-testing
- How to write a custom selector in React
- I Wrote an Online Escape Game
- Your 30th Year in Code
- Why switch is better than if-else
- Fluid layout animation: Invalidation and caching
- Creating a custom author box on WordPress
- A Failed Experiment with Python Type Annotations
- A Parade of Web Tech
- Terrible interview question: Swap variables without a temporary
- A programmer’s introduction to user portraits
- The amortized cost of vector insert is 3
- Lessons learned from recording my first class
- The Internet Lottery™ for content creators
- Invented here syndrome
- Essential code for lists and vectors in an interview
- Stop waving the wand of magic numbers
- How does a mutex work? What does it cost?
- How to fail a programming interview
- Of course HTML is a programming language
- The User
- Would you program a human?
- We don’t need a ternary operator
- ELI5: The filter, map, zip, and reduce operations
- Sadly, I must say goodbye to Leaf (my programming language)
- Creating a local screen overlay for streaming (OBS, Linux)
- ELI5: Algorithmic time complexity
- I don’t know how to create a website
- Keeping tabs on shady internet authorities — What is Certificate Transparency?
- How I use `variant` in the Leaf compiler
- Core Layout Protocol API (UI Engine)
- Fitting an image to its element frame
- How I write my blog?
- What is a “box model”? (UI Element layout)
- What is responsive layout?
- UI Engine Layout: Additive, Partitioned and Layered
- UI Layout: Working with Pixels, Points and Density
- Dissecting my Rusty Superhero Bots — The code review
- Dissecting my Rusty Superhero Bots — A contest post-mortem
- UI Layout: Natural versus dependent size
- Drawing a bitmap in the window (Leaf-SDL #2)
- Fixing some vector drawing issues
- New Game: A quest for graphics (Leaf-SDL #1)
- Innocent growth of technical debt
- Debugging a defect with a shared argument
- Should function arguments be reassignable or mutable?
- Interview Question: A two-player card game
- Are global variables bad?
- What is a closure?
- Hidden complexity in cute animal pictures
- Adding += and friends to Leaf
- Why I’m not a fan of pair programming
- What is reactive and stream programming?
- Debugging a synchronous callback in loop defect
- What is declarative programming?
- Embedding a text file in C++ code (with Scons)
- I’m proud to be a programmer
- What is event programming?
- Do we need 3, or just 2 error types?
- Writing software for a malicious world
- What is functional programming?
- Improve quality and lower costs with assisted manual testing
- Microsoft is absolutely at fault for WannaCry
- Sorting a file: A real program in Leaf
- What is imperative programming?
- Why does Amazon taunt me with surround sound?
- Yummy UI food with keyframe animations
- Fix your crappy ads and I’ll stop blocking them
- Bravely squash or cowardly refuse: a git conundrum
- Working with types and named constructors in Leaf
- Calculating pleasant stepping values for a chart
- The horribly horrible horrific horrifying horrid word horror
- The agonizing necessity of cached calculations
- Why can’t I get organic salt and vinegar chips?
- What is orthogonality?
- Programming won’t be automated, or it already has been
- The meta-field dilemma: `a.size` or `size(a)`
- Importing Blender object normal maps with permutations
- A game of what’d they press? Hit testing in a 2d/3d layout
- The bitwise complement, or not operator, is unsafe
- Stuffing curves into boxes: calculating the bounds
- Rendering an SVG elliptical arc as bezier curves
- Porting Leaf from Linux to OSX
- The smooth sexy curves of a bezier spline
- Ride the carousel of folly with a Python migration
- Optional Types and Leaf: Removing automatic dereference
- Smoothing 3d geometry, like a tunnel, with Catmull-Rom splines
- What is a normal map? An object normal map?
- Glowing graphics for that futuristic sci-fi feeling
- Radial Blitz – A rough journey from new technology to app store release
- Are we forever cursed with buggy software?
- The unfortunate world of boilerplate code
- A pattern bandage for messy virtual functions
- The very real mess of virtual functions
- The simple things I want in a text editor
- Is reference counting slower than GC?
- What is the cost of reference counting?
- What is the length of a string? A tricky question
- A pan, zoom, and rotate gesture model for touch devices
- Efficient open ended queues with deferred deletion
- The simple things matter – examples of UX failure from Amazon Video
- How blaming the user leads to tragedy
- API forensics for iOS system time: missing documentation
- The trouble with `floor` and `ceil`
- Implementing a Swipe gesture
- The hard part of error handling is not the error itself
- Why don’t we have runtime virtual dispatching?
- Everything can and will go wrong: all functions fail
- The exceptional myth of non-local flow
- Messy error handling in Rust with `try!`
- Adding the first type expression to Leaf: type_infer
- Defects allowed by imprecise access modifiers
- Robot journalist predicts programmers will be obsoleted
- The curse of varargs
- Reusing existing test suites for new features
- Calculating square root using Newton’s iterative method
- A real cost of low performing applications
- You can’t trade privacy for security
- Essential facts about floating point calculations
- Be a good mentor, not a dickhead
- Antialiasing with a signed distance field
- Get rid of those boolean function parameters
- Combining several GL draw calls into one: a rounded rectangle
- Quickly drawing a rounded rectangle with a GL shader
- Where the wild code grows
- Blocking and asynchronous operations without timeout are broken
- Debugging by binary searching through code revisions
- A bug, an error, or fault, and the irrelevance of classification
- A swipingly good time with edge gestures
- How HTTP cache headers betray your privacy
- Fast build turnaround time is essential
- Cohesion and coupling: good measures of quality
- Nobody cares about your code
- Using a hack, stifling the perfectionist, and moving on
- Measuring finger / mouse velocity at release time
- Complexity theory isn’t required to be a programmer
- Visions of generics and templates: How parametrics are compiled
- What a compiler does: Parsing
- Bringing blurry device independent pixels into focus
- Quelling the floating point demon in my line rendering code
- Adding proxies to C#: A simple proposition
- What a compiler does: internal types
- What a compiler does: type conversion basics
- Cubist artwork with the help of a GPU
- An unpleasant visit from the refactoring demon
- What a compiler does: symbol resolution
- A secure and private browser sandbox
- Blocking JavaScript seems like a good idea
- Using macros to simplify type visitors and enums
- What is an idempotent function?
- What is amortized time?
- Visiting nodes in a recursive data type with traversal contexts
- The false abstraction antipattern
- Counterargument: Don’t put logic in tests
- Why more eyes are helpful: time wasted on a simple bug
- Why social media needs to manipulate you
- A curious non-OOP virtual inheritance for a GPU
- Removing code by adding features
- Another Spam Loser: WordPress and Akismet
- Wait-free queueing and ultra-low latency logging
- The uninitialized variable anathema: non-deterministic C++
- Allowing unlimited access with CORS
- Stop signing crappy contracts
- The Infernal Loop Iterator
- Strings and Text are not the same
- Too big too care: How Twitter inadvertently revoked my developer access
- HTTP streaming of command output in Python Flask
- The dangers of OAuth/Social Login
- Simulating the way to victory: Bloons TD Battles
- Improving CSS Positioning with position-anchor
- Painlessly add a virtual to a large class structure
- JavaScript and 3d graphics don’t mix
- Is exception safe code truly possible?
- The string type is broken
- Bridging __VA_ARGS__ to C++ variadic templates
- Are explicit namespaces required?
- The true cost of zero cost exceptions
- We don’t need a string type
- Safely using enable_shared_from_this
- Cannot create a proper clone method with shared_ptr
- Compiling an overloaded function: the selectable type
- Rejuvenating the ternary conditional with optionals
- Do we need the conditional ternary operator ?:
- Why a ‘constexpr’ is just a return statement
- Breaking the type tree with modifiers
- Modelling type systems: The basics
- Overloading the broken universal reference ‘T&&’
- How to catch a “return” statement
- Building blocks: Compiling if, defer, break, continue, and exceptions
- 1/2 Should Not Equal Zero
- Why do we need pointers/references?
- Parsing an exact decimal value using GMP
- Leaf: Simple type conversions
- Leaf: Preserving “lvalue” status
- What is a System Language?
- Immutable Values and Invariant Names
- Divorcing a value from its name
- How to handle an error
- Of Faults and Errors: Who’s to blame?
- Antiquated Error Handling: abort/exit
- What is a closure?
- A trail through custom languages
- The syntax of a conditional
- Why I have my own Android game framework
- Android NDK Cross-Compile Setup (libpng and freetype)
- Complexity of simple data types
- Why I don’t use a Parser Generator
- Can the Ideal language allow custom operators?
- Pitfalls of Performance Testing
- Cloverleaf: Start with an expression parser
- Can a language be safe?
- Preprocessor Case Study: Message Dispatching
- Abstract Machines, Interpreters and Compilers
- What’s to love about C?
- How to choose a programming language?
- Everything wrong with exceptions
- The Necessity of Exceptions
- Double-checked locking: Why doesn’t it work and how to fix it
- Performance is irrelevant
- Never use the “continue” keyword!
- What is reference counting?
- What’s an object? What’s a variable?
- Dangerous and confusing casting
- Requirements for a Concurrent (Threaded) Library / API
- Mismatched Allocation and Delete Nonsense
- Implicit Type Promotion and Conversion
- The Ideal Language has “goto”
- How Polymorphism Works: Part 2: Virtual Table
- How Polymorphism Works: Part 1
- No new language will stop your program from crashing
- The Ideal Lanuage has a way to format strings
- Why Garbage Collection is not Necessary and actually Harmful
- What is an atomic operation?
- The ideal language must be automatically typed
- The Ideal Language cannot leak resources
- CPU Reordering – What is actually being reordered?
- CPU Memory – Why do I need a mutex?
- The Cost – A Function Call
- The Cost – Instantiation and the hidden enemy “new”
- The Cost – Programming Performance and Efficiency
- The Evil and Joy of Overloading
- Lingering Spaces and the Problems of Overformatting
- Curiously protective C++
- Rules for Framework Development
- Sessionless Authentication with Encrypted Tokens
- The 2 Most Important Equivalence Classes for Application Testing
- The 5 Ways to Test a Web Application – How They Work and How They Fail