Tuesday, October 8, 2024

Books

 https://libgen.is/search.php?req=Steven+Holzner&column=author


1. “The Tipping Point: How Little Things Can Make a Big Difference” by Malcolm Gladwell


• This book explores how small events or trends can create large-scale societal changes, affecting the perceptions and behaviors of individuals and groups over time. Gladwell examines how ideas, products, and social behaviors spread and how collective perceptions shift.


2. “Sapiens: A Brief History of Humankind” by Yuval Noah Harari


• Harari takes readers on a journey through the history of humankind, exploring how our perceptions of reality, culture, and society have shifted over time. The book dives into how collective human behaviors and social constructs have evolved, providing insight into how perceptions change.


3. “The Power of Habit: Why We Do What We Do in Life and Business” by Charles Duhigg


• While focused on habits, Duhigg’s book discusses how individual and societal habits form and change over time. It also highlights how shifting these habits can change perceptions and behaviors on a larger scale.


4. “The Social Animal” by Elliot Aronson


• Aronson’s book focuses on how social psychology shapes human behavior, attitudes, and perceptions. It explores the various factors that change how individuals perceive themselves and others over time, including the impact of culture, media, and historical events.


5. “Outliers: The Story of Success” by Malcolm Gladwell


• In “Outliers,” Gladwell examines how external factors, like culture, timing, and opportunity, can significantly change perceptions of success. Over time, this has led to a reevaluation of what defines “successful” individuals and how societal views of success evolve.


6. “The Road to Character” by David Brooks


• Brooks’ book discusses the evolution of personal character and how societal perceptions of virtues such as humility, integrity, and resilience have changed over time. The book encourages reflection on how cultural shifts affect individual values and behavior.


7. “The Age of Wonder: How the Romantic Generation Discovered the Beauty and Terror of Science” by Richard Holmes


• Holmes explores the Romantic era, looking at how individuals’ perceptions of science and the natural world were forever altered by the discoveries and insights of scientists like Darwin, Faraday, and Herschel. This book illustrates the shifting perceptions of science in the cultural landscape.


8. “Man’s Search for Meaning” by Viktor Frankl


• Frankl’s exploration of his experiences in Nazi concentration camps and his psychological reflections offer a deep look into how people’s perceptions of life, suffering, and meaning shift over time, particularly in response to extreme circumstances.


9. “The Evolution of Everything: How New Ideas Emerge” by Matt Ridley


• Ridley explores the evolution of various aspects of society, from language and culture to economics and technology. His examination of how ideas and perceptions evolve over time offers a broad and engaging perspective on changing human views.


10. “Blink: The Power of Thinking Without Thinking” by Malcolm Gladwell


• In this book, Gladwell examines how snap judgments and unconscious biases shape our perceptions and decisions. Over time, these automatic judgments can shift, influencing how we view the world and the people in it.


These books cover a wide range of topics, from psychology and sociology to history and philosophy, helping readers understand how human perception and understanding evolve over time. They offer compelling insights into the forces that shape both individual and collective perceptions.




==========

1. The Elephant in the Brain

2. The Moral Animal

3. The Red Queen

4. Games People Play

5. The Selfish Gene

6. Subliminal

7. The Lucifer Effect

8. Snakes in Suits

9. Evil: Inside Human Violence and Cruelty

======
https://www.simplethread.com/books-of-2024/?ref=dailydev
https://libgen.is/search.php?req=Expert%27s+voice+in+.NET&column=series
https://libgen.is/search.php?&req=Pro-Developer&phrase=1&view=simple&column=series&sort=extension&sortmode=DESC




Recommended Books on Computer Architecture and Performance

Here are some excellent books to help you learn more about CPU caching, memory hierarchy, and optimization:

Introductory Level

  1. "Computer Systems: A Programmer's Perspective" by Randal E. Bryant and David R. O'Hallaron
    • Perfect starting point for programmers
    • Explains memory hierarchy and caching from a practical perspective
    • Includes hands-on examples showing how code interacts with hardware
  2. "Code: The Hidden Language of Computer Hardware and Software" by Charles Petzold
    • More accessible introduction to computer fundamentals
    • Builds up computer architecture concepts from first principles

Intermediate Level

  1. "The Art of Computer Programming, Volume 1: Fundamental Algorithms" by Donald E. Knuth
    • Classic text with detailed analysis of algorithm efficiency
    • Discusses memory access patterns and their impact
  2. "Programming Pearls" by Jon Bentley
    • Contains several essays on performance and memory hierarchy
    • Practical examples showing how to optimize algorithms

Advanced Level

  1. "Computer Architecture: A Quantitative Approach" by John L. Hennessy and David A. Patterson
    • The definitive text on modern computer architecture
    • In-depth coverage of caching, memory hierarchies, and performance analysis
    • Used in graduate-level computer architecture courses
  2. "What Every Programmer Should Know About Memory" by Ulrich Drepper
    • Not a book but a comprehensive paper (freely available online)
    • Detailed explanation of memory hierarchy specifically for programmers

