Everything dumped in one place, just to ensure it’s linked somewhere for crawlers. It’s not really a useful list for human perusal.

• Musing Mortoray
  • About Edaqa
  • Archives
  • Dupesy Christmas
  • Leaf
    • Leaf Status
  • Radial Blitz
  • Redirect /cloverleaf/ -> /leaf/
  • Redirect dupseychristmas -> dupesychristmas
  • Topics
    • Compilers
    • Fundamental programming paradigms
    • Writing a UI Engine
  • Defective Language
  • Ideal Language

• 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
• Invented here syndrome
• 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?
• The amortized cost of vector insert is 3
• 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?
• How does a mutex work? What does it cost?
• 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