The Curious Engineer

All blogs / JavaScript / TypeScript

khalilstemmler.com RSS Feed

khalilstemmler.com

Advanced TypeScript & Node.js guides for large-scale applications. Learn to write flexible, maintainable TypeScript.

JavaScript / TypeScriptSoftware / engineering practiceTesting / QA

’16’17’18’19’20’21’22’23’24’25’26
Posts
141 from 29 Jan 2016 to 3 Sep 2026
Posting
now and then (5 in the last year)
Kind
personal blog
Feed
https://khalilstemmler.com/rss.xml

2026 4

  1. Six Systems That Save You Months
  2. Your Flywheel Isn't Spinning Yet
  3. The 5 Phases of Craftship (Why AI Amplifies Wherever You Already Are)
  4. Agentic Coding Is a Trap

2025 1

  1. The Power of Composition

2024 9

  1. Temporal Decoupling: Why We Use Events & Messages
  2. Tension Seeking Resolution (The Law of Polarity)
  3. Two Categories of Tests: High Value vs. Typical Tests
  4. Using Builders to Model Complex Test States
  5. How to Improve Legacy Code w/ Characterization Tests
  6. The Metaphysical Mental Models: Abstraction & The Feedback Loop
  7. Why You Have Spaghetti Code
  8. Reality → Perception → Definition → Action (Why Language Is Vital As a Developer)
  9. The Code-First Developer

2023 1

  1. "Tests Are a Waste of Time"

2022 19

  1. No title
  2. How to Find and Kill a Background Node Process
  3. 3 Steps to Solve Most Design Problems | How to Find Abstractions Effectively
  4. Object Stereotypes
  5. 98% of Developers Use React as a Framework, Not a Library
  6. No title
  7. No title
  8. No title
  9. No title
  10. What Is Hashing?
  11. Non-Functional Requirements (with Examples)
  12. JavaScript forEach | Looping Through an Array in JS
  13. Responsibility-Driven Design
  14. What are Dependencies, Composition, Delegation, and Aggregation in Object-Oriented Programming?
  15. 4 Principles of Object-Oriented Programming
  16. Is DDD Overrated? | Domain-Driven Design
  17. Update: I'm Teaching Software Design & Architecture Full-time @ khalilstemmler.com
  18. Hash Tables | What, Why & How to Use Them
  19. When to Use TypeScript Abstract Classes

2021 17

  1. Camel Case vs. Snake Case vs. Pascal Case — Naming Conventions
  2. How to use Prettier with ESLint and TypeScript in VSCode
  3. How to Test Code Coupled to APIs or Databases
  4. No title
  5. No title
  6. How to Mock without Providing an Implementation in TypeScript
  7. When to Use Mocks: Use Case Tests
  8. Existential State Machines
  9. What Would Albert Camus Think About Software Development?
  10. Why I Recommend a Feature-Driven Approach to Software Design
  11. Introduction to Test-Driven Development (TDD) with Classic TDD Example
  12. GraphQL Schemas vs. RESTful DTOs
  13. Use DTOs to Enforce a Layer of Indirection | Node.js w/ TypeScript
  14. Transcribing Video With DDD Discussion | Domain Driven Design w/ TypeScript
  15. No title
  16. No title
  17. Maintain a Single Layer of Abstraction at a Time | Object-Oriented Design Principles w/ TypeScript

2020 21

  1. 5 Ways to Manage Lambda Cold Starts
  2. I. Architecture
  3. IV. Conclusion
  4. Client-Side Architecture Basics [Guide]
  5. III. Layers
  6. II. Principles
  7. The Three Responsibilities of a Client-Side State Management Solution
  8. Accidental and Essential Complexity
  9. Enforcing Coding Conventions with Husky Pre-commit Hooks
  10. How to use ESLint with TypeScript
  11. Deploying Serverless GraphQL APIs with TypeScript on Netlify
  12. How to Deploy a Serverless GraphQL API on Netlify [Starters]
  13. Nested GraphQL Resolvers & Separating Concerns
  14. How to Get the Currently Playing Song using the Spotify Node.js API & TypeScript
  15. How to Build a Compiler?
  16. Ensuring Sequelize Hooks Always Get Run
  17. Domain-Driven GraphQL Schema Design using Event Storming
  18. How I Write Testable Code | Khalil's Simple Methodology
  19. GraphQL's Greatest Architectural Advantages
  20. No title
  21. Decade in Review | 2010-2020

