Goto

Interview with Elm creator Evan Czaplicki about Elm's slowed public releases and the personal, economic, and organizational reasons behind that decision. He discusses compiler and tooling work (notably error messages and cross-stack type safety), trade-offs in language and developer-experience design, and broader lessons about open-source sustainability, maintainer burnout, and business models for supporting language work.

Interview with Yevgeniy Brikman about practical DevOps and software delivery: why DevOps is about efficient, repeatable delivery; CI/CD, trunk-based development and feature flags; infrastructure-as-code (Terraform/Pulumi/OpenTofu), Kubernetes and app orchestration; platform engineering/IDPs; reconciliation loops, observability and interactive runbooks; and emerging paradigms like Crossplane and infrastructure-from-code.

Sheen Brisals’ GOTO 2025 talk explores how to recognize and manage complexity in serverless/cloud systems. He distinguishes essential vs accidental complexity, advocates decomposing systems via domain-driven design and bounded contexts, recommends governance for event-driven architectures (e.g., domain/enterprise event buses), warns against distributed monoliths (cross-account EventBridge sprawl), and promotes patterns like anti-corruption layers, modular primitives, composition and continuous refactoring.

A GOTO podcast interview about platform engineering covering how SRE and observability inform internal developer platforms, OpenTelemetry and vendor alignment, Kubernetes’ role as a building block (not a developer-facing platform), open-source maintenance challenges, onboarding and psychological safety, manager vs IC career choices, and operational priorities like build times and deployment cadence.

A GOTO podcast interview exploring "holistic engineering": making technical architecture and engineering decisions while explicitly factoring in non-technical forces (people, org processes, product strategy, career frameworks, history). Vanessa names common anti-patterns (kitchen sink, Swiss-army knife, multi-layer strangulation, problematic shared domain libraries), describes how to diagnose root causes and remediate them (reverse-engineer decisions, align domain-team-architecture, be realistic about investment vs. debt), and argues for cross-functional conversations and ethical engineering.

Abby Bangser interviews Kief Morris about the third edition of his book Infrastructure as Code. They review IaC's evolution (from CFengine/Puppet to Terraform, containers, serverless), the limits of low-level tooling and state files, the need for higher-level abstractions and reusable components, operational concerns (monitoring, testing, observability), platform engineering and team-topology considerations, and potential roles for AI in infrastructure workflows.

Robbie Kohler describes how his team rebuilt a global middleware product (Bite Connect) under a tight deadline by applying clear win conditions, pragmatic trade-offs, and composing AWS serverless primitives (API Gateway, Lambda, Step Functions, DynamoDB, SQS). He covers event-driven patterns (throttling, debounce, event schedules), active-passive multi-region resiliency, cost-conscious design, and early use of AI to accelerate development and ops; the system shipped quickly and met business KPIs.

Advocates starting automated testing from day one: write unit tests as the foundation, then add API, scenario, web and end-to-end tests. Testing should be automated and integrated into the development pipeline, and testers should learn to write code to implement those tests.

Interview with Alice Bartlett, Tech Director at the Financial Times, about leading the customer-products engineering organization (ft.com and apps). She discusses team structure and career tracks (IC vs manager), handling technical debt via a multi-phase rewrite of the content rendering pipeline, stakeholder management between editorial and commercial teams, handing work to platform teams, and her perspective on how AI/code-generation tools will change engineering review and skill requirements.

Dave Cheney describes lessons from building Contour, a Kubernetes ingress controller using Envoy. He covers Kubernetes ingress responsibilities, Contour’s architecture (translating Kubernetes API into Envoy config), Go-specific engineering practices (package layout, goroutine management, dependency handling), Docker/multi-stage builds and developer inner-loop strategies, and a pragmatic testing approach (unit, integration and deterministic end-to-end harnesses).

An interview with Dave Thomas about his book Simplicity, arguing developers should pursue minimal, maintainable designs via an orient–step–learn feedback loop, build intuition through recorded feedback, reduce unnecessary dependencies and meetings, use testing as a design tool, and exercise individual agency when organizations resist change.

Interview from the GOTO book club about the book "ASP.NET Core 9 Essentials." The authors describe the book’s structure (foundations to cloud-native), target readers (developers with programming background), and practical coverage: building UIs and Web APIs, persistence and security, best practices, and operational topics such as observability (OpenTelemetry), feature flags/App Configuration, containers and deployment. The book includes example code on GitHub and aims to guide developers from basics to cloud-native operations.

Conference talk describing how Confab used AWS serverless services (AppSync, Step Functions, Lambda@Edge, CloudFront, Bedrock) to build an event networking app in 15 days, covering real-time chat, push notifications, QR networking, automated payouts, AI-powered suggestions, and the business/technical benefits of serverless for speed, scalability and sustainability.

An interview with Piotr Sarna about writing technical content for developers: his path from engineering to writing and co-authoring a book, the editorial workflow (working with a co-author/editor), and distilled patterns for technical posts (bug-hunts, rewrites, how-we-built-it, lessons learned, trends, benchmarks). The episode covers practical advice on audience targeting, keeping posts concise, dealing with criticism, the benefits of publishing (visibility, hiring), and where to find more resources.

Luca Mezzalira’s GOTO 2025 talk examines how to integrate AI tools and LLM-powered code assistants into the design and implementation workflow for micro-frontend architectures. He explains differences between components and micro-frontends, a decision framework for splitting and composing micro-frontends (vertical/horizontal, SSR/CSR, routing, communication), and the need to document architectural context. He recommends context engineering, iterative prompt/code generation, automation (dependency updates, fitness functions, architectural tests like ts-arch), and emphasizes refactoring, developer judgment, and organizational factors. Practical use cases covered include modernization/migrations, rapid prototyping, testing, and UI generation, along with warnings about overreliance on AI.

A wide-ranging interview on applying classic software-engineering principles (modularity, cohesion, separation of concerns, abstraction, managed coupling) to data and platform problems. The speakers discuss data-mesh-style domains, automated ETL (parquet/Delta Lake on S3), schema and coupling issues between transactional microservices and analytic datasets, platform-as-product practices to avoid developmental coupling, and the role of CI/CD and TDD in producing stable, usable interfaces.

Interview with Naomi Ceder and Fabrizio Romano about the 4th edition of Learn Python Programming. They discuss the author’s background, editorial changes (removing GUI content, adding command-line applications and coding challenges), the evolution and trade-offs of Python typing, collaboration with a co-author, the role of AI coding assistants, and mentoring/team development.

A podcast interview exploring platform engineering’s blind spots: the tendency to focus on platform tooling and delivery velocity while under-emphasizing business-facing APIs, optionality, and organizational alignment. Guests argue platforms should promote reusable building blocks by default, shift appropriate responsibilities "down" into the platform, and keep business outcomes central—start small, measure, and design defaults that encourage reuse and composability.

A GOTO 2025 panel where senior engineers debate what software architecture really is — emphasizing it as a communication and people problem. They cover emergent vs deliberate/sustainable architecture, architecturally significant decisions and quality attributes (ATAM), ADRs/architecture hubs to scale decision-making, messaging/protocol trade-offs (gRPC vs Kafka), the monolith↔microservices debate, and the role of coaching and culture in making good architectural choices.

Martin Fowler recounts his role in the birth of Agile/Extreme Programming, describing the shift from upfront design to evolutionary design enabled by practices like testing, continuous integration, and refactoring (including databases). He stresses close collaboration with business stakeholders, pair programming, ubiquitous language/DDD ideas, and practical uses of GenAI for legacy analysis, and comments on measuring developer productivity.