Dev&Ops

En este episodio analizamos si Linux finalmente puede entrar a competir en el mercado de escritorio frente a Windows y MacOS. A partir de experiencias reales y noticias recientes, exploramos cómo ha evolucionado Linux en usabilidad y qué factores están impulsando su adopción fuera del mundo de servidores.

Hablamos del impacto de decisiones como la migración del gobierno de Francia hacia Linux, el crecimiento del gaming en este sistema operativo y el rol que está jugando la inteligencia artificial en cambiar las reglas del juego.

También discutimos los retos reales: compatibilidad, drivers, costos de migración y por qué, a pesar del progreso, Linux aún no compite directamente en desktop… al menos por ahora.

🔍 En este episodio aprenderás:

•  Por qué Linux domina servidores pero sigue rezagado en desktop 
•  Cómo la usabilidad de Linux ha cambiado en los últimos años 
•  El impacto de la migración del gobierno de Francia a Linux 
•  Por qué el gaming en Linux está creciendo 
•  Los verdaderos costos de migrar de Windows a Linux en empresas 
•  Cómo la inteligencia artificial podría hacer irrelevante el sistema operativo 
•  Si Linux realmente tiene futuro en el escritorio 

📑  Capítulos:
 (00:00) Introducción y contexto del episodio
 (02:10) Estado actual de Linux en desktop
 (05:30) Evolución de la usabilidad en Linux
 (09:00) Noticia: Migración del gobierno de Francia
 (13:30) Soberanía digital y Big Tech
 (17:30) Noticia: Crecimiento del gaming en Linux
 (21:30) Problemas de rendimiento en Windows
 (25:00) ¿Está Linux entrando en la pelea?
 (28:30) Adopción en empresas: costos y retos
 (32:30) Gaming en Linux: limitaciones actuales
 (35:30) Impacto de la inteligencia artificial en sistemas operativos
 (38:00) Reflexión final y cierre

¡Hola, comunidad Dev&Ops! 👋 En este episodio nos metemos de lleno en un debate que todo ingeniero ha tenido en algún momento ¿Realmente funcionan las metodologías ágiles en operaciones?

Douglas nos cuenta su experiencia (y frustración) al intentar encajar guardias impredecibles (on-call) dentro de Sprints de 80 horas, mientras Juan nos da su perspectiva desde el lado del desarrollo. Hablamos sobre el estrés de las alertas, la odisea de estimar tiempos, la importancia de tener empatía con los Project Managers (¡que a veces los tiran a los leones! 🦁) y por qué nuestra madurez profesional es la clave para que cualquier proceso funcione, nos guste o no.

¿Eres team Sprints o prefieres otra forma de organizarte? ¿Te cuesta loguear tus horas? ¡Queremos leer tu opinión y tus anécdotas en los comentarios! 👇 No olvides suscribirte para más pláticas honestas sobre el mundo tecnológico.

Nuestras redes sociales

YouTube: https://www.youtube.com/@DevAndOpsPodcast ▶️
TikTok: https://www.tiktok.com/@devandops
🕺 Instagram: https://www.instagram.com/devandopspodcast
📸 Facebook: https://www.facebook.com/devandops 👍
Spotify: https://open.spotify.com/show/1MuMODYsE4xN6RhOcd8EaG 🎧

Capítulos
(00:00) Bienvenida y las batallas de hardware de Juan
(02:33) ¿Por qué la cultura DevOps es nuestro pan de cada día?
(05:45) Guardias y On-Call: Cuando las emergencias rompen tu agenda
(08:49) El choque: Implementando Sprints en equipos operativos
(12:18) Diferentes sabores de Sprints: Desarrollo vs Infraestructura
(16:54) El arte (y el caos) de estimar horas de trabajo
(22:31) Berrinches vs Profesionalismo: Nuestra actitud cuenta
(28:41) Cómo aportar soluciones sin ser la "piedra de tropiezo"
(34:44) La rebelión de los tickets: ¿Por qué odiamos loguear tiempo?
(43:23) Piedad para los Project Managers: Empatía en el equipo
(48:17) El orden es necesario: Responsabilidades de gerentes e ingenieros
(54:02) Conclusión: Somos profesionales, hagamos que funcione

