Advertise on podcast: Techsplainers by IBM

This episode of Techsplainers explores the security challenges surrounding non-human identities and why governing them effectively has become a critical runtime security issue. As machine identities multiply across cloud, on-premises, and hybrid environments, many organizations are struggling with poor visibility, inconsistent controls, and access paths that fall outside traditional identity oversight. The episode examines how ephemerality, elasticity, automation, and AI-driven systems are making NHI sprawl harder to track and easier to misuse. It explains how shadow access forms when service accounts, tokens, and automated workflows gain permissions without clear ownership or lifecycle controls. Listeners will also hear about the operational burden teams face when manually rotating credentials, coordinating across engineering and security, and managing identities that can remain active for long periods. From there, the discussion turns to what effective governance looks like: unified identity management, centralized secrets controls, automated lifecycle processes, real-time posture monitoring, and just-in-time access. Practical actions are included to help teams reduce risk quickly while improving visibility and accountability across machine-driven environments. Find more information at https://www.ibm.com/think/insights/non-human-identity-guide Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast Narrated by Anna Gutowska

This episode of Techsplainers explores vibe coding security risks and examines what can happen when AI-generated code is trusted too quickly. Building on the earlier episodes in the series, it explains how vibe coding can speed up prototyping and development while also introducing security concerns that are easy to miss when code appears to work on first pass. The episode covers common risks such as insecure defaults, hardcoded credentials, weak validation, vulnerable dependencies, copied anti-patterns and overly broad permissions. It also looks at the human side of the issue, including how rapid AI-assisted coding can encourage teams to skip review or deploy code they do not fully understand. Along the way, the discussion connects these risks back to shift-left security, static code analysis, AI unit testing and AI debugging as part of a broader secure development practice. It concludes with practical guardrails like human code review, automated scanning, least privilege and clear governance for prompts and generated code. Find more information at https://www.ibm.com/think/insights/vibe-coding-security-risks Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast Narrated by Ian Smalley

This episode of Techsplainers explores AI debugging and how artificial intelligence can assist developers in finding, understanding and fixing software problems. Building on earlier episodes about shift-left security, static code analysis and AI unit testing, understanding and fixing software problems. Building on earlier episodes about shift-left security, static code analysis and AI unit testing, it explains how debugging fits into the broader effort to catch and resolve issues earlier in the development lifecycle. The episode walks through how AI tools can analyze code, stack traces, logs and test failures to suggest likely causes, summarize complex information and propose draft fixes. It also distinguishes between using AI to debug traditional software and debugging AI-powered systems themselves, where problems may involve prompts, retrieval quality, inconsistent outputs or model behavior rather than a single broken line of code. Along the way, it highlights the benefits of faster triage, clearer context and guided fix suggestions, while also addressing the limits of pattern-based recommendations, missing business context and overreliance on generated answers. The episode closes by connecting AI debugging to the upcoming discussion of vibe coding security risks. Find more information at https://www.ibm.com/think/topics/ai-debugging Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast Narrated by Ian Smalley

This episode of Techsplainers explores AI unit testing and how artificial intelligence can support one of software development’s most common quality practices. Building on the earlier episodes about shift-left security and static code analysis, it explains how unit tests check small pieces of code in isolation and how AI can help generate test cases, identify edge conditions, improve coverage and maintain tests as code changes. The episode also clarifies an important distinction between using AI to help test traditional software and testing software components that themselves rely on AI models or probabilistic outputs. Along the way, it examines the practical benefits of faster test creation, broader scenario coverage and stronger support for continuous development workflows. It also addresses the limits of AI-generated tests, including shallow assertions, duplicated assumptions, brittle test suites and the continued need for human review. Finally, the episode places AI unit testing within a larger development strategy that includes code analysis, debugging and secure review practices. Find more information at https://www.ibm.com/think/topics/ai-unit-testing Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast Narrated by Ian Smalley

