DEV

Eric Lamanna

Software and AI development podcast. We cover all things software development, including today's advanced AI development tricks and techniques.

  1. há 21 h

    White Label Software: The Shortcut That Could Make or Break Your Business

    For many businesses, the gap between a great software idea and an actual software product comes down to one thing: resources. White label development has emerged as a compelling way to close that gap — but like any strategic shortcut, it comes with fine print worth reading. This episode of Development walks through the full picture, drawing on the pros and cons of white label software development services to help listeners make an informed decision before committing to a partner or a contract. The episode covers the core mechanics of the white label model — where a third-party company builds the software and your business brands and delivers it as its own — then unpacks both the genuine advantages and the risks that tend to catch business owners off guard. Here's what's discussed: Speed to market: White label solutions start from a working foundation rather than zero, which is a significant edge when a market window is narrow or a competitor is already shipping.Cost efficiency: Avoiding the salaries, recruiting costs, and retention challenges of an in-house dev team can make the difference between having a product and not having one — especially for small and mid-sized businesses.Bundled expertise: The right white label partner brings specialists in your exact domain, whether that's healthcare compliance, fintech regulation, or another niche — without requiring you to recruit each one individually.Differentiation risk: If multiple competitors can license the same underlying platform, your branding and customer relationships — not the software itself — become your real competitive moat.Ownership and control: White label agreements vary widely in what you actually own. Customization limits, IP restrictions, and handoff constraints can all become problems if you're building a product your entire business depends on.Compliance and support gaps: Regulatory responsibility (GDPR, HIPAA, state-level data laws) stays with you regardless of who built the software, and your customer support team needs enough product knowledge to back up what you're selling.The episode closes with a practical framework for vetting a white label partner: getting clarity on intellectual property upfront, scrutinizing track records and client references, understanding the full pricing structure, and matching your partner's expertise to your specific industry. The takeaway isn't that white label development is good or bad — it's that it rewards businesses who go in with clear expectations and ask the hard questions before signing anything. For more on choosing the right external development partner, check out the earlier episode Outsourcing C++ Development: How to Find a Partner Worth Trusting. DEV

    8 min

  2. há 1 dia

    Outsourcing C++ Development: How to Find a Partner Worth Trusting

    C++ powers some of the most demanding software on the planet — from automotive braking systems and high-frequency trading engines to medical devices and AAA game physics. When internal teams are stretched thin or domain expertise simply doesn't exist in-house, outsourcing can be a smart strategic move. But the stakes of choosing poorly are uniquely high with C++, and the evaluation process deserves far more rigor than most teams give it. This episode walks through the practical framework laid out in the guide to evaluating outsourced C++ development partners — covering every dimension from technical vetting to contract language to long-term knowledge transfer. Here's what the episode covers: Domain specificity matters more than language familiarity — writing a compiler plugin and building a safety-critical medical device both require C++, but the skills involved are fundamentally different. Vendors must demonstrate expertise in your domain, not just the language.Concrete vetting over polished sales decks — requesting sample code or running a short paid pilot reveals far more than any portfolio presentation. Architectural choices around memory ownership, RAII patterns, and build system structure are honest signals of real competence.Code quality as a long-term asset — the right partner maintains static analysis tooling, runs sanitizers, enforces peer review, and writes tests that actually live in a CI pipeline. Poor documentation and absent code-health practices translate directly into hidden refactoring debt.Security, IP, and compliance are non-negotiable — vulnerabilities at the native layer are catastrophic, not just inconvenient. Evaluating a vendor's threat modeling process, secure coding practices, and open-source license handling is essential before any code is written — as is having legal counsel review IP assignment and NDA language upfront.Communication structure determines whether great code actually gets shipped — time-zone overlap, toolchain alignment, and direct access to the engineers writing the code all matter. A vendor who shields you behind a project manager at every turn is likely hiding skill gaps or staffing instability.Setting up the engagement for success from day one — defining scope precisely, establishing quantitative feedback loops, insisting on a mirrored CI pipeline, and starting knowledge transfer early all reduce vendor lock-in and make the eventual handoff far less painful.More from the show: if you're interested in pushing the boundaries of what's computationally possible, check out the recent episode on RevNets: Train Deeper Models Without Running Out of GPU Memory. DEV

    8 min

  3. há 2 dias

    RevNets: Train Deeper Models Without Running Out of GPU Memory

    Running out of GPU memory is one of the most common — and most frustrating — walls a deep learning engineer can hit. This episode of Development explores a powerful architectural fix that most developers never reach for: reversible residual networks. Drawing on this in-depth guide to building memory-efficient backprop with RevNets, the episode breaks down the math, the trade-offs, and the practical implementation steps in a way that's squarely aimed at working engineers. Here's what the episode covers: Why standard backprop is the real memory culprit — every layer caches its input activations for the backward pass, so memory scales as O(N) with network depth.The reversible block mechanism — splitting the feature map into two partitions and applying paired transformation functions F and G so that inputs can be algebraically reconstructed from outputs, eliminating the need to store them.The memory pay-off — moving from O(N) to O(1) activation memory, with real-world savings in the 40–50% range or more, potentially making the difference between a model that fits your hardware and one that doesn't.The honest trade-off — recomputing discarded activations during the backward pass costs roughly 1.5–2× the wall-clock time per iteration; understanding when that overhead is worth it is key to using RevNets wisely.Practical implementation in PyTorch — using libraries like torch-rev to drop reversible blocks into an existing network definition without custom CUDA kernels, keeping the training loop completely unchanged.Pitfalls to watch for — non-invertible layers like pooling, multi-GPU DDP compatibility, debugging without cached activations, and the cases where a standard ResNet is simply the better choice.The episode makes a clear case that when memory is the bottleneck, RevNets are a specialized but highly effective lever — one that lets you go bigger (deeper models, larger batches, higher resolution) on the same hardware rather than continuously shrinking your way to a fit. If memory pressure is a recurring constraint in your training workflows, this is an architectural option worth having in your toolkit. More from the show: if you're weighing framework decisions before you even start a project, check out the episode on React vs. Vue vs. Angular: Choosing the Right JavaScript Framework. DEV

    8 min

  4. há 3 dias

    React vs. Vue vs. Angular: Choosing the Right JavaScript Framework

    Picking a JavaScript framework isn't just a technical decision — it shapes how you hire, onboard engineers, structure your codebase, and maintain software years down the line. This episode of Development tackles one of the most debated questions in front-end development head-on, drawing on the React vs. Vue vs. Angular framework comparison from DEV to cut through social media noise and deliver a grounded, practical breakdown for developers and teams facing a real choice. Here's what the episode covers: React's strengths and trade-offs: Its massive ecosystem and job-market dominance are undeniable assets, but the freedom it grants teams also demands strong decision-making — and its rapid pace of paradigm shifts (class components → hooks → server components) isn't for everyone.Why Vue earns its "progressive framework" label: Built to scale both down to a single static page and up to a full SPA, Vue's single-file components, clean reactivity system, and cohesive official tooling make it a compelling middle ground between React's openness and Angular's rigidity.Angular as the enterprise-grade option: TypeScript, dependency injection, a CLI, routing, and testing all ship out of the box — a setup that suits large distributed teams and long-horizon projects, even if the learning curve and boilerplate are steep.The questions that actually drive the decision: Talent availability in your region, the expected lifespan and scale of the project, and your team's culture often matter more than any benchmark or feature comparison.The limits of "picking a winner": No single framework is objectively best — honest answers about team, timeline, and product goals are a more reliable compass than trending opinions.Staying adaptable for the long game: Whichever framework you land on, the JavaScript ecosystem will keep shifting; a commitment to continuous learning outweighs any logo in a package.json.For more on where JavaScript fits into the bigger picture, check out the earlier episode Why JavaScript Still Wins: Top Use Cases for Startups and Enterprises — a great companion listen to this one. DEV

    7 min

  5. há 4 dias

    Why JavaScript Still Wins: Top Use Cases for Startups and Enterprises

    JavaScript has spent thirty years defying expectations — born as a browser novelty, it now underpins cloud infrastructure, mobile apps, and real-time platforms at organizations of every size. This episode of Development uses this breakdown of top JavaScript use cases for startups and enterprises as its jumping-off point, making the case that JavaScript's dominance is less about trend-chasing and more about cold, practical engineering logic. Whether you're a founder placing your very first technology bet or an enterprise architect managing a sprawling legacy codebase, the episode walks through the full landscape of where and why JavaScript continues to win. Here's what's covered: Front-end development: How React, Vue, Angular, and newer compile-time frameworks like Svelte give startups access to massive UI ecosystems and give enterprises the TypeScript-backed structure needed to sustain complex interfaces at scale.Server-side development with Node.js: Why Node's event-driven, non-blocking architecture is a natural fit for REST APIs, GraphQL, microservices, and serverless functions — and how full-stack JavaScript reduces costly engineering silos.Cross-platform mobile: How React Native, Ionic, and Expo allow teams to share logic across iOS, Android, and the web — including over-the-air updates that sidestep slow app store approval cycles.Real-time and event-driven experiences: The tools (WebSockets, Socket.IO, RxJS) enabling collaborative documents, live dashboards, and instant messaging — and why lower latency translates directly to better user retention.Automation, testing, and DevOps: How Node.js lets teams write CI pipelines, end-to-end test suites with Playwright or Cypress, and even cloud infrastructure with AWS CDK or Pulumi — all in the same language they already know.Talent and longevity: Why covering the full stack with one language matters differently at each stage — generalist flexibility for startups, sustainable hiring pipelines and coherent onboarding for enterprises.The throughline across all five use cases is pragmatism over hype: JavaScript has earned its place at every layer of the stack by solving real problems for real teams. More from the show: if this episode's theme of enduring languages resonates, check out Why C++ Is Still a Top Choice for High-Performance Software in 2025 for a look at another language that refuses to be counted out. DEV

    8 min

  6. há 5 dias

    Why C++ Is Still a Top Choice for High-Performance Software in 2025

    Despite a constant parade of newer languages grabbing headlines, C++ continues to underpin some of the most performance-critical software on the planet — from high-frequency trading systems to AI inference engines to AAA game engines. This episode of Development cuts through the hype to examine the concrete, technical reasons why C++ isn't just surviving in 2025, but thriving. The discussion draws on the best practices for building scalable C++ applications outlined in the source article, applying those principles to the real architectural decisions engineers and CTOs face today. Here's what the episode covers: Raw, unmatched performance: C++ compiles directly to native machine code with no garbage collector or runtime overhead — and modern compilers like Clang 17 and MSVC 2025 push that advantage even further through auto-vectorization and aggressive inlining.Explicit memory control: The ability to design cache-friendly data layouts, write custom allocators, and place objects precisely in memory remains irreplaceable in domains where microseconds translate to real-world consequences.A dramatically safer modern toolchain: AddressSanitizer, ThreadSanitizer, static analyzers tied to the C++ Core Guidelines, and CI-integrated linting have transformed how safely teams can ship C++ — without surrendering low-level control.A living, evolving language standard: The three-year ISO release cadence has delivered smart pointers, move semantics, concepts, ranges, and coroutines — features that make contemporary C++ look far closer to Rust or Swift than to anything written in the nineties.Unrivaled portability and ecosystem maturity: C++ targets x86-64, Arm64, and RISC-V with minimal friction. Package managers like vcpkg and Conan 3 now offer dependency management competitive with npm or Cargo, while tools like pybind11 enable clean interoperability in polyglot architectures.Where it dominates in 2025: High-frequency finance, gaming and XR, autonomous robotics, AI compute backends (TensorRT, ONNX Runtime), and edge/telecom infrastructure all rely on C++ precisely because the fundamental physics of compute haven't changed — even if blog headlines suggest otherwise.The episode also addresses C++'s genuine trade-offs — long compile times, cryptic template errors, and foot-gun potential — and walks through the well-established mitigations that modern engineering teams use to manage them. The conclusion is clear: for workloads where speed, determinism, and broad hardware reach are non-negotiable, the more useful question in 2025 isn't "why C++?" but "do our requirements justify anything else?" For more on building intelligent tooling into your development workflow, check out the episode Build Smarter: Custom AI Workflows with N8N. DEV

    8 min

  7. há 6 dias

    Build Smarter: Custom AI Workflows with N8N

    Repetitive AI tasks — pulling data, prompting a model, cleaning the output, posting it somewhere — eat developer time without delivering proportional value. This episode of Development explores how n8n, an open-source visual workflow engine, changes that equation by letting teams prototype and ship AI automations without spinning up infrastructure from scratch every time. The discussion is grounded in this practical guide to custom AI workflow development using N8N.io, which rewards a careful read rather than a quick skim. The episode walks through what makes n8n a natural fit for AI-driven development and what it actually looks like to build something real with it. Key topics include: Why n8n fills a genuine gap: AI calls rarely live in isolation — they require input shaping, output validation, branching logic, and failure handling. N8n captures all of that in one shareable, version-controlled file.When to use n8n vs. a microservice: For stable, high-traffic integrations, a proper service with tests and a deployment pipeline makes sense. For the exploratory phase, n8n removes friction exactly when speed matters most.A concrete end-to-end example: The episode traces a workflow that polls an RSS feed, constructs a prompt, calls a language model via HTTP, cleans the output with deterministic code (not just prompt iteration), publishes to Twitter, routes failures to a Slack alert, and logs everything to a database — all in roughly ten minutes of configuration.Security and compliance: Using n8n's credentials store for API keys, scrubbing PII before payloads leave your infrastructure, and pointing the HTTP Request node at a self-hosted model when external LLMs aren't an option.Cost controls: Setting maximum iteration counters on loops, caching embeddings to avoid redundant generation, and routing tasks to cheaper models for drafts and more capable models only where genuinely needed.Production best practices: Committing workflow JSON to version control, using node Description fields to document reasoning, keeping prior versions inactive but recoverable, and enabling user management on shared instances.The throughline is straightforward: AI may feel like magic, but the engineering around it follows familiar patterns. N8n provides a canvas for applying those patterns — logging, retries, failure branching, security scrubbing — without rebuilding the scaffolding every time. The advice for teams new to the tool: start with one low-stakes automation that saves five minutes a day, build confidence in the approach, and grow from there. More from the show: if you're thinking about the broader backend ecosystem around AI, check out the episode Why Enterprises Keep Betting on Python for Backend Development. DEV

    8 min

  8. 26 de jun.

    Why Enterprises Keep Betting on Python for Backend Development

    Python isn't just surviving the era of Rust evangelism, Go's cloud-infrastructure push, and a never-ending parade of JavaScript frameworks — it's thriving inside the world's most demanding enterprise environments. This episode of Development digs into the analysis behind why enterprises are still choosing Python for backend development, unpacking a convergence of forces that make the language a uniquely durable bet for organizations with real stakes. The episode walks through five interconnected pillars that explain Python's enterprise dominance — each one more nuanced than a simple benchmark comparison: Ecosystem depth: With over 450,000 packages on PyPI and enterprise-hardened frameworks like Django and FastAPI, Python teams rarely build from scratch — they audit, integrate, and move on to solving the actual business problem.Developer productivity: Python's readability isn't just aesthetic — it measurably shortens onboarding, accelerates feature velocity, and creates cross-functional fluency between backend engineers, data scientists, and even product managers.Real-world scalability: Async runtimes (asyncio/ASGI), JIT tooling (PyPy, Cython), and stateless-by-design architectures mean Python handles production-scale load at companies like Netflix, Instagram, and Spotify — not by luck, but by deliberate architectural choice.Security and compliance: Built-in Django protections, static analysis via Bandit, OWASP-maintained Python guidelines, and native integration into AWS, Azure, and GCP compliance tooling have made Python a vetted link in the enterprise compliance chain — not a workaround.Business economics: A massive global talent pool, a single language that spans backend services, DevOps, data pipelines, and test automation, plus serverless-platform compatibility all reduce toolchain sprawl and long-term technical debt.Governance and longevity: Python's Enhancement Proposal process and active steering council keep the language evolving deliberately, with backward compatibility treated as a genuine priority — giving enterprises future-proofing without migration headaches.The episode closes with a reframe worth internalizing: the right question isn't why enterprises keep choosing Python, but what would realistically make them stop — and the honest answer is that there's nothing clearly visible on the horizon. More from the show: check out C++ in 2026: Why the 40-Year-Old Language Still Dominates High Performance for a complementary look at another language that refuses to be displaced. DEV

    9 min
Ver tudo (30)

Sobre

Software and AI development podcast. We cover all things software development, including today's advanced AI development tricks and techniques.

Informações

  • Criado por
    Eric Lamanna
  • Anos de atividade
    2 mil
  • Episódios
    30
  • Classificação
    Livre
  • Copyright
    © 2026 DEV.co
  • Site do podcast
    DEV