#devops #agile #oncall #sprints #scrum #infraestructura #desarrollo #tecnologia #culturaorganizacional #podcasttecnologico #programacion #ingenieria

Kubernetes se ha convertido en el estándar para orquestación de contenedores, pero no siempre es la solución correcta para todos los escenarios. En este episodio analizamos las principales consideraciones que debes tener en cuenta antes de implementarlo en tu empresa o proyecto.

Hablamos desde la complejidad inherente de Kubernetes, hasta errores comunes como sobreingeniería, falta de automatización o ausencia de observabilidad. También discutimos alternativas como Docker Swarm y cuándo realmente vale la pena dar el salto a Kubernetes.

Si estás evaluando migrar a contenedores o ya decidiste usar Kubernetes, este episodio te ayudará a evitar dolores de cabeza y tomar decisiones más informadas.

🔍 En este episodio aprenderás:

•  Cómo validar si realmente necesitas Kubernetes o estás forzando su uso 
•  Qué complejidades introduce Kubernetes incluso para aplicaciones simples 
•  Por qué no debes implementar todas las herramientas desde el inicio 
•  La importancia de automatizar la infraestructura desde el día uno 
•  Cómo manejar despliegues con Helm o Customize de forma escalable 
•  Por qué el monitoreo y la observabilidad son esenciales desde el comienzo 

📑 Capítulos:
 (00:00) Introducción al episodio y contexto
 (02:26) Consideraciones antes de implementar Kubernetes
 (03:36) Kubernetes vs Docker en producción
 (04:39) Por qué muchas empresas eligen Kubernetes
 (06:50) Complejidad de Kubernetes para apps simples
 (08:59) Alternativa: Docker Swarm
 (10:12) Reevaluar decisiones tecnológicas
 (15:15) No implementar todo desde el inicio
 (18:26) Service Mesh y herramientas avanzadas
 (20:30) GitOps: ¿cuándo sí y cuándo no?
 (29:57) Importancia del tiempo y el enfoque incremental
 (32:14) Automatización con Infrastructure as Code
 (42:19) Uso de Helm y manejo de manifiestos
 (51:28) Riesgos y complejidad en Kubernetes
 (55:12) Monitoreo y observabilidad desde el inicio
 (56:54) Experiencia práctica y dificultades sin observabilidad
 (59:32) Cierre y conclusiones

¿Crees que programar con IA es solo escribir prompts y copiar código? La realidad es muy distinta. En este episodio, Juan nos revela la "verdad" detrás de un flujo de trabajo profesional en 2026, donde el autocompletado ha quedado obsoleto para dar paso a los flujos agénticos y el "Vibe Coding". 

No se trata de magia, sino de estrategia. Descubre los 10 consejos prácticos basados en 10 años de experiencia en la industria para dejar de escribir código línea por línea y empezar a dirigir la arquitectura de tus sistemas, asegurando que el resultado sea escalable, mantenible y, sobre todo, profesional.

En este episodio aprenderás:

• La verdad sobre los patrones de diseño en la era de la IA.
• Por qué descargar "skills" genéricos es un error y cómo crear los tuyos.
• El uso real de AGENTS.md y PRDs para evitar que la IA alucine.
• La técnica de reducir el scope para sobrevivir a los Code Reviews.
• Cómo usar el modo "Planning" como una sesión de Rubber Ducking avanzada.

Nuestras redes sociales:

YouTube: https://www.youtube.com/@DevAndOpsPodcast ▶️

TikTok: https://www.tiktok.com/@devandops 🕺

Instagram: https://www.instagram.com/devandopspodcast 📸