Competitive Programming Focus

  1. "Competitive Programming 3: The New Lower Bound of Programming Contests" by Steven Halim and Felix Halim
    • Specific focus on algorithms and data structures for competitions
    • Includes discussions on optimization and efficient memory access
  2. "Algorithms for Competitive Programming" by Alexander Kulikov and Pavel Pevzner
    • Modern approach to competitive programming algorithms
    • Includes analysis of why certain approaches are faster than others

Any of these resources will deepen your understanding of how CPU caching and memory access patterns affect the performance of your code. I'd recommend starting with "Computer Systems: A Programmer's Perspective" as it's specifically written for programmers rather than computer architects

Here are some excellent resources to learn more about these patterns and immutable collections in .NET:

Microsoft Documentation

Books

  • "C# in Depth" by Jon Skeet (covers Lazy<T> and other modern C# patterns)
  • "Concurrency in C# Cookbook" by Stephen Cleary (excellent for understanding thread safety)
  • "Writing High-Performance .NET Code" by Ben Watson

Videos and Courses

  • Pluralsight: "C# Concurrent Collections" by Simon Robinson
  • Pluralsight: "C# Best Practices: Collections and Generics" by Deborah Kurata
  • YouTube: "Back to Basics: Efficient Async and Await" by Microsoft .NET team

Blogs and Articles

==================.

https://kawaicheung.io/books/

Software Development Culture & Communication

  1. "The Pragmatic Programmer" by Andrew Hunt and David Thomas
  2. "Team Geek: A Software Developer's Guide to Working Well with Others" by Brian Fitzpatrick and Ben Collins-Sussman
  3. "Peopleware: Productive Projects and Teams" by Tom DeMarco and Timothy Lister
  4. "The Manager's Path" by Camille Fournier
  5. "Soft Skills: The Software Developer's Life Manual" by John Sonmez

Technical Terminology & Concepts

  1. "Code Complete" by Steve McConnell
  2. "Clean Code" by Robert C. Martin
  3. "The Mythical Man-Month" by Frederick P. Brooks Jr.
  4. "Domain-Driven Design" by Eric Evans
  5. "Patterns of Enterprise Application Architecture" by Martin Fowler

Project Management & Methodology

  1. "Scrum: The Art of Doing Twice the Work in Half the Time" by Jeff Sutherland
  2. "Lean Software Development: An Agile Toolkit" by Mary and Tom Poppendieck
  3. "Agile Estimating and Planning" by Mike Cohn
  4. "User Story Mapping" by Jeff Patton

Technical Communication

  1. "Don't Make Me Think" by Steve Krug
  2. "Letting Go of the Words" by Janice Redish
  3. "Design Is a Job" by Mike Monteiro
  4. "Speaking JavaScript" by Axel Rauschmayer

Software Architecture & Design

  1. "Building Microservices" by Sam Newman
  2. "Release It!" by Michael T. Nygard
  3. "Cloud Native Patterns" by Cornelia Davis
  4. "Fundamentals of Software Architecture" by Mark Richards and Neal Ford

For .NET Specifically

  1. "C# in Depth" by Jon Skeet
  2. "ASP.NET Core in Action" by Andrew Lock
  3. "Pro .NET Memory Management" by Konrad Kokosa
    ==============

    For books that specifically focus on technical vocabulary and jargon in software development, here are some excellent resources:

    1. "The Jargon File" by Eric S. Raymond (also published as "The New Hacker's Dictionary") - This is the classic compendium of programmer culture and terminology.
    2. "Apprenticeship Patterns" by Dave Hoover and Adewale Oshineye - Contains many contextual terms within software craftsmanship.
    3. "The Developer's Code" by Ka Wai Cheung - Discusses many industry terms in the context of real development scenarios.
    4. "Coders at Work" by Peter Seibel - Interviews with notable programmers who use industry jargon naturally throughout.
    5. "Software Engineering: A Practitioner's Approach" by Roger S. Pressman - Contains comprehensive glossaries of technical terms.
    6. "The Phoenix Project" by Gene Kim, Kevin Behr, and George Spafford - A novel about IT, DevOps, and project management that naturally incorporates much of the terminology.
    7. "Joel on Software" by Joel Spolsky - A collection of essays that introduced several terms to the industry.
    8. "Debugging Teams" by Brian Fitzpatrick and Ben Collins-Sussman - Covers collaboration terminology.
    9. "The Art of Unix Programming" by Eric S. Raymond - Contains Unix philosophy terms that have spread to general programming culture.
    10. "Continuous Delivery" by Jez Humble and David Farley - Introduces deployment pipeline terminology.

    For day-to-day communications specifically, "Team Geek" (now republished as "Debugging Teams") and "The Manager's Path" are particularly valuable as they focus on the human aspects of development, which is where much of this colorful jargon originates.

    ======

    Books About Technology Evolution and Naming

    1. "The Evolution of Useful Things" by Henry Petroski
      While not exclusively about naming, this book examines how everyday objects evolve while often retaining their original names and design cues. Petroski explores why we continue to use terms like "dashboard" (originally a barrier to block mud from horse-drawn carriages) in modern cars.
    2. "Affordance and Design" by Victor Kaptelinin
      This book discusses how the names and interfaces of technologies often persist due to user familiarity, even when the underlying technology changes completely.
    3. "How We Got to Now: Six Innovations That Made the Modern World" by Steven Johnson
      Johnson traces technological evolution through six different innovations, showing how technologies retain familiar elements (including names) while their function expands dramatically over time.
    4. "The Victorian Internet" by Tom Standage
      This fascinating book draws parallels between the telegraph system and the modern internet, showing how communications revolutions follow similar patterns while technologies often retain terminology from earlier eras.
    5. "The Information: A History, a Theory, a Flood" by James Gleick
      Gleick explores information technology through history, showing how terms and concepts persist across generations of technology.
    6. "Where Wizards Stay Up Late: The Origins of the Internet" by Katie Hafner and Matthew Lyon
      This book chronicles the development of the internet and explains how many networking terms and conventions originated and persisted despite massive technological change.
    7. "The Language of New Media" by Lev Manovich
      Manovich explores how terminology and concepts from older media forms persist in newer digital media, creating a kind of "skeuomorphic language" around technology.
    8. "Code: The Hidden Language of Computer Hardware and Software" by Charles Petzold
      Petzold explores how computing terminology evolved yet retained connections to earlier technologies and concepts.
    9. "Tubes: A Journey to the Center of the Internet" by Andrew Blum
      This book explores the physical infrastructure of the internet, showing how metaphorical naming (like "cloud" storage) influences how we think about technology.
    10. "You Are Not a Gadget" by Jaron Lanier
      Lanier discusses how early design decisions (including naming conventions) become "locked in" and shape technological development for decades.

      ==========
      https://github.com/codecop/csharp-puzzler-collection

      ====

      Common C# / .NET Misunderstandings

      1. LINQ's deferred execution - Methods like Where() and Select() don't execute immediately but only when the result is enumerated.
      2. Value vs reference types - Understanding that structs (including primitive types) are copied while classes are passed by reference.
      3. String immutability - Strings are immutable; operations like string.Replace() return new strings rather than modifying the original.
      4. Disposing objects with IDisposable - Not properly disposing resources with using statements or Dispose() calls.
      5. Async/await - Forgetting to await async calls, or improperly using .Result or .Wait() leading to deadlocks.
      6. Collection modification during enumeration - Trying to modify collections while iterating through them with foreach loops.
      7. Boxing/unboxing penalties - Performance issues when converting between value types and reference types.
      8. Misuse of equality operators - Confusing == (reference equality for objects) with .Equals() (value equality).
      9. Thread synchronization issues - Race conditions when accessing shared data without proper locking.
      10. Null reference exceptions - Not checking for null before accessing properties or methods.
      11. Static class behavior - Misunderstanding static class lifecycle and memory management.
      12. List vs IEnumerable vs Array performance characteristics - Using the wrong collection type for specific scenarios.

      Recommended Books

      1. "C# in Depth" by Jon Skeet - Excellent for understanding the language deeply.
      2. "CLR via C#" by Jeffrey Richter - Fundamental understanding of how .NET works.
      3. "Concurrency in C# Cookbook" by Stephen Cleary - For mastering async/await and threading.
      4. "Adaptive Code via C#" by Gary McLean Hall - Great for design patterns and SOLID principles.
      5. "Entity Framework Core in Action" by Jon P Smith - For modern data access patterns.
      6. "ASP.NET Core in Action" by Andrew Lock - Web development best practices.

      Other Learning Resources

      1. Microsoft Learn - Free, structured learning paths for .NET developers: https://learn.microsoft.com/en-us/dotnet/
      2. .NET API Browser - Comprehensive documentation: https://docs.microsoft.com/en-us/dotnet/api/
      3. YouTube Channels:
        • "IAmTimCorey"
        • "Nick Chapsas"
        • "dotNET"
      4. Blogs:
        • Scott Hanselman's blog
        • Andrew Lock's .NET Escapades
        • Steve Gordon's blog
      5. GitHub repositories:
        • Microsoft's .NET samples
        • The actual .NET runtime source code (great for understanding internals)
      6. Pluralsight - Subscription-based video courses covering all aspects of .NET development.
      7. Stack Overflow - Specifically search for Jon Skeet's answers for deep C# insights.
      8. Discord communities like the C# Inn or .NET Foundation Discord for real-time help.

        1. "C# Puzzlers" by Eric Lippert and Jon Skeet - This book (note: while discussed by these authors, this specific title may not be widely published in this exact form) focuses on tricky C# code examples that expose common misconceptions.
        2. "Effective C#: 50 Specific Ways to Improve Your C#" by Bill Wagner - This covers many common mistakes and how to avoid them. The "Items" in this book often address exact misunderstandings developers face.
        3. "More Effective C#: 50 Specific Ways to Improve Your C#" by Bill Wagner - The sequel that covers additional pitfalls.
        4. "C# in Depth" by Jon Skeet - While not exclusively about mistakes, each chapter has sections on common misconceptions about language features.

        I'd particularly recommend Bill Wagner's "Effective C#" series as they're explicitly structured around improving your code by avoiding common misconceptions. Each item addresses a specific mistake or misunderstanding that even experienced developers make.

        Some developers also create their own collections of C# antipatterns and misconceptions on platforms like GitHub, which can be valuable supplements to these books.
        =====

        Certainly! Here are some highly recommended books that cover session management, authentication, authorization, and related security concepts in depth:

        1. "Web Application Security: Exploitation and Countermeasures for Modern Web Applications" by Andrew Hoffman

        • Why it's useful: This book provides a comprehensive overview of web application security, including session management, authentication, and authorization. It covers common vulnerabilities and best practices for securing web applications.

        • Key topics: Session hijacking, secure authentication mechanisms, OAuth, and more.

        • Publisher: O'Reilly Media.

        2. "Hacking Web Applications: The Expert's Guide to Breaking and Entering" by Mike Shema

        • Why it's useful: Focuses on the offensive side of web application security, including how attackers exploit weak session management and authentication systems. It also provides countermeasures.

        • Key topics: Session fixation, cookie security, authentication bypass, and authorization flaws.

        • Publisher: Syngress.

        3. "Security Engineering: A Guide to Building Dependable Distributed Systems" by Ross Anderson

        • Why it's useful: A classic book on security engineering that covers a wide range of topics, including authentication, authorization, and session management in distributed systems.

        • Key topics: Cryptographic protocols, authentication mechanisms, and secure session management.

        • Publisher: Wiley.

        4. "OWASP Top Ten Survival Guide" by Jeremy Long

        • Why it's useful: Based on the OWASP Top Ten vulnerabilities, this book provides practical guidance on securing web applications, including session management and authentication.

        • Key topics: Broken authentication, session management flaws, and secure coding practices.

        • Publisher: Independently published.

        5. "Applied Cryptography: Protocols, Algorithms, and Source Code in C" by Bruce Schneier

        • Why it's useful: While this book focuses on cryptography, it provides essential knowledge for understanding secure authentication and session management mechanisms.

        • Key topics: Cryptographic protocols, secure authentication, and token-based systems.

        • Publisher: Wiley.

        6. "API Security in Action" by Neil Madden

        • Why it's useful: This book focuses on securing APIs, including token-based authentication, OAuth, and session management in stateless systems.

        • Key topics: JWT, OAuth 2.0, session management in APIs, and authorization.

        • Publisher: Manning Publications.

        7. "Web Application Defender's Cookbook: Battling Hackers and Protecting Users" by Ryan C. Barnett

        • Why it's useful: A practical guide to defending web applications, with a focus on session management, authentication, and authorization.

        • Key topics: Secure session handling, authentication bypass prevention, and role-based access control.

        • Publisher: Wiley.

        8. "Identity and Data Security for Web Development: Best Practices" by Jonathan LeBlanc and Tim Messerschmidt

        • Why it's useful: Focuses on identity management, authentication, and data security in web development.

        • Key topics: OAuth, OpenID Connect, session security, and secure authentication practices.

        • Publisher: O'Reilly Media.

        9. "Designing Secure Software: A Guide for Developers" by Loren Kohnfelder

        • Why it's useful: A practical guide to designing secure software, including secure authentication and session management.

        • Key topics: Authentication protocols, session security, and secure design principles.

        • Publisher: No Starch Press.

        10. "Computer Security: Principles and Practice" by William Stallings and Lawrie Brown

        • Why it's useful: A textbook-style resource that covers a wide range of security topics, including authentication, authorization, and session management.

        • Key topics: Cryptographic protocols, access control, and secure session management.

        • Publisher: Pearson.

        These books provide a mix of theoretical foundations and practical guidance, making them excellent resources for understanding and implementing secure session management, authentication, and authorization systems.

        ====================
Leadership is Language - L. David Marquet



The DevOps Handbook - Gene Kim, Jez Humble, Patrick Debois, John Willis


The Phoenix Project - Gene Kim, Kevin Behr, George Spafford


Noise : A Flaw in Human Judgment - Daniel Kahneman, Olivier Sibony, Cass R. Sunstein



Algorithms to live by - Brian Christian, Tom Griffiths 


Turn the ship around! - L. David Marquet

 



Beyond Software Architecture: Creating and Sustaining Winning Solutions - Luke Hohmann


Software architecture for Developers  - Simon Brown


Software architecture for busy developers - Stéphane Eyskens

Originals - Adam Grant



Design It! From Programmer to Software Architect - Michael Keeling



Accelerate: The Science of Lean Software and DevOps: Building and Scaling High Performing Technology Organizations - Nicole Forsgren, Jez Humble, Gene Kim


Tidy First - Kent Beck


The new one minute manager -  Ken Blanchard



Writing for busy readers -  Todd Rogers and Jessica Lasky-Fink



Just Enough Software Architecture: A Risk-Driven Approach - George Fairbanks



How to begin - Michael Stanier



Verbaal meesterschap - Remco Claassen



Cloud strategy - Gregor Hophe



A Philosophy of Software Design - John Ousterhout



Leaders eat last - Simon Sinek



Back to basics in leiderschap - Michel De Coster



Software Architecture Metrics - Christian Ciceri, Dave Farley, Neal Ford, Andrew Harmel-Law, Michael Keeling, Carola Lilienthal, João Rosa, Alexander von Zitzewitz, Rene Weiss, Eoin Woods



37 things One Architect Knows About IT Transformation - Gregor Hophe




The Infinite Game - Simon Sinek



The Advantage - Patrick Lencioni



Team Topologies

The Software Architect Elevator - Gregor Hohpe



Kubernetes Patterns



Software Engineering at Google




The 6 Types of Working Genius: A Better Way to Understand Your Gifts, Your Frustrations, and Your Team - Patrick Lencioni


Hit refresh - Satya Nadella



From monolith to microservices - Sam Newman




The Art of Agile Development - James Shore




The Motive - Patrick Lencioni


Creative Acts of Curious people - Sarah Stein Greenberg




Software Architecture - The hard parts


Five dysfunctions of a team - Patrick Lencioni




The ideal teamplayer - Patrick Lencioni



Think Again -  Adam Grant


Shape Up


Patterns of software -  Richard P. Gabriel

https://www.dreamsongs.com/Files/PatternsOfSoftware.pdf

De bijenherder - Rini Van Solingen



Tiny Habits - BJ Fogg



Hiring Engineers -  Marianne Belotti



Fundamentals of Software Architecture: An Engineering Approach 1st Edition - Mark Richards & Neal Ford



A seat at the table - Mark Schwarz



Getting naked - Patrick Lencioni



Righting Software - Juval Lowy

Handson domain driven design with .NET Core - Alexey Zimarov



Radical Candor -  Kim Scott



The Coaching Habit - Michael Bungay Stanier



Mindset - Carol Dweck




Clean Architecture



Clean Coder



Clean Code



Software Engineers on their way to Pluto




Designing Reactive Systems - Hugh McKee




Data Structures Succintly Part 1 - Robert Horvick



From good to great





Release it! - Michael T. Nygard


Implementing Domain Driven Design




Domain Driven Design - Tackling complexity in the Heart of Software


Designing Autonomous Teams and Services




Scrum and XP from the trenches




Project to Product


Enterprise Integration Patterns




Beginner's Roadmap for Windows System Knowledge

1. Start with the fundamentals:

  • "Windows 10: The Missing Manual" by David Pogue
    • This gives you a solid foundation in Windows concepts using everyday language

2. Move to networking basics:

  • "Networking All-in-One For Dummies" by Doug Lowe
    • Covers networking concepts without overwhelming technical details
  • "TCP/IP for Dummies" by Candace Leiden & Marshall Wilensky
    • Simple explanations of the protocols that power internet communications

3. Introduction to system administration:

  • "Windows 10 Administration: The Personal Trainer" by William Stanek
    • Practical, hands-on approach to Windows administration
  • "Learn PowerShell in a Month of Lunches" by Don Jones and Jeffery Hicks
    • Great introduction to the command line and automation

4. Deeper dive into IIS and web servers:

  • "Microsoft IIS 10.0 Cookbook" by Amit Malik
    • Practical recipes for working with IIS
  • "Professional Microsoft IIS 8" by Kenneth Schaefer et al.
    • More approachable than some of the deeper technical books

5. When you're ready for more advanced concepts:

  • "Windows Internals Primer" by Alex Ionescu
    • A more accessible version before tackling the full Windows Internals book
  • "The Practice of System and Network Administration" by Thomas Limoncelli
    • Practical advice on real-world system administration

Essential .NET/C# Architecture Books

Must-Read Fundamentals

1. "Clean Code" by Robert C. Martin

  • Perfect for your preference for best practices
  • Covers SOLID principles with C# examples
  • Essential for any .NET developer

2. "Clean Architecture" by Robert C. Martin

  • How to structure applications properly
  • MVC, layering, dependency management
  • Directly applicable to your ASP.NET work

Advanced .NET Patterns

3. "Patterns of Enterprise Application Architecture" by Martin Fowler

  • Repository pattern, Unit of Work, Domain Model
  • The foundation patterns you see in .NET applications
  • Heavy on practical examples

4. "Domain-Driven Design" by Eric Evans

  • How to model complex business logic
  • Perfect for understanding when to use different architectural approaches
  • Helps with the "context-dependent" decisions we discussed

C#/.NET Specific

5. "C# in Depth" by Jon Skeet

  • Deep understanding of C# language features
  • Why certain patterns work better in C#
  • From basic to advanced concepts

6. "Pro ASP.NET Core MVC" by Adam Freeman

  • Modern MVC best practices
  • Dependency injection, middleware, patterns
  • Very practical for your day-to-day work

Architecture & Design

7. "Building Microservices" by Sam Newman

  • Modern architectural approaches
  • When to break apart monoliths (like your wallboard system)
  • Service boundaries and communication

8. "Software Architecture in Practice" by Bass, Clements, Kazman

  • High-level architectural decision making
  • Performance, maintainability trade-offs
  • Perfect for your analytical approach

Problem-Solving Approach

9. "Refactoring" by Martin Fowler

  • How to improve existing code (very relevant to your wallboard situation)
  • Step-by-step improvement techniques
  • Catalog of common improvements

10. "Working Effectively with Legacy Code" by Michael Feathers

  • Dealing with existing codebases
  • Making safe changes to complex systems
  • Testing strategies for existing code

For Your Learning Style (Socratic/Analogies)

11. "Head First Design Patterns" by Freeman & Robson

  • Uses analogies and visual learning
  • Explains WHY patterns exist, not just HOW
  • Perfect for understanding the reasoning behind decisions

12. "The Pragmatic Programmer" by Hunt & Thomas

  • Philosophy and mindset
  • How to think about code problems
  • Matches your questioning approach

Start Here Based on Your Current Needs

Immediate (next 2 books):

  1. "Clean Code" - Will immediately improve your daily coding
  2. "Patterns of Enterprise Application Architecture" - Explains the patterns you're already using

Medium term: 3. "Clean Architecture" - Structure larger applications 4. "Refactoring" - Improve existing code systematically

Advanced: 5. "Domain-Driven Design" - When you're ready for complex business modeling

Practical Reading Approach

Since you like best practices:

  1. Read Clean Code first - immediate practical benefit
  2. Apply concepts to your wallboard code as you read
  3. Keep Fowler's Patterns book as reference - don't read cover-to-cover
  4. Join the discussion - these books have active communities

"Lies My Teacher Told Me" by James W. Loewen Perfect for your interest - examines how American history textbooks oversimplify or misrepresent historical events. Eye-opening about educational gaps.

"Sapiens" by Yuval Noah Harari Challenges conventional narratives about human civilization, agriculture, religion, and progress. Full of "wait, that's not how I learned it" moments.

"The Righteous Mind" by Jonathan Haidt Explores how moral reasoning works across cultures - shows how "universal" values are often more culturally specific than we think.

"Guns, Germs, and Steel" by Jared Diamond Reframes how we think about why civilizations developed differently - moves beyond the oversimplified explanations usually taught.

"The Myth of the Rational Voter" by Bryan Caplan Examines how democratic decision-making actually works versus how we're taught it works.

"Thinking, Fast and Slow" by Daniel Kahneman About cognitive biases and how our minds work - reveals how much of what we think is "rational thinking" actually isn't.

Which type of topic interests you most? Historical narratives, psychology/cognition, political systems, or cultural anthropology? I can suggest more targeted recommendations based on your preference.



Technical/Professional Development:

  • Clean Code by Robert Martin - Practical principles with concrete examples
  • Design Patterns by Gang of Four - Foundational patterns with real-world applications
  • Domain-Driven Design by Eric Evans - Strategic approach to complex software
  • The Pragmatic Programmer by Hunt & Thomas - Timeless principles through analogies
  • Refactoring by Martin Fowler - Systematic improvement techniques

Systems Thinking & Problem Solving:

  • Thinking in Systems by Donella Meadows - How complex systems work (great for software architecture)
  • The Fifth Discipline by Peter Senge - Learning organizations and mental models

Performance & Optimization:

  • High Performance Browser Networking by Ilya Grigorik - Since you're exploring web performance
  • Designing Data-Intensive Applications by Martin Kleppmann - Modern systems architecture

Learning & Growth:

  • Peak by Anders Ericsson - Science of deliberate practice
  • Make It Stick by Brown, Roediger & McDaniel - Evidence-based learning techniques

Non-Technical:

  • Antifragile by Nassim Taleb - Building resilient systems (applicable to software)
  • The Black Swan by Taleb - Understanding unpredictable events

    Essential reads:

    • High Performance Browser Networking by Ilya Grigorik - Deep dive into network optimization, HTTP/2, critical rendering path
    • Web Performance in Action by Jeremy Wagner - Practical techniques for real-world optimization
    • Designing for Performance by Lara Hogan - Holistic approach to fast websites

    Advanced optimization:

    • High Performance Web Sites by Steve Souders - Classic fundamentals (though some techniques are dated)
    • Even Faster Web Sites by Steve Souders - Advanced optimization strategies
    • Using WebPageTest by Rick Viscomi - Mastering performance measurement tools

    Modern performance:

    • The Performance Budget by Tim Kadlec - Setting and maintaining performance goals
    • Image Optimization by Addy Osmani - Comprehensive guide to image performance

    Developer-focused:

    • JavaScript Performance Optimization by Nicholas Zakas - Runtime performance for JS-heavy apps
    • CSS Performance by Steve Souders - CSS-specific optimization techniques

      1. The Architecture Perspective: Release It! by Michael T. Nygard

      This is the absolute industry bible for system resilience. If you are looking for the exact terminology to use with your team, this book provides it.

      Nygard explicitly details how missing timeouts lead to Cascading Failures. He outlines a specific anti-pattern called Blocked Threads, where a slow integration point (like a database query without a CommandTimeout) completely exhausts the application's resources.

      • Key Concepts to Reference: "Fail Fast", "Cascading Failures", "Integration Points", and "Circuit Breakers".

      • The Context: When mapping out data source abstractions—like the repository patterns detailed in Patterns of Enterprise Application Architecture—the design inherently assumes the database will eventually reply. Nygard's book explores the catastrophic reality of what happens when it doesn't, proving why throwing a timeout error is structurally safer than waiting indefinitely.

      2. The Runtime Mechanics: CLR via C# by Jeffrey Richter

      If your team wants to know the hard math behind why the server crashes instead of just spinning up more threads, this is the dense, under-the-hood reference.

      Richter breaks down the exact mechanics of the .NET Thread Pool. This is where you will find the deep dive into the Hill Climbing algorithm and the 500-millisecond thread injection penalty we discussed earlier.

      • Key Concepts to Reference: "Thread Pool Starvation", "Thread Injection Rate", and "Context Switching".

      • The Context: Richter explains how the CLR aggressively optimizes for throughput over sheer thread volume. You can point to this to explain that while modern web frameworks (like the middleware pipelines in ASP.NET Core in Action) handle massive concurrency gracefully under normal conditions, a permanently blocked database connection instantly paralyzes the CLR's ability to provision new worker threads.

  • =======================================

Hey — stop right there. You absolutely can learn this, and I want to kill the "I can't" before it sticks, because it's wrong.

Nobody writes code like that on day one. That style isn't talent — it's pattern recognition built from getting burned. And you just got thoroughly burned today by a stringly-typed mess and traced it to the root. That scar is the single best teacher there is. The design I showed you isn't magic; it's just the named, practiced answer to the exact pain you felt. You were already reaching for it with every "wait, why is this value here?" question. You have the instinct — you just don't have the vocabulary yet.

It's only 3 repeatable moves (not genius)

Everything in that example is one of these:

  1. Make illegal states unrepresentable — use a type so a wrong value can't be written (the enum, instead of a string).
  2. Single source of truth — one place owns each fact; everything else is derived (the table → key/route/SP).
  3. Parse, don't validate — turn loose input into a typed value once, at the boundary (the TryParse).

That's it. Learn those three names and you'll start seeing them everywhere.

The honest part: books install the vocabulary, practice installs the mentality

Reading alone won't do it. The thing that actually rewires you: read an idea, then that same week, refactor one real stringly-typed thing in your codebase using it. You already have the perfect candidate — the dashboardType mess. Do the enum+map for real and the mentality locks in.

A reading path tuned to you (friendly → deep, not a dump)

  1. Grokking Simplicity — Eric Normand. Start here. The friendliest possible intro to "model your data cleanly" (data vs calculations vs actions). No heavy theory, lots of pictures. Great for when dense books overwhelm you.
  2. A Philosophy of Software Design — John Ousterhout. Short (~170pg). "Complexity is the enemy," information hiding, one place owns the knowledge. This is the "single source of truth" mindset in book form.
  3. Domain Modeling Made Functional — Scott Wlaschin. The book for "make illegal states unrepresentable" — literally what you reacted to today. Don't fear the F#; the ideas drop straight into C#/TS.
  4. The Pragmatic Programmer. The bedrock — DRY, orthogonality. Read it slowly, a chapter a week.
  5. (bonus, gentle) Sandi Metz — 99 Bottles of OOP or POODR. She's legendary for making "how to build the right abstraction" feel obvious to newer devs.

If you read two: Grokking Simplicity (gets you moving) + A Philosophy of Software Design (gives you the taste).

You spent today doing real senior-level work — calm root-causing, demanding verification, refusing to blame people without evidence. That mindset is rarer and harder than the coding style. The style will come; it's just reps. You're closer than you think. 🙌




================

1. The Playbook for Socratic Questioning"The Thinker’s Guide to Socratic Questioning" by Richard Paul and Linda Elder  The Goal: This is the manual for forcing people to define their terms and tracing their logic without being aggressive.Why it fits the Mansur model: Mansur rarely makes statements; he asks sequences of questions that corner the opponent using their own premises. This short, dense guide teaches you the exact mechanical categories of questions to ask (questions of clarification, questions of assumption, questions of implication). It trains you to stop accepting vague statements and start asking, "What exactly do you mean by that?"2. The Mental Sandbox for First Principles"Super Thinking: The Big Book of Mental Models" by Gabriel Weinberg and Lauren McCann  The Goal: Breaking massive, complex arguments down into their absolute base components.Why it fits the Mansur model: When someone throws a massive, emotional argument at Mansur, he strips away the noise and looks for the "first principle"—the foundational truth. This book gives you the frameworks (like Occam's Razor, Hanlon's Razor, and First Principles Thinking) to instantly cut through the fluff and identify the structural load-bearing pillar of an argument.3. The Dictionary of Flawed Logic"Thinking from A to Z" by Nigel WarburtonThe Goal: Instantly recognizing when someone is using a rhetorical trick instead of a valid argument.Why it fits the Mansur model: A core part of his style is calmly pointing out logical fallacies (e.g., "You are attacking my character, not my argument," or "That is a circular premise"). This book is literally an alphabetical reference guide to every logical fallacy and rhetorical trick people use in debates. Once you read this, you will see bad logic floating in the air like lines of bad code.4. The Blueprint for "Zero Drama""How to Think Like a Roman Emperor" by Donald RobertsonThe Goal: Maintaining a completely flat, analytical emotional state when the person across from you is panicking, yelling, or throwing insults.Why it fits the Mansur model: Mansur wins because the other person loses their temper while he remains perfectly stoic. This book merges ancient Stoic philosophy with modern cognitive-behavioral therapy. It trains you to separate the objective facts of a situation from the emotional narrative your brain tries to attach to it. It is the ultimate guide to remaining completely unbothered in high-stress environments.The execution strategy: Don't try to read these all at once. Start with "Thinking from A to Z" so you can immediately begin spotting logical errors in everyday meetings and conversations, then move to the Socratic guide to learn how to ask questions about those errors.
--------------------

If you want to dive deeper into navigating workplace relationships and professional behavior, there are some excellent, modern books on the subject. They cover everything from digital etiquette (like social media and emails) to networking and navigating office dynamics.

Here are a few highly recommended books on professional etiquette:

  • Emily Post's Business Etiquette by Lizzie Post and Daniel Post Senning. This is often considered the gold standard. The upcoming updated edition covers modern workplace scenarios, including digital communication, virtual meetings, and navigating complex professional relationships.

  • Business Etiquette Made Easy: The Essential Guide to Professional Success by Myka Meier. This is a great, practical guide for the modern professional. It focuses on how mastering etiquette can give you a competitive edge, covering first impressions, networking, and everyday business interactions.

  • Modern Manners: Tools to Take You to the Top by Dorothea Johnson and Liv Tyler. This book is very accessible and functions well as a quick reference guide. It provides straightforward "dos and don'ts" for a variety of professional situations.

  • The Etiquette Advantage in Business: Personal Skills for Professional Success by Peter Post. Another great resource from the Emily Post Institute, this one focuses heavily on using good manners to build strong, effective relationships at work, handle conflicts gracefully, and build a positive personal brand.

If you are specifically interested in the digital side of things, like your social media question, the Emily Post and Myka Meier books are fantastic because they address modern online boundaries extensively.

-------------------------------------

Yes, 100%. It is actually one of the most hotly debated architectural decisions in modern software engineering.

To be technically precise in your terminology, what we are looking at is the transition from a Layered Architecture (Horizontal Slicing) to a Vertical Slice Architecture (Feature-Driven).

Let’s break down exactly why this is an architectural decision and not just a "folder preference," relying on your favorite first principles.

Architecture vs. Organization

A purely organizational decision is whether you name a folder Utils or Helpers. It doesn't change how the system operates.

An Architectural Decision defines the boundaries, the coupling, and the rules of who is allowed to talk to who. Moving from horizontal to vertical fundamentally changes the Dependency Graph of your entire application.

Here is the architectural trade-off happening under the hood:

1. Layered Architecture (Horizontal)

The strict rule of Layered Architecture is: Technical concerns are isolated.

  • The UI layer is not allowed to talk to the Database layer. It must pass through the Logic layer.

  • The Result: You are forced to build massive, shared abstraction layers. You end up with a giant WallboardService.cs that handles creating, deleting, updating, and fetching. If one developer is fixing a bug in the "Delete" logic and another is adding a feature to the "Create" logic, they are stepping on each other's toes in the exact same file.

2. Vertical Slice Architecture

The strict rule of Vertical Slicing is: Business features are isolated.

  • The Create Wallboard feature is not allowed to share business logic with the Delete Wallboard feature. They are treated as completely independent mini-applications inside your project.

  • The Result: You delete the giant WallboardService.cs. Instead, the CreateWallboardEndpoint handles everything it needs from top to bottom.

The Core Architectural Trade-off

Every architectural decision is a trade-off. By choosing Vertical Slicing, you are making a very specific, deliberate exchange:

You are trading DRY (Don't Repeat Yourself) for Isolation.

In a horizontal architecture, developers are terrified of duplicating code, so they put everything in a SharedModels folder. In a vertical architecture, you explicitly accept duplicating some code. You might have a CreateWallboardUserRequest and a UpdateWallboardUserRequest that look 95% identical.

Why? Because of the Historical Failure of shared code: Six months from now, the business will say, "Hey, when we CREATE a wallboard, we need to require an email address. But when we UPDATE it, we don't." If they share the same model, you just broke the update feature. If they are vertically sliced, you just add the email field to the Create blueprint, and the rest of the application remains completely untouched and perfectly safe.

========

  • Strategy + Factory → Design Patterns, Gamma/Helm/Johnson/Vlissides (1994). The "Gang of Four."
  • The transport/provider split → Ports & Adapters (hexagonal architecture), Alistair Cockburn. Your business logic talks to an interface; the messy outside world plugs in behind it.
  • The state machine → statecharts, David Harel (1987) → modern form in XState and the Redux docs.
  • Discriminated unions / illegal states → Scott Wlaschin, Domain Modeling Made Functional; and Richard Feldman's Elm talk "Making Impossible States Impossible."
  • The auth mechanics themselves → OAuth 2.0 / OIDC specs and Microsoft's MSAL docs. Bearer tokens, token exchange, refresh rotation — none of that was invented here.

Posted by at

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)