Shows
Never RewriteEpisode 103: Recognizing When a Rewrite is FailingIsaac and Jeffrey discuss the challenges and signs of failing rewrites in software development.2025-05-0920 minNever RewriteEpisode 101: Relief vs. CureJeffrey and Isaac explore the complex trade-off between providing immediate relief for software issues versus investing time and resources into finding a permanent cure. They discuss the implications of these choices on customer satisfaction, business budgets, and the overall health of software systems. Through real-world examples, they illustrate how sometimes quick fixes can be more practical than ideal solutions, emphasizing the importance of understanding the context and priorities of a business.2025-04-2515 minNever RewriteEpisode 100: Detecting B.S. as a Non-Technical FounderIsaac, Dustin, and Jeffrey discuss the challenges faced by non-technical founders when working with developers. They explore issues of trust, communication, and the importance of iterative development. The discussion emphasizes the need for clear frameworks in product development, the significance of addressing technical debt and security concerns, and how to identify red flags in developer behavior. The conversation concludes with advice on balancing survival and enhancement in development and the importance of having technical expertise in-house.2025-04-1830 minNever RewriteEpisode 98: DOGE's Social Security Rewrite - Killing Americans to Save MoneyIsaac Askew and Jeffrey Sherman discuss DOGE's proposed rewrite of the Social Security system, focusing on the implications of transitioning from COBOL to a modern programming language like Java. They explore the motivations behind the rewrite, the challenges of legacy code, the potential role of AI, and the human cost of possible failures. The conversation culminates in predictions about the outcome of the rewrite and the impact on millions of Americans relying on Social Security.Show Notes:Wired Magazine article referenced: https://www.wired.com/story/doge-rebuild-social-security-administration-cobol-benefits/2025-04-0432 minNever RewriteEpisode 97: Fulfilling Friday - A Tattoo Scam?Isaac tells a 'fulfilling Friday' story about how he gained the attention of a famous tattoo artist. He just needed to act quickly and send money to secure the appointment...2025-03-2817 minNever RewriteEpisode 96: Inverting the Testing Pyramid - Testing Infrastructure Changes ft. Rob GonnellaIsaac Askew and Jeffrey Sherman discuss the complexities of testing infrastructure changes with guest Rob Gonnella. They explore the importance of building a robust testing infrastructure, the role of different types of tests, and the challenges faced when transitioning to new systems. Rob shares his experiences in developing local testing environments, engaging developers, and identifying bugs through end-to-end tests. The conversation emphasizes the need for a balanced approach to testing, particularly when making significant infrastructure changes.2025-03-2117 minNever RewriteEpisode 94: What Did You Think You Were Saying Yes To?Jeffrey and Isaac explore the motivations and expectations surrounding software rewrites from various stakeholders, including developers, IT leadership, product groups, marketing, finance, support, and customers. They discuss the perceived benefits and the reality of rewrites, emphasizing that while many believe rewrites will lead to improved reliability and a better work environment, the truth is that rewrites often fail to deliver on these promises.2025-03-0726 minNever RewriteEpisode 93: How to Put Work Down When Priorities ChangeIsaac and Jeffrey discuss the complexities of managing work priorities in a constantly changing environment. They explore the challenges of putting work down when priorities shift, emphasizing the importance of iterative development and smaller work increments to minimize risk and maintain productivity. The discussion also touches on the balance between delivering features and building trust with users, particularly in the context of product releases that may impact customer satisfaction.2025-02-2819 minNever RewriteEpisode 92: A Framework for Prioritizing Tech Debt ft. Dustin ReaWe're joined today by Dustin Rea to discuss frameworks for prioritizing technical debt in software development. We explore the 'Jobs to Be Done' framework, emphasizing the importance of aligning engineering and product teams on customer needs. The conversation covers strategies for managing tech debt effectively, the significance of team dynamics, and the role of technical leadership in guiding prioritization efforts.2025-02-2117 minNever RewriteEpisode 91: Pushing Pain to UsersIsaac Askew and Jeffrey Sherman discuss the implications of externalizing costs in software development, particularly the consequences of pushing pain to users. They explore the differences between internal and external software, the importance of customer experience, and the cost of support when users face difficulties. The discussion highlights the ethical considerations of prioritizing features over user satisfaction and the long-term impact on both customers and developers.2025-02-1414 minNever RewriteEpisode 90: The Hero and the LifeguardIsaac Askew and Jeffrey Sherman explore the dynamics between two types of developers: the 'hero' who swoops in to solve problems and the 'lifeguard' who encourages self-sufficiency. They discuss the tension that arises from these differing approaches and how to navigate conflicts between them. The conversation emphasizes the importance of balance in mentoring and the need for developers to understand when to guide and when to let others learn through experience.2025-02-0709 minNever RewriteEpisode 89: How Sonos Lost $500 Million Attempting a RewriteIsaac Askew and Jeffrey Sherman discuss the disastrous app rewrite by Sonos, exploring the technical debt, decision-making processes, and the consequences of the rewrite. They emphasize the importance of incremental updates over big bang releases and reflect on the lessons learned from this case.
Show notes:
https://www.wsj.com/tech/sonos-speakers-app-ceo-24250f2c
https://www.linkedin.com/pulse/what-happened-sonos-app-technical-analysis-andy-pennell-wigwc/2025-01-3124 minNever RewriteEpisode 88: Creating a Culture of Continuous Improvement with Guest Erik EngeErik Enge, COO of Ghost, discusses the principles of creating a culture of continuous improvement within organizations. He emphasizes the importance of applying the scientific method in business, setting measurable goals, and maintaining a learning loop to reflect on outcomes. The discussion also covers the significance of collaboration within teams, the risks associated with rewriting code, and the necessity of keeping context in software development. Real-world examples illustrate how these principles can lead to better decision-making and improved outcomes.
https://www.linkedin.com/in/erikenge/
https://ghost.org/2025-01-2423 minNever RewriteEpisode 87: 2025 Update - State of AI ProgrammingIn this conversation, Isaac and Jeffrey discuss the advancements of AI in coding, reflecting on its potential to replace junior developers and the evolving role of developers in the tech industry. They explore the implications of AI tools on productivity, the necessity for developers to adapt their skills, and the future landscape of software development as AI continues to improve.2025-01-1717 minNever RewriteEpisode 86: Annual Reminder - Prune Your MeetingsIsaac and Jeffrey discuss the importance of reassessing the necessity of meetings, especially at the beginning of the year. They emphasize the need to cancel unnecessary meetings, optimize meeting structures, and empower team members to decline meetings that do not require their input. The conversation highlights the significance of effective communication and time management in the workplace.2025-01-1008 minNever RewriteEpisode 85: 2024 Year In ReviewIsaac and Jeffrey reflect on their podcast journey throughout 2024, discussing their goals, achievements, and notable episodes. They share insights on their recording process, the impact of AI on their discussions, and the concept of 'musketeering' in problem-solving. The hosts also highlight their listener engagement and growth, expressing gratitude for their audience's support and outlining plans for the future.2025-01-0326 minNever RewriteEpisode 84: The Impact of AI on InterviewingSpecial guest Paul Giron discusses the transformative impact of AI on the interview experience, highlighting changes in candidate assessment, the shift towards remote interviews, and the evolving expectations of candidates. The discussion delves into the implications of AI in recruitment, including potential biases and the need for organizations to adapt their interview processes to attract top talent.
Paul's contact information:
https://www.linkedin.com/in/paulpgiron/
paul@g-techrecruitment.com2024-12-2719 minNever RewriteEpisode 83: The Impact of AI on RecruitingSpecial guest Paul Giron discusses the transformative impact of AI on recruiting and interviewing processes. He highlights the challenges faced by recruiters in adapting to AI tools, emphasizing that while AI can streamline resume sorting, it does not necessarily improve the quality of hires. The discussion also touches on the importance of understanding high performers within organizations and how structured interviewing can enhance recruitment outcomes. Ultimately, the conversation reflects on the need for organizations to invest in training recruiters to leverage AI effectively and improve hiring practices.
Paul's contact information:
https://www.linkedin.com/in/paulpgiron/
paul@g-techrecruitment.com2024-12-2033 minNever RewriteEpisode 82: Can You Like Tests And Also Believe You're Faster Without Them?Isaac and Jeffrey discuss the balance between unit testing and the need for speed in software development. The discussion delves into the contexts in which testing is most valuable, the challenges of rapid development, and real-world examples of testing practices. Ultimately, they emphasize the importance of adapting testing strategies based on the specific project and team dynamics.2024-12-1321 minNever RewriteEpisode 81: The Pause'The Pause'—a critical juncture where development on the old system is halted in favor of completing a new system. Isaac and Jeffrey discuss the inherent risks of this approach, the implications for customer value, and the often misguided desire for dramatic reveals in software releases. The conversation emphasizes the importance of maintaining continuous value delivery and offers strategies to avoid the pitfalls associated with pausing development.2024-12-0611 minNever RewriteEpisode 80: What is "De-Risking"?Isaac and Jeffrey delve into the concept of de-risking in project management. They discuss the importance of iterative delivery over big bang releases, using gambling analogies to illustrate risk management strategies. The conversation emphasizes the value of decoupling projects to reduce risk and the significance of obtaining feedback early in the development process. The hosts highlight how these strategies not only mitigate risks but also provide opportunities for value delivery and informed decision-making throughout the project lifecycle.2024-11-2912 minNever RewriteEpisode 79: The Toxicity of "Certainty"Isaac and Jeffrey explore the concept of certainty in software development and its potential toxicity. They discuss how certainty can lead to poor decision-making, the importance of experimentation, and the human behaviors that contribute to toxic environments. The dialogue emphasizes the need for a balance between certainty and uncertainty, particularly in leadership roles, and highlights the dangers of strong opinions that masquerade as certainty.2024-11-2218 minNever RewriteEpisode 78: Is Frontend Modernization a Valid Reason for Rewriting?Isaac and Jeffrey discuss the validity of rewriting front-end systems for modernization. They argue against the notion that a dated front end necessitates a complete rewrite, emphasizing the importance of iterative updates and customer experience. The conversation explores the risks of big bang rewrites, the benefits of gradual improvements, and the need for design consistency while still delivering value to customers. Ultimately, they advocate for a more thoughtful approach to modernization that prioritizes user experience over aesthetic uniformity.2024-11-1515 min
Never RewriteEpisode 77: Who Gets To Define 'Shit' Code?Isaac and Jeffrey explore the subjective nature of coding standards and what constitutes 'shit code.' They discuss the lack of industry-wide standards, the importance of intention in coding, and the balance between flexibility and adaptability in code quality. The conversation also touches on the fluidity of language and how it parallels coding practices, emphasizing that coding standards should evolve with the context and needs of the project.2024-11-0815 min
Never RewriteEpisode 76: Aligning Your Company Standards to its Lifecycle PhaseGuest Dustin Rea joins us to discuss the importance of aligning a company's standards and processes with its lifecycle stages. The discussion covers five key phases: the MVP phase, where the foundation is built; the Product User Fit phase, focusing on understanding customer needs; the Product Market Fit phase, solidifying the offering; the Scaling Up phase, managing growth; and finally, the Multi-Product Platform phase, where companies expand their offerings. Each phase presents unique challenges and requires different approaches to maintain quality and efficiency.2024-11-0124 min
Never RewriteEpisode 75: Rewriting is Gambling - A Lesson in RiskJeffrey and Isaac discuss the inherent risks associated with software rewrites, emphasizing how rewrites push risk to the end of the development cycle. The discussion highlights the need for iterative development and the significance of delivering independent components to ensure project success, particularly within the SaaS model, which thrives on continuous improvement and customer satisfaction.2024-10-2516 min
Never RewriteEpisode 74: MusketeeringJeffrey and Isaac explore the concept of 'musketeering' in software development, emphasizing the importance of collaboration in solving complex problems. They discuss the challenges of legacy code, the necessity of testing, and the strategy of 'divide and conquer' to tackle intertwined issues effectively.2024-10-1811 min
Never RewriteEpisode 73: The Politics of Delivering Trivial ChangesIsaac and Jeffrey discuss the philosophy of continuous iteration in software development, emphasizing the importance of making small, incremental changes rather than large, risky updates. They explore the challenges of communicating the value of these trivial changes to non-technical stakeholders and the benefits of refactoring code for future development. The discussion also highlights the significance of storytelling in conveying the purpose and impact of these changes to a broader audience.2024-10-1112 min
Never RewriteEpisode 72: Perfectionism in ProgrammingIsaac and Dustin Rea discuss the impact of perfectionism in programming, particularly how it can hinder project success. They explore the importance of launching minimum viable products (MVPs) to validate ideas in the market, the challenges of managing change in production software, and the balance between perfectionism and practicality. The discussion also highlights the significance of team dynamics and customer empathy in software development, as well as lessons learned from scaling and responding to customer demands.2024-10-0426 min
Never RewriteEpisode 71: Are Ignorable Errors Still "Errors"?Isaac and Jeffrey explore the complexities of error management in software development, particularly focusing on the significance of logs, the philosophical implications of ignoring errors, and the importance of proactive log management. They discuss how to differentiate between true errors and warnings, the role of telemetry in alerting, and the necessity of maintaining clean logs to enhance system understanding and customer experience.2024-09-2712 min
Never RewriteEpisode 70: Resource EngineeringIsaac and Jeffrey delve into the concept of resource engineering, emphasizing the importance of understanding cost implications in engineering decisions. They discuss how engineers often overlook financial aspects while focusing on technical solutions, leading to potential inefficiencies. The dialogue highlights the need for engineers to have greater visibility into costs, particularly in cloud services like AWS, and how this awareness can drive better decision-making. They also explore the balance between optimizing costs and developing new features, advocating for a more business-oriented mindset among engineers to enhance overall effectiveness.2024-09-2022 min
Never RewriteEpisode 69: Anxiety When Fixing a System You Didn't CreateIsaac and Jeffrey delve into the anxiety developers face when dealing with legacy systems they did not create. They explore the reasons behind the fear of fixing such systems, the challenges of refactoring, and the skills required to navigate these situations. The discussion emphasizes the importance of understanding legacy code, learning from it, and developing strategies to reduce anxiety when approaching refactoring tasks. Practical tips are provided for developers to build confidence and make meaningful contributions to legacy systems.2024-09-1317 min
Never RewriteEpisode 68: The Fallacy of Rewriting Software to Save MoneyJeffrey and Isaac discuss the fallacy of rewriting software to save money. They highlight that organizations end up running multiple systems simultaneously, resulting in increased costs. The conversation also touches on the challenges of maintaining multiple versions of a software system and the importance of continuous delivery and iteration. It concludes by emphasizing the need to prove the ability to migrate existing pages before starting a rewrite.2024-09-0617 min
Never RewriteEpisode 67: Revisiting "The Joel Test: 12 Steps to Better Code"Jeffrey revisits The Joel Test, a 12-question test to determine if a software development team is set up for success. Jeffrey and Isaac discuss the relevance of each question in today's context and how the industry has evolved over the years. The topics covered include source control, building and deployment processes, bug tracking, bug fixing, project scheduling, specifications, working conditions, and tools.2024-08-3038 min
Never RewriteEpisode 66: Squashing the Right BugsIsaac and Jeffrey discuss the importance of effective bug bashing and how to prioritize bug fixes. They highlight the need for categorizing bugs, understanding customer impact, and installing analytics to make informed decisions. They also emphasize the importance of writing tests and having a team member close to the customer to provide context. They recommend starting with backlog grooming and prioritization before diving into bug fixing. Overall, the conversation provides valuable insights for managers and developers dealing with bug backlogs.2024-08-2323 min
Never RewriteEpisode 65: Exploring Different Perspectives on Risk with Dustin ReaIsaac, Dustin, and Jeffrey discuss different profiles for de-risking releases. They explore the perspectives of software engineers, project managers, product owners, and executives in managing risk. They debate the benefits of incremental releases versus giant functionality releases and the importance of user feedback in de-risking product changes. They also discuss the trade-offs between time, size, and change in managing risk. The conversation touches on the challenges of balancing risk and reward, the importance of lean strategies in startups, and the need to be prepared for success as well as failure.2024-08-0919 min
Never RewriteEpisode 64: Aligning Yourself With the Company's Risk ProfileIsaac and Jeffrey discuss the importance of aligning oneself with a company's risk profile. They explore the concept of risk tolerance and how it varies depending on the company's stage of development and industry. They highlight the need for a balance between security and other business priorities, as well as the importance of having conversations about risk tolerance with managers and teams. They also touch on the potential misalignment between managers and companies, and the implicit cultural risk tolerance that can lead to security vulnerabilities. Overall, they emphasize the need for understanding and navigating risk in the context of software...2024-08-0216 min
Never RewriteEpisode 63: Fulfilling Friday: SMS Spamming SavedIsaac shares a story about a project where a quick MVP was built to send text messages to users. As the project gained more partners and volume, it became clear that the system couldn't handle mass texting at scale. A small change in the architecture caused some batches of text messages to be reprocessed multiple times, resulting in some users seemingly receiving an excessive number of texts. However, through many strokes of luck, each area where duplicate texts could have been sent was saved by a downstream setting. The issue was resolved, and the team learned the importance of implementing...2024-07-2616 min
Never RewriteEpisode 62: The Peculiar Failure of Correctly Predicting ProblemsIsaac and Jeffrey discuss the peculiar failure of correctly predicting problems. Jeffrey shares his experience of being able to accurately predict problems in projects but failing to gain traction and prevent them. They explore the importance of buy-in from leadership and the need for a collaborative engagement structure. They also discuss the role of consultants and the difference between being diagnostic and being collaborative. The conversation highlights the challenges of convincing leadership and the potential consequences of not being able to prevent problems.2024-07-1918 min
Never RewriteEpisode 61: Challenges of Multi-Product Platforms ft. Dustin ReaDustin Rea, CEO of Red Hook Agency, discusses the challenges and considerations of bringing new products into an existing platform and splitting products within the same platform. The conversation covers topics such as authentication and authorization, merging different products onto a platform, reorganizing teams, and converting internal tools to SaaS. The speakers also touch on the importance of onboarding experiences for new and existing customers.2024-07-1222 min
Never RewriteEpisode 60: Anybody Could Have Done It...But I Actually DidIsaac and Jeffrey discuss the feeling of anyone being able to make small, simple changes in code and question the value of their own contributions. They share anecdotes of fixing issues that others could have easily addressed but didn't, highlighting the importance of being the one to take action. They emphasize the value of iterative changes and the knowledge work involved in understanding the system. They also encourage developers to listen to complaints and pain points in order to identify opportunities for impactful improvements.2024-07-0512 min
Never RewriteEpisode 59: The Myth of the Boy Scout RuleIsaac and Jeffrey discuss the myth of the Boy Scout rule, which is the idea of leaving code better than you found it. Isaac shares his experience of encountering problems when trying to follow this rule in a codebase with no test coverage. He explains how fixing one issue led to unintended consequences and a cascade of errors. They emphasize the importance of being cautious when making changes in old and tightly coupled code and the need for thorough testing. They conclude that while refactoring is important, it should be done intentionally and not mixed with other changes.2024-06-2817 min
Never RewriteEpisode 58: When You Can’t IterateIsaac and Jeffrey discuss situations where software development teams are pushed to have fewer, larger releases. They highlight the challenges of big release-driven development and the need for careful planning and more QA before each release. They also explore strategies to make the problem less severe, such as minimizing the final push, using an API-first strategy, and feature flagging.2024-06-1421 min
Never RewriteEpisode 57: White Label CRM Updates with Dustin ReaWe check in with Dustin Rea, head of Red Hook Agency, to discuss where White Label CRM is with their 'turnaround story' - how they're handling 'bug hell', scaling issues, and what their trajectory is now.2024-06-0732 min
Never RewriteEpisode 56: AI-Driven TestingIsaac and Jeffrey discuss the potential of AI-driven testing and code generation. They reference an article by Codium AI, which explores the use of AI to generate tests and increase code coverage. While the generated tests may not be perfect, they can serve as scaffolding for legacy code and help identify areas for improvement. The conversation also touches on the idea of using AI to provide business context and legal compliance guidance during code refactoring. Overall, the discussion highlights the potential benefits of AI in improving code quality and reducing risk.2024-05-3124 min
Never RewriteEpisode 55: Writing Your Job Out Of ExistenceIsaac and Jeffrey discuss the mindset of writing your job out of existence. They explore the idea that being irreplaceable can be a trap and that making your current role disappear in a positive way is the key to career growth. They share examples of individuals who get stuck in repetitive tasks and fail to see the opportunity to transform their work. The conversation highlights the importance of reframing problems as opportunities for improvement and the need to overcome the fear of change. They also touch on the issue of intentionally not fixing problems to protect one's job.2024-05-2413 min
Never RewriteEpisode 54: Shadow Your ColleaguesJeffrey and Isaac discuss how to get started with shadowing people and solving their problems. They share their experiences and strategies for shadowing, including reaching out to the people you want to shadow, observing their tasks, and identifying areas for improvement. They emphasize the importance of shadowing during the onboarding process and the value of asking questions and challenging existing processes. They also highlight the benefits of building relationships and earning credibility by solving problems for others.2024-05-1714 min
Never RewriteEpisode 53: Cloud Infrastructure "Rewrites"Isaac and Jeffrey discuss the topic of doing full rewrites when it comes to architecture. They explore a case where a client needed to move from a single EC2 instance to a more stable system with load-balanced instances. They discuss the parallels between rewriting code and rewriting architecture, and the challenges and risks involved.2024-05-1016 min
Never RewriteEpisode 52: The Two-Clock ProblemIsaac and Jeffrey discuss the 'two clock problem' as a metaphor for software rewrites. They explain that adding a new system doesn't improve understanding if you don't know how the current system is wrong. They also emphasize that rewriting a system without understanding the current system is costly and may not be worth it. Instead, they suggest spending more time understanding and documenting the current system to mitigate the need for a rewrite.2024-05-0310 min
Never RewriteEpisode 51: How Company Culture Impacts Code DeliveryCompany culture can have a significant impact on the style of code delivery. A rigid and bottlenecked code review process can slow down code delivery and create frustration. On the other hand, a collaborative and open culture can lead to faster and more efficient code delivery. It is important to strike a balance between code quality and speed of delivery. Perfect code that doesn't solve the problem is not useful, while imperfect code that is easy to change and improve can be valuable. When considering a job, it is important to ask about the company's code delivery style and whether...2024-04-2628 min
Never RewriteEpisode 50: Fulfilling Friday - Saving Customers MillionsIn our new series 'fulfilling Fridays', Jeffrey shares a fulfilling software project he worked on at Guaranteed Rate, a mortgage broker company.2024-04-1920 min
Never RewriteEpisode 49: Falsehoods Programmers Believe About Projects Part 2Isaac and Jeffrey discuss falsehoods that programmers believe about projects. They explore the misconception that the project will solve the stated problem, highlighting instances where the delivered software did not actually solve the problem. They also discuss the importance of understanding how the user will use the software and the need for clear communication and feedback loops to ensure that the project is on track. They emphasize that the success of a project is not solely determined by the software, but also by factors such as the alignment of project goals and the availability of resources. Overall, they highlight the...2024-04-1226 min
Never RewriteEpisode 48: Falsehoods Programmers Believe About ProjectsIn this episode, Isaac and Jeffrey discuss falsehoods that programmers believe about projects. They explore assumptions such as projects having defined beginnings and endings, the role of priorities in project work, and the importance of clear communication and feedback. They also touch on the challenges of working on successful projects that transition into ongoing maintenance and the consequences of failed projects that continue to exist. The conversation highlights the need for programmers to question these assumptions and adapt their approach to project management.2024-04-0518 min
Never RewriteEpisode 47 - Maintenance Work as a Flight to Safety - A Manager's PerspectiveIsaac and Jeffrey discuss the flight to maintenance work as a safety option from the manager's perspective. They explore different perspectives on maintenance work and the value of taking on such work. They emphasize the importance of understanding the reality of the system and approaching maintenance work as an opportunity to solve real problems. They also discuss the role of accountability and changing the culture around maintenance work. The episode concludes with a discussion on the impact of not addressing maintenance work and the benefits of going slow to go fast.2024-03-2920 min
Never RewriteEpisode 46: Workshopping Live with Dustin ReaIn this conversation, Dustin Rea discusses the challenges faced by one of his clients who has a CRM. The CRM is built on a legacy codebase with issues in quality, scalability, and deliverability. The team has been working on improving the system, but there are still problems with emails, SMS, payments, and automations. The company is mission-driven and relies on the CRM to run their business, so rebuilding customer trust is crucial. They have made some improvements in infrastructure and email deliverability, but there is still work to be done. The conversation covered several topics related to database architecture and...2024-03-2236 min
Never RewriteEpisode 45 - Year In ReviewIsaac and Jeffrey celebrate the one-year anniversary of the podcast. They discuss the challenges of maintaining a consistent schedule and reflect on the evolution of topics covered in the past year. They also talk about running out of failure stories and the importance of finding interesting guests. The hosts discuss the concept of forcing functions for successful rewrites and the risks associated with rewrites. They also explore the idea of the Ship of Theseus and how it relates to software development. Lastly, they discuss how rewrites can discourage learning about the current system. In this episode, the hosts discuss various...2024-03-1534 min
Never RewriteEpisode 44 - Do More With LessJeffrey and Isaac discuss the concept of ‘doing more with less.’ They explore the initial visceral reaction to this idea and highlight the importance of doing less of things that don't matter. The impact of layoffs and the need to work smarter, not harder, are also discussed. The hosts emphasize the value of having honest discussions and creating a culture of transparency. They caution against burnout and advocate for trimming the fat responsibly. The episode concludes with a reminder to acknowledge mistakes and continuously learn.2024-03-0815 min
Never RewriteEpisode 43: Rewriting in the Age of AIJeffrey and Isaac discuss their stance on 'never rewriting' given the possibility of AI making rewriting faster, cheaper, and less risky. They explore the limitations of current AI capabilities and the potential benefits of AI-assisted refactoring. The conversation delves into the idea of using AI to write tests and improve code quality. They also discuss the challenges and opportunities of AI in language switching and high-performance code optimization. Overall, the episode highlights the evolving role of AI in the rewriting process and the potential impact it may have on software development in the future.2024-03-0120 min
Never RewriteEpisode 42: Iteration as a Defense From MicromanagementJeffrey and Isaac discuss how iteration can be a defense against micromanagement. They explore the reasons behind micromanagement, such as a lack of progress and fear, and how iteration provides observability and reassurance to managers. They emphasize the importance of breaking down nebulous projects into smaller deliverables and providing checkpoints to show progress.2024-02-2311 min
Never RewriteEpisode 41: Rewrites from a Manager's Perspective with Ryan CowanIn this episode, Isaac Askew interviews Ryan Cowan, a software engineering manager, about the perspective of managers on rewrites. They discuss the challenges of placating individual engineers who want to rewrite code, the role of managers in supporting engineers' ideas, and the frequency and success of large rewrites. Ryan shares a case study of data engineers rewriting a data pipeline and highlights the importance of understanding the root cause of concerns before deciding on a rewrite. They also discuss the difference between refactoring and rewriting and the expectations engineers have from their managers.2024-02-1634 min
Never RewriteEpisode 40: Convincing Emotionally-Committed Colleagues It's Not Worth ItIsaac and Jeffrey provide strategies for working with colleagues who are emotionally committed to rewriting old and flawed code at their companies.2024-02-0915 min
Never RewriteEpisode 39 - Project Risk with Jonathan StarkJonathan Stark joins as a guest to discuss the risks of hourly billing and the parallels between risk in a rewrite and in hourly billing.2024-02-0248 min
Never RewriteEpisode 38 - Maintenance Work as a Flight to SafetyIsaac and Jeffrey explore the significance of maintenance work for developers, stressing its strategic value during uncertain periods like layoffs. They share personal experiences, highlighting how tackling these tasks can lead to trust, new opportunities, and a more impactful role within a team.2024-01-2623 min
Never RewriteEpisode 37: Interview Insights - Changing the Game for Interviewers and CandidatesIsaac and Jeffrey dissect the flaws in the interviewing process and offer valuable insights for both interviewers and interviewees. They discuss the broken aspects of traditional interviews, highlight the importance of resume tailoring, and share anecdotes about handling past job experiences during interviews. The episode serves as a guide for interviewers to improve the hiring process and for candidates to enhance their chances by navigating the pitfalls and maximizing opportunities.2024-01-1945 min
Never RewriteEpisode 36: Becoming an Expert in your Company's BusinessJeffrey & Isaac discuss why understanding how your company makes money can help you build products that solve the right problems.2024-01-1230 min
Never RewriteEpisode 35: The Subtle Art of Refusing MeetingsJeffrey & Isaac discuss methods to clear out your recurring meetings and protect your time as new meetings get added to your calendar.2024-01-0520 min
Never RewriteEpisode 34: (F*ck-Up Friday Series) Don’t Fix What Ain’t BrokenContinuing our F*ck-Up Friday series, Jeffrey has another humorous story where he went out of his way to fix functionality to match the name of its function...with expensive results.2023-12-2908 min
Never RewriteEpisode 33: How to be a Terrible TeammateIn this humorous holiday episode, Isaac and Jeffrey discuss ways to be the worst possible teammate in ways that won’t get you immediately terminated by HR. If you didn’t make the naughty list this year and want to lock it in next time, this episode is for you!2023-12-2213 min
Never RewriteEpisode 32: Getting Started with Brownfield Testing (Part 2)Isaac and Jeffrey continue discussions around testing brownfield code, delving deeper into next steps and refactoring.Our ‘FlowSheet’ guide to help you with your testing and refactoring decisions: https://images.squarespace-cdn.com/content/v1/64127dab7e53173c1e7c39a1/9d699636-4625-4fc3-862c-a66907fd47dc/Getting+Started+With+Brownfield+Code.png?format=2500w2023-12-1517 min
Never RewriteEpisode 31: Getting Started with Brownfield Testing (Part 1)Brownfield code is existing code (rather than new code) that you might need to add tests for. Join us for a two-part episode on how to get started testing and refactoring existing applications.2023-12-0815 min
Never RewriteEpisode 30: Investing in Yourself Beyond EducationIsaac and Jeffrey discuss ways to improve yourself outside of traditional means like college, courses, or reading.2023-12-0128 min
Never RewriteEpisode 29: (F*ck-Up Friday Series) The Saleswoman Who Faked CancerA non technical story of deception, good deeds with terrible consequences, and weak HR.2023-11-2408 min
Never RewriteEpisode 28: Making Non-Compatible Changes During Long-Running UpgradesSometimes an upgrade to a new version of a framework takes weeks or even months. What do you do when you need to make changes to areas that are being affected by the upgrade?2023-11-1613 min
Never RewriteEpisode 27: The Ticket Master - Computerizing India’s Railways with Aadil Farid, Part 2Special Guest Aadil Farid joins us again to continue his discussion on the harsh realities he confronted when he led a team that computerized ticketing on India’s Railways in the 1980s.2023-11-0939 min
Never RewriteEpisode 26: The Ticket Master - Computerizing India’s Railways with Aadil Farid, Part 1Special Guest Aadil Farid joins us to discuss the harsh realities he confronted when he led a team that computerized ticketing on India’s Railways in the 1980s.2023-11-0326 min
Never RewriteEpisode 25: A Rewrite Success Story with Brian Genisio from Khan AcademySpecial guest Brian Genisio from Khan Academy joins us to talk about their 3.5 year rewrite that successfully wrapped up this year. Learn how Brian’s team was able to achieve the nearly impossible act of successfully completing a rewrite using many of the techniques we’ve talked about in the past, plus some brand new ones! If you want to learn about what it takes to do a rewrite, buckle up!2023-10-2636 min
Never RewriteEpisode 24: When AI Writes Your DocumentationAI tools can now write your incident retrospectives. Do developers lose by not formalizing their thoughts by writing? In this episode Isaac and Jeffrey weigh the pros and cons of having AI write incident retrospectives and documentation.2023-10-2019 min
Never RewriteEpisode 23: Live Workshop with Rob GonnellaSenior DevOps Engineer Rob Gonnella joins us in this special episode to live workshop an example of a rewrite case he believes is valid.2023-09-2234 min
Never RewriteEpisode 22: Running an Iterative Refactoring WorkshopJeffrey has been running an iterative refactoring workshop to improve his colleague’s development skills. This episode dives into how the workshop is run, what the developers get out of it, and how it directly improves the company’s codebase. If you’ve ever wanted to help your fellow developers but didn’t know how to start, this show is for you!2023-09-1424 min
Never RewriteEpisode 21 - Impostor SyndromeIn this episode Isaac defines impostor syndrome and ways to combat the feelings that you aren't qualified for your job.2023-09-0839 min
Never RewriteEpisode 20 - Shrink ModeSometimes companies shrink instead of grow, and that impacts your work, your team, and your career. In this episode we discuss what to expect from a shrinking company.2023-09-0130 min
Never RewriteEpisode Nineteen - The Beachhead StrategyJeffrey identifies a strategy we employed in a previous project that helped us dramatically improve the experience of 90% of our customers without requiring a complete rewrite of an email sending engine.2023-08-2516 min
Never RewriteEpisode Eighteen - Strategies for Upgrading SoftwareIsaac discusses strategies he's used to help companies upgrade their software, and Jeffrey helps distill them into a series of steps.2023-08-1235 min
Never RewriteEpisode Seventeen (F*ck-Up Friday Series) - Losing $1 billion for 4 hoursIn this episode Jeffrey discusses a f*ck-up of his own for this special 'F*ck-Up Friday' series - how a develop lost $1 billion (just for a little while).2023-07-2818 min
Never RewriteEpisode Sixteen - Tricks to Facilitate ConversationJeffrey suggests using a straw man to help facilitate difficult conversations about how to proceed; Isaac adds further examples and methods by which teams can generate productive conversations.2023-07-2112 min
Never RewriteEpisode Fifteen - Red Flag Development IdeasIn this episode Jeffrey brings up red flag development ideas that should make you second guess whether or not you're making the right decision for your product.2023-07-0722 min
Never RewriteEpisode Fourteen - How do you define ‘Minimum Viable Product’?In this episode Isaac and Jeffrey discuss the concept of a product MVP and misconceptions around what a 'minimum viable product' has to be.2023-06-2926 min
Never RewriteEpisode Thirteen - Transitioning from Microservices to Monolith with Josh BeckmanJosh Beckman is our guest in this episode where we talk about his experience in successfully transitioning multiple micro services back into a monolith - and why it was the right decision.2023-06-1544 min
Never RewriteEpisode Twelve - Company Culture Pt. 2 with Thomas MorrisIn this episode we re-visit the talks about company culture, this time with guest speaker Thomas Morris.2023-06-0741 min
Never RewriteEpisode Eleven - You Can’t Build to SpecIn this episode Jeffrey talks about an old manager who never seemed to be content with his deliverables, even if he met the acceptance criteria exactly. Isaac adds more to the conversation around managers that are too strict versus managers that are too aloof.2023-06-0125 min
Never RewriteEpisode Ten - The Rewrite CycleIn this episode Jeffrey and Isaac discuss the common phases of a rewrite cycle, and how iteration eliminates complexity.2023-05-2426 min
Never RewriteEpisode Nine (F*ck-Up Friday Series) - How Our Customers Got Raided by the FBIIn Episode 9 we start our first of many 'F*ck-up Fridays', where we talk about an interesting or crazy thing that has happened to a company we've worked at. Today Isaac talks about an early startup he worked for that ultimately failed after its customers were raided by the FBI.2023-05-1926 min
Never RewriteEpisode Eight - Transforming your Internal Software into a SaaS with Brian BegyBrian Begy is a guest in this week's episode. Brian shares his experience with companies that have attempted to transform software built for internal processes to using and selling it as a service.2023-05-1131 min
Never RewriteEpisode Seven - RiskJeffrey brings up the concept of risk in this episode, tying it back to our previous conversation with guests Nathan Keyes and Colleen Grafton in Episode 4 where we discussed their project 'Nozomi'.2023-05-0320 min
Never RewriteEpisode Six - How Company Culture Makes Or Breaks Your TeamIn this episode Isaac and Jeffrey discuss patterns they've seen in both highly performant and poorly-performing teams - how team culture is shaped, how overall company culture helps shape it, and why trust is one of the most important drivers of great teams.2023-04-2751 min
Never RewriteEpisode Five - Perverse IncentivesJeffrey introduces the concept of 'perverse incentives' for rewriting - reasons for rewriting that are pushed not for a better product or for the customer, but for the benefit of the engineer or the manager responsible for the project.2023-04-1919 min
Never RewriteEpisode Four - NozomiIn this episode Isaac and Jeffrey invite Colleen Grafton and Nathan Keyes to talk about a shared experience of a rewrite gone wrong - and what to learn from it.2023-04-1344 min
Never RewriteEpisode Three - Why You Hate TestingIn this episode Isaac talks about his early experience understanding the importance of testing, and reflects on three distinct reasons why testing seems to be hated by developers.2023-04-0829 min
Never RewriteEpisode Two - Iteratively ReplaceIn this episode we provide an alternative to rewriting a codebase from scratch: iteratively replacing bits of functionality over time.2023-03-2216 min
Never RewriteEpisode OneIn our pilot episode of “Never Rewrite”, we discuss what we mean when we tell developers to never rewrite code. Isaac reflects on what drives engineers to rewrite, and Jeffrey adds some real-world analogies involving baseball and New York stadiums.2023-03-1624 min