Facebook: https://www.facebook.com/devandops 👍

Spotify: https://open.spotify.com/show/1MuMODYsE4xN6RhOcd8EaG 🎧

Capítulos:

(00:00) Introducción y contexto: Programando en 2026
(02:54) De GitHub Copilot a los flujos agénticos
(05:09) ¿Cuándo usar IA y cuándo escribir código a mano?
(06:39) Consejo 1: La importancia de los Patrones de Diseño y Clean Architecture
(08:59) Consejo 2: Definir estándares y Naming Conventions
(10:54) Consejo 3: Por qué debes escribir tus propios "Skills" (y no descargarlos)
(14:19) Consejo 4: Maximizando el uso de AGENTS.md
(16:29) Consejo 5: Spec-Driven Development y la creación de PRDs
(18:49) Consejo 6: Reducir el scope para mejorar la mantenibilidad y el PR
(22:09) Consejos 7 y 8: Tratar a la IA como un humano y el apoyo visual
(24:49) Consejo 9: Planificación, iteración y Rubber Ducking con la IA
(27:39) Consejo 10: La regla de oro: Revisar y evaluar siempre el resultado
(29:59) Reflexiones finales: La IA no es magia, es preparación

#ia #devops #inteligenciaartificial #programacion #softwareengineering #aiagents #productivity #cleancode #vibeCoding #systemDesign

¿El Tech Lead es solo un Senior con un título más bonito o realmente cambia su función? En este episodio, Juan y Douglas desglosan la figura del Lead de Tecnología: desde la diferencia crucial entre gestionar personas (Engineering Manager) y gestionar el stack técnico, hasta por qué las empresas pequeñas también necesitan uno para evitar el caos. Si quieres escalar en tu carrera técnica sin despegarte del código, este episodio es para ti.

Lo que aprenderás hoy:

• La diferencia entre Tech Lead, Staff Engineer y Engineering Manager.
• Por qué el Tech Lead es el "dueño" del estándar técnico y no necesariamente el jefe administrativo.
• Habilidades clave: del troubleshooting experto a la evangelización y documentación.
• El modelo de Habilidades en T: profundidad en tu área y visión general del flujo (DNS, DB, Infra).
• Consejos prácticos para Juniors y Seniors que aspiran a liderar equipos.

¡Únete a nuestra comunidad y no te pierdas nada!

YouTube: https://www.youtube.com/@DevAndOpsPodcast ▶️
TikTok: https://www.tiktok.com/@devandops 🕺
Instagram: https://www.instagram.com/devandopspodcast 📸
Facebook: https://www.facebook.com/devandops 👍
Spotify: https://open.spotify.com/show/1MuMODYsE4xN6RhOcd8EaG 🎧

Capítulos:

(00:00) Introducción: Tech Leads en todas las disciplinas
(01:26) Bienvenidos a Dev&Ops: La importancia de compartir experiencias
(02:41) El reto de definir qué es un Tech Lead según la empresa
(04:00) El estándar de la industria vs. la realidad de las startups
(07:30) ¿Seguimos copiando lo que hacen las FAANG (Meta, Google, Netflix)?
(10:13) Nuevos roles: La IA y los puestos emergentes (LLM Operators)
(12:00) Definición formal: ¿Qué dice Indeed sobre el Tech Lead?
(14:48) Especializaciones: Tech Leads de Frontend, Backend y SRE
(16:34) "¿Suena caro?": Por qué un Tech Lead te ahorra dinero a largo plazo
(18:20) El Tech Lead como dueño del Stack y los estándares técnicos
(20:30) Diferencia entre liderazgo técnico y gestión administrativa
(23:10) ¿Debe un Tech Lead encargarse de las contrataciones?
(26:30) Habilidades blandas: El fit cultural más allá del código
(30:22) Tech Lead vs. Staff Engineer vs. Engineering Manager
(37:50) Estructuras de equipo: ¿Cuántos leads necesitas según tu tamaño?
(41:00) Evitando el caos: La importancia de la armonía técnica
(44:23) Hoja de ruta: Habilidades para ser considerado un Tech Lead
(47:44) La importancia del Research y entender el negocio
(50:55) De experto a mentor: Documentación y evangelización técnica
(56:23) Conclusión y consejos finales para tu carrera

