Podcasts about refactoring

Twintig jaar lang hard groeien, vijftien FD Gazelles binnenslepen en dat met exact núl managers op de loonlijst. Maak kennis met het bijzondere groeiverhaal van Nmbrs.Deze aflevering in het kort: ☑️ Hoe Nmbrs al 20 jaar plust zonder middenkader☑️ Waarom diepe domeinkennis cruciaal is voor een succesvol SAAS-bedrijf ☑️ Remy Gieling over het businessmodel van TolarianMichiel Chevalier komt uit een echt ondernemersgezin. Via een rechtenstudie rolde hij het HR-vak in, eerst door letterlijk zelf de salarisstroken te vouwen. Nmbrs transformeerde hij van externe personeelsafdeling tot een modern SaaS-platform. Hij vertelt hoe verouderde HR- en salarissystemen, gebouwd door en voor salarisadministrateurs, de kiem leggen voor een radicaal andere aanpak: cloud, gebruiksgemak en samenwerking tussen medewerkers, managers en dienstverleners. AI verandert ondertussen het product van binnenuit. Nmbrs bouwt al sinds 2007 aan AI-toepassingen en voegt nu een slimme agent toe die repetitieve taken automatiseert, zoals het verwerken van verkeersboetes of het doorvoeren van salarisverhogingen voor hele organisaties.

There's a term that's been on our minds a lot recently - refactoring.It's a computer programing that essentially refers to the idea of restructuring, and optimizing source code to improve the efficiency of software while persevering the intent and overall functionality.In this episode of The Offset Podcast, we want to extend that idea to postproduction businesses - most of which (ours included) could use some streamlining, added efficiency, automation, and in general, improvement on all things related to the business.    Specific topics covered include:Refactoring pre-sales & sales Improving the onboarding processGaining efficiencies in technical and operations workflowBringing the refactoring concept to creative approachUnderstanding the idea of taking a step backwards to take two steps forwardAnd more!    Check out offsetpodcast.com for our entire library of episodes. You can also follow us on Instagram & Facebook - just search for The Offset Podcast.  You can also watch this episode on YouTubeBe sure to like and subscribe to the podcast wherever you found it and be sure to check out our growing library of episodes.  If you like the podcast it'd mean the world to us if you'd consider supporting the show by buying us a cup of virtual coffee -https://buymeacoffee.com/theoffsetpodcastSee you in about two weeks for a new episode.

In questa puntata ci infiliamo fino al collo nel refactoring con gli LLM, partendo dall'ingenua tentazione di dire a Claude "migliora questo codice" e finendo a scoprire che la definizione di Fowler fa acqua da più parti. Ci rendiamo conto che "qualità del codice" è una coperta cortissima fatta di dieci attributi che spesso si pestano i piedi a vicenda, e che migliorarne uno può tranquillamente peggiorarne un altro. Giriamo intorno ai vari approcci di prompting — zero shot, two shot, rule based, step by step, objective based — per scoprire che le regole e gli step vincono quasi sempre, e ci tuffiamo nel paper Mantra che propone un sistema multi-agente dove la storia di Git diventa il miglior training set contestuale possibile. Chiudiamo con un'idea che ci frulla in testa: se lo human in the loop resta la chiave, perché non inchiodare il refactoring come hook alla fine di ogni azione di sviluppo, stile "implementa poi semplifica" delle skill di Osmani.

