🟥 Principios SOLID - 5 + 1 Reglas que CAMBIARÁN tu forma de PROGRAMAR [2022]

preview_player
Показать описание


Los Principios SOLID son uno de los conceptos de programación y diseño de software más populares.

Seguramente ya has intentado muchas veces aprenderlos y aplicarlos en tu día a día, pero se te siguen resistiendo.

Esto le pasa a todo el mundo, porque son conceptos abstractos difíciles de explicar y no se dan los detalles necesarios para bajarlos a tierra.

Soy Antonio Leiva, ingeniero de software y formador, y tras enseñarles a muchos de mis alumnos estos principios, puedo darte las claves para que los entiendas y los apliques de una vez por todas.

Además, si llegas hasta el final, vas a descubrir otro Principio que, aunque inicialmente no forma parte de los Principios SOLID, es vital aplicarlo también y muchas veces trabaja en conjunto.

00:00 ¿Qué son los Principios SOLID y para qué sirven?
05:33 Principio de Responsabilidad Única
12:22 Principio Open/Closed
19:26 Principio de Sustitución de Liskov
25:05 Principio de Segregación de Interfaces
32:46 Principio de Inversión de Dependencias
42:47 La última regla SÚPER SECRETA 😝

Espero que os guste ¡Un abrazo!

//////////////////////////////////////////////////////////////////////////////////////////

Si aún no te decides sobre si Kotlin es el lenguaje que deberías aprender, te animo a que te apuntes a mi masterclass gratuita donde te hablo sobre:

1️⃣ La situación de Kotlin en el mercado y la oportunidad de aprenderlo
2️⃣ Cómo empezar con Kotlin desde cero en pocos minutos
3️⃣ Cómo Kotlin puede hacerte mucho más productivo

/////////////////////////////////////////////////////////////////////////////////////////////

➡➡ SÍGUEME EN OTRAS REDES SOCIALES ⬅⬅

/////////////////////////////////////////////////////////////////////////////////////////////

📌 SÍGUEME EN YOUTUBE:

//////////////////////////////////////////////////////////////////////////////////////////

🎬🎬 ARTÍCULOS Y VÍDEOS RELACIONADOS: 🎬🎬

////////////////////////////////////////////////////////////////////////////////////////////////

Si te ha gustado el vídeo de hoy dame apoyo con un ❤ LIKE, deja un 💬 comentario/ duda y 🥇 SUSCRÍBETE si aún no lo has hecho! Nos vemos en el próximo vídeo!

Antonio Leiva
Рекомендации по теме
Комментарии
Автор

no me explico como este canal no tiene miles de vistas. Excelente material, bien explicado y muy util.

chepech
Автор

Es el mejor video de explicación de los principios SOLID, excelente trabajo el de este humano

snorfyl
Автор

Uno de las mejores explicaciones sobre principios SOLID que he visto. Gracias Antonio, me has aclarado muchisimas dudas 🙂

manueldominguez
Автор

Por ahora he visto 3 vídeos tuyos y ya me siento un mejor profesional. Gracias por crear contenido tan didáctico y compartirlo de manera gratuita. Eres un grande!!

manuelcachondo
Автор

Llevaba tiempo buscando un vídeo así por Youtube. No lo he visto y ya sé que merecerá la pena 100%. Basta decir que me lo ha recomendado mi profesor, jajaja.

Manuel-wjxs
Автор

¿Dónde está el botón para donar y decir que me encantó? Muy bien explicado.

Jel.Awesh.M
Автор

La claridad con la que explicas estos principios es excelente.
Gracias por el video!

emiberes
Автор

Muchas Gracias esto es lo que necesitaba para introducirme en Solid, puedo decir que tu video se acerca a la perfeccion en su categoria. TQM Antonio Leiva.

guzmanlopezcesar
Автор

Muchísimas gracias Antonio, ya tengo tu guía y ya la recomendé en todas mis redes sociales.