#devops #techlead #programacion #ingenieriadesoftware #staffengineer #crecimientoprofesional #tecnologia #systemdesign #podcasttecnologia #desarrolloweb

En este episodio hablamos a fondo sobre una de las preguntas más comunes hoy en día en inteligencia artificial: ¿es mejor usar modelos en la nube o correr IA en local?

Compartimos experiencias reales probando modelos locales, los retos de hardware, costos ocultos, rendimiento y qué tan viable es realmente para el día a día. También exploramos casos prácticos donde sí tiene sentido usar IA en local y cuándo definitivamente no vale la pena.

Si estás considerando montar tu propio entorno de IA o quieres optimizar costos, este episodio te va a dar claridad basada en experiencia real, no en “venta de humo”.

🔍 En este episodio aprenderás:

•  Qué es realmente la IA en local y cómo funciona 
•  Diferencia entre modelos “open source” y “open weights” 
•  Limitaciones reales de hardware (RAM, VRAM, contexto) 
•  Cuándo sí tiene sentido usar modelos locales 
•  Por qué la nube sigue siendo la mejor opción en muchos casos 
•  Casos prácticos donde modelos pequeños funcionan muy bien 
•  Cómo balancear costo, rendimiento y tiempo en tu workflow 

📑 Capítulos:
 (00:00) Introducción y contexto del episodio
 (02:00) Nuevo integrante en la familia y regreso al podcast
 (04:30) Tema del episodio: IA en local vs en la nube
 (07:30) ¿Qué es la IA en local?
 (10:30) Open source vs open weights
 (14:00) Evolución de modelos (Llama, Qwen, etc.)
 (18:30) Limitaciones reales del hardware
 (22:00) Quantization explicado
 (26:30) Experimentos en hardware limitado
 (30:00) Casos de uso prácticos con modelos pequeños
 (35:30) Debate: IA local vs nube
 (42:00) Costos, planes y modelos en la nube
 (48:00) Problemas reales de rendimiento en local
 (52:00) Privacidad: mitos y riesgos
 (56:30) Casos donde sí vale la pena IA local
 (01:02:00) Conclusiones y recomendaciones
 (01:10:00) Cierre del episodio

En este episodio hablamos de uno de los temas más mal entendidos al trabajar con contenedores: por qué “Docker rompe producción”… cuando en realidad el problema es cómo lo operamos.

A partir de experiencias reales migrando de VMs a contenedores, exploramos errores comunes que suelen pasar desapercibidos en desarrollo pero explotan en producción. Desde tratar contenedores como máquinas virtuales hasta no definir límites de recursos, usar latest o construir imágenes gigantes.

También abordamos errores de “día 2” como manejo de logs, secretos, health checks y seguridad, que pueden tumbar sistemas completos si no se manejan correctamente.

🔍 En este episodio aprenderás:

• Por qué los contenedores no son el problema, sino su operación 
• El error de tratar contenedores como VMs (y cómo cambiar esa mentalidad) 
• Cómo evitar caídas por falta de límites de CPU y memoria 
• Por qué nunca deberías usar latest en producción 
• Cómo optimizar imágenes Docker para mejorar performance y despliegues 
• Errores comunes en logs, secretos y health checks en entornos productivos 

📑 Capítulos:
 (00:00) Introducción y contexto del episodio
 (02:05) ¿Los contenedores realmente rompen producción?
 (05:10) Error #1: Tratar contenedores como VMs (pet vs cattle)
 (12:50) Error #2: No definir límites de recursos
 (19:40) Error #3: Usar el tag latest en producción
 (25:30) Error #4: Imágenes Docker pesadas
 (32:20) Errores de fase 2: logs, secretos, seguridad y health checks
 (39:30) Conclusiones y recomendaciones finales