ContestoEpisodio nato last-minute. L'idea: riprendere un episodio di 5 anni fa e commentare cosa è cambiato da allora. Spoiler: è invecchiato male.Temi principaliDal muratore al guardiano. Nel 2020 si criticava la tendenza a concentrarsi sui dettagli implementativi (cappello del muratore) invece che sul sistema (cappello dell'ingegnere). Oggi il lavoro micro sta sparendo: servono nuovi cappelli, quello dell'addestratore (guidare l'LLM) e quello del guardiano (custodire l'intento).Code review insostenibili. Il codice generato dagli LLM è troppo per essere revisionato riga per riga. Il carico cognitivo non è più sostenibile. Lo "human in the loop" come lo conosciamo potrebbe sparire. Mauro cita Caveman, una skill che fa comunicare l'LLM come un cavernicolo: zero fronzoli, solo fatti.Test come nuova guardia. Luca ha cambiato approccio: prima di tutto scrive test. Se una coverage del 95% si ottiene in 12 minuti con tre prompt, concetti che davamo per assodati vanno ripensati.Qualità del codice ≠ qualità del software. Leggibilità e facilità di modifica erano i parametri per valutare il codice. Ma se un LLM può spiegare e modificare qualsiasi codice, quei parametri perdono rilevanza. La qualità del software (funziona, è efficiente, fa quello che deve) resta.Phoenix Architecture e codice disposable. Il concetto centrale: il codice non è più l'asset da proteggere, l'intento lo è. Scrivere codice costa quasi nulla, comprenderlo diventa costoso. Il codice diventa immutabile: invece di modificarlo, lo riscrivi da zero. Il developer passa da "curare un albero" a "guardiano della foresta".Tracciabilità causale. Manca il collegamento tra specifica → implementazione → evaluation. Mauro immagina un futuro dove passando su un blocco di codice si vede: da quale spec è nato, con quali test/eval è stato validato, cosa ha triggerato l'ultimo cambiamento. Potenziale idea startup: "end-to-end observability dell'agent-driven coding".Skill per il futuro. Capacità di adattamento, comprendere domini diversi, pensare da imprenditori. Mauro vede opportunità nel product management e nel ponte tra digitale e mondo fisico (meccatronica).Paese dei BalocchiCLI Anything (Luca): repository GitHub (31k stelle), collezione di CLI per interagire via AI con programmi come GIMP, LibreOffice, OBS, Zoom, DrawIO"L'Ultimo Programmatore" di Angelo Frascella (Luca): racconto sci-fi pre-2020 dove nessuno sa più leggere il codice tranne una persona"Regenerative Software" dal blog The Phoenix Architecture (Mauro): in un mondo dove generare è abbondante, la cosa più costosa è possedere codice che hai paura di cambiare

Software maintenance is often framed as a technical problem. Refactoring code, fixing bugs, or upgrading dependencies. In this conversation, Robby Russell talks with Rein Henrichs about a different lens, one centered on understanding. Rein is a Principal Software Engineer at Procore, where he works within a large, long-lived system used across the construction industry. Rather than focusing on tooling, Rein emphasizes that well-maintained software is software that makes sense to the people maintaining it. To explain this, Rein introduces the idea of the line of representation, drawing on the work of Richard Cook. Engineers do not interact directly with systems. They rely on representations such as logs, dashboards, and code. These are approximations, not reality, echoing ideas from Plato's Allegory of the Cave. When those representations break down, teams lose shared understanding, what Rein describes as “common ground.” This often shows up as weak signals. Subtle indicators that something is not quite right. They are easy to ignore, but over time they lead to confusion and slower decision-making. Incidents make this especially visible. Rein explains how teams build alignment under pressure, highlighting that the role of an incident commander is coordination, not control. Clear communication matters as much as technical correctness. The conversation also explores how large systems behave in practice. They rarely fail completely. Instead, they degrade in multiple ways at once. While SLOs can help teams respond to customer-facing issues, they do not capture internal clarity or alignment. Rein references W. Edwards Deming to highlight a common trap. Not everything that matters can be measured. High-performing teams often rely on judgment, experience, and shared context. Toward the end, Rein connects these ideas to The Field Guide to Understanding Human Error by Sidney Dekker, challenging the idea that incidents are simply caused by mistakes. Instead, they emerge from the same behaviors that usually lead to success, just under different conditions. For teams working in complex systems, the takeaway is straightforward. Maintaining software depends on maintaining understanding. Links & Resources Procore Rein Henrichs on LinkedIn Concepts & References How Complex Systems Fail – Richard Cook The Field Guide to Understanding Human Error – Sidney Dekker W. Edwards Deming Gerald Weinberg – Secrets of Consulting Referenced in this Conversation Kent Beck: You're Ignoring Optionality and Paying for It Charity Majors: Deploys Are Just the Beginning Heidi Helfand: The Art and Wisdom of Changing Teams Thanks to Our Sponsor! Turn hours of debugging into just minutes! AppSignal is a performance monitoring and error-tracking tool designed for Ruby, Elixir, Python, Node.js, Javascript, and other frameworks. It offers six powerful features with one simple interface, providing developers with real-time insights into the performance and health of web applications. Keep your coding cool and error-free, one line at a time!  Use the code maintainable to get a 10% discount for your first year. Check them out! Subscribe to Maintainable on:Apple PodcastsSpotifyOr search "Maintainable" wherever you stream your podcasts.Keep up to date with the Maintainable Podcast by joining the newsletter.

Zapier is doing hundreds of millions in ARR, has 800 employees, and has more AI agents than people. That ratio isn't an accident. Wade Foster, CEO and co-founder of Zapier, built one of the most capital-efficient software companies in history on less than $1 million in venture funding. When GPT-4 launched in March 2023, he called a company-wide "code red" (a term he'd never used before) and stopped the entire company for a week-long hackathon. What happened next reshaped how Zapier hires, operates, prices its product, and thinks about the future of software. In this episode of Founded & Funded, Karan Mehandru sits down with Wade to unpack: Why ChatGPT didn't trigger urgency at Zapier, but GPT-4 did — and the specific signal Wade used to make that call How Zapier went from 10% AI tool adoption to 90%+ across the company in a single week The pricing overhaul that simplified Zapier's model around task-based usage and why agents made seat-based pricing structurally broken Why Zapier's head of HR became the Chief People and AI Transformation Officer, and what that reveals about who actually leads change inside organizations The "build first, run always" framework Wade uses for deploying AI agents safely inside enterprise workflows For founders and operators navigating their own AI transformation, this is a practical, unfiltered look at what it actually takes from a CEO who's in the middle of it. Full Transcript: https://www.madrona.com/zapier-has-more-ai-agents-than-employees-heres-how-that-happened Chapters:  (00:00) – Introduction (01:44) – Zapier Today: Hundreds of Millions ARR, 800 Employees, More Agents Than People (06:16) – Why ChatGPT Didn't Trigger Urgency — But GPT-4 Six Months Later Did (07:12) – Code Red: Stopping the Entire Company for a Week-Long AI Hackathon (08:00) – How Zapier Moved AI Adoption From 10% to 90% of Employees in One Week (10:11) – Managing the Psychology of Change When Numbers Still Look "Okay" (13:11) – Why Companies in the Middle Ground Face the Hardest AI Transformation Problem (15:01) – From Bottoms-Up Adoption to Systematic ROI: The Two-Phase AI Rollout (17:00) – Why Zapier's Head of HR Became the Chief AI Transformation Officer (19:54) – Refactoring the Legacy Monolith: Writing Code for Agents Instead of Humans (21:25) – Zapier's Pricing Overhaul: Why Task-Based Usage Beats Seat Pricing (23:26) – Why Agents Will Choose What Software to Buy — and What That Does to SaaS (28:03) – The Build-First, Run-Always Framework for Enterprise Agent Governance (29:40) – Wade's AI Hiring War Council: A Multi-Agent System He Built That Morning (34:14) – The Leadership Profile That Thrives When the Job Is Rebuilding, Not Scaling (40:08) – If You're Starting a Company Today, Distribution Is the Bottleneck (42:10) – Why AI Deals Are Hard to Renew and the Rise of the Field Delivery Engineer

Most AI projects look impressive… right until you try to use them in production.A flashy demo? Easy.A scalable, structured, production-ready solution? That's a different game.Over the past year, we've seen teams build incredible AI prototypes in days. But when it comes to:• Maintaining consistent design systems• Avoiding hardcoded chaos• Managing dependencies properly• Creating reusable components• Refactoring for scale• Enabling multiple teams to collaborateThings start to fall apart.That's exactly what we're addressing in our upcoming live session of Leveraging AI with Joanna Stoffregen. She recently published a YouTube walkthrough on building websites with AI that reached 26,000+ viewers. But what makes her approach different isn't the tools.In this session, she'll break down how to move from “vibe coding” and experimentation to production-grade AI solutions, the kind that organizations can actually ship, maintain, and scale.If you're a business leader driving AI initiatives, this conversation is for you. The bottleneck in 2026 isn't access to AI.It's execution discipline.About Leveraging AI The Ultimate AI Course for Business People: https://multiplai.ai/ai-course/ YouTube Full Episodes: https://www.youtube.com/@Multiplai_AI/ Connect with Isar Meitis: https://www.linkedin.com/in/isarmeitis/ Join our Live Sessions, AI Hangouts and newsletter: https://services.multiplai.ai/events If you've enjoyed or benefited from some of the insights of this episode, leave us a five-star review on your favorite podcast platform, and let us know what you learned, found helpful, or liked most about this show!

