Interviews with some of the experts in cloud and hosting industry. Our guests are on the front lines actually doing the work and giving you real world context.
Site
RSS
Apple
Données mises à jour le 14/07/2026
Classements récents
Dernières positions dans les classements Apple Podcasts et Spotify.
Liens partagés entre épisodes et podcasts
Liens présents dans les descriptions d'épisodes et autres podcasts les utilisant également.
Découvrez des podcasts liées à Cloud Experts Unleashed. Explorez des podcasts avec des thèmes, sujets, et formats similaires. Ces similarités sont calculées grâce à des données tangibles, pas d'extrapolations !
In this episode, your hosts Ben Nadel and Ryan Brown go guest-free and take the opportunity to dive into ColdFusion bugs, guinea pig maintenance, and their latest experiments in app building and AI usage.They kick things off with some light banter, guinea pig parenting tips, and custom shoes, before transitioning into deep debugging talk, asynchronous programming quirks in ColdFusion 2025, and the evolving relationship developers have with AI tooling.Key Points• Ryan surprises Ben with custom ColdFusion-themed shoes for the upcoming CF Summit.• Ben shares two deep ColdFusion 2025 bugs related to asynchronous iteration and CFQuery behavior.• Big Sexy Poems—a side project by Ben—is being built using HTMX and AlpineJS with a ColdFusion backend.• Debugging ColdFusion edge cases requires intense reduction and isolation of code to find root causes.• Ryan and Ben discuss AI voice mode frustrations and using AI for sales and dev support—highlighting both promise and pitfalls.Ben introduces his new ColdFusion 2025 app, “Big Sexy Poems,” and why he built it.• The app helps poets count syllables, find rhymes, and synonyms using the Datamuse API.• Ben is rebuilding it to learn HTMX and AlpineJS in a real-world context.• ColdFusion 2025 forces him to rethink and modernize old code written for CF2021.• Features include caching, shareable links, and saving user poems.Ben outlines two complex ColdFusion bugs that derailed development.• Bug #1: CFQuery inside asynchronous iteration dumps SQL statements to the page.• Bug #2: A three-level deep array iteration causes closure variables to vanish.• Both bugs are confirmed to go back as far as ColdFusion 2021.• Fixes required rewriting code to remove async parallelism and use manual loops.They explore how to isolate and debug ColdFusion bugs in large codebases.• Ben shares his method: reduce files down to minimal reproducible cases.• Progressively merge and remove components until only the bug trigger remains.• Use CF’s ability to simulate services to isolate logic layers during debugging.• Debugging complex async issues often takes hours but can result in 20-line reproductions.Conversation pivots to AI tools, frustrations, and how Ryan uses AI for sales support.• Ben tried ChatGPT voice mode again and found it frustratingly sycophantic.• Ryan uses persona-driven GPTs to simulate sales coaches and customer role-play.• Operator and GPT Agents have shown promise in configuring servers from specs.• Even advanced tools sometimes fail mid-task or require lots of oversight.• The team plans a live Ben and Ryan Show at CF Summit to talk AI and dev tools in person.
Ben & Ryan Show - Vibe Coding
Épisode 23
mercredi 20 août 2025 • Durée 01:19:33
Ben & Ryan Show Episode 23
In this episode, your hosts Ben Nadel and Ryan Brown are joined by Mark Takata, Senior Technical Evangelist for Adobe ColdFusion, to dive deep into the evolving world of "vibe coding" and how AI is transforming development workflows. The trio explore the tools, mental friction, and cultural shifts developers face when working alongside AI, offering a mix of real-world use cases, developer gripes, and future-gazing insights into how AI might shape team structure and job roles.
Key Points
• Vibe coding is reshaping how developers approach prototyping, testing, and feature iteration using tools like Claude, ChatGPT, and Cursor
• Developers are grappling with trust issues, debugging quirks, and the loss of "good friction" in the coding process
• Cursor, a VS Code-based AI IDE, is emerging as a powerful tool for AI-assisted development and code generation at scale
• AI could reshape team roles, potentially phasing out junior positions and introducing roles like AI coaches or prompt engineers
• The group previews their upcoming live session at the Adobe ColdFusion Summit, where these AI coding dynamics will take center stage
Vibe coding is introduced as a developer trend where AI tools generate code based on high-level input
• Ben shares that his team's lead has spent months learning how to "steer" Claude and manage scope, memory, and output reliability
• Ryan recounts building a Bingo app with ChatGPT, running into scope creep and frustrating regressions with each iteration
• The team discusses the challenge of context loss and how to handle patching or manually adjusting code when working with AI
Ben & Ryan Show - BoxLang
Épisode 22
lundi 28 juillet 2025 • Durée 01:24:23
Ben & Ryan Show Episode 22
In this episode, your hosts Ben Nadel and Ryan Brown sit down with Luis Majano and Daniel Garcia from Ortus Solutions to dive deep into BoxLang, the dynamic new language for the JVM. From modular design to multi-runtime capabilities and modern tooling, this conversation explores past, present, and future of BoxLang.
BoxLang is introduced as a dynamic JVM language designed to bring modularity, productivity, and compatibility to CFML and Java developers
• Supports multiple parsers, including ColdFusion and Lucee
• Designed for serverless, desktop, web, and embedded device runtimes
• Built from scratch rather than forking existing JVM languages like Groovy
• AST-driven transpilation makes it future-friendly and language-agnostic
• Modular runtime allows lean deployments without unnecessary overhead
The discussion explores the difference between static and dynamic languages and how BoxLang blends both paradigms for flexibility and control
• Dynamic types allow runtime decisions and simpler syntax
• Static typing can still be used where guardrails are helpful
• Designed for developers who want modern language flexibility with compiler-like structure
• Enables smoother transitions for CFML developers familiar with dynamic paradigms
• Brings in innovations absent in the JVM space for over a decade
Luis and Daniel outline how BoxLang was purposefully built to address long-standing developer frustrations and legacy CFML limitations
• Entire language and ecosystem are modular and extensible
Ben & Ryan Show - Adobe ColdFusion Hackathon
Épisode 21
mardi 15 juillet 2025 • Durée 55:51
In this episode, your hosts Ben Nadel and Ryan Brown are joined by guests Ray Camden and Wade Bachelder to break down their experiences at the recent Adobe ColdFusion 2025 Hackathon. Together, they dive into the projects, challenges, bugs, and lessons learned while exploring new CFML features like CSV handling, charting, and Java integration.
Key Points
• Wade, Ray, and Ben each created unique apps that showcased new CF2025 features like CSV processing, charts, and cfCatch improvements
• Participants found critical bugs in the charting and CSV implementations, sparking valuable discussion
• They explored integration possibilities with Java, BoxLang, and Maven, discussing tradeoffs and developer ergonomics
• The hosts offered thoughtful feedback to Adobe on how to improve future hackathons, including ideas for in-person events and broader outreach
Wade describes his security-focused project that visualized CVEs using ColdFusion's updated charting and CSV features
• He used CVE data to build pie and line charts comparing vulnerabilities across ColdFusion and Adobe
• Found that new charting features were brittle and theming often broke rendering
• Deployed "classic" CFML mixing old tag-based code with modern features
Ray walks through his one-file bug tracker project designed for quick logging without a database
• Wrote bug data to a CSV file for Excel or Jira import
• Used minimal dependencies, all loaded via CDN
• Added simple HTML charts despite his long-standing dislike for CF's client-side tools
Ben explains his Sitter Snacks app, a lighthearted tool for logging snack preferences using CF's CSV features
Ben & Ryan Show - wheels.dev
Épisode 20
jeudi 3 juillet 2025 • Durée 01:29:55
In this episode, your hosts Ben Nadel and Ryan Brown are joined by Peter Amiri, the current maintainer of the Wheels framework (formerly CF Wheels), to discuss its evolution and future. They dive into the history of the ColdFusion-based framework, its comparison with other MVC options, and how it's being modernized for AI-assisted development.
Key Points
• Wheels is a CFML MVC framework inspired by Ruby on Rails, focused on convention over configuration.
• Peter Amiri discusses taking over as maintainer and revitalizing the project with better tooling, testing, and documentation.
• The team explains the pros and cons of adopting Wheels over other frameworks like ColdBox and Framework One.
• Extensive discussion on integrating Wheels into legacy apps and migrating code incrementally.
• Exploration of AI’s potential role in software development and how Wheels is being shaped to support AI-driven tooling.
When Ben and Ryan introduce Peter Amiri, they quickly establish his role as the maintainer of the Wheels framework and dive into what the framework is and its CFML roots.
• Wheels uses the MVC pattern and draws inspiration from Ruby on Rails.
• It emphasizes convention over configuration, simplifying developer onboarding.
• Originated as ColdFusion on Wheels and recently dropped “CF” to become more inclusive.
Peter discusses his motivation to maintain Wheels and shares his experience of revitalizing the project as the former maintainers stepped away.
• Took over after the previous team burned out, motivated by personal reliance on the framework.
• Focused on reducing friction for contributors and users.
Ben & Ryan Show - Catching Up
Épisode 19
mercredi 25 juin 2025 • Durée 58:09
Ben & Ryan Show Episode 19
In this episode, your hosts Ben Nadel and Ryan Brown catch up after a short hiatus with a wide-ranging, unscripted conversation covering everything from the latest ColdFusion trends to personal experiments with AI and vibe coding. With no guest this time, it's a freestyle episode filled with developer insights, community stories, tech musings, and even a few nostalgic tangents about their careers and upcoming conferences.
Key Points
• Ryan shares insights from attending Into the Box
• Ben discusses his limited but productive use of AI, leveraging pseudocode to retain creative ownership of his code.
• The hosts dive into technical and philosophical challenges around AI-assisted development, including context limits, prompt strategies, and tooling.
• Fun anecdotes cover experiments with vibe coding, from building a bingo app to letting kids iterate on games in Replit.
• They preview plans for ColdFusion Summit, hinting at retro themes and marketing tactics like well-chosen swag.
The hosts kick off their catch-up with banter about attending Into the Box
• Into the Box was professionally run with in-depth sessions and tons of fun like mariachi karaoke.
• Ryan explores the idea of xByte Cloud sponsoring future ColdFusion events.
• Discussion of possible future guests from the "Box" ecosystem
• Ben shares his troubles getting BoxLang running in CommandBox due to Java version conflicts.
They reflect on how AI is influencing development workflows, particularly through testing and safe deployments.
• Testing is increasingly seen as essential, especially with frequent Adobe ColdFusion patches.
Ben & Ryan Show - ColdFusion Custom UDFs
Épisode 18
mardi 22 avril 2025 • Durée 01:36:54
Ben & Ryan Show Episode 18
In this episode, your hosts, Ben Nadel and Ryan Brown, are joined by longtime ColdFusion developer James Moberg, CTO of Sunstar Media, for a deep-dive into the wild world of user-defined functions (UDFs) and decades of real-world development hacks. From building custom tools that bridge gaps in ColdFusion and Lucee, to mastering performance and security through clever abstraction, the crew shares a treasure trove of lessons learned from the trenches.
Key Points
• James shares his approach to building reusable ColdFusion UDFs that work across Adobe CF and Lucee.
• The crew explores performance wins using command-line tools versus built-in CF tags like CFZip and CFImage.
• Strategies are shared for data sanitization, accessibility, and obfuscation using tools like Jsoup and hashing functions.
• They discuss how caching, output buffering, and shadow DOM techniques can power dynamic web experiences and secure flows.
• Real talk on AI’s limits when it comes to ColdFusion code generation—and why real-world testing still matters.
Different kinds of UDFs and how naming collisions and platform differences have influenced his work.
• Three main categories of UDFs: logic abstraction, proxying functionality, and UI simplification.
• Discusses how CF versions and Lucee differ in function availability and behavior.
• Talks about CF Backport as a strategy for extending older ColdFusion versions.
A spirited discussion on real-world cross-platform quirks, unscoped variables, and strategies for HTML standardization.
Ben & Ryan Show - Surviving Ransomware
Épisode 17
mardi 15 avril 2025 • Durée 01:21:42
Ben and Ryan Show Episode 17
In this episode, your hosts Ben Nadel and Ryan Brown are joined by Peter Amiri to share the gripping, real-world story of what it's like to experience—and recover from—a devastating ransomware attack. They dive deep into the technical and emotional toll of cyber extortion, walking through how it happened, what went wrong, and the long road to restoring operations while learning critical lessons along the way.
Key Points
• Peter recounts a ransomware attack that began with a zero-day exploit in their firewall and resulted in full encryption of their Windows-based infrastructure.
• Despite following industry best practices like 3-2-1 backups, cyber insurance, and EDR tools, the breach occurred due to overlooked alerts and underestimated risks.
• The team responded by cutting internet access, engaging incident response vendors, and rebuilding their environment from scratch in parallel with negotiating a ransom.
• Lessons include the critical need for MDR services, verified air-gapped backups, centralized SSO/MFA security, and proactive disaster recovery planning.
• Ultimately, the company recovered within 8 days, avoiding catastrophic data loss by leveraging unencrypted legacy copies and strategic capacity planning.
Peter discusses the company's security posture before the attack
• Cyber insurance renewals demanded increased security: MFA, then EDR, leading to major financial investment.
• EDR picked up early malicious activity, but alerts were missed due to noise and lack of security specialization.
• Overconfidence in lesser-used virtualization tools contributed to a false sense of security.
• Alarm fatigue contributed to overlooking early breach signals.
Ben & Ryan Show - CMS Deep Dive
Épisode 16
lundi 7 avril 2025 • Durée 01:22:32
Ben and Ryan Show Episode 16
In this episode of the Ben and Ryan Show, hosts Ben Nadel and Ryan Brown are joined by guest John Nessim to explore the evolving world of content management systems (CMS). With his deep development background and years of practical experience, John dives into everything from traditional platforms like WordPress to advanced headless CMS solutions, offering valuable insights into when and why to choose different tools for your website.
Key Points:
• CMS platforms have evolved to balance user-friendliness with developer control, from WYSIWYG editors to headless solutions.
• WordPress dominates the market but can be bloated and vulnerable if not managed properly.
• Headless CMS options like Strapi and Sanity allow for greater flexibility, scalability, and multi-platform content distribution.
• Accessibility enhancements not only improve user experience but also deliver measurable SEO benefits.
• Choosing the right CMS depends on business maturity, scalability needs, and how content is consumed and maintained.
Definition and purpose of a CMS
• The key function of CMS is to give control over content to non-developers.
• Static site generators may not qualify as CMS unless they include content creation tools.
• CMS evolved from managing unstructured text to structuring rich data like events and services.
• Headless CMS is described as content blocks managed separately from the front-end template.
Headless CMS
• Headless CMS organizes content in blocks delivered via APIs (usually JSON/XML).
Ben & Ryan Show 2025 Early Reflections
Épisode 15
mardi 11 mars 2025 • Durée 01:07:15
In this episode, your hosts Ben Nadel and Ryan Brown take a break from their usual guest interviews to reflect on their personal and professional journeys in the first months of 2025. They discuss major career transitions, the challenges of job hunting in today's market, and the evolving landscape of software development, all while sharing personal stories and insights on adapting to change.
Key Points:
• Ben shares his transition from co-founding Envision to joining a new company in a completely different industry, facing a steep learning curve.
• Ryan talks about how networking and content creation play a key role in career opportunities, and why developers should build a public presence.
• They discuss the struggles of job searching, from dealing with stress and rejection to navigating a shifting industry.
• The importance of continuous learning, including Ben’s deep dive into CF Wheels and Ryan’s exploration of AI tools for productivity.
• A surprising story about purchasing fake AirPods from a major retailer and the unexpected resolution.
Ben reflects on his career shift after Envision’s closure, now working with Peter Amiri in a company focused on truck parts manufacturing.
• He describes the shift from self-directed work to structured teamwork and ticket-based workflows.
• Adjusting to new processes, communication methods, and working with a small but growing development team.
• Learning CF Wheels as part of the new job and the challenges of adapting to a new framework.
• The difficulty of balancing personal projects with work and feeling mentally exhausted from constant adaptation.
Ryan discusses his experience with job hunting and how networking made all the difference.
Mark breaks down his real-world usage of Cursor and how it differs from using ChatGPT
• Developers can open existing projects, give directions, and have Cursor fill in the gaps based on previous patterns
• He highlights how he uses it to rapidly prototype ColdFusion demos, noting an increase in productivity and output
• Cursor allows mixing Claude, GPT, and Check55 models for different task types
• Pro-level versions of Cursor offer metrics, visibility into prompt volume, and sophisticated model orchestration
Ben reflects on his preference for copy-paste workflows over AI generation
• He points out the "non-deterministic" nature of AI and the potential for it to introduce unseen changes across entire files
• The team debates whether AI is removing helpful friction that leads to better abstractions and more thoughtful code
• The trio agrees that AI needs better guardrails and consistency for it to be fully trusted in production codebases
The group explores how AI tools could evolve to meet professional coding standards
• Cursor could serve as a CFQuery-like abstraction for AI tooling, handling the translation between models
• AI-generated code may need standardization through community-driven templates or frameworks like PromptOS
• The role of code review could shift, with AI models doing first-pass reviews and flagging issues for humans
• Review at scale is a concern as AI-generated code grows in complexity and volume
Ryan and Ben explore the idea of AI as a team member
• Mark tells a story of a developer with a briefcase of AIs acting as a full software team
• They discuss how AI may appeal more to managers than ICs due to the loss of individual agency
• Ben shares concerns about how PR (pull request) reviews become unmanageable when AI floods teams with code
• Mark mentions teams are already using multiple AIs to cross-review code before surfacing issues to humans
The conversation shifts to how companies should approach AI adoption
• There's concern about erasing junior roles and losing the traditional developer learning pipeline
• Ryan suggests managers be transparent about whether the goal is augmentation or headcount reduction
• Mark emphasizes the need for AI coaches—specialists who manage prompt libraries, usage patterns, and workflows
• Supports CFML compatibility as a module—not a bolt-on
• Developers can build and run only what they need (eg, no web stack for CLI apps)
• Designed to work on everything from Lambda functions to ARM devices
• Emphasizes maintainability and performance
The team shares the adoption journey of BoxLang and how Java developers are responding to its flexibility and productivity tooling
• Java developers can use BoxLang as a library or full language
• Serverless and single-file conventions are major adoption drivers
• In-person events like Into the Box helped validate its appeal
• Clear demand for better tooling helped shape roadmap
• Initial pushback has faded as understanding and usage grow
Ortus highlights how AI has become integral to the BoxLang development process and future vision
• Used AI tools (Claude, ChatGPT, Gemini) for documentation, peer reviews, and prototyping
• Built a localized AI assistant for VSCode pre-trained on BoxLang docs
• Introduced BXAI module to offer LLM integration with fluent APIs
• Planning future MCP support to make apps LLM-ready by default
• AI accelerates everything from code generation to user education
The team discusses real-world adoption examples, Java interoperability, and long-awaited features like extending Java classes from CFML-like syntax
• Implemented GitHub Discussions, a sponsorship model, and improved the CLI.
They explore the role of testing and CI/CD within Wheels, highlighting its robust GitHub Actions pipeline for various CFML engines and databases.
• Automated testing runs on multiple versions of Lucee and Adobe ColdFusion.
• Test matrix includes various databases like MySQL, PostgreSQL, and now Oracle.
• Emphasizes the ease of contributing thanks to a well-structured test pipeline.
Discussion shifts to why one would use a framework in CFML, with arguments around organization, maintainability, and community standards.
• Frameworks reduce decision fatigue by offering structured conventions.
• Onboarding becomes easier for new developers.
• Wheels allows some customization while still being opinionated.
Peter and Ben compare Wheels with ColdBox and Framework One, detailing where Wheels fits in the CFML framework ecosystem.
• Wheels sits between lightweight Framework One and feature-heavy ColdBox.
• Each framework has its own philosophy and target use cases.
• Wheels balances inclusivity and opinionation, supporting plug-ins and modular growth.
They explain how a legacy CFML app can be gradually migrated into Wheels using a strategy like the “strangler pattern.”
• Use the “miscellaneous” folder to encapsulate legacy code.
• Gradually migrate logic into Wheels views, then controllers, and finally models.
• Existing templates can often be reused with minor routing updates.
Discussion turns toward how AI is already helping with Wheels development and where Peter sees it heading.
• AI tools like Claude and ChatGPT are surprisingly capable with CFML.
• Peter is exploring how to optimize Wheels documentation and tooling for AI understanding.
• Talks about Model Context Protocol (MCP) as a way to feed runtime data to AI agents.
The episode wraps up with practical recommendations for showing how to onboard legacy codebases into Wheels and the importance of a smooth developer experience.
• Possible screencast idea for walking through a real-world legacy migration.
• Encouragement to adopt modern MVC for maintainability and scalability.
• Wheels’ goal is to offer a polished developer experience rivaling modern frameworks like Rails or Laravel.
• Ryan mentions synthetic testing tools like Datadog as helpful for customer QA.
• Ben confesses he’s historically done manual testing, though AI might shift that.
• They explore release practices and breaking changes in Adobe CF updates.
• xByte Cloud supports parallel environments to ease upgrade testing.
The conversation shifts to vibe coding, with examples from both hosts of small projects and the value of playful iteration.
• Ben and Ryan explore Replit and building simple games or utilities with ChatGPT.
• Ryan’s son built a Flappy Bird-style game, iteratively adding features via prompts.
• Ryan vibe-coded a virtual bingo game when the usual service went down.
• They appreciate the immediacy of coding with AI assistance and rapid prototyping.
AI’s limitations and best uses become a recurring thread, as Ben and Ryan wrestle with how to use AI tools without sacrificing learning or control.
• Ben prefers using AI to generate pseudocode but insists on doing the final implementation himself.
• Prompt engineering emerges as a key skill—Ryan tests role-based agent workflows.
• They debate the fear of losing mastery versus gaining productivity.
• Ryan tries auto-correcting code through multiple AI agent passes.
• Both agree curiosity and experimentation are crucial to productive AI use.
Security and maintenance surface toward the end as they react to the latest data breach news and dream of AI-powered password management.
• A recent leak of 16 billion passwords prompts questions about best practices.
• Ben considers how 1Password’s Watchtower could integrate AI to rotate credentials.
• They riff on AI agents auto-managing security tasks like 2FA and password changes.
• The conversation ties back to larger questions about trust, safety, and AI autonomy.
Wrapping up, they share a few final thoughts on CF Summit, marketing swag wins, and what listeners might want from future episodes.
• CF Summit 2025 will celebrate ColdFusion’s 30th anniversary.
• They’re expecting retro-themed parties and looking to bring value as vendors.
• Ben’s wife loves the travel mug from xbyte Cloud—a marketing win.
• The episode ends with a call for listener feedback and a promise to keep the show going.
• Importance of using scoped variables to prevent unexpected collisions in code.
• How ColdFusion's HTML output can be sanitized using Jsoup and AI-assisted validation.
• Real-world examples of legacy platform quirks that led to better testing and abstraction strategies.
They unpack the use of executables and CFExecute for performance-heavy tasks like PDF generation, image processing, and zipping files.
• CFZip and CFImage are shown to be slower than OS-level executables like 7-Zip or GhostScript.
• Explains how using external tools avoids Java heap memory issues.
• Highlights the benefits of file-based tools for consistency and speed across deployments.
James walks through some of his favorite UDFs
• hashID: CFML user-defined functions (UDFs) provide a simple mechanism for generating and validating hash-based identifiers.
• createShadowHtml: CFML user-defined function (UDF) generates HTML and inline JavaScript to create a dynamic, client-side preview of a given HTML document within a shadow DOM
• streamFindNoCase: user-defined function (UDF) searches the currently accumulated output buffer for the presence of a given string, performing a case-insensitive comparison.
• generateEmailHashCode: user-defined function (UDF) processes an email address by extracting the domain, sanitizing the username by removing periods (dots) and any part after the first "+", converting both parts to lowercase, and then returning a Java-generated integer hash code of the resulting string.
• enableWKHTMLTOPDFForms: user-defined function (UDF) modifies the binary of a non-Adobe-generated PDF file to enable the editing of form fields in Adobe Acrobat.
• tempCache: user-defined function (UDF) allows you to temporarily store data in the ColdFusion cache and retrieve it using a generated UUID.
• jreEscape: user-defined function (UDF) ensures strings can be safely used in regex patterns by preventing special characters from being interpreted as regex metacharacters.
• maskCC: user-defined function (UDF) takes a text string as input, searches for patterns that resemble credit card numbers, attempts to validate these potential numbers using ColdFusion's built-in credit card validation, and then masks the validated numbers by replacing all but the last four digits with asterisks.
