All Segments
I Interviewed Uncle Bob
51 segments available
Recorded live on twitch, GET IN ### Uncle Bob https://x.com/unclebobmartin http://cleancoder.com/register ### My Stream https://twitch.tv/ThePrimeagen ### Best Way To Support Me Become a backend engineer. Its my favorite site https://boot.dev/?promo=PRIMEYT This is also the best way to support me is to support yourself becoming a better backend engineer. MY MAIN YT CHANNEL: Has well edited engineering videos https://youtube.com/ThePrimeagen Discord https://discord.gg/ThePrimeagen Have something for me to read or react to?: https://www.reddit.com/r/ThePrimeagenReact/ Kinesis Advantage 360: https://bit.ly/Prime-Kinesis Hey I am sponsored by Turso, an edge database. I think they are pretty neet. Give them a try for free and if you want you can get a decent amount off (the free tier is the best (better than planetscale or any other)) https://turso.tech/deeznuts
Segments Timeline
Meet Uncle Bob: The Programming Legend
Uncle Bob, also known as Robert Martin, introduces himself and shares his extensive programming background, spanning over 50 years. He discusses his experience with various programming languages, including Assembly, C, Fortran, and Java, and highlights his current work in Clojure. As a co-author of the Agile Manifesto and author of 'Clean Code,' Uncle Bob's insights are invaluable for anyone in the software development field.
"okay so today we are joined right here by Uncle Bob the Robert Martin himself how you doing I'm well thank you why don't you give like a kind of an introduction to who you are so anyone that doesn't k..."
The Journey to Clojure
Uncle Bob recounts his transition to Clojure, sparked by a book recommendation he received 20 years ago. He describes how 'The Structure and Interpretation of Computer Programs' captivated him and changed his perspective on programming languages, particularly Lisp. This segment explores the challenges and revelations he faced while embracing a functional programming paradigm.
"also signed the original agile Manifesto 2003 February 131 February 2001 yes that's true we were all there together yep 17 us I just have to ask how did you get to closure because I I did read that ar..."
The Simplicity of Lisp Syntax
In this segment, Uncle Bob discusses the simplicity of Lisp and Clojure's syntax, emphasizing that the lack of complex syntax allows for greater expressiveness in programming. He contrasts this with more traditional languages, explaining how the minimalistic approach can be both liberating and challenging for programmers accustomed to more structured syntax.
"what's the name of the book again can you say the name one more time the structure and interpretation of computer programs which you can get for free nowadays it's sip. org I think okay I don't think ..."
Creating Your Own Language in Lisp
Uncle Bob elaborates on the idea that programming in Lisp allows developers to create their own unique languages. He explains how the sparse syntax enables programmers to express their problems creatively, leading to a more personalized coding experience. This segment highlights the flexibility and power of Lisp as a programming language.
"hickey off and on for for long years cuz he used to debate on the C++ uh news groups back when there were news groups uh and I saw his work on closure and I thought I'm gonna get this language I'm gon..."
The Double-Edged Sword of Expressivity
Uncle Bob discusses the dual nature of Lisp's expressivity, where the lack of syntax can lead to both innovative solutions and potential pitfalls. He reflects on the freedom it provides while cautioning that this freedom requires discipline to avoid chaotic code. This segment emphasizes the balance between creativity and structure in programming.
"myself so the the syntax of lisp and therefore closure is so absurdly simple that there is no syntax uh barrier to cross and there there's almost no syntax to the language so the most startling thing ..."
The Importance of Design Patterns
In this segment, Uncle Bob addresses the relevance of design patterns in modern programming. He notes a shift in focus away from traditional design patterns and discusses the implications of this change. Uncle Bob argues for the continued importance of design patterns in facilitating clear communication and understanding among developers.
"expressive because you're not constrained by this big syntax Iron Curtain that drags around you all the time yeah but you have freedom to kill yourself so so that does that mean because I've heard thi..."
Clean Code Principles in Clojure
Uncle Bob explains how the principles outlined in his book 'Clean Code' apply to Clojure programming. He emphasizes the need for discipline in a language that offers so much freedom and discusses how maintaining clean, expressive code is achievable in Clojure. This segment reinforces the connection between clean coding practices and effective programming.
"but there's no other way to say that okay okay I I think I I think I understand what you're trying to say if if I were to resay that it sounds like you're trying to say that the language allows you to..."
Interoperability with Java
Uncle Bob discusses Clojure's interoperability with Java, highlighting how it allows developers to leverage existing Java libraries and frameworks. He explains the benefits of this seamless integration and how it enhances the functionality of Clojure, making it a versatile choice for developers familiar with the Java ecosystem.
"in does does it have a concept of interface yes it does uh you can have polymorphic interfaces there's like three different ways to do that uh since closure rides on top of the Java stack you can actu..."
The Evolution of Programming Languages
In this segment, Uncle Bob reflects on the evolution of programming languages and the impact of new languages like Go and Rust. He discusses how these languages have influenced modern programming practices and the importance of adapting to new paradigms while retaining foundational principles like clean code.
"work in go I mean go is essentially C with a couple of widgets uh attached onto it and and uh very easy to do clean codish like things in in any language that's derived from C and any of the C style l..."
Reviving Design Patterns in Modern Development
Uncle Bob advocates for the revival of design patterns in contemporary software development. He argues that understanding and applying design patterns can enhance communication among developers and improve code quality. This segment emphasizes the timeless relevance of design patterns in creating robust software solutions.
"permanent Pro Pearl programmer the the triple P all right so let's get kind of into some more the the fun stuff so the general goal here today is that I'm not trying to make this into some sort of deb..."
The Programming Demand Surge
Uncle Bob discusses the exponential growth in the number of programmers over the last 50 years, emphasizing how this surge has made it challenging to maintain consistent thought leadership in the field. He highlights the overwhelming influx of new ideas and the difficulty of keeping up with the rapid changes in programming paradigms.
"years the same it's the same effect and and the effect is that the demand for programmers is so large that the number number of programmers in the world doubles every five years or so and there's no w..."
Reviving Design Patterns
In this segment, Uncle Bob stresses the importance of design patterns in modern software development. He argues that foundational concepts, like those found in the design patterns book, should not be forgotten amidst the influx of new programmers, as they provide essential frameworks for understanding and discussing code.
"sense one of the things I try to do is yell out enough so that people remember some of these things and bring them back into the present so that they can look at them and go oh there are these things ..."
The Power of Abstraction
Uncle Bob explains how design patterns serve as a means to communicate complex structures in programming. By naming these patterns, developers can engage in more intelligent discussions about code, allowing for a shared understanding that enhances collaboration and problem-solving.
"do do you think that a lot of modern software can have the same benefit with these design patterns uh because I I'll I'll tell you like personally I I pretty much am a strategy pattern guy right I thi..."
Concrete vs. Abstract Thinking
This segment explores the balance between concrete coding and abstract design. Uncle Bob shares his approach of starting with concrete implementations and allowing abstractions to emerge naturally as the code evolves, contrasting it with the tendency to reach for abstractions prematurely.
"go line by line by line by line yes okay no I mean it's a very good answer because you know we often have a lot of data structures or algorithms if I say hey this is a general tree you already know wh..."
When to Abstract in Coding
Uncle Bob discusses the nuanced decision-making process involved in determining when to introduce abstractions in code. He emphasizes the importance of context and intuition, sharing insights on how to recognize when a piece of code needs to be abstracted for clarity and maintainability.
"um but one thing can I say it this way that a lot of times what I see is that when people kind of are really into this because remember Netflix was a ja a large Java shop was there for a long time and..."
Learning from Past Mistakes
Reflecting on his earlier experiences, Uncle Bob shares lessons learned from over-abstracting in programming. He highlights the pitfalls of creating overly complex systems and the importance of staying grounded in practical coding practices.
"is that some people or your suggested ways to like kind of design all things and you kind of create the abstractions and think about the structure of your code before you start coding is that correct ..."
The Role of UML in Software Design
In this segment, Uncle Bob reminisces about the days of UML (Unified Modeling Language) and its initial promise to streamline software design. He critiques the limitations of UML, emphasizing that while it can be useful, it often fails to capture the dynamic nature of software development.
"think about it and then I will then I will enter it if the problem is large enough then I will do that and then I go right for the most concrete thing I can and then I I have the problem force me to b..."
Agile Manifesto Reflections
Uncle Bob reflects on the evolution of the Agile Manifesto since its inception. He expresses concern over how its original intent has been distorted over the years, advocating for a return to its core principles focused on small teams and effective collaboration.
"decision um for me it's a kind of feel thing as I'm working in the code I look at it and I I get this itchy feeling in in some part of my face or gut and I think oh man that's going to kill me later o..."
The Impact of Scrum on Agile
Discussing the rise of Scrum, Uncle Bob recounts how the introduction of the Certified Scrum Master course shifted the Agile landscape. He critiques the commercialization of Agile practices and how it diverged from the original vision of the Agile Manifesto.
"careful okay have you ever have you ever had a situation let's kind of keep on going with this whole message thing right you're coming up with some sort of custom protocol that's going to have a vario..."
The Cost of Abstraction
Uncle Bob elaborates on the costs associated with using abstractions in programming. He warns that while abstractions can simplify code, they can also introduce complexity and maintenance challenges if not applied judiciously.
"forced out of the concrete world you know that's it's it's funny it's funny you should say that because I I often you know I we have enough people hanging around here I don't know where we're at right..."
Navigating Software Design Challenges
In this concluding segment, Uncle Bob shares insights on navigating the challenges of software design. He emphasizes the importance of adaptability and learning from past experiences to improve future coding practices.
"generally I I generally don't feel like I have to think hard in the sense that whenever I give a problem I just know the structure I want it to be and that is usually good for what I know what the inp..."
The Flaws of Early Software Development
Uncle Bob reflects on the pre-agile era of software development, sharing his experience of spending six months on diagrams that ultimately led to a failed program. He emphasizes the inefficiency of this approach and sets the stage for discussing the evolution of agile methodologies.
"is before agile before the agile Movement we used to think that you should spend weeks and weeks on those diagrams get the diagrams right first and then the code will just pour out well that never wor..."
The Agile Manifesto: A Reflection
As a signatory of the Agile Manifesto, Uncle Bob discusses the misinterpretation and evolution of agile practices over the past 23 years. He expresses concern about how the original intent of agile has been distorted, leading to a focus on project management rather than team collaboration.
"agile that's that's pretty a a pretty kind of a Hot Topic here um how do you feel because you obviously signed the original you're one of the signatories or whatever they call whatever word they use t..."
The Rise of Scrum and Its Impact
Uncle Bob recounts the introduction of the Certified Scrum Master course by Ken Schwaber and how it shifted the focus of agile from programming to project management. He explains how this change led to programmers feeling sidelined in the agile movement.
"agile was a small idea for helping small teams do small things it was not the overarching pattern of software development that was to dominate the world it was just a way to get six or seven guys to b..."
Defining Proper Agile Practices
Uncle Bob outlines the core principles of agile, emphasizing the importance of short cycles and measuring productivity. He critiques the rigid structures that have emerged around agile, advocating for flexibility and team autonomy in implementing agile methodologies.
"not one programmer wanted to be a certified scrum master all the project managers wanted it they wanted that little checkbox on their resume and the project managers flooded into the field they floode..."
The Chaos of Over-Structured Agile
Discussing the pitfalls of overly structured agile practices, Uncle Bob warns against imposing uniform processes across teams. He argues that true agile should allow teams to operate independently, fostering creativity and adaptability rather than chaos.
"generally that date is so terrifying that people are like oh maybe we've got to do something about this early enough to actually get something done okay um so so there there's so proper agile has no d..."
Convincing Organizations to Embrace Agile
Uncle Bob shares his experiences in advocating for agile practices within organizations. He discusses the challenges of changing entrenched behaviors and the importance of fostering a culture that values individual team decisions over rigid frameworks.
"a lot more detail but that's just an extension on top of agile okay I I mean I like this topic a lot we don't have a ton of time so I don't want to I don't want to linger here too long but I mean to m..."
The Challenge of Introducing Agile
Uncle Bob reflects on the difficulties of introducing agile concepts into organizations that are heavily influenced by scrum practices. He shares insights on how to effectively communicate the benefits of agile to management and teams.
"days a week for everybody you know we do this we do this we do this like how do how do you say no no no no let those three people make their own determination let those five over there make their own ..."
Function Size and Code Readability
Uncle Bob discusses his philosophy on function size in programming, advocating for smaller, more manageable functions. He explains how this approach enhances readability and maintainability, while also addressing concerns about code complexity.
"yelling loud and Publishing a lot uh but when I get into an individual company it's very very difficult what what will happen to me is that I will wind up leaving that company with one or two people w..."
Navigating Code Reviews with Small Functions
In this segment, Uncle Bob addresses the challenges of code reviews when working with numerous small functions. He shares strategies for maintaining clarity and understanding in code, emphasizing the importance of function naming and organization.
"yeah yeah again mine mine is completely irrational so I'm not saying that you have to have rationality described this is just my feeling punch card width so that's rational 80 columns we've been livin..."
Structuring Functions for Readability
Uncle Bob elaborates on his approach to structuring functions within a class. He prefers to order functions based on their call hierarchy, allowing for a more intuitive reading experience. This method helps developers grasp the flow of the program without needing to navigate through unrelated functions.
"anything in your head because you're constantly going here and you're constantly going there but that is a smell that's a symptom that's not that doesn't follow from the the process of breaking things..."
Learning from Experience
Uncle Bob reflects on the learning curve in programming, suggesting that developers often need to make mistakes to understand the intricacies of clean code. He emphasizes the importance of being considerate in coding practices to avoid creating 'rude' code that complicates the work of others.
"very difficult but I but I difficult yes yes that's why I'm just like man I don't know if I could I don't know if I could do that uh I I generally have a a different a slightly different ordering but ..."
The Role of Comments in Code
In this discussion, Uncle Bob critiques the use of comments in code, arguing that they often introduce accidental complexity. He advocates for reducing unnecessary complexity and stresses the importance of writing clear, self-explanatory code that minimizes the need for comments.
"person coming right so any kind of code that forces someone to puzzle it out or leap around is rude it's rude code and I don't like my code to be rude I want it to be polite do you think that there I ..."
Test-Driven Development Insights
Uncle Bob shares his thoughts on Test-Driven Development (TDD), recounting a successful experience with TDD in a past project. He discusses the challenges of applying TDD in unfamiliar situations and how it can be beneficial when the problem is well understood.
"zero as you can get it okay I like to Rite a nice a nice 100% accidental complexity line it just feels good job security um all right all right how about how about tdd so I've I I've been I've gone ba..."
The Complexity of New Problems
In this segment, Uncle Bob addresses the difficulties of writing tests for new and complex problems. He explains his approach to TDD, emphasizing the importance of understanding the problem before writing tests, and how this can lead to more effective development practices.
"all that because there was no zooming this was just a web app and a canvas and so we just you know we invented our own math there and so we did all that it was a lot of fun um but if you touch the scr..."
Double Entry Bookkeeping in Coding
Uncle Bob likens Test-Driven Development to double-entry bookkeeping, where every line of code is accompanied by a corresponding test. He explains how this practice helps ensure code correctness and reduces the risk of introducing bugs during development.
"about it is that I only know so much and most of the time I don't get the information that I need it's like hey let's do something we've never done before I don't even know what the enemy looks like y..."
The Importance of Test Suites
Uncle Bob discusses the significance of having a comprehensive suite of tests that instills confidence in code deployment. He shares his philosophy on testing, emphasizing the need for thorough coverage to facilitate safe refactoring and deployment.
"development is it's double entry bookkeeping it is a way for me on a minute by minute basis to be sure that I have not done something so globally stupid that it'll cost me three hours of debugging tim..."
Trusting Your Tests
In this concluding segment, Uncle Bob reflects on the relationship between test coverage and confidence in code quality. He argues that while achieving 100% code coverage is unrealistic, striving for high coverage is essential for maintaining trust in the testing process and ensuring reliable deployments.
"kind of doing this back and forth on it sure that happens all the time so why not just start with your base implementation first there's another another reason that I want I'm very curious by the way ..."
The Myth of 100% Code Coverage
In this segment, Uncle Bob challenges the notion of 100% code coverage, arguing that it can be misleading. He explains that while aiming for high coverage is beneficial, it should not be quantified, as it can create a false sense of security. He emphasizes the need for a trustworthy test suite to facilitate fearless refactoring.
"there's not bugs in it right like I just I'm just like there's probably bugs like I just simply don't know what I don't know and so even though all things are green I'm highly confident I've screwed s..."
Refactoring with Confidence
Uncle Bob elaborates on the significance of having a reliable test suite that allows for confident refactoring. He shares his experiences of working with trustworthy tests that enable him to make significant changes to the codebase without fear, contrasting it with situations where tests cannot be trusted.
"do you try to test every line try try to test it first of all I agree with you I don't want to number on it uh any kind of number you put on that is is a lie uh but I think that you're also you're alw..."
Design Principles in Testing
This segment focuses on the design principles that should guide testing practices. Uncle Bob discusses the importance of writing tests that do not couple to the implementation, aiming for modularity so that changes in one area do not affect others. He stresses that effective design minimizes the number of tests that break when requirements change.
"code if I have a suite of tests that I can trust so I have lived in the world the other world I have lived in the world where the suite of tests can't be trusted right and there's no point in running ..."
The Role of Abstraction in Testing
Uncle Bob shares his perspective on abstraction in code and testing. He argues that while abstractions can introduce unnecessary complexity, they are essential for maintaining a flexible system. He discusses the balance between minimal abstraction and the need for interfaces that facilitate easier modifications.
"change yes so that this is something you learn over a long period of time when you're doing test driven development you have to write your tests in such a way that they don't couple to the implementat..."
Managing Dependencies in Code
In this segment, Uncle Bob addresses the challenges of managing dependencies in code. He explains how having too many dependencies can lead to design problems and emphasizes the importance of controlling the number of dependencies between modules to ensure maintainability and ease of change.
"problem so you internalize a developer well so you have a requirements change how many tests should break if the requirements change and the answer is one if you can get there it's not always easy to ..."
Testing Philosophy: Direct vs. Indirect
Uncle Bob discusses his philosophy on testing, advocating for indirect testing over direct tests for trivial code. He explains that while all code should be tested, not every line needs direct tests, especially for simple functions. He references Kent Beck's principle of testing only what could possibly break.
"of dependencies between modules that's I wrote another book about that called clean architecture but don't you by but but that if you do that you also introduce natural abstraction that doesn't techni..."
Error Handling in Programming
This segment delves into error handling strategies in programming. Uncle Bob contrasts exception handling with error codes, discussing the implications of each approach on code clarity and state management. He shares his preference for exceptions while acknowledging the complexities they introduce.
"I'm very Pro or I'm very pro- anti- abstraction I'm not sure I probably should just say anti- abstraction I try to very minimally abstract my code when possible all right so that we began this by sayi..."
The Value of Integration Testing
Uncle Bob emphasizes the importance of integration testing, explaining that it should focus on data flow and interactions between components rather than individual business rules. He discusses the balance between unit tests and integration tests, advocating for a strategic approach to testing that aligns with system complexity.
"mean that you can't mitigate it and by the way also when you get bit by that you have the opportunity then to make sure you don't get bit by it again because the most likely thing to change is the thi..."
Business Rules and Integration Tests
In this concluding segment, Uncle Bob clarifies the relationship between integration tests and business rules. He argues that while integration tests may touch on business rules, their primary goal should be to validate data flows and interactions, rather than exhaustively testing every business rule.
"testing directly I don't mind indirect tests you know for example I don't write tests for my Getters and Setters that's stupid right but I do write tests for the functions that call the Getters and se..."
The Role of Experience in Software Development
Uncle Bob reflects on the importance of experience in software development, sharing that making mistakes is a crucial part of learning. He discusses how understanding principles comes from real-world experience rather than just theoretical knowledge, highlighting the journey of becoming a better developer.
"flows okay okay I've got unit test okay so you you just do more like does the system continue to operate I asked for a piece of data it did return this type out we're good enough is that kind of what ..."
The Importance of Continuous Learning
In this segment, Uncle Bob encourages viewers to keep learning and to read widely, even materials they may not agree with. He shares a personal anecdote about a book that changed his perspective, emphasizing the value of maintaining an open mind and a commitment to lifelong learning in the field of software development.
"thing a system architect does they trying to Plum out the way the whole system functions how do you feel about Golden F I see I see that a lot in integration tests like a bunch of uh golden files bein..."
Writing and Programming Insights
Uncle Bob discusses his current work, including a book he is writing about the history of ancient programmers. He shares insights into his writing process and the challenges of creating content without automated tests, drawing parallels between programming and writing.
"didn't cover and you don't even know what those conditions are yeah so you get a false sense of security now if that's all you got okay that's all you got but uh I would not start a system uh and and ..."
Final Thoughts and Farewell
As the interview wraps up, Uncle Bob shares final thoughts on the importance of understanding the complexities of software systems. He expresses gratitude for the conversation and encourages viewers to continue exploring and learning in their programming journeys. The segment concludes with a light-hearted exchange and a farewell.
"covered am I 100% certain no am I relatively certain to a high degree yes golden standard doesn't give you that because the golden standard is way too far out at the at the user interface there's too ..."