The difference between a junior and a senior engineer isn't coding speed, it's knowing when to say "no.""The best code you can write is the code you don't write." In this episode, I sit down with Alessandro Mautone (Senior Software Engineer at Aquablu, ex-WeTransfer) to discuss the reality of engineering at a scale-up: how do you maintain technical excellence when the business demands speed?We break down why delivering features "fast" pays your salary, but how to negotiate deadlines so you don't drown in technical debt later. If you want to move from writing code to owning product decisions, this conversation is for you.In this episode, we cover:- How to push back on features and negotiate deadlines without upsetting stakeholders- Why chasing "perfect code" can hurt a company in growth mode- The Generalist vs. Specialist career path: Which one is right for you?- The potential pitfalls of using AI for unit tests without proper oversightTimestamps:00:00:00 - Intro00:01:06 - Balancing Technical Excellence With Delivery Speed00:04:11 - Why Delivering Features Pays Your Salary00:06:51 - The Importance of Ownership and "Skin in the Game"00:08:59 - Leaving WeTransfer: When Company Direction Shifts00:11:49 - The Generalist vs. Specialist Career Path Debate00:16:46 - How to Attract Top Engineering Talent to Your Team00:18:50 - Is LeetCode the Right Way to Hire for Scale-Ups?00:23:16 - Learning to "Say No" is a Sign of Seniority00:25:17 - Negotiating Scope Without Burning Bridges00:26:02 - When AI Generates Bad Unit Tests00:28:14 - Never Compromise on Tests, Even in "Code Red"00:33:59 - Communicating Technical Concepts to Non-Tech Stakeholders00:35:35 - The Never-Ending Battle Against Complexity00:37:26 - When to Build for the Future vs. Ship Now00:42:30 - A Real-World Example of Refactoring for Simplicity00:46:48 - The Skill That Will Be Make or Break for Engineers#SoftwareEngineering #ScaleUp #TechnicalDebt

Cosa succede quando l'idea è giusta, il mercato risponde… ma la tecnologia non regge?In questa puntata di Pionieri del Tech, parlo con Stefano Tazio, CEO e co-founder di Builtdifferent, di una storia che molte startup conoscono fin troppo bene:- MVP costruito in outsourcing- Backend “Frankenstein”- Database che non scala- Migrazione disastrosa- Refactoring totale da zeroParliamo di debito tecnico, internalizzazione del team, errori di comunicazione nel lancio di una 2.0, hype creato troppo presto, migrazione di milioni di record e della scelta di passare a Flutter per ricostruire tutto.E poi affrontiamo il tema che oggi nessuna tech company può ignorare: come integrare l'AI senza farsi sostituire dall'AI.Una conversazione concreta, cruda, reale.Niente storytelling patinato. Solo cosa succede davvero quando fai prodotto.Capitoli:00:00 Intro e il background medico di Stefano Tazio01:22 Validare l'idea con Excel: lo "0 a 1" senza codice02:45 Il bivio dell'Outsourcing e il primo MVP03:50 Frankenstein tecnologico: quando il Low-Code diventa un limite05:15 Rifare tutto: il passaggio a Flutter e database relazionali06:40 Internalizzare il team: perché il codice deve essere tuo08:15 Errori di migrazione e gestione dell'Hype10:30 Consigli per founder: l'importanza del co-founder tecnico12:10 L'AI nel wellness: Human-in-the-loop e nuove feature14:50 Conclusioni e visione futura

Saving American Liberty, Session 8 In this session, Michael O'Fallon argues that contemporary post-liberal and integralist movements, while often presented as moral correctives to modern liberalism, pose significant challenges to pluralism, constitutional governance, and individual liberty. O'Fallon examines how concepts such as distributism and subsidiarity can shift authority away from individuals toward centralized structures claiming to serve the “common good,” and how modern forms of integralism blur the distinction between spiritual and temporal power, raising concerns about dissent and conscience in diverse societies. O'Fallon situates these developments within broader dynamics of social destabilization and reform, noting how periods of cultural conflict and institutional distrust create openings for sweeping structural change. He further explores the evolving role of religious institutions, cautioning that partnerships with political and economic elites risk instrumentalizing faith in support of technocratic agendas. O'Fallon concludes that the convergence of political theory, religion, and technology signals a transition toward more integrated forms of authority that require careful, historically informed scrutiny to ensure they remain compatible with freedom, accountability, and human dignity. Latest from New Discourses Press! The Queering of the American Child: https://queeringbook.com/ Support New Discourses: https://newdiscourses.com/support Follow New Discourses on other platforms: https://newdiscourses.com/subscribe Follow James Lindsay: https://linktr.ee/conceptualjames © 2026 New Discourses. All rights reserved. #NewDiscourses #michaelofallon #Integralism

One of the things I see software developers often talking about is how they refactor code. As they touch a class, method, etc., they may take the time to refactor the code to make it cleaner, perform better, or just add some documentation. It seems that a regular part of a software developer's job is refactoring code in the codebase. That is unless they see a "don't touch this, no idea how it works" comment. There are plenty of those, and often everyone leaves that code alone. Read the rest of Refactoring SQL Code

Pour l'épisode #328 je recevais Antoine Jacoutot. On en débrief avec Adrien.🎙️ Soutenez le podcast If This Then Dev ! 🎙️ Chaque contribution aide à maintenir et améliorer nos épisodes. Cliquez ici pour nous soutenir sur Tipeee 🙏Archives | Site | Boutique | TikTok | Discord | Twitter | LinkedIn | Instagram | Youtube | Twitch | Job Board |Hébergé par Audiomeans. Visitez audiomeans.fr/politique-de-confidentialite pour plus d'informations.

This interview was recorded for GOTO Unscripted.https://gotopia.techAndrew Harmel-Law - Technical Principal at Thoughtworks & Author of "Facilitating Software Architecture"Marit van Dijk - Developer Advocate at JetBrains, Java Champion & Open Source ContributorRESOURCESAndrewhttps://bsky.app/profile/andrewhl.bsky.socialhttps://www.linkedin.com/in/andrewharmellawhttps://andrewharmellaw.github.ioMarithttps://bsky.app/profile/maritvandijk.bsky.socialhttps://linkedin.com/in/maritvandijkhttps://medium.com/@mlvandijkhttps://maritvandijk.comLinkshttps://facilitatingsoftwarearchitecture.comhttps://ruthmalan.comhttps://www.linkedin.com/pulseDESCRIPTIONAndrew Harmel-Law discusses their book "Facilitating Software Architecture" and how traditional architecture approaches often become bottlenecks that slow down high-performing development teams.Rather than architects making top-down decisions in isolation, they advocate for a facilitation approach centered on the "advice process".This collaborative method shifts the architect's role from decision-maker to conversation facilitator. The approach has proven successful even in traditional corporate environments, ultimately creating more maintainable code bases where development teams actually enjoy working and can respond effectively to changing requirements.RECOMMENDED BOOKAndrew Harmel-Law • Facilitating Software Architecture • https://amzn.eu/d/5kZKVfUPsst! The Folium Diary has something it wants to tell you - please come a little closer...YOU can change the world - you do it every day. Let's change it for the better, together.Listen on: Apple Podcasts SpotifyBlueskyTwitterInstagramLinkedInFacebookCHANNEL MEMBERSHIP BONUSJoin this channel to get early access to videos & other perks:https://www.youtube.com/channel/UCs_tLP3AiwYKwdUHpltJPuA/joinLooking for a unique learning experience?Attend the next GOTO conference near you! Get your ticket: gotopia.techSUBSCRIBE TO OUR YOUTUBE CHANNEL - new videos posted daily!

