Podcasts about Software architecture

In this episode of Elixir Wizards, Charles Suggs and Emma Whamond are joined by Mike Ratliff, co-founder and CTO of GridVar, to talk about the role software plays in the changing energy infrastructure. With over 30 years of experience in technology, Mike shares the path that took him from the early internet and cloud computing into energy and utility software, along with what he has learned about staying adaptable as the industry continues to shift. Mike explains why building software for the power grid comes with a very different set of constraints than building a typical web application and breaks down some of the challenges utilities are facing, including grid interconnection delays, power quality, increasing energy demand, and the growth of distributed energy resources. We also discuss demand response, microgrids, virtual power plants, battery storage, and how software can help utilities better understand and manage a grid that is becoming more complex. Mike also explains why Elixir and the BEAM are a strong fit for always-on energy systems, how an Erlang MQTT server first led him into the ecosystem, and what it takes to introduce Elixir inside an established organization. The episode closes with a broader look at AI-assisted development, the value of domain expertise, and why technical leaders still need communication, judgment, and a compelling story to move important ideas forward. Key topics discussed in this episode: Mike Ratliff's path from software to energy technology Lessons from three decades of technology industry change The value of generalists in modern software engineering Why good technical judgment remains difficult to replace Building software that interacts with physical infrastructure Why utility technology adoption can move slowly Understanding today's grid interconnection backlog Power quality challenges affecting new grid connections Using simulation to accelerate utility engineering studies Centralized and distributed approaches to grid management How solar energy creates the duck curve Using demand response to balance electricity consumption Edge devices supporting real-time grid coordination Microgrids and resilience in distributed energy systems Cybersecurity considerations for increasingly connected power grids Preparing utility infrastructure for extreme weather events Battery storage and the growth of renewable energy How virtual power plants coordinate distributed resources Why Elixir works well for energy software BEAM reliability for always-on utility infrastructure Discovering Elixir through Erlang and MQTT Building an early virtual power plant with Elixir Making the business case for an Elixir migration Why technical leadership also requires effective storytelling Links Mentioned: GridVAR https://www.gridvar.com/ GridPoint https://www.gridpoint.com/ https://en.wikipedia.org/wiki/2025_Iberian_Peninsula_blackout Demand Response: https://en.wikipedia.org/wiki/Demand_response Virtual Power Plant: https://en.wikipedia.org/wiki/Virtual_power_plant Microgrid: https://en.wikipedia.org/wiki/Microgrid Volts podcast: https://www.volts.wtf/

https://clearmeasure.com/developers/forums/ Chris Woodruff, or as his friends call him, Woody, is a software architect of over 25 years. Woody loves software engineering, especially allowing applications and services to communicate across networks and through Web APIs. He has received Microsoft MVP awards in SQL, Data and C# in the past, along with multiple years of being awarded the AWS Community Builder Award. He's a current board member of the .NET Foundation Woody lives in Grand Rapids, Michigan, where he explores the many breweries in West Michigan and travels with his family. Woody is also a long-time bourbon fan and loves hunting for whiskey bottles. Website - https://woodruff.dev/ LinkedIn - https://www.linkedin.com/in/chriswoodruff/ Twitter - https://twitter.com/cwoodruff Simplicity-First Website - https://simplicity-first.dev/ Previous Appearances on the Azure & DevOps Podcast: Episode 262 - Chris "Woody" Woodruff: Network Programming https://azuredevopspodcast.clear-measure.com/chris-woody-woodruff-network-programming-episode-262 ---------------------------------------- Want to Learn More? Visit AzureDevOps.Show for show notes and additional episodes.

In this special episode of Book Overflow, Carter and Nathan are joined by Mark Richards and Neal Ford, authors of Software Architecture: The Hard Parts!Join the official Book Overflow Discord! https://discord.gg/ZwS2fqW7ZZ -- Want to talk with Carter or Nathan? Book a coaching session! ------------------------------------------------------------Carterhttps://www.joinleland.com/coach/carter-m-1Nathanhttps://www.joinleland.com/coach/nathan-t-2-- Books Mentioned in this Episode --Note: As an Amazon Associate, we earn from qualifying purchases.----------------------------------------------------------Software Architecture: The Hard Parts: Modern Trade-Off Analyses for Distributed Architectures byNeal Ford, Mark Richards, Pramod Sadalage, and Zhamak Dehghanihttps://amzn.to/43cb833 (Paid Link)----------------Spotify: https://open.spotify.com/show/5kj6DLCEWR5nHShlSYJI5LApple Podcasts: https://podcasts.apple.com/us/podcast/book-overflow/id1745257325X: https://x.com/bookoverflowpodCarter on X: https://x.com/cartermorganNathan's Functionally Imperative: www.functionallyimperative.com----------------Book Overflow is a podcast for software engineers, by software engineers dedicated to improving our craft by reading the best technical books in the world. Join Carter Morgan and Nathan Toups as they read and discuss a new technical book each week!The full book schedule and links to every major podcast player can be found at https://www.bookoverflow.io

In this episode of Elixir Wizards, hosts Charles Suggs and Emma Whamond sit down with Marek Šuppa, creator of the Missing GitHub Status page, a project that reconstructs GitHub's historical uptime data and reveals discrepancies between official status reporting and the platform's actual reliability. Marek tells us about his dev journey from open source contributor at DuckDuckGo to machine learning engineer at Cisco-acquired Slido. Then, we discuss GitHub's evolution from a hosted Git service into a critical developer tool. We cover reliability, transparency, AI-driven platform growth, developer workflows, and the challenges of balancing convenience with resilience. Along the way, we cover alternative platforms, self-hosted solutions, and whether recent outages are changing how developers think about ownership, dependency, and the future of software collaboration. Topics Discussed in this Episode: Why did Mr. Shu create the Missing GitHub Status Page? GitHub's reported uptime versus developer experiences How open source contributions shaped Marek's career The evolution of GitHub from tool to critical infrastructure Centralization risks in modern software development Git's distributed roots and today's platform-centric workflows Developer reactions to GitHub outages Transparency and accountability in status reporting AI's impact on developer platforms and infrastructure demands Microsoft's stewardship of GitHub Forgejo, Codeberg, and alternative Git hosting platforms Self-hosted Git solutions and tradeoffs Network effects and platform lock-in The social side of software collaboration Building resilience into developer workflows What GitHub outages teach us about infrastructure dependency Links Mentioned: The Missing GitHub Status Page https://mrshu.github.io/github-statuses/ Slido https://www.slido.com/ https://duckduckgo.com/ The official GitHub Status Page https://www.githubstatus.com/ Statuspage.iohttps://www.atlassian.com/software/statuspage Zig Leaves GitHub https://ziglang.org/news/migrating-from-github-to-codeberg/ Ghostty Leaves GitHub https://mitchellh.com/writing/ghostty-leaving-github GitLab https://about.gitlab.com/ Codeberg https://codeberg.org/ https://git.kernel.org/ Forgejo Lightweight Self-Hosting https://forgejo.org/ Former GitHub CEO Thomas Dohmke launches Entire https://entire.io/news/former-github-ceo-thomas-dohmke-raises-60-million-seed-round Update on Spain and LALIGA blocks of the internet https://vercel.com/blog/update-on-spain-and-laliga-blocks-of-the-internet

In this episode of Elixir Wizards, hosts Charles Suggs and Emma Whamond sit down with Saša Jurić, Elixir mentor and author of Elixir in Action, to discuss software craftsmanship in the age of AI. As AI coding tools become increasingly capable, Saša argues that the real challenge isn't generating code, it's maintaining quality, clarity, and shared understanding within a codebase. We explore the difference between correct code and good code, and why code is more than a set of instructions for a machine to execute. Code is also documentation, communication, and a long-term investment that future developers must be able to understand and maintain. Saša shares his concerns about the growing "theater of pull requests," where teams go through the motions of code review without creating meaningful opportunities for learning, feedback, or knowledge sharing. The hosts and Saša talk about practical ways to work effectively with AI, including taking smaller steps, carefully reviewing AI-generated code, and using AI as a collaborative tool rather than an autonomous developer. Throughout the discussion, Saša challenges the industry's obsession with speed and makes the case that the principles of good software development (incremental progress, clear communication, and human judgment) remain important in the age of AI. Key Topics Discussed The difference between correct code and good code Code as communication, documentation, and shared understanding The "theater of pull requests" and ineffective review practices How AI is changing software development workflows Using AI as a collaborator rather than a replacement Why smaller, incremental changes lead to better outcomes Human oversight in AI-assisted development Balancing development speed with maintainability Pull request size and review effectiveness Commit history as a tool for storytelling and context The risks of accumulating technical debt faster with AI Testing and validating AI-generated code Refactoring AI-generated solutions for clarity Applying agile principles to AI-assisted workflows The role of experience and judgment in software design Why software craftsmanship still matters in the age of AI Links mentioned Code Complete by Steve McConnell https://khmerbamboo.wordpress.com/wp-content/uploads/2014/09/code-complete-2nd-edition-v413hav.pdf Harness AI for DevOps, Testing, and AppSec https://www.harness.io/ Claude Code https://claude.com/product/claude-code Claude Code GitHub https://github.com/anthropics/claude-code Pull Request for Oban https://github.com/oban-bg/oban/pull/331 SMPP https://en.wikipedia.org/wiki/Short_Message_Peer-to-Peer OpenAI Codex https://chatgpt.com/codex/ Opus AI https://opus.ai/ Tidewave https://tidewave.ai/ Credo Static Code Analysis https://github.com/rrrene/credo https://smartlogic.io/podcast/elixir-wizards/s11-e09-static-code-analyzer-elixir-credo-ruby-rubocop/ Link to Sasa's X post https://x.com/sasajuric/status/2029522378196238503 Saša Jurić “Tell Me A Story” at Goatmire https://www.youtube.com/watch?v=GOrKfCs-mr0 https://meks.quest/blogs/the-theatre-of-pull-requests-and-code-review Looks Good to Me: Constructive Code Reviews by Adrienne Braganza https://www.manning.com/books/looks-good-to-me Towards Maintainable Elixir: Testing https://medium.com/very-big-things/towards-maintainable-elixir-testing-b32ac0604b99 TDD, Where Did It All Go Wrong (Ian Cooper) https://youtu.be/EZ05e7EMOLMSpecial Guest: Saša Jurić.