This episode of Techsplainers explores static code analysis, a development practice that inspects source code without running the application. Building on the series opener about shift-left security, it explains how static analysis helps teams identify potential bugs, security flaws and code quality issues earlier in the software development lifecycle, when fixes are typically simpler and less costly. The episode walks through how these tools work by scanning code and less costly. The episode walks through how these tools work by scanning code against rules and models, and it clarifies the difference between simple rule checks and deeper data flow analysis. It also explains how static code analysis can reveal issues such as insecure input handling, hardcoded secrets, dead code and possible SQL injection risks. Along the way, the episode examines the benefits of consistent automated scanning, faster feedback for developers and better support for code review, while also addressing practical limitations like false positives and the fact that static analysis cannot detect every runtime problem. Finally, it places static code analysis within a broader strategy that also includes testing, debugging and secure review practices. Find more information at https://www.ibm.com/think/topics/static-code-analysis Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast Narrated by Ian Smalley

This episode of Techsplainers introduces shift-left security, the practice of moving security earlier in the software development lifecycle instead of treating it as a final review step. It explains how teams can build security into planning, coding, testing and delivery workflows so vulnerabilities are found when they are easier and less costly to fix. The episode walks through the logic behind the approach, clarifies how shift-left security fits modern development methods like CI/CD, and defines related concepts such as static application security testing and software composition analysis in plain language. It also explores the benefits of earlier detection, reduced remediation effort and stronger collaboration between development and security teams, while addressing common challenges like alert overload, false positives and skills gaps. Finally, it sets up the rest of the series by showing how topics like static code analysis, AI unit testing, AI debugging and AI-generated code risks connect back to this broader security approach. Find more information at https://www.ibm.com/think/topics/shift-left-security Find all the Techsplainers episodes here https://www.ibm.biz/techsplainers-podcast Narrated by Ian Smalley

Quantum memory is designed to record, preserve and retrieve quantum states without destroying the properties that make quantum computing possible. Matt Finio explains how quantum memory differs from classical memory and explores concepts including qubits, superposition, decoherence, the no-cloning theorem and quantum error correction. The episode also examines solid-state systems, cold atoms, trapped ions and the role of memory in quantum networks, repeaters and a future quantum internet.Find more information at: https://www.ibm.com/think/topics/quantum-memoryFind all the Techsplainers episodes here: https://www.ibm.biz/techsplainers-podcast Narrated by Matt Finio

Disaggregated hyperconverged infrastructure, or dHCI, combines the centralized management of hyperconverged infrastructure with the ability to scale storage and compute separately. Matt Finio explains how dHCI differs from traditional three-tier architecture, converged infrastructure, standard HCI and cloud infrastructure. Learn where dHCI can improve efficiency, reduce overprovisioning and support AI, analytics and mixed enterprise workloads.Find more information at: https://www.ibm.com/think/topics/dhciFind all the Techsplainers episodes here: https://www.ibm.biz/techsplainers-podcast Narrated by Matt Finio

Disaggregated storage separates storage resources from compute and reconnects them through a high-speed network. In this episode, Matt Finio explains how this architecture enables independent scaling, shared data access and more efficient infrastructure refresh cycles. Discover the role of software-defined storage, NVMe over Fabrics, TCP, RDMA and Fibre Channel, along with the benefits and challenges of disaggregated storage for AI, cloud services and distributed systems.Find more information at: https://www.ibm.com/think/topics/disaggregated-storageFind all the Techsplainers episodes here: https://www.ibm.biz/techsplainers-podcast Narrated by Matt Finio

EEPROM and flash are both types of non-volatile memory, but they are designed for very different jobs. Matt Finio explains how EEPROM supports precise byte-level updates, while flash memory handles larger blocks of data at scale. Explore their differences in endurance, capacity, speed and cost, along with common applications in embedded systems, smartphones, SSDs, enterprise storage and AI infrastructure.Find more information at: https://www.ibm.com/think/topics/nvme-vs-sataFind all the Techsplainers episodes here: https://www.ibm.biz/techsplainers-podcast Narrated by Matt Finio