This interview was recorded for the GOTO Book Club.Read the full transcription of the interview here:https://gotopia.tech/episodes/387Prof. Andreas Zeller - Faculty at CISPA Helmholtz Center for Information Security & Author of "The Debugging Book"Clare Sudbery - Independent Technical CoachRESOURCESAndreashttps://bsky.app/profile/andreaszeller.bsky.socialhttps://www.linkedin.com/in/andreaszellerhttps://andreas-zeller.infoClarehttps://bsky.app/profile/claresudbery.bsky.socialhttps://www.madetech.com/podcasthttps://insimpleterms.blogLinkshttps://www.debuggingbook.orghttps://github.com/uds-se/debuggingbookhttps://www.st.cs.uni-saarland.de/ddDESCRIPTIONProgramming education has a critical blind spot: while we extensively teach code creation, we barely scratch the surface of testing and give almost no attention to debugging—despite debugging consuming half of all software development time.In this conversation with Clare Sudbery, Prof. Andreas Zeller argues that systematic debugging skills and modern automated debugging tools are the "ugly stepchild" of programming that nobody wants to discuss, yet debugging represents the biggest business risk and time sink in software development.RECOMMENDED BOOKSAndreas Zeller • The Debugging Book • https://www.debuggingbook.orgSy Brand • Building a Debugger • https://amzn.to/4cWWr84Nora Sandler • Writing a C Compiler • https://amzn.to/3Z6SMhUInspiring Tech Leaders - The Technology PodcastInterviews with Tech Leaders and insights on the latest emerging technology trends.Listen on: Apple Podcasts SpotifyBlueskyTwitterInstagramLinkedInFacebookCHANNEL MEMBERSHIP BONUSJoin this channel to get early access to videos & other perks:https://www.youtube.com/channel/UCs_tLP3AiwYKwdUHpltJPuA/joinLooking for a unique learning experience?Attend the next GOTO conference near you! Get your ticket: gotopia.techSUBSCRIBE TO OUR YOUTUBE CHANNEL - new videos posted daily!

This interview was recorded for the GOTO Book Club.http://gotopia.tech/bookclubRead the full transcription of the interview here:https://gotopia.tech/episodes/389Alessandro Colla - Partner & Head of Development at Evoluzione & Co-Author of "Domain-Driven Refactoring"Alberto Acerbis - Software Architect at Intré & Co-Author of "Domain-Driven Refactoring"Xin Yao - Independent Consultant Contextualizing DDD & Sociotechnical ArchitectureRESOURCESAlessandrohttps://www.linkedin.com/in/alessandrocollahttps://www.alessandrocolla.comAlbertohttps://www.linkedin.com/in/aacerbishttps://albertoacerbis.comXinhttps://bsky.app/profile/settling-mud.bsky.socialhttps://www.linkedin.com/in/xinxinLinkshttps://github.com/PacktPublishing/Domain-driven-Refactoringhttps://github.com/BrewUpDESCRIPTIONLegacy code isn't just old - it's a treasure chest of lost business knowledge waiting to be rediscovered. Alessandro Colla and Alberto Acerbis share their battle-tested approach to domain-driven refactoring, explaining why you should start with understanding the business problem before touching a single line of code. Like Michelangelo seeing the statue of David hidden in marble, they show how the right solution already exists within your legacy codebase—you just need the right tools and techniques to set it free.From event storming workshops over beer to modular monoliths as stepping stones, these "double-A battery" developers prove that thoughtful, incremental refactoring beats flashy microservices migrations every time.RECOMMENDED BOOKSColla & Acerbis • Domain-Driven Refactoring • https://amzn.to/3I3I7zfEvans • Domain-Driven Design • https://amzn.to/3tnGhwmVernon • Implementing Domain-Driven Design • https://amzn.to/44r39PBNilsson • Applying Domain-Driven Design and Patterns • https://amzn.to/3GoxYwInspiring Tech Leaders - The Technology PodcastInterviews with Tech Leaders and insights on the latest emerging technology trends.Listen on: Apple Podcasts SpotifyBlueskyTwitterInstagramLinkedInFacebookCHANNEL MEMBERSHIP BONUSJoin this channel to get early access to videos & other perks:https://www.youtube.com/channel/UCs_tLP3AiwYKwdUHpltJPuA/joinLooking for a unique learning experience?Attend the next GOTO conference near you! Get your ticket: gotopia.techSUBSCRIBE TO OUR YOUTUBE CHANNEL - new videos posted daily!

Send me a textJeroen shares his real-world iOS development journey working on a legacy app at Dawn Technologies. He details his systematic approach to modernizing an 8-year-old codebase that serves as a critical tool for companies.• Breaking down a monolithic App Delegate into dedicated managers with single responsibilities• Leveraging the existing feature flag system to safely deploy new implementations• Refactoring the walkie-talkie functionality with real-time audio streaming over WebSockets• Completely rewriting the chat system to use a modern service-based architecture• Overhauling the location tracking system to use iOS 17's new async location tracking APIs• Implementing WiFi settings fixes for iOS 16 compatibility using modern APIs• Maintaining a cleanup branch to remove deprecated APIs and fix compiler warningsCheck out Do iOS, the iOS development conference I'm organizing later this year. Visit do-ios.com for more information and tickets - link in the show notes.Join me in Amsterdam for Do iOS 2025, tickets and details available now. Lead Software Developer Learn best practices for being a great lead software developer.Lead Software DeveloperLearn best practices for being a great lead software developer.Disclaimer: This post contains affiliate links. If you make a purchase, I may receive a commission at no extra cost to you.Support the showDo iOS: https://do-ios.com Rate me on Apple Podcasts. Send feedback on SpeakPipeOr contact me: Mastodon: https://hachyderm.io/@appforce1 X: https://x.com/appforce1 BlueSky: https://bsky.app/profile/appforce1.net LinkedIN: https://www.linkedin.com/in/leenarts/ Support my podcast with a monthly subscription, it really helps.My book: Being a Lead Software Developer