Right now, the questions we have about our careers feel existential. We keep coming back to the same theme: how do you prepare for an industry that's changing this fast, and what mindset actually works in this new reality? One skill keeps surfacing as the answer — your ability to update your own mental models. In today's episode, I want to push on that further and put some of software engineering's most beloved thinking models under scrutiny. Some of these models served you well for years. Some of them now deserve to be challenged, replaced, or thrown out entirely — and learning how to tell the difference is itself the skill that will determine whether you hit a ceiling. Move Past "So What" Questions: The typical engineering objection to agentic coding is that it produces quality issues. But the people deciding to adopt these tools already accept that. Our job is to stop arguing the surface-level point and start asking the real one: so what do we actually do about this new economic reality? The Economics of Acceptable Loss: Abstraction always leaves something to be desired. An agent's code may not match what a staff engineer produces by hand over months — but that gap is usually an acceptable trade against shipping something two, three, or four times faster. Understand the cost-benefit picture instead of pretending the cost doesn't exist. Abstraction Has Always Done This: This isn't new. The calculator dissolved the specialization once required for complex math. Spreadsheets commoditized ledgering and accounting. Agentic coding is the same pattern arriving for our work — making something that required deep specialization suddenly far more accessible. Roles Are Blurring: As these generic tools raise everyone's ability to abstract, the boundaries soften. You're already seeing product managers open pull requests and engineers making product decisions. The neat lines around "what an engineer is" are not as fixed as they used to feel. Why Your Hard-Won Wisdom Is the Target: If you've spent years in this industry, your models were bought with blood, sweat, and failed projects. That experience is real wisdom — and it's exactly what I'm asking you to be willing to challenge, because the thing that always worked for you is the thing most likely to become a ceiling. This Skill Survives Either Way: Even if you think AI is mostly hype and I've been infected by it — fine. The ability to challenge your pre-existing models is a critical skill regardless. It's how you keep growing as you get more senior instead of repeating what used to work. Models Are Approximations: The whole point of a model is to approximate the reality around us. That's their value and their limitation. When the underlying reality shifts this dramatically, holding tightly to an old approximation stops being wisdom and starts being a liability.

If you're a software engineer right now, you likely feel like your world is changing overnight. We are writing half or less the amount of code that we wrote even a year ago, which represents a seismic, groundbreaking shift in our industry. For many of us, this career has always been engaging for deeply creative and intellectual reasons—and that excitement is still here. But our mental models of what it means to be a good engineer, and what it means to keep improving, have gone a little stale. In today's episode, I want to talk about a distinction that I believe will become the cornerstone mistake for seasoned engineers: confusing _practice_ with _adaptation_, and leaning on the wrong one at the worst possible moment. Two Surfaces Coming Into Contact: Picture your knowledge, skills, and toolset as one surface, and the actual state of the art as another. We've always known the surface area we could learn far exceeds what we can learn, which forces us to place bets on a learning strategy. What's changing is how fast that second surface is moving underneath us. Improvement by Practice vs. Improvement by Change: Practice is wielding what you've already adopted—smoothing out errors, building muscle memory, refining what you already know. Adaptation is fundamentally folding something new into your repertoire. Both are real forms of improvement, but they are not interchangeable. The Cornerstone Mistake for Senior Engineers: Later in your career, the time you spend adapting naturally goes down as you settle into practice. The biggest error I'm already watching engineers make is moving too quickly toward practice when the industry is loudly calling for adaptation instead. Inspect and Adapt—at the Right Altitude: Sprint retros were never really about getting marginally better at the thing you already do. The intent of "inspect and adapt" is to step up one level and examine the system. The trap is treating adaptation like a minor refinement—getting a little better at prompting—when it should mean asking whether you're thinking about prompting in the wrong way entirely. Question the Ratio, Not Just the Output: Real adaptation looks like asking whether you have the right mix of human and agent on a problem. Are you leaning on the agent for things you shouldn't, or failing to lean on it for the things you should? Have you genuinely thought about how sub-agents or an agent team are working the problem you're producing? A Spectrum, Not a Binary: On one end, you make micro-adjustments to your refinement process. On the other end of experimentation, you ask whether refinement—or even having engineers plan the work—is the right thing at all. The point isn't that practice is dead; it's that the industry is changing fast enough that the adaptive end of that spectrum deserves far more of your attention than it used to. Episode Homework: Take something you currently treat as a practice problem—"how do I refine tickets faster?"—and step up a level. Ask the adaptive version of the question instead: "Is refinement even the right thing anymore?"

In Elixir Wizards S15E04, Charles Suggs and Emma Whamond are joined by Somtochi Onyekwere, a software engineer at Fly.io and contributor to the Corrosion distributed database project, to talk about distributed systems, infrastructure resilience, and the growing fragility of centralized cloud platforms.   We discuss what recent outages across major providers reveal about modern infrastructure and why more teams are starting to rethink assumptions around reliability, failover, and system design. Somtochi explains how Fly.io approaches geographic distribution, eventual consistency, and replication across nodes, along with the trade-offs that come with building systems this way.   The conversation explores CRDTs (Conflict-free Replicated Data Types), consensus, split-brain prevention, and what actually happens when distributed systems fail in production. We also talk about testing strategies, rollback planning, property-based testing tools, and how teams can reduce blast radius when things inevitably go wrong.   Along the way, we discuss AI infrastructure, sandboxing AI agents, and how newer workloads may add pressure to already centralized systems. The episode closes with practical advice for developers who want to build more resilient applications without over-complicating their architecture. Topics Discussed in this Episode: Corrosion and distributed database replication Centralized cloud fragility and recent outage patterns Distributed systems versus traditional cloud architectures Multi-region deployment strategies for Phoenix applications CRDTs and conflict resolution in distributed systems Eventual consistency versus strict consistency tradeoffs Consensus, leader election, and split-brain prevention Testing failover and recovery scenarios Property-based testing and Antithesis Rollback planning for database schema migrations Reducing blast radius through system isolation Health checks and blue-green deployment strategies Fly Proxy request routing and replay behavior Cross-region synchronization and replication challenges Single points of failure inside “redundant” systems Backup restoration testing and disaster recovery planning Network partitions and failure handling in production Infrastructure monitoring and operational visibility AI infrastructure workloads and operational strain Sandboxing and securing AI agents Sprites and AI workflows at Fly.io Latency improvements from geographic distribution Distributed systems tradeoffs in real-world environments Transitive dependency failures across cloud providers Practical resilience strategies for modern engineering teams Links Mentioned: https://fly.io https://github.com/superfly/corrosion https://docs.gitops.weaveworks.org/ FluxCD https://fluxcd.io/ Fly.io Stateful Sandbox Environments https://sprites.dev/ Cloudflare Workers AI Inference Platform https://www.cloudflare.com/products/workers-ai/ “An AI Agent Just Destroyed Our Production Data. It Confessed in Writing” Twitter post from PocketOS founder: https://x.com/lifeof_jer/status/2048103471019434248 Oct 2025 AWS Outage https://www.theguardian.com/technology/2025/oct/24/amazon-reveals-cause-of-aws-outage Dec 2025 Cloudflare Outage https://www.theguardian.com/technology/2025/dec/05/another-cloudflare-outage-takes-down-websites-linkedin-zoom July 2025 Crowdstrike Outage https://www.ibm.com/think/news/recent-crowdstrike-outage-what-you-should-know March 2026 Stryker Cyber Attack https://www.stryker.com/us/en/about/news/2026/a-message-to-our-customers-03-2026.html https://aws.amazon.com/ https://cloud.google.com/ https://azure.microsoft.com/en-us https://fly.io/docs/elixir/ CRDTs!! https://smartlogic.io/podcast/elixir-wizards/s13-e03-local-first-liveview-svelte-pwa/ https://antithesis.com/docs/resources/property_based_testing/ https://hex.pm/packages/proper

This interview was recorded for the GOTO Book Club.http://gotopia.tech/bookclubEkaterina Gorshkova - Apache Kafka Engineer at SOFTEC & Author of "Kafka for Architects"Viktor Gamov - Principal Developer Advocate at Confluent & Co-Author of "Kafka in Action"Check out more here:https://gotopia.tech/episodes/440RESOURCESEkaterinahttps://www.linkedin.com/in/ekaterina-gorshkova-978bb6https://medium.com/@katyagorshkovaViktorhttps://bsky.app/profile/gamussa.devhttps://x.com/gAmUssAhttps://github.com/gamussahttps://www.linkedin.com/in/vikgamovhttps://gamov.ioLinks45% off discount code (expires on 25 May 2026): GOTOKGKafkaAffiliate link: https://hubs.la/Q044HgTvhttps://current.confluent.io/londonDESCRIPTIONApache Kafka has evolved far beyond a simple message broker — it has become a foundational layer for modern enterprise software. In this GOTO Book Club episode, Ekaterina Gorshkova, author of "Kafka for Architects", shares how her decade-long journey with Kafka — starting in a Czech bank's integration team in 2015 — shaped her understanding of what it really takes to design Kafka-based systems at scale. The conversation covers core architectural decisions, real-world patterns for enterprise integration, the role of Kafka Streams, and how to avoid the classic pitfalls of building systems that "only three engineers understand".The episode also looks forward: Ekaterina and host Viktor Gamov explore how Kafka is increasingly becoming the connective tissue for AI-driven systems, acting as an orchestration layer between intelligent agents, real-time data, and business workflows. Her book's central argument is that while AI and tooling change fast, the fundamental knowledge of how to design robust, event-driven systems is durable and career-proof. Kafka for Architects is framed not just as a technical manual, but as a roadmap for architects who want to get Kafka right from day one — requirements, design, testing, and all.RECOMMENDED BOOKSEkaterina Gorshkova • Kafka for Architects • https://amzn.to/42mDarUDylan Scott, Viktor Gamov & Dave Klein • Kafka in Action • https://amzn.to/4vJ3KcjViktor Gamov, Tartakovsky, Rasputnis & Fain • Enterprise Web Development • https://amzn.to/3CezL0RShapira, Palino, Sivaram & Petty • Kafka: The Definitive Guide • https://amzn.to/3RPtdLPBill Bejeck • Kafka Streams in Action • https://amzn.to/3CGJiiMBlueskyInstagramLinkedInFacebookCHANNEL 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!

If you've heard that your job in the agentic coding era is to "become a manager of agents," you may have noticed something doesn't quite fit. Most of us never trained to be managers, and frankly, that's not the role most engineers want. In today's episode, I unpack what that shift _actually_ means — it's closer to a tech lead or architect mindset — and zoom in on a specific interviewing and on-the-job skill that will help you stay employable: how you think about, talk about, and take ownership of failure. Don't Just Bring Star Stories — Bring Failure Stories: Interviewers don't only want to hear how you succeeded. They want to know what you do when the pressure's on and things fall apart. If every story you tell is a highlight reel, there's a built-in social signal that you're hiding something. Get comfortable telling the other kind of story. Identify the Real Problem, Not the Proximal One: The most common failure story I hear in interviews is "the knowledge transfer was bad" or "the docs weren't good." That's not wrong — it's just incomplete. The senior mindset asks why that happened. Why didn't we have docs? Why was context insufficient? Walk it back until you hit something actionable but not too abstract. The Systemic Diagnosis is the Leveled-Up Answer: Fixing the proximal cause fixes this instance. Fixing the root cause fixes the system that keeps producing instances like this. When you connect what you learned to a systemic adjustment, you stop sounding like someone who survived a bad project and start sounding like someone who improves the organization around them. Ownership Means Owning the Outcome, Not the Task: Use the homeowner metaphor. A homeowner doesn't personally fix every leaking pipe — but the outcome of the home is theirs. As an engineer, your scope of ownership has expanded dramatically in the agentic era. You're now responsible for outcomes of code you may not have even read, and the deciding skill is how you carry that responsibility. The Word to Pair With Ownership is Relentlessness: Not in an anxious, burn-yourself-out way. Relentlessness means following a thread to its natural end — through escalation, through asking the next question, through finding the right person if it's not you. It's the antidote to "I'll let someone else handle it" syndrome. You Don't Have to Do It All Yourself: Relentless ownership is not "carry every task across the finish line personally." If you're not qualified, the owner's job is to find who is, communicate risk to stakeholders, and keep the trail alive until the outcome is resolved. That's the differentiator between a senior thinking engineer and a junior one working through assigned tickets. Failure Is Usually a Lapse in Ownership: If you make a list of five things you've failed at (and you should), you'll often find the through-line isn't lack of skill — it's that you stopped escalating, stopped following up, stopped staying with the thing until it was actually resolved. Episode Homework: Write down five real failures. For each one, ask: where did I stop being relentless? What system produced this outcome — and what would I change upstream next time?