What is the difference between NVMe and SATA? In this episode, Matt Finio explains how these storage protocols work, why NVMe delivers faster performance and lower latency, and why SATA remains useful for legacy systems, backups and everyday workloads. Learn how drive types, protocols and form factors such as M.2 affect storage compatibility, performance and purchasing decisionsFind more information at: https://www.ibm.com/think/topics/eeprom-vs-flashFind all the Techsplainers episodes here: https://www.ibm.biz/techsplainers-podcast Narrated by Matt Finio

This episode of Techsplainers explores the core phases of a post-quantum cryptography transition and why organizations should approach it as a long-term transformation program rather than a one-time technical upgrade. As post-quantum cryptography standards become available and the risk of “harvest now, decrypt later” attacks grows, CIOs and security leaders can structure a realistic path toward quantum-safe readiness. The episode introduces a three-phase transition model: 1. Preparing teams through awareness and risk assessment 2. Preparing the organization with governance, roadmaps and cryptographic observability 3. Running the migration through prioritized execution, testing and crypto-agile design. Listeners will also hear about practical challenges in migrating core infrastructure and legacy technologies. Overall, the episode provides a grounded framework for managing one of the most important cybersecurity transitions of the coming decade. Find more information at https://www.ibm.com/think/insights/cios-must-prepare-their-organizations-today-for-quantum-safe-cryp... Find all the Techsplainers episodes here: https://www.ibm.biz/techsplainers-podcast Narrated by Teaganne Finn

This episode of Techsplainers explores why the transition to post-quantum cryptography matters right now. As quantum computing advances and governments move from long-term strategy to concrete deadlines, the discussion explains why this moment represents a turning point for organizations responsible for protecting sensitive data, critical systems, and long-lived digital assets. The episode examines the convergence of five forces shaping the present moment: advancing quantum capability, “harvest now, decrypt later” risk, the availability of post-quantum cryptography standards, new government directives, and the long timelines required for cryptographic migration across large IT environments. It also explains how recent executive orders in the United States signal a shift from awareness to structured execution, especially for federal agencies, contractors, and organizations connected to regulated ecosystems. Find more information at https://www.ibm.com/think/perspectives/americas-quantum-moment-two-new-executive-orders-signal-new-e... Find all the Techsplainers episodes here: https://www.ibm.biz/techsplainers-podcast Narrated by Teaganne Finn

This episode of Techsplainers explores crypto-agility and why it has become a critical part of quantum-safe readiness. As organizations prepare for the transition to post-quantum cryptography, the challenge is not only selecting stronger algorithms, but also making cryptographic systems easier to find, manage, and update across complex IT environments. The episode explains crypto-agility as the ability of systems and organizations to rapidly adapt cryptographic mechanisms in response to new threats, evolving standards, and newly discovered vulnerabilities. It walks through the three core pillars that make this possible: architecture, automation, and governance. The discussion also covers the importance of cryptographic discovery, third-party dependencies, implementation risks, and emerging tools such as the Cryptography Bill of Materials. Overall, the episode shows how crypto-agility supports a step-by-step migration to quantum-safe cryptography while helping organizations build a more flexible and resilient long-term security posture. Find more information at https://www.ibm.com/quantum/blog/crypto-agility. Find all the Techsplainers episodes here: https://www.ibm.biz/techsplainers-podcast Narrated by Teaganne Finn

This episode of Techsplainers explores quantum-safe cryptography, the security approach designed to protect sensitive data, digital access, and communications in the era of quantum computing. The episode explains why modern cryptography has remained so effective for decades, and why future quantum systems could eventually threaten widely used public-key methods such as RSA, Diffie-Hellman, and elliptic curve cryptography. Listeners are guided through the basics of encryption and authentication, the difference between public-key and symmetric cryptography, and how quantum algorithms such as Shor’s and Grover’s change the long-term security picture. The discussion also clarifies an important distinction: quantum-safe cryptography is not the same as quantum cryptography. The episode also covers why this issue matters now, including long migration timelines, “harvest now, decrypt later” risks, the role of NIST standards, and the importance of crypto-agility. Find more information at https://www.ibm.com/think/topics/quantum-safe-cryptography Find all the Techsplainers episodes here: https://www.ibm.biz/techsplainers-podcast Narrated by Teaganne Finn