"la transformation c'est un kickstart" Le D.E.V. de la semaine est Antoine Jacoutot, CTO @ Believe. Antoine livre son expérience sur la refonte technologique de Believe, entreprise en plein refactoring depuis deux ans. Il met en avant l'importance de la réorganisation des équipes et du développement d'une culture collaborative, tout en soulignant la nécessité de l'équilibre entre le développement de nouvelles fonctionnalités et le refactoring. La migration vers le cloud et l'introduction de Java comme second langage ont renforcé la flexibilité et l'optimisation des systèmes. Il conclut en insistant sur l'importance de la communication et de l'implication des équipes dans ce processus de changement continu.Chapitrages00:00:56 : Introduction à la transformation chez Believe00:05:12 : La nécessité du refactoring00:08:49 : Stratégies de préparation à la transformation00:10:35 : Organisation et collaboration dans la transformation00:15:40 : Éducation et communication pendant la transformation00:20:01 : Choix technologiques et modernisation00:25:21 : Refondre l'organisation et le management00:34:30 : Le manifesto de transformation00:39:49 : North Stars de la technologie00:43:04 : Chronologie de la transformation00:48:35 : Retours d'expérience et leçons apprises00:55:57 : Focus sur les promoteurs de la transformation00:56:51 : Conclusion et perspectives futures00:58:41 : Recommandation de lecture00:59:05 : Clôture de l'épisode Liens évoqués pendant l'émission Reinventing Organisation 🎙️ Soutenez le podcast If This Then Dev ! 🎙️ Chaque contribution aide à maintenir et améliorer nos épisodes. Cliquez ici pour nous soutenir sur Tipeee 🙏Archives | Site | Boutique | TikTok | Discord | Twitter | LinkedIn | Instagram | Youtube | Twitch | Job Board |Hébergé par Audiomeans. Visitez audiomeans.fr/politique-de-confidentialite pour plus d'informations.

En este episodio hablamos con Alexandre Soncini, cofundador de VTEX, la plataforma de e-commerce enterprise que opera en modelo SaaS multi-tenant. Hablamos de su rol en la expansión internacional (EE. UU., México, Europa y Asia) y de cómo VTEX impulsa a retailers globales con storefront, catálogo, checkout y un Order Management System que se integra con ERP y WMS para orquestar inventario, envíos y promesas de entrega. También comparamos su propuesta con alternativas como Shopify u opciones on-premise tradicionales, y por qué los clientes con operaciones complejas acaban optando por una solución más completa y ágil. Entramos al detalle técnico del producto: arquitectura de microservicios con 20–30 despliegues al día, plataforma multi-tenant con actualizaciones continuas y extensibilidad “low-code” vía VTEX IO para personalizar sin bifurcar versiones. Repasamos su pricing híbrido (fijo + variable sobre GMV) y compartimos métricas recientes: ~$4,8B de GMV trimestral, ~$230M de ingresos LTM, 3000+ clientes, crecimiento en el rango 10–15% anual y varios trimestres rentables. Además, Alexandre cuenta la historia: los inicios en 2000, el punto de inflexión con Walmart Brasil en 2007, la decisión de apostar únicamente por SaaS en un mundo acostumbrado al on-premise y el refactor de dos años con ~200 ingenieros para soportar el modelo marketplace. Menciona verticales y casos de clientes enterprise, y por qué muchas compañías que internalizaron su e-commerce hace años ahora migran a plataformas SaaS por coste total, seguridad, velocidad y capacidad de personalización.

Struggling with technical debt and code quality? Learn how a technical coach can help your team level up.In this episode, Emily Bache, a Samman technical coach, shares her proven method for building better engineering teams through structured learning and collaborative coding. We explore ensemble programming, learning hours, and why AI makes fundamental engineering practices more important than ever.Key topics discussed:The role of a Technical Coach and the Samman Method explainedHow AI amplifies good engineering practices instead of replacing themHow to use ensemble programming to achieve single-piece flowRunning effective ensemble sessions and avoiding common failure modesWhy learning is part of the work, not only a side activityWhy pull requests should not be the primary tool for mentoring junior developersThe dangerous trend of “vibe coding” with AI toolsTimestamps:(00:00) Trailer & Intro(02:22) Career Turning Points(03:23) Being Part of Modern Engineering YouTube Channel(04:27) The Role of a Technical Coach(05:42) The Impact of AI on Technical Coaching(08:20) Sofware Engineering is a Learning Process(09:55) Optimizing Learning With Samman Method(11:40) The Samman Method: Ensemble (Mob Programming)(14:59) The Main Benefit of Ensemble: Single Piece Flow(17:26) How to Do Ensemble and Avoid Common Failure Modes(20:27) The Types of Coding to Ensemble On(22:12) The Importance of Trust, Communication, and Kindness(23:52) Common Things Development Teams Are Struggling With(25:37) Prompt Engineering(27:16) The Samman Method: Learning Hours(29:08) Learning is Part of the Work(31:32) The Practice of Learning as a Team(34:39) The Constraint When Learning from Pull Requests(36:30) Putting Aside Time for Learning Hours(39:14) Becoming a Technical Coach(41:23) How to Measure the Effectiveness of Technical Coaching(43:52) Danger of AI Assisted Coding(46:59) The (Still) Important Skills in the AI Era(49:56) Why We Should Not Refactor Through AI(52:41) The Samman Method & Technical Coaching Resources(53:29) 3 Tech Lead Wisdom(54:56) Finding Mentors for Career Progression_____Emily Bache's BioEmily Bache is an independent consultant, YouTuber and Technical Coach. She works with developers, training and coaching effective agile practices like Refactoring and Test-Driven Development.Emily has worked with software development for 25 years, written two books and teaches courses on platforms including Pluralsight and O'Reilly. A frequent conference speaker, Emily has been invited to keynote at prestigious developer events including EuroPython, Craft and ACCU. Emily founded the Samman Technical Coaching Society in order to promote technical excellence and support coaches everywhere.Follow Emily:LinkedIn – linkedin.com/in/emilybacheX – x.com/emilybacheMastodon – sw-development-is.social/web/@emilybacheGitHub – github.com/emilybacheWebsite – emilybache.comSamman Coaching – sammancoaching.orgYouTube – youtube.com/@EmilyBache-tech-coachModern Software Engineering – youtube.com/@ModernSoftwareEngineeringYTLike this episode?Show notes & transcript: techleadjournal.dev/episodes/230.Follow @techleadjournal on LinkedIn, Twitter, and Instagram.Buy me a coffee or become a patron.

Duncan McGregor and Nat Pryce, co-authors of Java to Kotlin: Refactoring Guidebook, speak with host Giovanni Asproni about their hands-on experiences migrating Java codebases. The episode starts by highlighting Kotlin's seamless interoperability with Java, allowing teams to incrementally adopt Kotlin without disrupting existing Java code. Duncan and Nat then describe some of the benefits of using Kotlin — including stronger type safety, non-nullable types, and better support for immutability — and some of the gotchas when refactoring from Java to Kotlin due to the different idioms supported by the two languages. Finally, they discuss the importance of testing and tooling, and the evolving role of AI-assisted tools in complex and large-scale refactorings — in the context of work done by teams, as opposed to individuals. This episode is sponsored by Monday Dev