josefernandouseche
Автор

Antonio como siempre un abrazo con gratitud por tus videos, siempre explicas con mayor habilidad. Cuando tendremos los videos de los patrones como por ejemplo COMANDER?

aliciabeltran
Автор

Antonio muchas gracias, me has ayudado a entenderlo de mejor manera.

mataplucheable
Автор

pedazo de video, precisamente estaba buscando la implementación de estos principios en kotlin! me ha caido del cielo

patriciaespert
Автор

Menudo currazo de video Antonio, me ha quedado mucho más claro, espero más vídeos de este tipo

astarothMD
Автор

uff 52 minutos que se pasaron volando, sin duda cada minuto valió la pena! como siempre un gran video y muy explicativo muchas gracias!

Respecto al principio de Liskov me gusto mucho como lo abordaste, pocos saben explicarlo tan bien como tu, de hecho considero que es el principio con referencias donde lo llegan a confundir con interface segregation o simplemente lo enfocan mal. Para mi es el mas complicado de entender correctamente porque aparte de lo que bien comentas sobre la congruencia que debe tener el sustituir el hijo con el padre sin romper la funcionalidad, el principio también hace referencia a las pre y post condiciones de subtipos de la covarianza y contra-varianza de un método, y si, también suena a trabalenguas y explicar eso es aun mas complicado.

Buenisima la ley de Deméter, yo conocía ese problema como el code smell Message Chains que menciona Martin Fowler en su libro de Refactoring, una de las soluciones propuestas es que se use la técnica de refactor Hide Delegate pero sigue siendo algo un tanto abstracto y aun se me hace complicado llegar a una solución solida.

tadeogonzalezalvarez
Автор

En el caso de Liskov y el elefante que no salta, no estaría mal que el elefante no saltara y se colara por el agujero si lo que defines bien es el método "jumpHole()". Precisamente porque no todos los animales pueden saltar, lo que ese método debe devolver es que el animal salte (si puede) y si no que se caiga por el agujero.
Estoy pensando que si programas un videojuego donde el personaje "elefante" no puede pasar por ciertas zonas, aun así el personaje sigue siendo la clase genérica y cuando no puede saltar lo que devuelve es "la caída"...

Entiendo perfectamente el ejemplo y además es que están muy bien explicados, pero quizá también hay que ver que muchas veces la solución no es única y depende de la semantica que le damos a nuestras clases.
Es una chorrada, pero en Python existen posiciones negativas en un "String" y lo que hace es recorrer la lista empezando por la última posición (-1 es el último carácter). El método "find" te devuelve -1 si no encuentra lo que buscas, pero -1 es la última posicion. Sin embargo, el método "index" sí lanza una excepción cuando no encuentra lo que buscas. Por tanto, "find" devuelve una posición válida cuando no encuentra algo, pero el uso está en el propio método.

Quizá lo estoy complicando un poco para un ejemplo sencillo y que explicas bien, pero quería simplemente aportar que no siempre será necesariamente incorrecto devolver una excepción o no hacer nada si lo que estás haciendo es manejar una posicion por la que después sabrás que no hay movimiento y, por tanto, el elefante se cae :)

En cualquier caso, enhorabuena por el vídeo y ya me tienes suscrito aquí y a la web, a ver si me pongo las pilas con estas cosas otra vez.

Muchas gracias.

danifgx
Автор

Muchas gracias por compartir tu conocimiento, Antonio.

gratiniano
Автор

Fantástico Antonio! Me ha gustado mucho el vídeo

ccencisoj
Автор

Excelente video, muy claro explicado con manzanas!

mauri
Автор

Gracias por el buen video, por fin entendí los 2 principios que me falta comprender

pablohernandez
Автор

Fantástico Antonio! Me ha gustado mucho el vídeo. Tienes un don para explicar las cosas. Creo que la S y la D son los más importantes. Saludos y gracias!

albertmartorellgarcia