In Season 15 episode 2, Elixir Wizards Sundi Myint and Charles Suggs chat with Micah Cooper to talk about distributed systems, data replication, and what it actually looks like to build these ideas in Elixir.   Micah shares his journey from Ruby to Elixir and walks us through Visor, a library he's building based on the Viewstamps replication algorithm. Inspired by systems like TigerBeetle, Visor explores how you can replicate state across nodes using GenServers, giving you fault tolerance and recovery without relying entirely on traditional database patterns.   We talk about the difference between distributed systems and data replication, where things tend to get misunderstood, and what changes when you start thinking about state this way. The conversation also touches on event sourcing, tradeoffs in system design, and how Elixir's distributed model makes some of these concepts more approachable than you might expect.   Along the way, we talk about building for curiosity, experimenting with new ideas, and how projects like this push the ecosystem forward.   Topics discussed in this episode: Building Visor and working with the Viewstamps replication model Replicating GenServer state across nodes Distributed systems vs. data replication Lessons from TigerBeetle and financial system design Event sourcing challenges and tradeoffs Rethinking database-first architectures Snapshotting, recovery, and fault tolerance The role of Elixir's distributed model Experimentation, learning, and building for curiosity   Links mentioned: Micah's GitHub https://github.com/mrmicahcooper Micah's GitLab https://gitlab.com/mrmicahcooper The Visor repository: https://gitlab.com/mrmicahcooper/visor Visor Hex Package https://hex.pm/packages/visor Ruby on Rails https://rubyonrails.org/ Phoenix LiveView Framework https://www.phoenixframework.org/ Zig Programming Language https://ziglang.org/ TigerBeetle https://tigerbeetle.com/ TigerBeetle internal docs https://github.com/tigerbeetle/tigerbeetle/tree/main/docs/internals The BEAM https://www.erlang-solutions.com/blog/the-beam-erlangs-virtual-machine/ GenServer https://hexdocs.pm/elixir/GenServer.html Apache Kafka https://github.com/apache/kafka RabbitMQ https://www.rabbitmq.com/ Redpanda https://www.redpanda.com/ SQL https://www.ibm.com/think/topics/structured-query-language Kubernetes https://kubernetes.io/ YAML https://yaml.org/ Nomad Workload Orchestrator https://developer.hashicorp.com/nomad Flutter https://flutter.dev/ Commanded https://hexdocs.pm/commanded/Commanded.html Go Programming Language https://go.dev/ Clojure Programming Language https://clojure.org/ Nebulex https://hexdocs.pm/nebulex/Nebulex.html Mnesia https://www.erlang.org/doc/apps/mnesia/mnesia.html Cachex https://hexdocs.pm/cachex/Cachex.html libgraph https://hexdocs.pm/libgraph/Graph.html Horde https://hexdocs.pm/horde/Horde.Registry.html NocFree split keyboard https://www.nocfree.com/ Micah's LinkedIn https://www.linkedin.com/in/micah-cooper-4a737560/ 

This interview was recorded for the GOTO Book Club.http://gotopia.tech/bookclubLukasz Dynowski - Independent Consultant & Co-Author of "Learning API Styles"Sam Newman - Author of "Building Microservices" & "Monolith to Microservices"Check out more here:https://gotopia.tech/episodes/436RESOURCESLukaszhttps://github.com/ludyn-leohttps://www.linkedin.com/in/ldyniahttps://learningapistyles.comSamhttps://twitter.com/samnewmanhttps://github.com/snewmanhttps://www.linkedin.com/in/samnewmanhttp://samnewman.iohttp://samnewman.io/blogLinkshttps://www.youtube.com/@ldynia1https://www.youtube.com/playlist?list=PLRkB-vSK4koOHYIhpKXuXpipVpByEKuPuhttps://learningapistyles.comhttps://github.com/ldynia/learning-api-styleshttps://nordicapis.com/the-bezos-api-mandate-amazons-manifesto-for-externalizationhttps://dl.acm.org/doi/10.1145/1176617.1176622DESCRIPTIONIn this GOTO Book Club episode, Sam Newman — author of "Building Microservices" — sits down with Lukasz Dynowski, co-author of "Learning API Styles", for a refreshingly low-level deep dive into a subject most developers think they already understand. The book deliberately starts from the network layer up — transmission modes, TCP, protocol stacks — rather than jumping straight to REST and GraphQL, because, as Lukasz explains, most API problems only become visible when you understand the substrate beneath them. The conversation covers the full spectrum: public vs internal APIs, the Bezos API Mandate moment, why treating your API as a product is non-negotiable, and why the choice between binary and textual protocols is never as obvious as performance benchmarks suggest.The real gold comes in two moments. First, Lukasz lays out a crisp checklist for what makes a good API — audience-awareness, maintainability, efficiency, intuitiveness, resilience, security, testability, and documentation that actually matches behavior. Second, Sam shares a war story about a credit derivative system where the only way to figure out who was accessing the database was to turn off the credentials and wait for angry phone calls.The lesson: context shapes every trade-off, there's no universal right answer between REST, gRPC, WebSockets, or messaging, and the best API decision is the one that fits your situation — not the one that fits the conference talk.RECOMMENDED BOOKSLukasz Dynowski • Learning API Styles • https://amzn.to/3PFembKSam Newman • Building Resilient Distributed Systems • https://www.oreilly.com/library/view/building-resilient-distributed/9781098163532Sam Newman • Monolith to Microservices • https://amzn.to/2Nml96ESam Newman • Building Microservices • https://amzn.to/3dMPbOsRonnie Mitra & Irakli Nadareishvili • Microservices: Up and Running• https://amzn.to/3c4HmmLBlueskyInstagramLinkedInFacebookCHANNEL 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 Book Overflow, Carter and Nathan finish discussing Software Architecture: The Hard Parts!Join the Book Overflow Discord here! https://discord.gg/ZwS2fqW7ZZ -- Want to talk with Carter or Nathan? Book a coaching session! ------------------------------------------------------------Carterhttps://www.joinleland.com/coach/carter-m-1Nathanhttps://www.joinleland.com/coach/nathan-t-2-- Books Mentioned in this Episode --Note: As an Amazon Associate, we earn from qualifying purchases.----------------------------------------------------------Software Architecture: The Hard Parts--Spotify: https://open.spotify.com/show/5kj6DLCEWR5nHShlSYJI5LApple Podcasts: https://podcasts.apple.com/us/podcast/book-overflow/id1745257325X: https://x.com/bookoverflowpodCarter on X: https://x.com/cartermorganNathan's Functionally Imperative: www.functionallyimperative.com----------------Book Overflow is a podcast for software engineers, by software engineers dedicated to improving our craft by reading the best technical books in the world. Join Carter Morgan and Nathan Toups as they read and discuss a new technical book each week!The full book schedule and links to every major podcast player can be found at https://www.bookoverflow.io

Neal Ford: software architect, author, speaker, and independent consultant (formerly 20+ years at ThoughtWorks), joins Tobias to explore what happens to software architecture when AI agents write the code. We unpack the critical distinction between behavior and capabilities: why everyone focuses on what code does, but too few think about scalability, security, and responsiveness. Neal introduces architectural fitness functions as the essential guardrail for agentic systems, and explains why non-deterministic code generation demands deterministic tests. Finally, we dig into legacy modernization, the Dreyfus scale applied to LLMs, ephemerality as the new architectural dimension, and why AI is a multiplier, not a replacement, for experienced engineers.

In this episode of Book Overflow, Carter and Nathan continue discussing Software Architecture: The Hard Parts!Join the Book Overflow Discord here! https://discord.gg/ZwS2fqW7ZZ -- Want to talk with Carter or Nathan? Book a coaching session! ------------------------------------------------------------Carterhttps://www.joinleland.com/coach/carter-m-1Nathanhttps://www.joinleland.com/coach/nathan-t-2-- Books Mentioned in this Episode --Note: As an Amazon Associate, we earn from qualifying purchases.----------------------------------------------------------Software Architecture: The Hard Parts--Spotify: https://open.spotify.com/show/5kj6DLCEWR5nHShlSYJI5LApple Podcasts: https://podcasts.apple.com/us/podcast/book-overflow/id1745257325X: https://x.com/bookoverflowpodCarter on X: https://x.com/cartermorganNathan's Functionally Imperative: www.functionallyimperative.com----------------Book Overflow is a podcast for software engineers, by software engineers dedicated to improving our craft by reading the best technical books in the world. Join Carter Morgan and Nathan Toups as they read and discuss a new technical book each week!The full book schedule and links to every major podcast player can be found at https://www.bookoverflow.io

This presentation was recorded at GOTO Copenhagen 2025.https://gotocph.comRebecca Parsons - CTO Emerita at ThoughtworksGregor Hohpe - Author of "Platform Strategy", "The Software Architect Elevator", et al.Barry O'Reilly - Founder at Black Tulip Tech and Author of "Residues" & "The Architect's Paradox"Andrew Harmel-Law - Technical Principal at Thoughtworks & Author of "Facilitating Software Architecture"RESOURCESRebeccahttps://www.linkedin.com/in/rebecca-parsons-871491https://twitter.com/rebeccaparsonsGregorhttps://twitter.com/ghohpehttps://www.linkedin.com/in/ghohpehttp://eaipatterns.comhttps://architectelevator.comBarryhttps://bsky.app/profile/technologytulip.bsky.socialhttps://www.linkedin.com/in/barry-o-reilly-b924657https://www.blacktulip.seAndrewhttps://bsky.app/profile/andrewhl.bsky.socialhttps://twit.social/@ahlhttps://x.com/al94781https://github.com/andrewharmellawhttps://www.linkedin.com/in/andrewharmellawhttps://andrewharmellaw.github.ioABSTRACTSpeakers interview each other on topics that matter to them. [...]Read the full abstract here:https://gotocph.com/2025/sessions/3782RECOMMENDED BOOKSFord, Parsons, Kua & Sadalage  • Building Evolutionary Architectures 2nd Edition • https://amzn.to/3lqr5Q8Gregor Hohpe • Platform Strategy • https://amzn.to/4cxfYdbGregor Hohpe • The Software Architect Elevator • https://amzn.to/3F6d2axBarry O'Reilly • Residues • https://leanpub.com/residualityBarry O'Reilly • The Architect's Paradox • https://leanpub.com/architectsparadoxAndrew Harmel-Law • Facilitating Software Architecture • https://amzn.eu/d/5kZKVfUBlueskyInstagramLinkedInFacebookCHANNEL 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 Book Overflow, Carter and Nathan begin discussing Software Architecture: The Hard Parts!Join the Book Overflow Discord here! https://discord.gg/ZwS2fqW7ZZ -- Want to talk with Carter or Nathan? Book a coaching session! ------------------------------------------------------------Carterhttps://www.joinleland.com/coach/carter-m-1Nathanhttps://www.joinleland.com/coach/nathan-t-2-- Books Mentioned in this Episode --Note: As an Amazon Associate, we earn from qualifying purchases.----------------------------------------------------------Software Architecture: The Hard Parts--00:00 Intro04:20 Service Architecture Strategy15:36 When Good Strategy Goes Bad20:52 Stripe's Developer API Strategy38:39 Strategy and the Curse of Knowledge51:16 Making Time for Strategy58:16 Final Thoughts------Spotify: https://open.spotify.com/show/5kj6DLCEWR5nHShlSYJI5LApple Podcasts: https://podcasts.apple.com/us/podcast/book-overflow/id1745257325X: https://x.com/bookoverflowpodCarter on X: https://x.com/cartermorganNathan's Functionally Imperative: www.functionallyimperative.com----------------Book Overflow is a podcast for software engineers, by software engineers dedicated to improving our craft by reading the best technical books in the world. Join Carter Morgan and Nathan Toups as they read and discuss a new technical book each week!The full book schedule and links to every major podcast player can be found at https://www.bookoverflow.io