This interview was recorded for GOTO Unscripted.https://gotopia.techRead the full transcription of this interview hereMarit van Dijk - Developer Advocate at JetBrains, Java Champion & Open Source ContributorHannes Lowette - Principal Consultant at Axxes, Monolith Advocate, Speaker & Whiskey LoverRESOURCESMarithttps://bsky.app/profile/maritvandijk.bsky.socialhttps://linkedin.com/in/maritvandijkhttps://github.com/mlvandijkhttps://medium.com/@mlvandijkhttps://maritvandijk.comHanneshttps://bsky.app/profile/hanneslowette.nethttps://twitter.com/hannes_lowettehttps://github.com/Belenarhttps://linkedin.com/in/hanneslowetteLinkshttps://www.felienne.comhttps://codereading.clubhttps://github.com/neontribe/code-reading-clubDESCRIPTIONReading code is a critical yet often underappreciated skill in software development. Marit van Dijk & Hannes Lowette highlight that while developers are trained to write code, they spend most of their time understanding existing codebases—often with incomplete documentation and evolving complexity.They discuss research-backed strategies, such as structured code reading exercises, participation in communities like the Code Reading Club, and leveraging modern IDE tools to navigate and comprehend unfamiliar code. The conversation underscores the importance of empathy in code reviews, writing clear commit messages, and using tests as documentation to improve collaboration and maintainability. By practicing code reading deliberately and utilizing available resources, developers can become more effective and adaptable in their work.RECOMMENDED BOOKSFelienne Hermans • The Programmer's BrainAdrienne Braganza Tacke • "Looks Good to Me": Constructive Code ReviewsDuncan McGregor & Nat Pryce • Java to KotlinSaleem Siddiqui • Learning Test-Driven DevelopmentRoy Osherove • The Art of Unit TestingTrisha Gee & Helen Scott • Getting to Know IntelliJ IDEAJacqui Read • Communication PattBlueskyTwitterInstagramLinkedInFacebookCHANNEL MEMBERSHIP BONUSJoin this channel to get early access to videos & other perks:https://www.youtube.com/channel/UCs_tLP3AiwYKwdUHpltJPuA/joinLooking for a unique learning experience?Attend the next GOTO conference near you! Get your ticket: gotopia.techSUBSCRIBE TO OUR YOUTUBE CHANNEL - new videos posted daily!

In this episode of the Building Better Developers podcast, Rob Broadhead and Michael Meloche revisit one of their most foundational topics: evolving from coder to developer. Explored initially in the “Skill Sets for Success” episode, this updated discussion is guided by fresh talking points generated via ChatGPT—though the core theme remains the same: how to grow from a task-focused coder into a solution-oriented developer. Understanding the Shift: From Coder to Developer At the heart of this episode is the distinction between coders and developers. Coders complete the job. Developers solve the problem—and think beyond the current task. Michael emphasizes that evolving from coder to developer is about ownership. Developers consider reusability, maintainability, and long-term value. They don't just write code—they build tools that scale and adapt.

"Tu te rends compte au bout d'un an que tu refais, avec une stack toute neuve, les même erreurs que tu jugeais durement dans le legacy que tu es en train de refactorer."Et oui, la grande refonte n'est pas si simple, même souvent un leurre.Alors quand il faut vraiment refondre un système, comment faire ?Quand les baby steps ne suffisent plus pour refactorer du code, tu fais comment ?Et puis tu fais comment pour garder la motivation pendant la traversée du désert ?On parle de tout ça dans l'épisode du jour avec Thomas qui nous partage son retour d'expérience sur un gros chantier de refactoring chez Agicap.Hébergé par Ausha. Visitez ausha.co/politique-de-confidentialite pour plus d'informations.