2019 63

  1. Why Event-Based Systems? | Enterprise Node.js + TypeScript
  2. How Apollo REST Data Source Deduplicates and Caches API calls [Deep Dive]
  3. No title
  4. Books that Developers Should Read in 2020 [List]
  5. Make Illegal States Unrepresentable! - Domain-Driven Design w/ TypeScript
  6. Static Factory Methods | Object-Oriented Programming w/ TypeScript
  7. When to Use a Private Constructor | TypeScript OOP
  8. I'm Learning Everything GraphQL in 2020
  9. How to Handle Updates on Aggregates - Domain-Driven Design w/ TypeScript
  10. Brutalist Web Design
  11. Comparison of Domain-Driven Design and Clean Architecture Concepts
  12. How to Prerender Comments | Gatsbyjs Guide
  13. How to Learn Software Design and Architecture | The Full-stack Software Design & Architecture Map
  14. Decoupling Logic with Domain Events [Guide] - Domain-Driven Design w/ TypeScript
  15. Does DDD Belong on the Frontend? - Domain-Driven Design w/ TypeScript
  16. Organizing App Logic with the Clean Architecture [with Examples]
  17. Why I Don't Use a DI Container | Node.js w/ TypeScript
  18. No title
  19. No title
  20. No title
  21. Dependency Injection & Inversion Explained | Node.js w/ TypeScript
  22. Command Query Separation | Object-Oriented Design Principles w/ TypeScript
  23. How to Setup a TypeScript + Node.js Project
  24. What's Unscalable about JavaScript? | TypeScript OOP
  25. Functional Error Handling with Express.js and DDD | Enterprise Node.js + TypeScript
  26. An Introduction to Domain-Driven Design (DDD)
  27. No title
  28. Handling Collections in Aggregates (0-to-Many, Many-to-Many) - Domain-Driven Design w/ TypeScript
  29. Challenges in Aggregate Design #1 - Domain-Driven Design w/ TypeScript
  30. How to Design & Persist Aggregates - Domain-Driven Design w/ TypeScript
  31. There Is No Dominant Paradigm | Software Professionalism
  32. Intention Revealing Interfaces [w/ Examples] - Domain-Driven Design w/ TypeScript
  33. All about TypeScript Static Members | TypeScript OOP
  34. Where Do Domain Events Get Created? | Domain Driven Design w/ TypeScript
  35. No title
  36. TypeScript & JavaScript Getters and Setters: Are they useless?
  37. Better Software Design with Application Layer Use Cases | Enterprise Node.js + TypeScript
  38. Implementing DTOs, Mappers & the Repository Pattern using the Sequelize ORM [with Examples] - DDD w/ TypeScript
  39. Domain Knowledge & Interpretation of the Single Responsibility Principle | SOLID Node.js + TypeScript
  40. Over $85 billion spent on fixing bad code [bootcamps, junior devs, JavaScript, and software design principles]
  41. Clean Node.js Architecture | Enterprise Node.js + TypeScript
  42. Understanding Domain Entities [with Examples] - DDD w/ TypeScript
  43. No title
  44. No title
  45. Knowing When CRUD & MVC Isn't Enough | Enterprise Node.js + TypeScript
  46. SOLID Principles: The Software Developer's Framework to Robust & Maintainable Code [with Examples]
  47. Flexible Error Handling w/ the Result Class | Enterprise Node.js + TypeScript
  48. REST-first design is Imperative, DDD is Declarative [Comparison] - DDD w/ TypeScript
  49. No title
  50. Clean & Consistent Express.js Controllers | Enterprise Node.js + TypeScript
  51. TypeScript vs. JavaScript [Pros / cons]
  52. Junction Model Pattern: Many-to-Many - Sequelize
  53. UML Cheatsheet | Class Diagram Resource
  54. Migrate Primary Keys to UUIDs - Sequelize/Node
  55. How to Build a Related Posts Component with Gatsby.js
  56. No title
  57. No title
  58. No title
  59. No title
  60. Value Objects - DDD w/ TypeScript
  61. When To Use TypeScript - A Detailed Guide Through Common Scenarios
  62. No title
  63. No title

2018 3

  1. Cleaner Code with Async / Await Tutorial
  2. Fixing Sequelize Models with Migrations
  3. How To Optimize Your Gatsby Blog For SEO

2017 1

  1. What Does A Tilde Do In JavaScript?

2016 2

  1. How To Easily Understand Callbacks In JavaScript
  2. Hacking the Asterisk AMI to Send Missed Call Notifications with NodeJS