Join Dave Farley — co-author of Continuous Delivery (Jolt Award winner), author of Modern Software Engineering, and inventor of the CD Deployment Pipeline - and guest Steve Freeman in this fascinating episode. Steve is a pioneer of the software craftsmanship movement and a foundational figure in the global Agile community. He is the co-author of the seminal book Growing Object-Oriented Software, Guided by Tests, a winner of the Gordon Pask Award, and the co-creator of JMock. With a PhD from Cambridge, Steve has spent decades refining the "London School" of TDD, shifting testing from a verification step to a profound tool for architectural design.----------------------------------------Only Patreon supporters get to see the full length video episodes of "The Engineering Room” Sign up here: https://www.patreon.com/c/continuousdeliveryLinkedIn Steve Freeman: https://www.linkedin.com/in/stevefreeman/Equal Experts is a product software development consultancy with a network of over 1,000 experienced technology consultants globally. They increase the pace of innovation by using modern software engineering practices that embrace Continuous Delivery, Security, and Operability from the outset ➡️ https://bit.ly/3ASy8n0

This interview was recorded for the GOTO Book Club.http://gotopia.tech/bookclubCheck out more here:https://gotopia.tech/episodes/424Susanne Kaiser - Independent Tech Consultant & Author of "Architecture for Flow"James Lewis - Software Architect & Director at ThoughtworksRESOURCESSusannehttps://bsky.app/profile/suksr.bsky.socialhttps://mastodon.social/@suksrhttps://twitter.com/suksrhttps://www.linkedin.com/in/susannekaiser1https://susannekaiser.netJameshttps://bsky.app/profile/boicy.bovon.orghttps://twitter.com/boicyhttps://linkedin.com/in/james-lewis-microserviceshttps://github.com/boicyhttps://www.bovon.orgLinkshttps://susannekaiser.net/the-architecture-for-flow-canvashttps://susannekaiser.net/articleshttps://www.christenseninstitute.org/theory/jobs-to-be-doneDESCRIPTIONJames Lewis interviews Susanne Kaiser about her comprehensive new book "Architecture for Flow: Adaptive Systems with Domain-Driven Design, Wardley Mapping and Team Topologies".Susanne shares how she brought together 3 powerful frameworks over several years of her consulting work, creating a holistic approach to designing socio-technical systems. The discussion covers her journey from startup CTO to independent consultant, the evolution of her thinking around value streams and team organization, and her practical "Architecture for Flow Canvas" that teams can use to assess their current state and envision their future.With 126 hand-drawn illustrations and 599 sticky notes in the book, Kaiser emphasizes the importance of visual communication and starting with the problem space before jumping to solutions.RECOMMENDED BOOKSSusanne Kaiser • Adaptive Systems With Domain-Driven Design, Wardley Mapping & Team Topologies • https://amzn.to/3XTmNCcMatthew Skelton & Manuel Pais • Team Topologies • https://amzn.to/4a2gh0iWoods, Erder & Pureur • Continuous Architecture in Practice • https://amzn.to/2QWAmklSteve Pereira & Andrew Davis • Flow Engineering • https://amzn.to/3GY3u44Stefan Hofer & Henning Schwentner • Domain Storytelling • https://amzn.to/3EroBH7BlueskyInstagramLinkedInFacebookCHANNEL 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 conversation was recorded at GOTO Copenhagen 2025.https://gotocph.comSam Newman - Author of Building Microservices & Monolith to MicroservicesJacqui Read - Author of Communication Patterns: A Guide for Developers and ArchitectsSimon Rohrer - Global Head of Enterprise Tech Architecture and Ways of ThinkingORIGINAL TALK TITLESoftware Design, Architecture & Giving Clarity at ScaleRESOURCESSamhttps://twitter.com/samnewmanhttps://www.linkedin.com/in/samnewmanhttp://samnewman.iohttp://samnewman.io/bloghttps://github.com/snewmanJacquihttps://bsky.app/profile/tekiegirl.bsky.socialhttps://jacquiread.comhttps://fosstodon.org/@tekiegirlhttps://www.linkedin.com/in/jacquelinereadhttps://github.com/tekiegirlSimonhttps://bsky.app/profile/simon.bvssh.comhttps://mastodon.social/@simonrhttps://x.com/sirohrerhttps://www.linkedin.com/in/simonrohrerhttps://github.com/sirohrerhttps://www.soonersaferhappier.comLinkshttps://acedmodel.comABSTRACTIn this session, we will explore the nature of software design - what is it, and where is the intersection with architecture? We'll also look at the importance of communicating context, design, and architecture across an organization.If you'd like to do some advanced reading, head over to acedmodel.com for more.Both Jacqui and Simon will be sharing their expertise and experiences, but this session is also all about your questions. Come along, and get involved! [...]Read the full abstract here:https://gotocph.com/2025/sessions/3932RECOMMENDED BOOKSJacqui Read • Communication Patterns • https://amzn.to/3E37lvvSam Newman • Building Resilient Distributed Systems • https://www.oreilly.com/library/view/building-resilient-distributed/9781098163532Sam Newman • Monolith to Microservices • https://amzn.to/2Nml96ESam Newman • Building Microservices • https://amzn.to/3dMPbOsJonathan Smart, Zsolt Berend, Myles Ogilvie & Simon Rohrer • Sooner Safer Happier • https://amzn.to/3Emm9p2BlueskyInstagramLinkedInFacebookCHANNEL 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/bookclubCheck out more here:https://gotopia.tech/episodes/418Sam Keen - Founder & Researcher at AlteredCraft & Author of "Clean Architecture with Python"Max Kirchoff - CTO at Ginko & Multidisciplinary Technologist & CreativeRESOURCESSamhttps://bsky.app/profile/samkeen.bsky.socialhttps://x.com/samkeenhttps://github.com/samkeenhttps://www.linkedin.com/in/samkeenhttps://samkeen.devMaxhttps://x.com/ProductNihilisthttps://github.com/maxkirchoffhttps://www.linkedin.com/in/maxkirchoffhttps://maxkirchoff.comLinkshttps://www.heyginko.comhttps://martinfowler.com/bliki/TestPyramid.htmlDESCRIPTIONMax Kirchoff interviews Sam Keen about his book "Clean Architecture with Python". Sam, a software developer with 30 years of experience spanning companies from startups to AWS, shares his approach to applying clean architecture principles with Python while maintaining the language's pragmatic nature.The conversation explores the balance between architectural rigor and practical development, the critical relationship between architecture and testability, and how clean architecture principles can enhance AI-assisted coding workflows. Sam emphasizes that clean architecture isn't an all-or-nothing approach but a set of principles that developers can adapt to their context, with the core value lying in thoughtful dependency management and clear domain modeling.RECOMMENDED BOOKSSam Keen • Clean Architecture with Python • https://amzn.to/4pBT5g0Fabrizio Romano & Heinrich Kruger • Learn Python Programming • https://amzn.to/4myLBItUncle Bob • Clean Code • https://amzn.to/3soPO6kUncle Bob • Clean Architecture • https://amzn.to/3x0gjBQEric Evans • Domain-Driven Design • https://amzn.to/3tnGhwmNaomi Ceder • The Quick Python Book • https://amzn.to/3zwdDOaLuciano Ramalho • Fluent Python • https://amzn.to/3oSw2jeDavid Beazley • Python Distilled (Developer's Library) • https://amzn.to/3QjNBEvSaleem Siddiqui • Learning Test-Driven Development • https://amzn.to/35OMb3nMaciej «MJ» Jedrzejewski • Master Software Architecture • https://leanpub.com/master-software-architectureBlueskyTwitterInstagramLinkedInFacebookCHANNEL 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!

AI coding assistants promise speed, but what do they mean for quality, trust, and the architect's craft? In this inaugural episode of Next Gen Architecture Playbook, Shweta Vohra and Grady Booch explore a principled view of how architecture must evolve when machines begin writing code alongside humans. They unpack the third golden age of software engineering, where productivity gains are real, where the risks lie, and how architects can design review gates and practices that preserve long term integrity. Drawing on decades of experience across the history of software engineering, the conversation goes beyond hype to examine what should remain firmly human in an AI augmented world, and why architectural judgement, responsibility, and creative thinking matter more now, than ever. Read a transcript of this interview: https://bit.ly/4tmTR30 Subscribe to the Software Architects' Newsletter for your monthly guide to the essential news and experience from industry peers on emerging patterns and technologies: https://www.infoq.com/software-architects-newsletter Upcoming Events: QCon London 2026 (March 16-19, 2026) QCon London equips senior engineers, architects, and technical leaders with trusted, practical insights to lead the change in software development. Get real-world solutions and leadership strategies from senior software practitioners defining current trends and solving today's toughest software challenges. https://qconlondon.com/ QCon AI Boston 2026 (June 1-2, 2026) Learn how real teams are accelerating the entire software lifecycle with AI. https://boston.qcon.ai The InfoQ Podcasts: Weekly inspiration to drive innovation and build great teams from senior software leaders. Listen to all our podcasts and read interview transcripts: - The InfoQ Podcast https://www.infoq.com/podcasts/ - Engineering Culture Podcast by InfoQ https://www.infoq.com/podcasts/#engineering_culture - Generally AI: https://www.infoq.com/generally-ai-podcast/ Follow InfoQ: - Mastodon: https://techhub.social/@infoq - X: https://x.com/InfoQ?from=@ - LinkedIn: https://www.linkedin.com/company/infoq/ - Facebook: https://www.facebook.com/InfoQdotcom# - Instagram: https://www.instagram.com/infoqdotcom/?hl=en - Youtube: https://www.youtube.com/infoq - Bluesky: https://bsky.app/profile/infoq.com Write for InfoQ: Learn and share the changes and innovations in professional software development. - Join a community of experts. - Increase your visibility. - Grow your career. https://www.infoq.com/write-for-infoq

