All Segments
Martin Fowler - Software Design in the 21st Century
33 segments available
Recorded on 2/28/2019
Segments Timeline
Etsy's Learning Culture
The introduction highlights Etsy's commitment to a learning culture, emphasizing the collaborative environment where engineers and product managers support each other. The speaker invites attendees to engage with the company, showcasing their open-source initiatives and hiring opportunities, reflecting the values of sharing knowledge and continuous improvement.
"hi everyone hi I make for sure I'm the CTO here at Etsy and so if you're in the back again we have an overflow space you'll be much more comfortable yeah so I'm go ahead and make your way over there i..."
Introducing Martin Fowler
Rebecca Slider, a senior engineering manager at Etsy, introduces Martin Fowler, expressing her excitement about his influence on software development. She discusses the importance of refactoring and how it resonates with engineers, framing coding as a craft that requires ongoing learning and improvement.
"and so now Rebecca is slider is gonna come up she's one of our amazing engineering managers and to be honest this all happens because of her she finds the speaker she sets up the events she does every..."
The Challenge of Writing a Second Edition
Martin Fowler discusses the complexities of writing a second edition of his influential book on refactoring. He reflects on the fear of disappointing readers and the challenge of updating content to remain relevant in a rapidly evolving industry, emphasizing the ongoing need for understanding refactoring among new developers.
"Fowler thank you so I use the title software oops I should put my mic on should Marcus I won't be here we'll hear me in the other room I mean I can easily fill this room with my voice getting over the..."
Refactoring: A Timeless Topic
Fowler explains why refactoring remains a crucial topic in software development. He shares insights from discussions with colleagues about the necessity of teaching refactoring to new developers, highlighting the importance of keeping the subject matter current and accessible.
"done but after a while a book begins to look old and people who are coming into the profession sort of look at this and say is this book still relevant and not and that maybe not so much of an issue b..."
From Video Stores to Theatrical Companies
In this segment, Fowler introduces a new example for his book, transitioning from a video store scenario to a theatrical company performing plays. He explains how this updated context will help illustrate the principles of refactoring in a more relatable manner for contemporary audiences.
"host it on a download if you go to the link there now you'll see a nice little link saying download the first chapter for free so you don't even have to buy the book so for the example in the original..."
The Importance of Code Structure
Fowler discusses the significance of code structure in software development, particularly in large systems. He introduces the concept of 'code smells' and emphasizes the need for well-structured code to facilitate easier maintenance and refactoring, setting the stage for practical examples.
"I mean that's just an example right so so much will fit on the screen and then when our company of players goes and carries out a performance they capture the details of the performance with this data..."
Function Length and Code Smells
In this segment, Fowler elaborates on the idea of function length as a code smell. He shares his personal standards for function length and explains how breaking code into smaller, well-named functions can enhance readability and maintainability, ultimately leading to better software design.
"because I can only talk about a piece of code so big in a book or in front of people but it'll give you a feel for it you'll notice it if you know anything at all that this is in JavaScript this is of..."
Highlighting Code Semantics
Fowler illustrates the importance of semantic clarity in code through an example from Smalltalk. He discusses how naming conventions and function clarity can impact code understanding, reinforcing the idea that well-structured code leads to better software development practices.
"spend some time refactoring this code if you've only got a lump of code that size it doesn't really matter whether it's well structured or not what you've got to do is imagine this is part of a large ..."
Refactoring with Extract Function
Fowler explains the 'extract function' refactoring technique, which involves taking a piece of code and encapsulating it within a new function. He highlights the importance of managing local state and ensuring that the refactoring does not alter the overall behavior of the code.
"very rare obviously because you can usually get it in a word or so and that can be really critical I don't know how many times that has really helped me because when you do need to change the implemen..."
The Art of Small Changes
Fowler emphasizes that refactoring should consist of many small changes that collectively lead to significant improvements. He discusses how these incremental changes maintain the code's functionality while enhancing clarity and structure.
"thing but you were using the names to reinforce the fact you don't have to be in an object-oriented language to do this extract function is really very simple it's really a case of in essence taking t..."
Maintaining Code Behavior During Refactoring
In this segment, Fowler outlines the principle that refactoring should not change the observable behavior of the code. He stresses the importance of being able to deploy code at any point during the refactoring process without introducing errors.
"gives us what we need to do now in some languages this can actually be done completely automatically in Java for instance there are excellent IDs that will do extract method just like that you just ha..."
The Importance of Naming Conventions
Fowler discusses the significance of consistent naming conventions in code. He shares his personal coding conventions and the importance of aligning with team standards to enhance code readability and maintainability.
"observable behavior one of the nice consequences of this is at any point in refactoring you can stop you're never broken you could I could commit this deploy send it into production I've not broken an..."
Choosing Meaningful Variable Names
Fowler elaborates on the practice of renaming variables to improve clarity. He shares his approach to naming conventions and the importance of ensuring that variable names accurately reflect their purpose within the code.
"weird name so the next refactoring I'm gonna do is rename variable because I'm very keen to rename things when I don't seem to be communicating accurately and renaming variable is very straightforward..."
Avoiding Abbreviations in Code
In this segment, Fowler advises against using abbreviations in variable names, emphasizing the need for clarity. He discusses his personal conventions for naming parameters in dynamically typed languages and the importance of consistency in coding practices.
"now if I was on a team with Bob what would be the thing to do we would have to come up with a convention between us that we would both live with if I'm on a team with somebody else I said what's your ..."
Replacing Temporary Variables
Fowler introduces the 'replace temp with query' refactoring technique, which involves eliminating temporary variables to simplify code. He explains how this approach can facilitate breaking down large blocks of code into more manageable functions.
"of code I'll be reluctant to abbreviate here let's go back and look and see what it where it's being used okay so it's okay it's the it's the performance that we're looping through in the quaint littl..."
Refactoring Temporary Variables
Fowler explains his approach to handling temporary variables in large blocks of code. He advocates for replacing temporary variables with functions to improve code readability and facilitate refactoring, introducing the 'replace temp with query' refactoring technique.
"convention you pick your own conventions that work for you but be consistent about it and I find it's very helpful cuz it allows me to see what types I have so I'll do that and then I look at play so ..."
Performance Considerations in Refactoring
In this segment, Fowler addresses concerns about calling functions multiple times during refactoring. He highlights the importance of avoiding side effects and emphasizes that performance should be measured and profiled rather than assumed, advocating for clear and understandable code first.
"so I'm going to use their olfactory called replace temp with query which basically means I'm going to replace that temporary variable with a function initially and the first step is just extract funct..."
The Discipline of Performance Optimization
Fowler stresses the need for a disciplined approach to performance optimization. He advises against premature optimization and encourages developers to focus on clear code structure first, suggesting that performance improvements should be based on profiling results rather than assumptions.
"as you can and that's one of the configs and if you looked at replaced temp with query it would point out the fact you've got to make sure there's no side effects the other question is performance and..."
Combining Refactorings for Clarity
Fowler discusses the process of combining multiple refactorings to enhance code clarity. He explains how extracting methods and inlining variables can simplify code, making it easier to understand and maintain while also preparing it for future enhancements.
"optimizations than if you've got big blobs of code instead people I know who are serious on performance and I know some very serious performance people they stress the fact make your code clear unders..."
Minimizing State in Function Calls
In this segment, Fowler emphasizes the importance of minimizing state passed around in functions. He explains how reducing temporary variables and using function calls can lead to cleaner code, ultimately enhancing maintainability and reducing complexity.
"combination of two refactorings there was the one to extract new method followed by the in line and that is often the case you build bigger refactorings on top of smaller ones in a sequence so that ge..."
The Role of Comments in Code
Fowler critiques the use of comments in code, suggesting that excessive comments often indicate overly complex code. He advocates for writing clear code that minimizes the need for comments, while acknowledging that comments can be useful when clarity is not achieved.
"going over it faster now because you've already seen it worse notice something else that I did here is I got rid of the comment I did have somebody tweet saying hey you made a mistake in your book you..."
Refactoring for Different Outputs
Fowler discusses the benefits of refactoring code to separate concerns, particularly when adapting code for different output formats, such as HTML. He illustrates how clear function separation can facilitate future enhancements and adaptations.
"function I prefer to explicitly declare them in this way and of course that's another piece of data I'll get rid of in the process that's a style thing more than anything else I know some people who r..."
Introducing Split-Phase Refactoring
In this final segment, Fowler introduces the concept of split-phase refactoring, a technique that divides computation into two distinct steps. He explains how this approach can lead to clearer code and better organization, drawing parallels to compiler design.
"of extra functions but we've also got something else interesting what's happened notice a difference between the code that's been shoved into those functions and the code that's remaining in the state..."
Extracting Functions for Clarity
In this segment, Fowler demonstrates a simple yet effective refactoring technique by extracting a statement function to create space for a new data structure. He explains how this small step can lead to significant improvements in code organization and clarity.
"the idea to split-phase refactoring is you've got some lump of computation and you divide it into two steps and you send a data where the first step produces a data structure that you then pass to the..."
Enriching Data Structures
Fowler elaborates on the process of enriching data structures during refactoring. He discusses how to load performance data into the new structure, emphasizing the importance of separating data handling from rendering to improve code maintainability.
"small it's not worth doing it's a simple extract method it hasn't done anything useful but what it does is it gives me the room gives me to space to introduce a data structure and this data structure ..."
Separation of Concerns in Refactoring
Fowler explains the benefits of separating calculation logic from rendering logic in code. He highlights how this separation allows for easier modifications in the future, enabling developers to change one aspect of the code without affecting the other.
"as much as you can separate the needs of things to know about data the better then we can continue I need to take the performances and I need to load them up with all the information that's needed to ..."
The Calm of Continuous Refactoring
In this segment, Fowler discusses the philosophy of continuous refactoring, where small, incremental changes are made without altering the overall behavior of the program. He emphasizes the importance of maintaining a safe coding environment through frequent commits and testing.
"function that creates the statement data and has all of the calculation code in it I have one function that renders the statement in plain text given the data and one function that just assembles the ..."
The Purpose of Refactoring
Fowler answers a question about the primary purpose of refactoring, stating that it aims to make code easier to understand and modify. He explains that refactoring is essential for delivering features quickly and efficiently, allowing developers to focus on small changes without needing to grasp the entire codebase.
"safe space if you have them cause things too right I mean the usual cycle is you do the refactoring you run your test suite if it's green you carry on if it's red if you can immediately spot what you'..."
The Impact of Refactoring Tools
Fowler shares his insights on how automated refactoring tools have changed the approach to code refactoring. He discusses the efficiency these tools bring, allowing developers to extract functions and rename variables with ease, ultimately speeding up the refactoring process.
"much thank you was a good question to ask so I should have said that even without the question I'm gonna try the same title trick but I don't think my abstracts will get accepted the same way so one r..."
Gradual Refactoring Techniques
In this segment, Fowler explains the nuances of changing function signatures and the importance of taking small, manageable steps during refactoring. He discusses the benefits of wrapping functions and inlining them later, showcasing how automated tools facilitate this process.
"across a quite large body of code and you don't even have to think about it you go I'll stick that naming does that name look right maybe not let's change it again to do that without tools you can do ..."
When to Refactor vs. Rewrite
Fowler addresses the critical decision-making process between refactoring existing code and opting for a complete rewrite. He emphasizes the importance of understanding which features are truly utilized and how a rewrite can simplify and enhance the software's functionality.
"I suppose one difference is if you've got very gnarly code and you have a tool that has very strong refactoring capabilities you can see if that does alter the way you do some of the refactorings beca..."
The Skill of Refactoring
Fowler underscores the significance of mastering refactoring as a core skill for software developers. He shares his personal approach to coding, which involves continuous refactoring, and draws parallels between programming and writing, highlighting the iterative nature of both processes.
"because often with a larger system or a larger program you actually don't use half the features or in the original so you when you rewrite it you want to actually get rid of all those features that ar..."
Learning Through Collaboration
In this segment, Fowler discusses the value of learning from others in the programming community. He advocates for pair programming as a method to discover new patterns and improve skills, emphasizing that collaboration accelerates learning and enhances understanding of software design.
"things to begin with so many of the patterns that you showed it could in fact be the way you implement things start so how does that oh oh well I mean I reflect to write for the beginning anyway I mea..."