Topics covered in this episode: * ty documentation site and uv migration guide* * uv build backend is now stable + other Astral news* * Refactoring long boolean expressions* * fastapi-ml-skeleton* Extras Joke Watch on YouTube About the show Sponsored by Sentry: pythonbytes.fm/sentry Connect with the hosts Michael: @mkennedy@fosstodon.org / @mkennedy.codes (bsky) Brian: @brianokken@fosstodon.org / @brianokken.bsky.social Show: @pythonbytes@fosstodon.org / @pythonbytes.fm (bsky) Join us on YouTube at pythonbytes.fm/live to be part of the audience. Usually Monday at 10am PT. Older video versions available there too. Finally, if you want an artisanal, hand-crafted digest of every week of the show notes in email form? Add your name and email to our friends of the show list, we'll never share it. Michael #1: ty documentation site and uv migration guide via Skyler Kasko Astral created a documentation site for ty (PR #744 in release 0.0.1-alpha.13). Astral added a page on migrating from pip to a uv project in the uv documentation. (PR #12382 in release 0.7.19). Talk Python episode on ty. Brian #2: uv build backend is now stable + other Astral news The uv build backend is now stable Tim Hopper via Python Developer Tooling Handbook From Charlie Marsh “The uv build backend is now stable, and considered ready for production use. An alternative to setuptools, hatchling, etc. for pure Python projects, with a focus on good defaults, user-friendly error messages, and performance. When used with uv, it's 10-35x faster.” “(In a future release, we'll make this the default.)” [build-system] requires = ["uv_build>=0.7.19,

Kristen Shaker joins Timur and Phil. Kristen talks to us about her C++ on Sea keynote about the C++ interview process, her previous work at Google, and why she has made a slightly unusual career change. Show Notes News libc++ removed the base template for std::char_traits "how to break or continue from a lambda loop?" - Vittoria Romeo Results from the 2025 Annual C++ Developer Survey "Lite" (pdf) Links C++ on Sea schedule (with Kristen and Timur's keynotes) BrontoSource "What Can We Learn From the Results of C++ Community Surveys?" - Anastasia Kazakova "Sorting Resumes" - Joel Spolsky (introducing the idea of filtering) "How to Build Your First C++ Automated Refactoring Tool" - Kristen's CppCon 2023 talk

In this episode, Amir sits down with Brent Keator, an expert advisor at Primary Venture Partners, to unpack one of the most debated engineering challenges: tech debt versus reengineering. They explore how to define tech debt, when to refactor versus rebuild, the ROI of revisiting old code, and how AI is (and isn't) changing the equation. This is a must-listen for engineering leaders navigating complex technical decisions in fast-moving environments.

Stewart Alsop sat down with Nick Ludwig, the creator of Kibitz and lead developer at Hyperware, to talk about the evolution of AI-powered coding, the rise of agentic software development, and the security challenges that come with giving AI more autonomy. They explored the power of Claude MCP servers, the potential for AI to manage entire development workflows, and what it means to have swarms of digital agents handling tasks across business and personal life. If you're curious to dive deeper, check out Nick's work on Kibitz and Hyperware, and follow him on Twitter at @Nick1udwig (with a ‘1' instead of an ‘L').Check out this GPT we trained on the conversation!Timestamps00:00 Introduction to the Crazy Wisdom Podcast00:52 Nick Ludwig's Journey with Cloud MCP Servers04:17 The Evolution of Coding with AI07:23 Challenges and Solutions in AI-Assisted Coding17:53 Security Implications of AI Agents27:34 Containerization for Safe Agent Operations29:07 Cold Wallets and Agent Security29:55 Agents and Financial Transactions33:29 Integrating APIs with Agents36:43 Discovering and Using Libraries43:19 Understanding MCP Servers47:41 Future of Agents in Business and Personal Life54:29 Educational and Medical Revolutions with AI56:36 Conclusion and Contact InformationKey InsightsAI is shifting software development from writing code to managing intelligent agents. Nick Ludwig emphasized how modern AI tools, particularly MCP servers, are enabling developers to transition from manually coding to overseeing AI-driven development. The ultimate goal is for AI to handle the bulk of programming while developers focus on high-level problem-solving and system design.Agentic software is the next frontier of automation. The discussion highlighted how AI agents, especially those using MCP servers, are moving beyond simple chatbots to autonomous digital workers capable of executing complex, multi-step tasks. These agents will soon be able to operate independently for extended periods, executing high-level commands rather than requiring constant human oversight.Security remains a major challenge with AI-driven tools. One of the biggest risks with AI-powered automation is security, particularly regarding prompt injection attacks and unintended system modifications. Ludwig pointed out that giving AI access to command-line functions, file systems, and financial accounts requires careful sandboxing and permissions to prevent catastrophic errors or exploitation.Containerization will be critical for safe AI execution. Ludwig proposed that solutions like Docker and other containerization technologies can provide a secure environment where AI agents can operate freely without endangering core systems. By restricting AI's ability to modify critical files and limiting its spending permissions, businesses can safely integrate autonomous agents into their workflows.The future of AI is deeply tied to education. AI has the potential to revolutionize learning by providing real-time, personalized tutoring. Ludwig noted that LLMs have already changed how people learn to code, making complex programming more accessible to beginners. This concept can be extended to broader education, where AI-powered tutors could replace traditional classroom models with highly adaptive learning experiences.AI-driven businesses will operate at unprecedented efficiency. The conversation explored how companies will soon leverage AI agents to handle research, automate customer service, generate content, and even manage finances. Businesses that successfully integrate AI-powered workflows will have a significant competitive edge in speed, cost reduction, and adaptability.We are on the verge of an "intelligence explosion" in both AI and human capabilities. While some fear AI advancements will outpace human control, Ludwig argued that AI will also dramatically enhance human intelligence. By offloading cognitive burdens, AI will allow people to focus on creativity, strategy, and high-level decision-making, potentially leading to an era of rapid innovation and problem-solving across all industries.

Artificial intelligence is radically transforming software development. AI-assisted coding tools are generating billions in investment, promising faster development cycles, and shifting engineering roles from code authors to code editors. But how does this impact software quality, security, and team dynamics? How can product teams embrace AI without falling into the hype? In this episode, AI assisted Agile expert Mike Gehard shares his hands-on experiments with AI in software development. From his deep background at Pivotal Labs to his current work pushing the boundaries of AI-assisted coding, Mike reveals how AI tools can amplify quality practices, speed up prototyping, and even challenge the way we think about source code. He discusses the future of pair programming, the evolving role of test-driven development, and how engineers can better focus on delivering user value. Unlock the full potential of your product team with Integral's player coaches, experts in lean, human-centered design. Visit integral.io/convergence for a free Product Success Lab workshop to gain clarity and confidence in tackling any product design or engineering challenge. Inside the episode... Mike's background at Pivotal Labs and why he kept returning How AI is changing the way we think about source code as a liability Why test-driven development still matters in an AI-assisted world The future of pair programming with AI copilots The importance of designing better software in an AI-driven development process Using AI to prototype faster and build user-facing value sooner Lessons learned from real-world experiments with AI-driven development The risks of AI-assisted software, from hallucinations to security Mentioned in this episode Mike's Substack: https://aiassistedagiledevelopment.substack.com/ Mike's Github repo: https://github.com/mikegehard/ai-assisted-agile-development Pivotal Labs: https://en.wikipedia.org/wiki/Pivotal_Labs 12-Factor Apps: https://12factor.net/  GitHub Copilot: https://github.com/features/copilot Cloud Foundry: https://en.wikipedia.org/wiki/Cloud_Foundry Lean Startup by Eric Ries: https://www.amazon.com/Lean-Startup-Entrepreneurs-Continuous-Innovation/dp/0307887898 Refactoring by Martin Fowler and Kent Beck https://www.amazon.com/Refactoring-Improving-Existing-Addison-Wesley-Signature/dp/0134757599 Dependabot: https://github.com/dependabot Tessl CEO Guy Podjarny's talk: https://youtu.be/e1a3WuxTY-k  Aider AI Pair programming terminal: https://aider.chat/ Gemini LLM: https://gemini.google.com/app Perplexity AI: https://www.perplexity.ai/ DeepSeek: https://www.deepseek.com/ Ian Cooper's talk on TDD: https://www.youtube.com/watch?v=IN9lftH0cJc Mike's newest Mountain Bike IBIS Ripmo V2S: https://www.ibiscycles.com/bikes/past-models/ripmo-v2s Mike's recommended house slippers: https://us.giesswein.com/collections/mens-wool-slippers/products/wool-slippers-dannheim Sorba Chattanooga Mountain Biking Trails: https://www.sorbachattanooga.org/localtrails Subscribe to the Convergence podcast wherever you get podcasts, including video episodes on YouTube at youtube.com/@convergencefmpodcast Learn something? Give us a 5-star review and like the podcast on YouTube. It's how we grow.

Ivett Ördög speaks with host Sam Taggart about rewrite versus refactor -- a choice that many projects face as they grow. It's a topic that inspires a lot of dogmatic feelings. They discuss how companies and projects end up at this crossroads and consider some strategies to try to avoid it. Ivett challenges the myth that you should never rewrite but points to two key factors that need to be present for a successful large-scale rewrite or refactor. They end by talking about how to get management on board for such large-scale rewrite or refactor projects. Brought to you by IEEE Computer Society and IEEE Software magazine.

To open the show, Ben and Andrew dive into the latest headlines about DeepSeek from last week. We answer questions like “why did everyone search ‘Jevons paradox'?” and discuss strategic AI investments from financial giants like Goldman Sachs. These moves underscore the growing importance of strong engineering leadership in the age of AI.Then, Luca Rossi of Refactoring joins us to discuss his latest research. Drawing from a comprehensive survey of engineering professionals (thanks to you!), Luca breaks down the key traits and practices of successful engineering teams, revealing surprising correlations between team happiness, shipping frequency, and recognition by non-technical leadership.Be sure to grab your copy of the report to follow along with today's insights.Show Notes:Dev Interrupted SurveyBeyond the DORA FrameworksIntroducing AI-Powered Code Review with gitStreamBook a demoFollow the hosts:Follow BenFollow AndrewFollow today's guest:Follow LucaReferenced in today's show:IBM cashing in on AIAI Stocks: How DeepSeek Changed Views On U.S.-China Artificial Intelligence Competition | Investor's Business DailyWilliam Stanley JevonsGoldman Sachs hires Amazon exec in senior AI engineering role | ReutersSupport the show: Subscribe to our Substack Leave us a review Subscribe on YouTube Follow us on Twitter or LinkedIn Offers: Learn about Continuous Merge with gitStream Get your DORA Metrics free forever

Scott and Wes explore the world of coding agents, diving into tools like Cursor and Windsurf that promise to change how we write and manage code. They discuss modes, workflows, and practical tips for experimenting with these AI-powered tools in your next project. Show Notes 00:00 Welcome to Syntax! 04:12 What are AI Agents? Cursor Features, Windsurf Features. 07:25 Brought to you by Sentry.io. 07:50 Chat Mode. 08:11 Composer Mode. 08:55 Agent Mode. 10:03 Inline Chat Mode. 11:02 JavaScript Set Methods Demo. Wes' Example on X. 16:10 Fire Dispatch Data. 20:01 Rules Files. Cursor Directory. 22:37 Use screenshots. 23:36 Refactoring to separate files. 23:53 Use it to experiment. Hit us up on Socials! Syntax: X Instagram Tiktok LinkedIn Threads Wes: X Instagram Tiktok LinkedIn Threads Scott: X Instagram Tiktok LinkedIn Threads Randy: X Instagram YouTube Threads

In this episode of Tech Talks Daily, I explore the cutting-edge intersection of AI and software development with Justine Gehring, an AI researcher at Moderne and the author of AI for Mass-Scale Code Refactoring and Analysis. Justine shares her insights into how AI is addressing one of the most complex challenges in the industry: large-scale code migrations and updates across enterprise environments. While AI tools like GitHub Copilot and ChatGPT have excelled at assisting individual developers with writing and optimizing code, Justine explains how large-scale code refactoring requires an entirely different approach. At this level, AI must account for enterprise-wide complexity, maintain reliability, and ensure security across thousands of repositories. She also dives into Moderne's use of open-source frameworks like OpenRewrite, which enable deterministic, verifiable code changes and combine machine learning for targeted tasks. We also discuss how this transformative use of AI is reshaping collaboration between human developers and machines. From accelerating the onboarding process for developers to simplifying migrations for legacy systems, AI is offering groundbreaking opportunities to enhance productivity, maintainability, and innovation. How are industries like banking, insurance, and others with vast, complex codebases benefiting from these advancements? And what does the future hold for AI-human collaboration in software development? Tune in to find out.

AI is being integrated and adopted across much of the IT world, but can it work magic in transforming old legacy code into shiny modern code? When it comes to this magic trick, it’s important to look behind the curtain. On today’s Day Two DevOps podcast we discuss the reality of AI in refactoring code... Read more »

Safely inside Station 151, Richard and Astrid confront Wayne about a mysterious, painful mass on his neck. Richard leaves the station to hunt down Spegg, but returns with an unexpected and disturbing find. Content warning: profanity, loud noises, violence, bodily sounds Can't wait for more? Patreon members get all episodes early and ad-free. Headphones highly recommended Support the show If you're enjoying the Station 151 science-fiction podcast series, we invite you to connect with us on Facebook, Twitter, and Instagram, or come and hang out with us and other fans on Discord! If you really like what you hear, you can support us over at Patreon—every dollar helps fund our monthly costs. Please follow the series on your favorite podcast platform, and let us know how you're liking it by leaving us a rating or review. Your support goes a long way toward helping us grow our listener base. Learn more about your ad choices. Visit megaphone.fm/adchoices

What's the difference between solving problems and recognizing patterns, and why does it matter for developers? In this episode, Stephanie and Joël discuss transitioning from collecting solutions to identifying patterns applicable to broader contexts in software development. They explore the role of heuristics, common misconceptions among junior and intermediate developers, and strategies for leveling up from a solution-focused mindset to thinking in patterns. They also discuss their experiences of moving through this transition during their careers and share advice for upcoming software developers to navigate it successfully. They explore how learning abstraction, engaging in code reviews, and developing a strong intuition for code quality help developers grow. Uncover the issue of over-applying patterns and gain insights into the benefits of broader, reusable approaches in code development. Join us to discover how to build your own set of coding heuristics, the pitfalls of pattern misuse, and how to become a more thoughtful developer. Tune in now! Key Points From This Episode: Stephanie unpacks the differences between patterns and solutions. The role of software development experience in recognizing patterns. Why transitioning from solving problems to recognizing patterns is crucial. Joël and Stephanie talk about the challenges of learning abstraction. Hear pragmatic strategies for implementing patterns effectively. How junior developers can build their own set of heuristics for code quality. Discover valuable tools and techniques to identify patterns in your work. Find out about approaches to documenting, learning, and sharing patterns. Gain insights into the process of refactoring a solution into a pattern. Outlining the common mistakes developers make and the pitfalls to avoid. Steps for navigating disagreements and feedback in a team environment. Links Mentioned in Today's Episode: RubyConf 2021 - The Intro to Abstraction I Wish I'd Received (https://www.youtube.com/watch?v=m0dC5RmxcFk) 'Ruby Science' (https://thoughtbot.com/ruby-science/introduction.html) Refactoring.Guru (https://refactoring.guru/) Thoughtbot code review guide (https://github.com/thoughtbot/guides/blob/main/code-review/README.md) The Bike Shed (https://bikeshed.thoughtbot.com/) Joël Quenneville on LinkedIn (https://www.linkedin.com/in/joel-quenneville-96b18b58/) Joël Quenneville on X (https://x.com/joelquen) Support The Bike Shed (https://github.com/sponsors/thoughtbot)

Scott and Wes serve up ways developers can use AI tools like Claude, GitHub Copilot, and more to boost productivity. From error tracing to refactoring code and automating mundane tasks, they break down how AI can handle the heavy lifting so you can focus on the fun stuff! Show Notes 00:00 Welcome to Syntax! 01:23 Brought to you by Sentry.io. 01:43 Using AI tools effectively. 05:29 Stack trace reading and error finding. 08:37 San Francisco Syntax Meetup! 09:19 Research and validation. 12:19 Completing mundane tasks. 14:10 Refactoring. 18:56 Simple typescript. 20:29 Summarizing docs and source code. 23:56 Quick hits. Hit us up on Socials! Syntax: X Instagram Tiktok LinkedIn Threads Wes: X Instagram Tiktok LinkedIn Threads Scott: X Instagram Tiktok LinkedIn Threads Randy: X Instagram YouTube Threads