Od ostatnich odcinków minęło trochę czasu, ale świat IT nie stał w miejscu – wręcz przeciwnie, przyspieszył tak, że momentami trudno nadążyć. Dlatego w tym odcinku, wspólnie z Łukaszem Szydło i Marcinem Markowskim, próbujemy po prostu głośno zastanowić się, co tak naprawdę dzieje się z pracą architekta oprogramowania i ogólnie architekturą software'u w dobie wszechobecnego Generative AI.Gdy kolejne modele wychodzą w coraz szybszym tempie, w zasadzie trochę trudno rozmawiać o tym, jakie 10 narzędzi zmieni Twoje życie architekta, z których warto korzystać już teraz. Zamiast tego usiedliśmy, żeby porozmawiać o naszych spostrzeżeniach i obserwacjach z placu boju. AI wpędza nas po trochu w pułapkę: kod powstaje błyskawicznie, ale nasze ludzkie moce przerobowe do jego czytania i weryfikacji pozostają w zasadzie bez zmian. Czy przez to nie zmieniamy się powoli w redaktorów kodu i czy Code Review nie stanie się zaraz największym wąskim gardłem w naszych projektach? Ale Code Review jest tylko jednym z etapów procesu Software Development Lifecycle, na którym widać wpływ narzędzi AI.Ogłoszenie!Już niedługo, bo 17 lutego, będziemy mogli się spotkać na otwartym warsztacie DevHours: Fullstack x EventStorming, który mam przyjemność współorganizować z Capgemini. Jeśli interesujesz się oprogramowaniem i chcesz podnieść swoje umiejętności w projektowaniu software'u, zapraszam do rejestracji.

January is the perfect time to take stock, and in this episode we share the most common lessons we've learned from six years of coaching Python developers. Drawing on hundreds of real-world conversations, we break down seven practical fixes that consistently help developers move forward - from stopping endless consumption and actually building, to escaping abandoned GitHub repos, getting proper code reviews, and shifting from scripts to real systems with solid tooling, testing, and version control.The conversation also dives into mindset: overcoming imposter syndrome, using AI without becoming dependent on it, and why going it alone often makes your journey harder than it needs to be. Download the Free 7-Engineering Shifts Guide Here: https://pybit.es/escape-tutorial-hell/Books mentioned:Fundamentals of Software Architecture -https://pybitesbooks.com/books/yClOEQAAQBAJBefore We Say Goodbye - https://pybitesbooks.com/books/GMGhEAAAQBAJ___

This interview was recorded for the GOTO Book Club.http://gotopia.tech/bookclubCheck out more here:https://gotopia.tech/episodes/413Alexandre Malavasi - CTO at Marelo & Author of "Modern Full-Stack Web Development with ASP.NET Core"Albert S. Tanure - Cross Solutions Architec at Microsoft & Author of "ASP.NET Core 9 Essentials"RESOURCESAlexandrehttps://x.com/alemalavasihttps://github.com/alexandremalavasihttps://www.linkedin.com/in/alexandremalavasiAlberthttps://x.com/alberttanurehttps://github.com/tanurehttps://www.linkedin.com/in/albert-tanurehttps://www.codefc.io/enDESCRIPTIONMicrosoft Cloud Solution Architect Albert Tanure interviews Microsoft MVP Alexandre Malavasi about his fourth book, "Modern Full-Stack Web Development with ASP.NET Core". The discussion explores the challenges of writing comprehensive technical books, the importance of foundational knowledge in full stack development, and how to integrate ASP.NET Core with modern JavaScript frameworks like React, Angular, and Vue.js.Alexandre emphasizes that successful architecture decisions depend primarily on team expertise and the ability to facilitate change, rather than following trends.The conversation also highlights the critical importance of looking beyond just coding - encompassing project planning, DevOps practices, monitoring, and continuous optimization - to truly bring value to customers and become well-rounded software engineers.RECOMMENDED BOOKSAlexandre Malavasi • Modern Full-Stack Web Development with ASP.NET Core • https://amzn.to/4pvEXnYAlexandre Malavasi • Implementing Design Patterns in C# 11 and .NET 7 • https://amzn.to/49CapwnAlexandre Malavasi • Enterprise Applications with C# and .NET • https://amzn.to/4iiVidkAlexandre Malavasi • Implementing Design Patterns in C# and .NET 5 • https://amzn.to/3JU5UD2Albert Tanure • ASP.NET Core 9 Essentials • https://amzn.to/43bH73tBlueskyTwitterInstagramLinkedInFacebookCHANNEL 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 podcast Michael Stiefel spoke with David Gudeman about software architecture for startups. The discussion starts by illuminating how to make decisions with imperfect information, and how uncertainty and ambiguity flow through all aspects of developing the architecture. This leads to analyzing how the architect must focus on both product strategy and technical decisions, and how there must be a collaborative effort between the product and technical teams. David Gudeman then talks about how one never really throws away working software, and how to evolve your architecture as the startup grows. The podcast concludes with advice for somebody who is thinking about being a software architect in a startup. Read a transcript of this interview: https://bit.ly/3NEvVrc Subscribe to the Software Architects' Newsletter for your monthly guide to the essential news and experience from industry peers on emerging patterns and technologies: https://www.infoq.com/software-architects-newsletter Upcoming Events: QCon London 2026 (March 16-19, 2026) QCon London equips senior engineers, architects, and technical leaders with trusted, practical insights to lead the change in software development. Get real-world solutions and leadership strategies from senior software practitioners defining current trends and solving today's toughest software challenges. https://qconlondon.com/ QCon AI Boston 2026 (June 1-2, 2026) Learn how real teams are accelerating the entire software lifecycle with AI. https://boston.qcon.ai The InfoQ Podcasts: Weekly inspiration to drive innovation and build great teams from senior software leaders. Listen to all our podcasts and read interview transcripts: - The InfoQ Podcast https://www.infoq.com/podcasts/ - Engineering Culture Podcast by InfoQ https://www.infoq.com/podcasts/#engineering_culture - Generally AI: https://www.infoq.com/generally-ai-podcast/ Follow InfoQ: - Mastodon: https://techhub.social/@infoq - X: https://x.com/InfoQ?from=@ - LinkedIn: https://www.linkedin.com/company/infoq/ - Facebook: https://www.facebook.com/InfoQdotcom# - Instagram: https://www.instagram.com/infoqdotcom/?hl=en - Youtube: https://www.youtube.com/infoq - Bluesky: https://bsky.app/profile/infoq.com Write for InfoQ: Learn and share the changes and innovations in professional software development. - Join a community of experts. - Increase your visibility. - Grow your career. https://www.infoq.com/write-for-infoq

Legacy systems work. So why do companies waste millions rewriting them? In this episode of Arguing Agile, Product Manager Nisha Patel joins Product Manager Brian Orlando and Enterprise Business Agility Consultant Om Patel for a debate on the dangerous obsession with rewriting legacy systems — from COBOL to green screens — that still power ATMs, government systems, and Fortune 500 billing engines. Watch or listen as we discuss the myth that "modern" equals "better" and reveal how most rewrites fail because they ignore customer value, edge cases, and real ROI as well as other topics, such as:How Chesterton's Fence applies to code (Brian still doesn't know)How Developers kill software with Resume-Driven Development (RDD)How Finance kills software with spreadsheet-driven development (SDD)Why chasing "parity" kills innovationRisk Mitigation, or, framing technical debt in business termsIf you've ever worked on or tried to replace legacy systems, this episode will either give you nightmares, or help how you approach legacy systems while helping you also stop burning budget on vanity projects.#LegacyCode #ProductManagement #AgileCoachingREFERENCESAA148 - An Introduction to Software Development FinancesLINKSYouTube: https://www.youtube.com/@arguingagileSpotify: https://open.spotify.com/show/362QvYORmtZRKAeTAE57v3Apple: https://podcasts.apple.com/us/podcast/agile-podcast/id1568557596INTRO MUSICToronto Is My BeatBy Whitewolf (Source: https://ccmixter.org/files/whitewolf225/60181)CC BY 4.0 DEED (https://creativecommons.org/licenses/by/4.0/deed.en)

Ned and Kyler sit down with industry analyst Jon Collins for a fun and free-ranging discussion that covers everything from the changing landscape of software engineering to the importance of good architecture (physical and digital). They tackle the pros and cons of “Vibe Coding” as well as the “Augmentation Gap”, the idea that AI tools... Read more »

Ned and Kyler sit down with industry analyst Jon Collins for a fun and free-ranging discussion that covers everything from the changing landscape of software engineering to the importance of good architecture (physical and digital). They tackle the pros and cons of “Vibe Coding” as well as the “Augmentation Gap”, the idea that AI tools... Read more »

Ned and Kyler sit down with industry analyst Jon Collins for a fun and free-ranging discussion that covers everything from the changing landscape of software engineering to the importance of good architecture (physical and digital). They tackle the pros and cons of “Vibe Coding” as well as the “Augmentation Gap”, the idea that AI tools... Read more »

"Architects shouldn't try to be the smartest people in the room, they should make everybody else smarter."In this episode, Gregor Hohpe (ex-Google & AWS, author of "The Software Architect Elevator") breaks down exactly how to transition from software engineer to architect. He shares the mental models used at Big Tech to handle complexity, visualize systems, and navigate office politics without losing your technical edge.We cover:- Why "lowering risk" is the architect's real value proposition- The "Phantom Sketch Artist" technique to visualize unclear requirements- How to gain "political capital" to push back on bad decisions- Why simple architectures are often the hardest to buildIf you want to move beyond just writing code and start designing systems that scale, this conversation is for you.Connect with Gregor:https://www.linkedin.com/in/ghohpe00:00:00 - Intro 00:01:15 - How to Spot Bad Architects vs. Great Amplifiers 00:03:44 - Why Architects Are Actually Risk Managers in Disguise 00:06:13 - The Truth About Complexity and Simplicity at Scale 00:09:55 - How to Resolve Technical Disagreements Without Arguments 00:13:57 - Why You Should Use Pen and Paper for Architecture 00:17:24 - Mastering the Left-Right Brain Ping Pong Technique 00:20:42 - The "Architect Elevator": Connecting Code to Strategy 00:23:06 - The Rubber Duck Test: Are You a Good Architect? 00:25:41 - The "Phantom Sketch Artist" Method for System Design 00:30:37 - Stop Being a Cartographer, Start Being a Scout 00:34:47 - How to Keep Your Technical Skills Sharp as an Architect 00:44:37 - Navigating Office Politics using the "Court Jester" Strategy 00:48:08 - How to Earn and Spend Political Capital Wisely 00:53:17 - Why the "Big Ball of Mud" Might Be a Good Architecture 00:57:08 - How Executives Spot Gaps in Your Technical Logic 01:00:00 - Why Using AI for Architecture is a Dangerous Trap#SoftwareArchitecture #SystemDesign #SeniorDeveloper

