- Index
- Wisdom
- Systems Design
- Computer Science
- General Programming
- Organization
- Performance
- JS Framework Wars
- JavaScript
- TypeScript
- HTML/CSS
- React
- Redux
- Video
- UX
- Networking
- API
- Tinkering
-
Things I Learnt The Hard Way (in 30 Years of Software Development)
-
My Guiding Principles After 20 Years of Programming
-
Lisping at JPL
"The situation is particularly ironic because the argument that has been advanced for discarding Lisp in favor of C++ (and now for Java) is that JPL should use "industry best practice." The problem with this argument is twofold: first, we're confusing best practice with standard practice. The two are not the same. And second, we're assuming that best (or even standard) practice is an invariant with respect to the task, that the best way to write a word processor is also the best way to write a spacecacraft control system. It isn't."
-
100 Things Every Web Developer Should Know
-
What to Learn
https://danluu.com/learn-what/
-
Reading Postmortems
"If you care about building robust systems, the error checking code is the main code!"
-
Complexity Has to Live Somewhere
"Complexity has to live somewhere. If you embrace it, give it the place it deserves, design your system and organisation knowing it exists, and focus on adapting, it might just become a strength."
-
My Engineering Axioms
-
The Rise of Worse is Better
"The lesson to be learned from this is that it is often undesirable to go for the right thing first. It is better to get half of the right thing available so that it spreads like a virus. Once people are hooked on it, take the time to improve it to 90% of the right thing."
-
50 Short Product Lessons
-
Technical Debt Quadrant
A useful explanation of how to conceive of the Technical Debt metaphor and different kinds of Technical Debt.
-
New Evidence That British Workplaces Are Losing Viewpoint Diversity
"However, organizations can depolarize. Leaders and communicators can influence this process by creating a sense of common purpose, firmly rooted in a clear and reassuring view of the future, in which everyone understands the role they have to play and all voices are listened to, even if they don’t feel confident about speaking up."
-
How Philosophers Think
"The pressure to have an opinion on every important topic has incentivized lazy thinking, the consequences of which we feel every day. Only by expanding our intellectual aperture and attacking our own ideas can we wage war on the narcotic of cheap, bumper sticker arguments. As we do, we can identify the intellectual cancers that plague our culture and constrict our worldview."
-
Building for the 99% Developers
-
Mental Model Example and Their Explanations
-
How Do You Solve Content Moderation Problems on Twitter?
-
Advice That Actually Worked for Me
https://nabeelqu.co/advice
-
Ideas that Changed My Life
You spend years trying to learn new stuff but then look back and realize that maybe like 10 big ideas truly changed how you think and drive most of what you believe.
-
On Demand Learning is Ruining the Tech Industry
-
How Developers Stop Learning - Rise of the Expert Beginner
-
Software development topics I've changed my mind on after 6 years in the industry
-
Systems Design Explains the World: Volume 1
https://apenwarr.ca/log/20201227
-
Comprehensive Guide to Learn Computer Science Online
-
Open Source Computer Science Courses
-
Finite State Machines
-
On the criteria to be used in decomposing systems into modules - David Lorge Parnas
This paper discusses modularization as a mechanism for improving the flexibility and comprehensibility of a system while allowing the shortening of its development time. The effectiveness of a "modulariza tion11 is dependent upon the criteria used in dividing the system into modules.
-
Goodbye, Clean Code
'Am I saying that you should write “dirty” code? No. I suggest to think deeply about what you mean when you say “clean” or “dirty”. Do you get a feeling of revolt? Righteousness? Beauty? Elegance? How sure are you that you can name the concrete engineering outcomes corresponding to those qualities? How exactly do they affect the way the code is written and modified?'
-
Flattening Arrow Code
An explanation of why arrow code is bad and some good strategies for dealing with it.
-
A Philosophy of Software Design
-
Theory-building and why employee churn is lethal to software companies
-
Product-Centric is Just as Bad as Sales Driven
A common complaint I hear from product folk is that management is too “sales-driven”. It is a common ailment indeed, but I can tell you that the opposite condition, the strictly “product-focused” company, is pretty bad too. Both companies suffer from over-focus and a narrow worldview.
-
Lessons learned as a software developer turned project manager
-
Waterfall doesn't mean what you think it means
-
Optimizing Javascript
A good overview of a number of optimization strategies in JavaScript.
-
Idle Until Urgent
Provides a good look at common JavaScripe bottlenecks and how to improve them by using an "Idle Until Urgent" strategy whereby tasks are scheduled using
requestIdleCallbackunless they are needed earlier in which case they are evaluated immediately upon being required. -
Big O Notation
A simple and quick explanation of Big O Notation with numerous examples.
-
Scheduling in React
Similar to the Idle Until Urgent article above, this article digs into some advanced React scheduling features coming down the pipe. A good introduction to the future of some React APIs and a good article to keep tabs on as these scheduler features are developed.
-
The Unseen Performance Cost of CSS-in-JS
In this article, I will attempt to demystify the high-level strategies of the most popular CSS-in-JS libraries, discuss the performance issues they may introduce on occasion and finally consider techniques that we can employ to mitigate them.
-
Ubiquity: The Fallacy of Premature Optimization
Randall Hyde argues that optimization is important even when memory and processor double regularly. Trying to do the optimization too early can be a futile time-waster.
-
Reflection on Performance
-
What forces layout / reflow
This is an extremely helpful (and maintained) list of properties that cause layouts and reflows, along with a number of good source to help avoid layout thrashing.
-
Understanding Why a Build Got 15x Slower with Webpack 5
-
Speeding Up the Javascript Ecosystem
-
When You Should Prefer Map Over Object in JavaScript
Excellent deep-dive into the differences between Map and Object and some good tidbits on how to run benchmarks in general.
-
If Not React, Then What
An argument against using React and a list of helpful resources to avoid it.
-
What to Expect From Your Framework
But come on: we’re living in the 2020s and if you’re not at like 95% “framework does it for you” for things that aren’t business logic, then you’ve lashed yourself to a very bad mast ‒ you’re stuck building rote infrastructure instead of working on your app, likely creating a bunch of nasty attack surfaces along the way. And what are you getting in return? The warm and fuzzy feeling of deciding precisely how your session cookie is stored and encrypted?
-
Things you forgot (or never knew) because of React
I don’t think most people using React on a regular basis realize quite how much it’s fallen behind.
-
Web Components are not Framework Components — and That’s Okay
The core it is that Web Components and Frameworks are not necessarily in direct competition with each other. We mistakenly believe that because we have lumped two distinct categories of things under the term "component". The first is Generalizable Elements and the second is Reactive Templating. The first category would be ideally handled by Web Components because there is no need to be remaking all of these general components (Tabs, Popovers etc) in each framework. But frameworks have a role to play because for complex applications they still provided a lot of funcionality that would be hard to do with pure HTML/CSS/WebComponents.
-
Patterns.dev
https://www.patterns.dev/
Patterns.dev is a free book on design patterns and component patterns for building powerful web apps with vanilla JavaScript and React.
-
In The Loop: JsConf Talk
This talk looks at the browser's event loop, the thing that orchestrates the main thread of the browser, which includes JavaScript, events, and rendering. We'll look at the difference between tasks, microtasks, requestAnimationFrame, requestIdleCallback, and where events land.
-
Anatomy of a Video Game
While this article is focused on game programming specifically, it's a good exlanantion of how to efficiently schedule rendering and user input using
requestAnimationFrameto achieve high frame rates. For this reason it's a good read for those using therequestAnimationFrameAPI for other applications. -
Understand JavaScript’s “this” With Clarity, and Master It
This is simply the best article I've found about how this works in JavaScript.
-
A Bloatless Web
An excellent discussion of how to cut down on JavaScript bloat on modern web apps. Includes some specific steps that can be taken to avoid unnecessary code caused by transpilers.
-
Metaprogramming in ES6: Symbols and why they're awesome
-
Vanilla JS Toolkit
A great resource for brushing up on fundamentals and no-nonsense JS stuff. JS-Free Components is short but good resource for how to do some common things without JS.
-
Vanilla List
https://vanillalist.top/
-
From JavaScript to WebAssembly in three steps
-
The Modern Guide to Packaging your JavaScript Library
-
Loading Polyfills Only When Needed
-
Micro-libraries Need to Die Already
https://bvisness.me/microlibraries/
-
Tackling TypeScript: Upgrading from JavaScript
-
React TypeScript Cheat Sheet
-
A Different Way to Think About Typescript*
Thinking of Typescript as a functional language to operate over sets.
-
Everything you need to know about
https://htmlhead.dev/
-
Breaking Up with SVG-in-JS in 2023
-
Every Layout
https://every-layout.dev/
A number of example layouts and how to create them using minimal CSS and HTML. Also includes several lessons on good fundamentals that are very informative.
-
Details on <details>
A short presentation on how powerful the
detailselement is and how it can be used to replace JS-heavy UI components. -
Tree Views in CSS
Pure HTML/CSS collapsible tree views.
-
How Did REST Come to Mean the Opposite of REST?
-
Plain Vanilla
An explainer for doing web development using only vanilla techniques. No tools, no frameworks — just HTML, CSS, and JavaScript.
-
React is Slow, React is Fast: Optimizing React Apps in Practice
An excellent overview of common performance pitfalls in React and how to solve them.
-
React as a UI Runtime
This one is long but it's an excellent deep dive into the concepts and thinking behind React. By the man himself, Dan Abramov.
-
Building Great User Experiences with Concurrent Mode and Suspense
This includes an excellent discussion on data fetching in a React app.
-
Why I don't miss React: a story about using the platform
This is not an argument against React specifically but rather an argument that the Web platform has introduced many features over the last 5 years or so that render web frameworks unnecessary for many use-cases.
-
A well-researched, clear, and dispassionate review of React Server Components
-
Wordpress Calypso: Our Approach to Data
The team behind Wordpress's new admin panel looks at their migration from emitters to Flux to Redux, and describes how they organize their state tree, use selectors to extract state, run queries with components, and persist their store state through refreshes.
-
A Digital Media Primer for Geeks Episode 1
This first video from Xiph.Org presents the technical foundations of modern digital media via a half-hour firehose of information. One community member called it "a Uni lecture I never got but really wanted."
The program offers a brief history of digital media, a quick summary of the sampling theorem, and myriad details of low level audio and video characterization and formatting. It's intended for budding geeks looking to get into video coding, as well as the technically curious who want to know more about the media they wrangle for work or play.
-
A Digital Media Primer for Geeks Episode 2
Continuing the "firehose" tradition of maximum information density, Xiph.Org's second video on digital media explores multiple facets of digital audio signals and how they really behave in the real world.
Demonstrations of sampling, quantization, bit-depth, and dither explore digital audio behavior on real audio equipment using both modern digital analysis and vintage analog bench equipment... just in case we can't trust those newfangled digital gizmos. You can also download the source code for each demo and try it all for yourself!
-
Digital Video Introduction
A gentle introduction to video technology, although it's aimed at software developers / engineers, we want to make it easy for anyone to learn.
-
Why so much “science” used in design is bullshit: Android, Losada and Frankfurt.
-
4 Rules for Intuitive UX
-
UI Playbook
A helpful resource that explains the behaviour of basic UI elements, and how to make them accessible etc.
https://uiplaybook.dev/
-
Microcopy
-
Please Stop Using Grey Text
-
Fighting back against proper noun feature names
-
The Grammar of Interactivity
Introduces the the "Would you like to? / I would like to" (WYLTIWLT) test to determine button copy. Button copy should answer these two questions grammatically.
- Control boolean state
- Switches are for System States (not local)
- Switches should have immediate effect
- Label copy should be obvious (user’s shouldn’t have to flip the switch to discover what it does)
- Labels should describe what the control will do when the switch is on
- https://www.justinmind.com/blog/toggle-design-patterns-examples/
- https://developer.yoast.com/blog/when-to-use-toggle-switches/
- https://www.nngroup.com/articles/toggle-switch-guidelines/
-
HTTP headers for the responsible developer
-
High Performance Browser Networking
https://hpbn.co/
-
Why I'm Over GraphQL