La inteligencia artificial se ha robado la atención de toda la industria tecnológica, pero eso no significa que herramientas clave como Docker hayan desaparecido del flujo de trabajo de desarrollo y operaciones. En este episodio hablamos sobre cómo Docker Desktop sigue siendo una pieza fundamental en el desarrollo moderno, incluso en plena era de los agentes y los LLMs. 

Exploramos cómo los equipos de desarrollo y DevOps pueden aprovechar Docker Desktop no solo para ambientes de desarrollo tradicionales, sino también para nuevos flujos de trabajo relacionados con inteligencia artificial.

En particular, analizamos dos funcionalidades interesantes que pueden integrarse fácilmente en el entorno local: Docker Model Runner para ejecutar modelos LLM locales y las herramientas de Docker para correr MCP Servers, permitiendo conectar aplicaciones de IA con servicios externos de forma más segura y estandarizada.

Si ya utilizas contenedores en tu flujo de desarrollo, estas capacidades podrían ayudarte a simplificar la integración de IA en tu stack sin añadir más herramientas externas.

🔍 En este episodio aprenderás:

• Por qué Docker dejó de ser un “buzzword” pero sigue siendo clave en DevOps
• Cómo Docker Desktop sigue facilitando ambientes de desarrollo locales con contenedores
• Qué es Docker Model Runner y cómo permite correr LLMs locales
• Cómo interactuar con modelos locales usando APIs tipo OpenAI u Ollama
• Qué es Model Context Protocol (MCP) y por qué es importante para aplicaciones de IA
• Cómo Docker Desktop facilita ejecutar MCP Servers de forma aislada y segura
• Cuándo tiene sentido usar Docker Desktop en flujos de trabajo con inteligencia artificial

📑 Capítulos:

(00:00) Introducción: IA, buzzwords y el rol actual de Docker
 (01:45) ¿Por qué Docker dejó de ser un buzzword?
 (04:20) Docker Desktop en los flujos de desarrollo modernos
 (07:30) Ambientes de desarrollo locales con contenedores
 (10:10) Kubernetes local dentro de Docker Desktop
 (13:00) Cómo la IA está cambiando el trabajo de desarrollo y operaciones
 (16:20) Primer enfoque: correr modelos LLM locales
 (19:10) Docker Model Runner: cómo funciona
 (22:40) APIs compatibles con OpenAI y Ollama
 (25:00) Segundo enfoque: qué es MCP (Model Context Protocol)
 (27:20) Problemas comunes al ejecutar MCP servers
 (29:40) Docker MCP Toolkit y MCP Catalog
 (31:50) Docker MCP Gateway y orquestación de MCP servers
 (33:10) Reflexión final: cuándo considerar Docker Desktop en la era de la IA

¡Bienvenidos a un nuevo episodio experimental de Dev&Ops! 🎉 Esta semana, Juan y Douglas salen un poco de la rutina y se sientan a reaccionar a tres artículos tecnológicos que están dando mucho de qué hablar en la industria.

¿Alguna vez has considerado reemplazar tus scripts de Bash con Python? Analizamos los pros y contras de la portabilidad tanto en entornos locales como en servidores de producción. Luego, entramos en un debate picante: ¿Deberíamos dejar de usar Redis, MongoDB y Pinecone para meter TODO dentro de PostgreSQL?  Hablamos sobre la centralización, la robustez de los sistemas complejos y el temido "Single Point of Failure".

Para cerrar, exploramos el fascinante pero doloroso mundo de las aplicaciones "Local First". ¿Por qué no son el estándar de la industria si prometen tanta seguridad y control? Profundizamos en la pesadilla que es la sincronización de datos, abordando conceptos complejos como los Relojes Lógicos Híbridos (HLC)  y los Conflict-free Replicated Data Types (CRDTs).