This interview was recorded for GOTO Unscripted.https://gotopia.techCheck out more here:https://gotopia.tech/articles/400David Whitney - Director of Architecture at NewDayIan Cooper - A Polyglot Coding Architect at Just EatHannes Lowette - Principal Consultant at Axxes, Monolith Advocate, Speaker & Whiskey LoverRESOURCESDavidhttps://bsky.app/profile/davidwhitney.co.ukhttp://twitter.com/david_whitneyhttps://www.instagram.com/davidwhitneycoukhttps://github.com/davidwhitneyhttps://www.linkedin.com/in/davidwhitneyhttps://davidwhitney.co.uk/blogIanhttps://bsky.app/profile/icooper.bsky.socialhttps://hachyderm.io/@ICooperhttps://twitter.com/ICooperhttps://www.linkedin.com/in/ian-cooper-2b059bhttps://github.com/iancooperhttps://ian-cooper.writeas.comDESCRIPTIONThree experienced software engineers - Ian Cooper, David Whitney, and Hannes Lowette - discuss the evolution of software architecture from traditional "ivory tower" approaches to modern, collaborative practices. The conversation explores the tension between emergent and designed architecture, the importance of sustainable versus "slash-and-burn" development approaches, and how architectural decisions scale with organizational growth.Key themes include the critical role of communication and coaching in architecture, the dangers of pattern cargo-culting, and the fundamental reality that all architectural challenges are ultimately people problems requiring empathy, shared language, and cultural change.RECOMMENDED BOOKSBarry O'Reilly • Residues • https://leanpub.com/residualityBarry O'Reilly • The Architect's Paradox • https://leanpub.com/architectsparadoxDiana Montalion • Learning Systems Thinking • https://amzn.to/3ZpycdJSam Newman • Monolith to Microservices • https://amzn.to/2Nml96ERonnie Mitra & Irakli Nadareishvili • Microservices: Up and Running• https://amzn.to/3c4HmmLJacqui Read • Communication Patterns • https://amzn.to/3E37lvvVaughn Vernon & Tomasz Jaskula • Strategic Monoliths & Microservices • https://amzn.to/3AcUscjHow Hacks HappenHacks, scams, cyber crimes, and other shenanigans explored and explained. Presented...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!

Welcome to another episode of Road to CTO, our series where we sit down with some of the most experienced and influential technology leaders in the world.In this episode, we talk with Dorion Carroll, a veteran with 35 years of tech leadership experience, former CTO at Zynga, VP at Amazon, and one of the most insightful engineering minds in the industry.From scaling engineering teams from 280 to 3,600 people, to navigating billion-dollar decisions, to understanding what truly makes a great CTO, Dorion shares the lessons, stories and frameworks that shaped his extraordinary career.If you're an aspiring CTO, an engineering manager, or simply passionate about how world-class tech organisations operate behind the scenes, this is a masterclass.Support the show

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!

Нас можно найти: 1. Telegram: https://t.me/proConf 2. Youtube: https://www.youtube.com/c/proconf 3. SoundCloud: https://soundcloud.com/proconf 4. Itunes: https://podcasts.apple.com/by/podcast/podcast-proconf/id1455023466 5. Spotify: https://open.spotify.com/show/77BSWwGavfnMKGIg5TDnLz

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!

This interview was recorded for the GOTO Book Club.http://gotopia.tech/bookclubRead the full transcription of the interview here:https://gotopia.tech/episodes/385Kief Morris - Author of "Infrastructure as Code" & Distinguished Engineer at ThoughtworksAbby Bangser - Principal Engineer at Syntasso & Team Topologies AdvocateRESOURCESKiefhttps://bsky.app/profile/kief.comhttps://twitter.com/kiefhttps://github.com/kiefhttps://www.linkedin.com/in/kiefmorrishttps://kief.comAbbyhttps://bsky.app/profile/abangser.bsky.socialhttps://twitter.com/a_bangserhttps://github.com/abangserhttps://www.linkedin.com/in/abbybangserhttps://www.syntasso.io/members-area/abby/profileLinkshttps://infrastructure-as-code.comDESCRIPTIONAbby Bangser (Principal Engineer at Syntasso) speaks with Kief Morris (Distinguished Engineer at Thoughtworks consultant and Author of "Infrastructure as Code") about the evolution of infrastructure as code over the past decade. They discuss how the field has grown from simple server configuration management to complex cloud architectures, the challenges of current tooling, and emerging solutions like System Initiative.The conversation explores the importance of abstraction layers, the application of software development principles to infrastructure, and how AI might transform the field. They emphasize that infrastructure decisions must align with business needs rather than being treated as generic plumbing, highlighting the ongoing need for platform engineering and developer experience considerations.RECOMMENDED BOOKSKief Morris • Infrastructure as Code • https://amzn.to/4e6EBQcMatthew Skelton & Manuel Pais • Team Topologies • http://amzn.to/3sVLyLQDave Thomas • simplicity • https://amzn.to/43FghBJDave Thomas & Andy Inspiring 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 GOTO Unscripted.https://gotopia.techRead the full transcription of this interview here:https://gotopia.tech/articles/382Alice Bartlett - Tech Director for Customer Products at Financial TimesCharles Humble - Freelance Techie, Podcaster, Editor, Author & ConsultantRESOURCESAlicehttps://x.com/alicebartletthttps://github.com/alicebartletthttps://www.linkedin.com/in/alicebartletthttps://medium.com/@alice.bartletthttps://alicebartlett.co.ukCharleshttps://bsky.app/profile/charleshumble.bsky.socialhttps://linkedin.com/in/charleshumblehttps://mastodon.social/@charleshumblehttps://conissaunce.comLinkshttps://blog.container-solutions.com/wtf-happens-to-psychological-safetyDESCRIPTIONAlice Bartlett, Tech Director at the Financial Times, discusses her journey from principal engineer to leading a 70-person team responsible for https://www.ft.com and mobile apps. She shares insights on managing editorial stakeholders, balancing technical debt with business priorities, leading difficult conversations, and navigating the challenges of AI in software development.The conversation with Charles Humble covers her approach to architectural challenges, communication strategies, and the evolving role of technology leadership in modern media organizations.RECOMMENDED BOOKSSimon Wardley • Wardley Maps • https://amzn.to/45U8UprSimon Wardley • Wardley Mapping, The Knowledge • https://amzn.to/3XQEeDuSun Tzu • The Art of War • https://amzn.to/2BqDehaMark Craddock • Wardley Mapping Doctrine • https://amzn.to/4b3jRYbSusanne Kaiser • Adaptive Systems With Domain-Driven Design, Wardley Mapping & Team Topologies • https://amzn.to/3XTmNCcDInspiring 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!

“Architecture is something that has to emerge naturally from the code. If it doesn't make the code better, more elegant, and more flexible, then you should not be doing it.”Why do so many developers have a love-hate relationship with ORM? The creator of Hibernate reveals the real reasons behind the controversy and what's being done to fix the fundamental issues.In this episode, Gavin King, the creator of Hibernate, shares the story behind its creation, from a debate with his boss to its rise as a popular open-source. He dives deep into why developers often dislike ORM, pinpointing the “magic” of the stateful persistence context as a major pain point.Gavin explains how modern specifications are fixing these historical issues with an emphasis on type safety and more explicit, stateless operations, giving developers greater control.Key topics discussed:The origin story of Hibernate and the early frustrations with Java EEThe single biggest mistake that led some developers to hate ORMWhy type safety matters and how the new Jakarta specifications enable type-safe queriesWhy architecture should emerge from code, not from whiteboard diagramsA critique on industry dogmas and architecture best practices, including DDD aggregatesWhy disagreement is essential for healthy engineering teamsTimestamps:(00:00:00) Trailer & Intro(00:02:24) Career Turning Points(00:16:11) The Problems That Led to Hibernate Creation(00:24:22) Key Things That Make Hibernate Successful(00:31:57) Behind the Scene of Java EE Specifications(00:37:42) The Renaming of Java EE to Jakarta EE(00:40:15) Jakarta Persistence, Jakarta Data, Jakarta Query Language(00:47:20) The Importance of Type Safety(00:54:08) Why Some People Dislike ORM(01:00:47) The Fundamental of Data Fetching and Association(01:08:52) The Upcoming Jakarta Data and QL Updates(01:16:06) Gavin's View on Software Architecture(01:26:08) The DDD from Gavin's Perspective(01:30:55) Tech Lead Wisdom_____Gavin King's BioGavin King is the creator of Hibernate, the revolutionary framework that redefined data persistence for millions of Java developers. A key figure in the evolution of enterprise Java, he has led the development of major industry standards like the Java Persistence API (JPA) and CDI. After a decade designing the Ceylon programming language, he has returned to his roots to advance the next generation of data persistence with Jakarta EE.Follow Gavin:LinkedIn – linkedin.com/in/gavinkingTwitter – x.com/1ovthafewWebsite – hibernate.orgLike this episode?Show notes & transcript: techleadjournal.dev/episodes/232.Follow @techleadjournal on LinkedIn, Twitter, and Instagram.Buy me a coffee or become a patron.

This interview was recorded for GOTO Unscripted.https://gotopia.techRead the full transcription of this interview hereBrooklyn Zelenka - Author of Numerous Libraries Including Witchcraft & Founded the Vancouver Functional Programming MeetupJulian Wood - Serverless Developer Advocate at AWSRESOURCESBrooklynhttps://bsky.app/profile/expede.wtfhttps://octodon.social/@expede@types.plhttps://github.com/expedehttps://www.linkedin.com/in/brooklynzelenkahttps://notes.brooklynzelenka.comJulianhttps://bsky.app/profile/julianwood.comhttps://twitter.com/julian_woodhttp://www.wooditwork.comhttps://www.linkedin.com/in/julianrwoodLinkshttps://automerge.orghttps://discord.com/invite/zKGe4DCfgRhttps://www.robinsloan.com/notes/home-cooked-apphttps://github.com/ipvm-wghttps://www.localfirst.fmhttps://localfirstweb.devDESCRIPTIONDistributed systems researcher Brooklyn Zelenka unpacks the paradigm shift of local-first computing, where applications primarily run on users' devices and synchronize seamlessly without central servers.In a conversation with Julian Wood, she explains how this approach reduces latency, enables offline functionality, improves privacy through encryption, and democratizes app development—all while using sophisticated data structures. Perfect for collaborative tools and "cozy web" applications serving smaller communities, local-first software represents a fundamental rethinking of how we've built software for the past 30 years.RECOMMENDED BOOKSFord, Parsons, Kua & Sadalage • Building Evolutionary Architectures 2nd EditionFord, Richards, Sadalage & Dehghani • Software Architecture: The Hard PartsMark Richards & Neal Ford • Fundamentals of Software ArchitectureFord, Parsons & Kua • Building Evolutionary ArchitecturesNeal Ford • Functional ThinkingMichael Feathers • Working Effectively with Legacy CodeBlueskyTwitterInstagramLinkedInFacebookCHANNEL 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!

Ted Neward currently labors on behalf of Capital One as a Senior Distinguished Engineer, leveraging his speaking, writing, and coding experience to bring a technology-focused and -sharpened mindset to the mortgage industry. During his more code-focused years, he specialized in high-scale enterprise systems, working with clients ranging in size from Fortune 500 corporations to small 10-person shops. He is an authority in Java and .NET technologies, particularly in the areas of Java/.NET integration (both in-process and via integration tools like Web services), programming languages of all forms, back-end enterprise software systems, and virtual machine/execution engine plumbing.   He is the author or co-author of several books, including Professional F# 2.0, Effective Enterprise Java, C# In a Nutshell, SSCLI Essentials, Server-Based Java Programming, and a contributor to several technology journals. All told, he has written well over a hundred articles in both print and online form.   Ted has also been an “insider” of one form or another with a variety of the technology providers of the world: an IBM Champion of Cloud, a Microsoft F# MVP (having also been an Architect and C# MVP in prior years), an F# Insider, C# Insider, VB Insider, INETA speaker, DevelopMentor instructor, PluralSight course author, and a member of various Java JSRs.   Topics of Discussion: [2:44] Ted's career journey and what keeps him motivated in the industry. [4:16] Why Ted believes the industry is overdue for a new mainstream programming language. [8:12] The evolution of case tools, UML, and why generating code has never been the real problem. [15:14] The challenge of keeping architecture simple versus embracing complexity. [22:33] The role of philosophy in software development. [38:01] Lessons from calculators, fundamentals, and why developers must still master core skills. [38:46] The impact of AI on productivity and job roles. [43:25] The Importance of Domain-Specific Languages (DSLs). [56:26] Ted and Jeffrey talk about a recent article in The Economist, “Jane Street's sneaky retention tactic”. [1:01:54] The importance of writing as a tool for developers to structure their thoughts and improve communication. [1:04:02] A few of the upcoming places and events that you can catch Ted speaking live!   Mentioned in this Episode: Clear Measure Way Architect Forum Software Engineer Forum Programming with Palermo — New Video Podcast! Email us at programming@palermo.net. Ted Neward LinkedIn Visual Studio Live! KCDC Voxxed Days, Crete Build Stuff   Want to Learn More? Visit AzureDevOps.Show for show notes and additional episodes.

Send us your thoughtsIn this month's Finance Transformation Live host Hannah Munro explores how finance leaders can design scalable, resilient systems that adapt to change and support long-term growth.Key topics covered:The four pillars of future-proof finance architecture: data, APIs, expandability, and maintenanceWhy multi-dimensional data structures are essential for reporting, AI, and agilityHow to evaluate API strength, integration flexibility, and vendor transparencyAvoiding common pitfalls like over-customisation, poor data design, and dead-end system configurationsBuilding layered tech stacks to support FP&A, BI, automation, governance, and collaborationPlanning for continuous improvement: training, upgrades, and staying ahead of business needsLinks mentioned: Previous session: Finance Record to Report Maturity ModelConnect with Hannah MunroBuilding Out Your Finance Data Strategy Reporting Tools in Sage IntacctWhich Sage Product is Right For You Quiz!Book a discovery call  Explore other CFO 4.0 Podcast episodes here. Subscribe to our Podcast!

Back in 1994, Peter Deutsch and his colleagues at Sun Microsystems identified what they described as the "eight fallacies of distributed computing" — flawed assumptions that often get made when teams move from monolithic to distributed software architectures. In recent years, software architecture experts and regular writing partners Neal Ford and Mark Richards have identified a further three new fallacies of distributed computing: versioning is easy; compensating updates always work; and observability is optional. In this episode of the Technology Podcast, Neal and Mark join host Prem Chandrasekaran to talk through these three new fallacies, before digging deeper into other important issues in software architecture, including modular monoliths and governing architectural characteristics. Listen for a fresh perspective on software architecture and to explore key ideas shaping the discipline in 2025. Learn more about the second edition of Neal and Mark's Fundamentals of Software Architecture: https://www.oreilly.com/library/view/fundamentals-of-software/9781098175504/      

Steven Smith, also known in the developer community as Ardalis, is an entrepreneur, author, and software architect with a deep passion for building effective, maintainable software. Through his company, NimblePros, Steve helps organizations — ranging from household names like Microsoft and Quicken Loans to growing teams across industries — maximize their development potential. His clients frequently describe him as a “force multiplier,” amplifying the productivity and impact of the teams he supports.   Steve has been recognized as a Microsoft MVP for over two decades and continues to lead through education and mentorship. He's published numerous courses on Pluralsight and Dometrain, focusing on topics like domain-driven design, software architecture, and design patterns. He also empowers developers through his mentorship platform, DevBetter.com, helping the next generation of professionals grow their careers with intention and clarity.   Topics of Discussion: [2:28] What keeps Steve excited about computer programming and software architecture? [4:42] What is software architecture? [6:18] The importance of understanding the logical components of a software system and how they interact. [7:06] Artifacts for architecture decisions. [8:52] How lightweight documentation and diagrams, like those in the C4 Model, can clarify system design without overburdening the team. [10:53] The modern architecture books that have caught Steve's eye. [12:57] The KISS principle and keeping software architecture simple. [19:38] Clean architecture and domain-driven design principles. [22:52] Managing out-of-process dependencies and service integrations. [26:07] Adapter pattern and interface abstractions. [28:33] Decorator pattern for adding functionality. [33:14] Pipeline Architecture. [40:35] What Steve thinks the future holds for AI-driven development, what he uses it for, and the challenges of AI currently.   Mentioned in this Episode: Clear Measure Way Architect Forum Software Engineer Forum Programming with Palermo — New Video Podcast! Email us at programming@palermo.net. Clear Measure, Inc. (Sponsor) “Steve Smith: .NET 8 and Architecture” - Episode 276 NimblePros  Architect Modern Web Applications with ASP.NET Core and Azure  C4 Model  “Simon Brown on Architecture for Developers - Episode 96” Fundamentals of Software Architecture, by Mark Richards & Neal Ford, summarized as a platform-agnostic, principle-driven guide   .NET Rocks! “Architecture vs. Code with Steve Smith”  .NET Rocks! “Vertical Slice Architecture with Jeremy Miller”  GoF Adapter pattern .NET API interface estimate  Decorator pattern Bus vs. Pipeline patternsBus Vs. Pipeline patterns   Want to Learn More? Visit AzureDevOps.Show for show notes and additional episodes.

Mark Ericksen, creator of the Elixir LangChain framework, joins the Elixir Wizards to talk about LLM integration in Elixir apps. He explains how LangChain abstracts away the quirks of different AI providers (OpenAI, Anthropic's Claude, Google's Gemini) so you can work with any LLM in one more consistent API. We dig into core features like conversation chaining, tool execution, automatic retries, and production-grade fallback strategies. Mark shares his experiences maintaining LangChain in a fast-moving AI world: how it shields developers from API drift, manages token budgets, and handles rate limits and outages. He also reveals testing tactics for non-deterministic AI outputs, configuration tips for custom authentication, and the highlights of the new v0.4 release, including “content parts” support for thinking-style models. Key topics discussed in this episode: • Abstracting LLM APIs behind a unified Elixir interface • Building and managing conversation chains across multiple models • Exposing application functionality to LLMs through tool integrations • Automatic retries and fallback chains for production resilience • Supporting a variety of LLM providers • Tracking and optimizing token usage for cost control • Configuring API keys, authentication, and provider-specific settings • Handling rate limits and service outages with degradation • Processing multimodal inputs (text, images) in Langchain workflows • Extracting structured data from unstructured LLM responses • Leveraging “content parts” in v0.4 for advanced thinking-model support • Debugging LLM interactions using verbose logging and telemetry • Kickstarting experiments in LiveBook notebooks and demos • Comparing Elixir LangChain to the original Python implementation • Crafting human-in-the-loop workflows for interactive AI features • Integrating Langchain with the Ash framework for chat-driven interfaces • Contributing to open-source LLM adapters and staying ahead of API changes • Building fallback chains (e.g., OpenAI → Azure) for seamless continuity • Embedding business logic decisions directly into AI-powered tools • Summarization techniques for token efficiency in ongoing conversations • Batch processing tactics to leverage lower-cost API rate tiers • Real-world lessons on maintaining uptime amid LLM service disruptions Links mentioned: https://rubyonrails.org/ https://fly.io/ https://zionnationalpark.com/ https://podcast.thinkingelixir.com/ https://github.com/brainlid/langchain https://openai.com/ https://claude.ai/ https://gemini.google.com/ https://www.anthropic.com/ Vertex AI Studio https://cloud.google.com/generative-ai-studio https://www.perplexity.ai/ https://azure.microsoft.com/ https://hexdocs.pm/ecto/Ecto.html https://oban.pro/ Chris McCord's ElixirConf EU 2025 Talk https://www.youtube.com/watch?v=ojL_VHc4gLk Getting started: https://hexdocs.pm/langchain/gettingstarted.html https://ash-hq.org/ https://hex.pm/packages/langchain https://hexdocs.pm/igniter/readme.html https://www.youtube.com/watch?v=WM9iQlQSFg @brainlid on Twitter and BlueSky Special Guest: Mark Ericksen.

Connor Rigby joins the Elixir Wizards to talk about Blue Heron BLE (Bluetooth Low Energy) support for Elixir apps. Blue Heron implements the BLE specs in pure Elixir, leveraging binary pattern matching and concurrent message processing to handle Bluetooth protocols. Unlike most solutions that require C ports or NIFs, Blue Heron runs entirely in user space, so it works seamlessly in both Nerves-based embedded projects and (eventually) desktop Elixir applications. We discuss how Nerves development differs from building Phoenix apps. Connor shares challenges he's experienced with hardware compatibility, where some chips only partially implement the spec, and he discusses the surprisingly deep (but sometimes incomplete) world of BLE device profiles. His tip for anyone entering the BLE space: read the official spec instead of trusting secondhand blog posts. Tools like Nerves LiveBook give you hands-on examples, so you can get a BLE prototype running on a Raspberry Pi and your phone in no time. Key topics discussed in this episode: Blue Heron origins and “bird” naming convention BLE vs. Bluetooth Classic: core differences Pure Elixir implementation—no C dependencies Binary pattern matching for packet parsing Hardware transport options: UART, SPI, USB, SDIO GenServer patterns in Nerves vs. Phoenix Linux requirement and power-consumption trade-offs GATT (Generic Attribute Table) implementation patterns SQLite integration for Nerves apps Hardware chip quirks and spec compliance Manufacturer-specific commands and workarounds BLE device profiles and spec gaps Security Management Profile (SMP) for encryption Device connection and pairing workflows Web vs. embedded development differences Where to get started: hardware recommendations and docs Links mentioned: https://github.com/ConnorRigby/ https://github.com/blue-heron/ https://nerves-project.org/ BLE (Bluetooth Low Energy) https://en.wikipedia.org/wiki/BluetoothLowEnergy https://developer.apple.com/ibeacon/ https://learnyousomeerlang.com/building-otp-applications Linux https://www.linux.org/ HCI (Host Controller Interface) https://en.wikipedia.org/wiki/Hostcontrollerinterface Circuits UART Library https://hexdocs.pm/circuitsuart/readme.html SPI (Serial Peripheral Interface) https://github.com/elixir-circuits/circuitsspi SDIO (Secure Digital Input Output https://en.wikipedia.org/wiki/SDIO Raspberry Pi https://www.raspberrypi.com/ Coral SoM Dev Board https://coral.ai/products/dev-board/ BeagleBone Single-Board Linux Computer https://www.beagleboard.org/boards/beaglebone-black https://www.bluetooth.com/bluetooth-resources/intro-to-bluetooth-gap-gatt/ Genservers https://hexdocs.pm/elixir/1.12/GenServer.html https://hexdocs.pm/ecto/Ecto.html https://github.com/elixir-sqlite/ectosqlite3 https://github.com/nerves-livebook/nerveslivebook Special Guest: Connor Rigby.