¡No olvides dejarnos en los comentarios qué opinas tú! ¿Te quedarías solo con Postgres? ¿Eres team Bash o team Python? 👇

YouTube: https://www.youtube.com/@DevAndOpsPodcast ▶️
TikTok: https://www.tiktok.com/@devandops 🕺
Instagram: https://www.instagram.com/devandopspodcast 📸
Facebook: https://www.facebook.com/devandops 👍
Spotify: https://open.spotify.com/show/1MuMODYsE4xN6RhOcd8EaG 🎧

📑 Chapters:
(00:00) Bienvenidos a Dev&Ops y la saturación tecnológica
(03:45) Artículo 1: Usar Python en lugar de Bash Scripting
(08:15) La portabilidad de scripts en diferentes sistemas operativos
(16:30) Veredicto: Python para local, Bash para servidores
(22:30) Artículo 2: La trampa de usar la herramienta "correcta"
(28:20) ¿Reemplazar Redis, Mongo y Pinecone solo con PostgreSQL?
(38:45) Complejidad vs Robustez en arquitecturas de bases de datos
(44:00) Artículo 3: El misterio de las aplicaciones Local First
(48:25) El verdadero reto: Sincronización, HLCs y conflictos CRDTs
(54:45) ¿Hay mercado real para las aplicaciones Local First?
(01:03:30) Conclusiones, comentarios y despedida

#devops #programacion #python #bash #postgresql #basededatos #localfirst #softwarearchitecture #backend #podcasttecnologico #desarrollodesoftware

En este episodio de Dev&Ops analizamos un debate que ya no es debate: ¿por qué Linux terminó dominando los servidores web y de aplicaciones?

Recorremos la historia desde los 90s: Perl, CGI, PHP, Java, ASP, ColdFusion, el nacimiento del stack LAMP, el auge de Apache y NGINX, y cómo la comunidad open source inclinó definitivamente la balanza.

No es una conversación basada en fanatismo. Es un análisis histórico y técnico sobre costos, rendimiento, comunidad, estabilidad y cómo la nube terminó de consolidar el dominio de Linux en la web.

🔍 En este episodio aprenderás:

• Cómo el stack LAMP revolucionó el desarrollo web
• Por qué el modelo open source aceleró la adopción de Linux
• Qué papel jugaron PHP, Java, Ruby y ASP en esta batalla
• Cómo el rendimiento y la arquitectura multiusuario marcaron la diferencia
• Por qué la nube terminó de consolidar el dominio de Linux
• En qué áreas Windows sigue siendo el rey (Exchange y Active Directory)

📑 Capítulos recomendados
 (00:00) Introducción al EP50
 (02:10) ¿Linux vs Windows en servidores? Una batalla ya ganada
 (05:46) ¿Qué pasaría si hoy te pidieran montar un servidor web en Windows?
 (09:11) Servidores Windows en los 2000: IIS, NT y Windows 2000
 (12:00) El factor costo: licencias vs open source
 (16:01) Linux como puerta de entrada para desarrolladores
 (21:00) Los lenguajes que marcaron la historia web (Perl, CGI, C/C++)
 (29:40) El nacimiento de PHP y el auge del stack LAMP
 (31:44) Ruby on Rails y su impacto en la web
 (37:42) ColdFusion, enterprise y software propietario
 (43:38) ASP y el ecosistema cerrado de Windows
 (46:45) Java y la era de los Servlets
 (51:33) Open source vs propietario: quién inclinó la balanza
 (57:44) Comunidad, Apache y la consolidación de Linux
 (1:01:03) Automatización y facilidad de despliegue
 (1:03:21) Estabilidad, rendimiento y arquitectura multiusuario
 (1:13:21) Microsoft adopta Linux en la nube
 (1:16:00) La nube como golpe final a la batalla
 (1:18:00) Conclusiones: hechos históricos, no fanatismo