As the Vice President of Strategy at Xebia Microsoft Services, Rocky leads the vision and direction of the company's software development solutions and services. He brings extensive expertise in framework design and implementation, distributed systems architecture, and cloud and container technologies, helping clients achieve their business goals and deliver value to their customers.   He is also the creator of CSLA .NET, an open-source development framework that enables developers to build scalable, maintainable, and secure object-oriented applications. As an accomplished author, he has written multiple books on the subject and frequently shares his insights at major conferences worldwide. He is honored to be a member of the Microsoft Regional Director and MVP programs and serves as co-chair of Visual Studio Live! as well as chair of the Cloud & Containers Live conferences. His passion lies in advancing the software industry and empowering developers to create better software.   Topics of Discussion: [3:30] Rockford shares his first job experience at an independent software vendor (ISV) building software to dispatch and manage the delivery of ready-mix concrete trucks. [8:30] The evolution of software and its connection to real-world processes. [9:53] The impact of technology advancements, such as miniaturization and material science, on modern software applications. [12:40] The influence of AI on software architecture and decision making. [19:15] Rockford about the importance of open-source libraries and personal projects in software development. [21:35] How does one become aware of what's available these days? [23:14] Rockford suggests using RSS readers, curated feeds, and platforms like Feedly and Mastodon to stay informed about industry developments. [27:06] The upside to blogging and microblogging. [28:25] Importance of sharing knowledge and expertise. [29:19] Expertise through teaching and sharing. [32:19] Impact of Large Language Models (LLMs) on Coding. [38:22] Infrastructure challenges with AI. [40:21] Legacy software modernization. [40:52] Career advice for leaders and recognizing it as its own career path.   Mentioned in this Episode: Clear Measure Way Architect Forum Software Engineer Forum Programming with Palermo — New Video Podcast! Email us at programming@palermo.net. Clear Measure, Inc. (Sponsor) .NET DevOps for Azure: A Developer's Guide to DevOps Architecture the Right Way, by Jeffrey Palermo Azure & DevOps Podcast: Rocky Lhotka: CSLA - Episode 210 CSLA.NET Rockford on LinkedIn Rockford Lhotka Rockford's Blog Feedly Morning Dew — Alvin Ashcroft Drive by Daniel Pink  Visual Studio Live! Tunisia DevDays   Want to Learn More? Visit AzureDevOps.Show for show notes and additional episodes.

BONUS: From Waterfall to Flow—Rethinking Mental Models in Software Delivery With Henrik Mårtensson In this BONUS episode, we explore the origins and persistence of waterfall methodology in software development with management consultant Henrik Mårtensson. Based on an article where he details the history of Waterfall, Henrik explains the historical context of waterfall, challenges the mental models that keep it alive in modern organizations, and offers insights into how systems thinking can transform our approach to software delivery. This conversation is essential for anyone looking to understand why outdated methodologies persist and how to move toward more effective approaches to software development. The True Origins of Waterfall "Waterfall came from the SAGE project, the first large software project in history, where they came up with a methodology based on an economic analysis." Henrik takes us on a fascinating historical journey to uncover the true origins of waterfall methodology. Contrary to popular belief, the waterfall approach wasn't invented by Winston Royce but emerged from the SAGE project in the 1950s. Bennington published the original paper outlining this approach, while it was Bell and Tayer who later named it "waterfall" when referencing Royce's work. Henrik explains how gated process models eventually led to the formalized waterfall methodology and points out that an entire generation of methods existed between waterfall and modern Agile approaches that are often overlooked in the conversation. In this segment we refer to:  The paper titled “Production of Large Computer Programs” by Herbert D. Benington (direct PDF link) Updated and re-published in 1983 in Annals of the History of Computing ( Volume: 5, Issue: 4, Oct.-Dec. 1983) Winston Royce's paper from 1970 that erroneously is given the source of the waterfall term. Direct PDF Link. Bell and Thayer's paper “Software Requirements: Are They Really A Problem?”, that finally “baptized” the waterfall process. Direct PDF link.   Mental Models That Keep Us Stuck "Fredrik Taylor's model of work missed the concept of a system, leading us to equate busyness with productivity." The persistence of waterfall thinking stems from outdated mental models about work and productivity. Henrik highlights how Frederick Taylor's scientific management principles continue to influence software development despite missing the crucial concept of systems thinking. This leads organizations to equate busyness with productivity, as illustrated by Henrik's anecdote about 50 projects assigned to just 70 people. We explore how project management practices often enforce waterfall thinking, and why organizations tend to follow what others do rather than questioning established practices. Henrik emphasizes several critical concepts that are often overlooked: Systems thinking Deming's principles Understanding variation and statistics Psychology of work Epistemology (how we know what we know) In this segment, we refer to:  Frederik Taylor's book “The Principles of Scientific Management” The video explaining why Project Management leads to Coordination Chaos James C. Scott's book, “Seeing Like a State” Queueing theory Little's Law The Estimation Trap "The system architecture was overcomplicated, and the organizational structure followed it, creating a three-minute door unlock that required major architectural changes." Henrik shares a compelling story about a seemingly simple feature—unlocking a door—that was estimated to take three minutes but actually required significant architectural changes due to Conway's Law. This illustrates how organizational structures often mirror system architecture, creating unnecessary complexity that impacts delivery timelines. The anecdote serves as a powerful reminder of how estimation in software development is frequently disconnected from reality when we don't account for systemic constraints and architectural dependencies. In this segment, we refer to Conway's Law, the observation that explicitly called out how system architecture is so often linked to organizational structures. Moving Beyond Waterfall "Understanding queueing theory and Little's Law gives us the tools to rethink flow in software delivery." To move beyond waterfall thinking, Henrik recommends several resources and concepts that can help transform our approach to software development. By understanding queueing theory and Little's Law, teams can better manage workflow and improve delivery predictability. Henrik's article on coordination chaos highlights the importance of addressing organizational complexity, while James C. Scott's book "Seeing Like a State" provides insights into how central planning often fails in complex environments. About Henrik Mårtensson Henrik Mårtensson is a management consultant specializing in strategy, organizational development, and process improvement. He blends Theory of Constraints, Lean, Agile, and Six Sigma to solve complex challenges. A published author and licensed ScrumMaster, Henrik brings sharp systems thinking—and a love of storytelling—to help teams grow and thrive. You can link with Henrik Mårtensson on LinkedIn and connect with Henrik Mårtensson on Twitter.

Organizations build and deploy applications at an unprecedented pace, but security is often an afterthought. This episode of ITSPmagazine's Brand Story features Jim Manico, founder of Manicode Security, in conversation with hosts Sean Martin and Marco Ciappelli. The discussion explores the current state of application security, the importance of developer training, and how organizations can integrate security from the ground up to drive better business outcomes.The Foundation of Secure DevelopmentJim Manico has spent decades helping engineers and architects understand and implement secure coding practices. His work with the Open Web Application Security Project (OWASP), including contributions to the OWASP Top 10 and the OWASP Cheat Sheet Series, has influenced how security is approached in software development. He emphasizes that security should not be an afterthought but a fundamental part of the development process.He highlights OWASP's role in providing documentation, security tools, and standards like the Application Security Verification Standard (ASVS), which is now in its 5.0 release. These resources help organizations build secure applications, but Manico points out that simply having the guidance available isn't enough—engineers need the right training to apply security principles effectively.Why Training MattersManico has trained thousands of engineers worldwide and sees firsthand the impact of hands-on education. He explains that developers often lack formal security training, which leads to common mistakes such as insecure authentication, improper data handling, and vulnerabilities in third-party dependencies. His training programs focus on practical, real-world applications, allowing developers to immediately integrate security into their work.Security training also helps businesses beyond just compliance. While some companies initially engage in training to meet regulatory requirements, many realize the long-term value of security in reducing risk, improving product quality, and building customer trust. Manico shares an example of a startup that embedded security from the beginning, investing heavily in training early on. That approach helped differentiate them in the market and contributed to their success as a multi-billion-dollar company.The Role of AI and Continuous LearningManico acknowledges that the speed of technological change presents challenges for security training. Frameworks, programming languages, and attack techniques evolve constantly, requiring continuous learning. He has integrated AI tools into his training workflow to help answer complex questions, identify knowledge gaps, and refine content. AI serves as an augmentation tool, not a replacement, and he encourages developers to use it as an assistant to strengthen their understanding of security concepts.Security as a Business EnablerThe conversation reinforces that secure coding is not just about avoiding breaches—it is about building better software. Organizations that prioritize security early can reduce costs, improve reliability, and increase customer confidence. Manico's approach to education is about empowering developers to think beyond compliance and see security as a critical component of software quality and business success.For organizations looking to enhance their security posture, developer training is an investment that pays off. Manicode Security offers customized training programs to meet the specific needs of teams, covering topics from secure coding fundamentals to advanced application security techniques. To learn more or schedule a session, Jim Manico can be reached at Jim@manicode.com.Tune in to the full episode to hear more insights from Jim Manico on how security training is shaping the future of application security.Learn more about Manicode: https://itspm.ag/manicode-security-7q8iNote: This story contains promotional content. Learn more.Guest: Jim Manico, Founder and Secure Coding Educator at Manicode Security | On Linkedin: https://www.linkedin.com/in/jmanico/ResourcesDownload the Course Catalog: https://itspm.ag/manicode-x684Learn more and catch more stories from Manicode Security: https://www.itspmagazine.com/directory/manicode-securityAre you interested in telling your story?https://www.itspmagazine.com/telling-your-story

MotorTrend's Ed Loh & Jonny Lieberman sit down with Scout Motors President & CEO, Scott Keogh! The guys discuss Scout's Reemergence into the Market with the Scout Traveler SUV & Terra Truck, Market Demand for EREVs, their Unique Electrification Strategy, Community UX Infotainment System, Consumer Reception, and How Their Plan to Refresh on the Modern American Truck & SUV Market.0:08 - The Vision Behind Scout's Revival.3:36 - Understanding Electric Range Extended Vehicles (EREVs).8:54 - Market Timing and Consumer Demand for EREV SUVs.9:11 - Getting a Look at the Scout Traveler & Scout Terra.12:00 - The Evolution of Scout's Electrification Strategy13:08 - Technical Considerations of EREVs vs. Pure EVs.17:55 - Consumer Reception and Market Insights.19:48 - Multi Platform Approach.23:10 - Understanding Customer Habits.27:17 - Understanding Scout Motors' Relationship with Volkswagen.31:17 - Navigating Complexity in EREVs.35:15 - The Role of Traditional Manufacturers in EV Transition.39:34 - User Experience and Community Engagement.41:11 - Direct To Consumer Sales Approach.44:07 - Innovative Design Choices in Scout Motors.51:02 - Community UX Infotainment System, Software Architecture and Over-the-Air Updates.56:54 - Brand Identity and Market Positioning.01:00:42 - Future Models and Market Strategy.01:04:32 - Challenges and Opportunities in the Truck & SUV Market.01:08:40 - Building an American Brand for the Future.