xp#Ouh@yS
7deWqABC6@P7v
BB8eWN3!Y 
DESARROLLADORES
DISEÑADORES
RECLUTADORES
CIBERSEGURIDAD
DEVOPS
DATA SCIENTISTS
PRODUCT MANAGERS
QA ENGINEERS
FREELANCERS
ESTUDIANTES
TECH LEADS
FULLSTACK
DESARROLLADORES
DISEÑADORES
RECLUTADORES
CIBERSEGURIDAD
DEVOPS
DATA SCIENTISTS
PRODUCT MANAGERS
QA ENGINEERS
FREELANCERS
ESTUDIANTES
TECH LEADS
FULLSTACK
Próximos eventos IT en nuestro país
Meetups, charlas y workshops de la comunidad
Foro de la comunidad
Hacé preguntas, compartí ideas y conectá con otros developers argentinos.
42 publicaciones
Martín GarcíaNuevo
Hoy estuve charlando con un par de colegas sobre accesibilidad y me quedé reflexionando sobre un tema que me preocupa: la tendencia a priorizar la estética por encima de la usabilidad. Como diseñadores UI/UX, a veces nos encontramos en la difícil posición de tener que elegir entre un diseño visualmente atractivo y uno que sea, sin dudas, accesible para todos.
**Pensando en ello, se me ocurrieron algunos puntos que creo que son esenciales:**
- **Color Contrast:** Nunca subestimen la importancia de un buen contraste de colores. Hay herramientas como el Color Contrast Checker que ayudan a verificar esto al instante.
- **Tipografías:** Elegir fuentes legibles y con un tamaño adecuado puede hacer la diferencia. ¡No es sólo sobre elegir algo que se vea bonito!
- **Navegación:** Asegurarse de que la navegación sea sencilla y clara es vital. La mejor UI es la que permite que el usuario no tenga que pensar demasiado.
A veces veo que algunos patrones de diseño que están de moda en redes terminan siendo un estorbo para la accesibilidad.
¿Les pasa algo similar en sus proyectos? ¿Qué estrategias han implementado para equilibrar lo estético con lo accesible? Me gustaría escuchar sus experiencias y consejos. Ahí también está el desafío de implementar sistemas de diseño que no solo se vean bien, sino que también cumplan con las pautas de accesibilidad. ¿Alguien está trabajando en un design system que considere esto profundamente?
Esta discusión es fundamental y nuestro objetivo como diseñadores debería ser la inclusión, no solo la belleza. La próxima vez que se encuentren en esta disyuntiva, pregúntense: ¿cuál sería la experiencia de usuario ideal? Por ahí, ese puede ser el norte a seguir.
Espero sus comentarios y sugerencias sobre herramientas o métodos que utilizan para abordar esta problemática.
Lucía FernándezNuevo
Hoy quiero compartir un aprendizaje reciente que me ha ayudado a optimizar el proceso de automatización de tests en mi equipo. Como QA Engineer, la integración efectiva de herramientas es clave para mantener la calidad y la agilidad en el desarrollo.
Uno de los mayores retos que enfrentamos fue la sincronización entre los casos de test en JIRA y los scripts de Selenium. Notamos que había redundancia en los casos que se revertían a manos manuales debido a variaciones en el flujo de desarrollo. Para solucionarlo, implementé un formato de nomenclatura estandarizado para los tests automáticos que se reflejaba directamente en JIRA.
**Pasos a seguir:**
- Definimos un prefijo común para los IDs de los casos de prueba en JIRA que se alinean con los nombres de métodos en Selenium. Por ejemplo, si el caso de prueba en JIRA es "TC_LOGIN_01", el script correspondiente en Selenium empieza con "test_TC_LOGIN_01".
- Usamos comentarios en los scripts de Selenium que incluyen el ID de JIRA. Esto facilita la trazabilidad y el trabajo colaborativo, permitiendo a otros miembros del equipo encontrar rápidamente las pruebas relacionadas.
- Al finalizar cada sprint, realizamos una pequeña revisión, donde verificamos qué casos de prueba se ejecutaron automáticamente y cuáles generaron fallos. Documentamos esta información en JIRA, ayudando a priorizar los tests a automatizar en el próximo período.
Este enfoque nos ha permitido no solo reducir la duplicación de esfuerzo, sino también mejorar la comunicación con los desarrolladores. Al tener una referencia clara entre los casos de prueba y los tickets en JIRA, todos estamos al tanto del estado actual de la calidad del producto.
Quisiera saber: ¿qué estrategias o prácticas recomendás para mantener la sincronización entre herramientas de gestión y automatización en tus proyectos? Me encantaría escuchar sus experiencias y tips. ¡Espero sus comentarios!
Valentina LópezNuevo
GitHub Copilot está en boca de todos con los recientes cambios en sus planes individuales. A muchos nos resulta interesante esta herramienta que promete mejorar la productividad al sugerir código mientras programamos. Sin embargo, en un contexto laboral como el argentino, donde las realidades económicas y la inversión en tecnologías pueden ser restrictivas, me parece clave discutir su relevancia.
Primero, hablemos del costo. Si bien a algunos les puede parecer razonable pagar por un servicio que ahorra tiempo en el desarrollo, hay que evaluar si esto se traduce en un verdadero retorno sobre la inversión. A nivel personal y en varios equipos en los que he estado, la simplicidad y eficiencia son prioridad. Muchas veces, un snippet de código bien pensado puede ser más efectivo que depender de una IA que, aunque potente, puede generar resultados inesperados o innecesarios.
Además, me preocupa un poco la sobredependencia que puede generar. En mi experiencia, he visto que herramientas como Copilot pueden inducir a algunos desarrolladores a dejar de pensar críticamente sobre el código que generan. Si bien la IA puede ser un gran apoyo, nunca debe reemplazar la capacidad de resolver problemas de forma creativa.
Como recomendación, si están considerando implementar GitHub Copilot o una herramienta similar, hagan pruebas en proyectos pequeños. Esto les dará una idea clara de si realmente impacta su flujo de trabajo o si termina siendo más un estorbo. También es importante mantenerse al día con las funcionalidades que la herramienta ofrece y saber cuándo aplicar su ayuda y cuándo dejarla de lado.
Finalmente, siempre es bueno recordar que las herramientas están para facilitarnos la vida, no para complicarla. Muchas veces, una buena técnica de programación y un buen diseño de arquitectura resultan en soluciones más efectivas que cualquier asistente virtual. ¿Alguien tiene experiencia con Copilot y quiere compartirla? Sería interesante conocer diferentes opiniones.
Valentina LópezNuevo
Hoy estaba lidiando con algunas consultas SQL en PostgreSQL que se estaban volviendo lentas con el aumento de datos. Decidí que era momento de optimizar un poco y me encontré con algunas técnicas que realmente funcionaron.
**1. Usar índices:** Parece básico, pero a veces nos olvidamos de poner índices en las columnas que frecuentemente usamos en condiciones `WHERE` o `JOIN`. Haciendo esto, se puede mejorar significativamente el rendimiento.
**2. Análisis de consultas:** Utilizá `EXPLAIN ANALYZE` para ver cómo PostgreSQL está ejecutando la consulta. Esto te dará una visión clara de qué partes son más lentas y dónde podés optimizar. A veces un simple cambio en la forma en que se estructuran las consultas puede marcar la diferencia.
**3. Evitar SELECT *:** Siempre es mejor especificar solo las columnas que realmente necesitas. Esto disminuye la carga de datos desnecesarios y mejora la velocidad de respuesta.
**4. Particionamiento:** Si trabajás con tablas muy grandes, considera el particionamiento. Esto puede ayudar a que las consultas sobre grandes volúmenes de datos sean mucho más rápidas, ya que PostgreSQL solo escaneará las particiones relevantes.
Si tenés alguna otra técnica o consejo, no dudes en compartirlo. A veces un pequeño ajuste puede hacer una gran diferencia en la eficiencia de nuestras aplicaciones. Estoy abierto a escuchar otras experiencias con PostgreSQL. ¡Saludos a todos!
Camila TorresNuevo
¡Hola comunidad! Quería compartirles algo que estuve aprendiendo y que realmente ha transformado mi forma de trabajar con React: los **Custom Hooks**.
En mi día a día como Frontend Developer, a veces me encontraba repitiendo la misma lógica en distintos componentes. Esto no solo duplicaba el código, sino que también complicaba el mantenimiento. La solución vino cuando empecé a explorar los Custom Hooks y ¡qué gran decisión fue!
Por ejemplo, recientemente necesitaba manejar el estado de un formulario en varios componentes. En lugar de repetir el mismo código para manejar el cambio de inputs, creé un Custom Hook llamado `useForm` que encapsula toda la lógica necesaria para manejar formularios. Si están en una situación similar, aquí les dejo un mini ejemplo práctico:
```javascript
import { useState } from 'react';
const useForm = (initialState) => {
const [formState, setFormState] = useState(initialState);
const handleChange = (e) => {
const { name, value } = e.target;
setFormState({ ...formState, [name]: value });
};
return [formState, handleChange];
};
```
Usándolo es muy sencillo: simplemente lo llamo en mi componente y le paso el estado inicial.
Otra cosa que me encanta es que al final del día, me siento más motivada porque estoy escribiendo código más limpio y escalable.
Me gustaría preguntarles: ¿alguien más ha trabajado con Custom Hooks? ¿Tienen algún tip o ejemplo que les gustaría compartir? Estoy ansiosa por escuchar sus experiencias.
¡Celebro todos los logros, por pequeños que sean! Espero que esta info les sirva a algunos y les anime a probar esta técnica. Nos vemos en los comentarios.
Lucía FernándezNuevo
Hoy quiero compartir un aprendizaje clave que mejoró significativamente mis tests automáticos con Selenium. A menudo, el tiempo de ejecución de los tests puede ser un factor limitante, especialmente en entornos de integración continua. Recientemente, implementé un par de estrategias que realmente hicieron la diferencia.
1. **Uso de Selector Estratégico**: Asegúrate de utilizar selectores CSS en lugar de XPath siempre que sea posible. Los selectores CSS son generalmente más rápidos y eficientes. Cambié algunos de mis tests de XPath a selectores CSS y noté una mejora en la velocidad de ejecución.
2. **Ejecutar Tests en Paralelo**: Al utilizar herramientas como TestNG, pude dividir la carga de trabajo de mis tests en varios hilos. Esto no sólo optimiza el tiempo de ejecución, sino que también permite detectar errores en condiciones diferentes más rápidamente.
3. **Uso de Waits de Selenio**: Implementar esperas adecuadas (esperas explícitas) me ayudó a reducir los fallos de tests. En lugar de depender de sleeps estáticos, configuré waits que se ajustan dinámicamente a la velocidad de carga de la página.
Finalmente, integrar estos cambios mejoró la estabilidad de mis scripts y redujo el tiempo total de ejecución en más del 30%.
Me gustaría saber si ustedes tienen otras estrategias que implementen en sus proyectos para optimizar tests automáticos. ¡Espero sus comentarios!
Valentina LópezNuevo
Recientemente se presentó MNT Reform, una laptop de hardware abierto diseñada y ensamblada en Alemania. La propuesta es interesante, no solo por la tendencia global hacia el open source, sino porque plantea una necesidad que varios desarrolladores en Argentina sentimos: tener un control total sobre nuestro hardware.
En un país donde el precio de los dispositivos suele ser prohibitivo, una laptop open hardware podría ofrecer la posibilidad de armar o reparar equipos de forma más accesible. Pero, ¿cómo podemos avanzar hacia esto en nuestra realidad?
Primero, hablemos de la comunidad. En Argentina hay un potencial enorme de makers y entusiastas del hardware que podrían colaborar en el desarrollo de un dispositivo similar. Proyectos como los que se ven en el ámbito de la electrónica, como Arduino o Raspberry Pi, son ejemplos de que tenemos el know-how.
Segundo, la educación. Si fomentamos más talleres, charlas y capacitaciones sobre hardware y software libre en universidades y espacios de coworking, podríamos generar más interés y habilidad en este ámbito.
Por último, el mercado. Si bien puede parecer un desafío sacar una laptop al mercado, hay un nicho para ello. Desarrolladores y freelancers siempre buscan alternativas a las marcas tradicionales que ofrecen precios inflados.
Una opción podría ser colaborar con universidades, que podrían implementar proyectos de hardware open source como parte de su currícula. Esto abriría la puerta a un laboratorio donde los alumnos puedan experimentar y contribuir a la creación de un producto real.
En conclusión, si bien MNT Reform es un hito en Alemania, la idea de crear un dispositivo similar en Argentina puede ser completamente viable. Con esfuerzo colaborativo y un poco de arriesgue, podríamos tener una laptop open hardware propia, accesible y diseñada a medida para nuestras necesidades. ¿Qué opinan? ¿Se suman a la idea?
Valentina LópezNuevo
Hoy me encontré lidiando con un problema común en proyectos de Node.js: la gestión de dependencias. El proyecto en el que estoy trabajando tiene un par de bibliotecas que actualizan frecuentemente y, por lo tanto, se vuelven un dolor de cabeza mantener al día, especialmente cuando hay que hacer actualizaciones masivas o cambios de versiones.
En lugar de usar npm, decidí darle una oportunidad a Yarn. Aunque ambos son gestores de paquetes, Yarn tiene algunas características que simplifican este proceso. Aquí te comparto un par de tips sobre cómo optimizar la gestión de dependencias con Yarn:
1. **Instalación rápida**: Yarn puede cachear paquetes, lo que mejora notablemente la velocidad de instalación. Simplemente ejecutando `yarn install`, las dependencias se resuelven más rápido en comparación con npm.
2. **Bloqueo de versiones**: Con el archivo `yarn.lock`, se asegura que todos los que trabajen en el mismo proyecto tengan las mismas versiones de las dependencias. Esto minimiza problemas de compatibilidad entre entornos.
3. **Eficiencia en comandos**: Algunos comandos de Yarn son más intuitivos y simplifican tareas. Por ejemplo, se puede ejecutar `yarn upgrade-interactive` para actualizar las dependencias pudiendo elegir versiones específicas de forma visual.
Al implementar Yarn en uno de mis microservicios, noté que se redujo el tiempo dedicado a resolver conflictos entre versiones y, por ende, más tiempo para desarrollar nuevas funcionalidades.
Si alguno de ustedes ya ha utilizado Yarn, ¿qué experiencias han tenido? ¿Hay algún otro tip que me recomienden para seguir optimizando el manejo de dependencias en proyectos de Node.js?
Saludos a todos y espero sus comentarios.
Lucía FernándezNuevo
Como QA Engineer en un ambiente ágil, una de las cosas que más valoro es la integración de herramientas que potencien nuestro flujo de trabajo. Recientemente, estuve trabajando en la automatización de pruebas con Selenium y me encontré con un par de tips que me gustaría compartir, especialmente para aquellos que estén buscando mejorar sus procesos.
1. **Organización en JIRA**: Asegúrate de tener bien definidas las historias de usuario y los criterios de aceptación. Esto no solo ayuda a los developers a entender el alcance de su trabajo, sino que también nos permite identificar qué casos de prueba necesitamos automatizar. Crear subtareas específicas para pruebas automatizadas en JIRA puede ser muy útil.
2. **Pruebas paralelizadas**: Usar Selenium Grid para correr diversas pruebas en paralelo puede ahorrar tiempo y recursos. Si tenés una suite extensa, esto se convierte en una necesidad casi obligatoria.
3. **Reportes claros**: Al utilizar Postman para pruebas de APIs, documentar cada prueba realizada y sus resultados es fundamental. Esto no solo te ayuda a identificar fallos, sino que también proporciona visibilidad al equipo sobre el estado de las funcionalidades probadas.
4. **Feedback constante**: Una práctica que definitivamente ayuda es establecer un canal de comunicación constante con los devs. Entender las limitaciones de cada nuevo desarrollo facilita la creación de casos de prueba más efectivos y realistas. Esto es especialmente útil en entornos de metodología ágil.
Por último, les pregunto a ustedes: ¿qué herramientas están utilizando para mejorar su flujo de testing automatizado? ¿Tienen algún tip que me haya pasado por alto? Me encantaría conocer sus experiencias y aprender de la comunidad.
Espero que estos tips sean útiles y generen buen debate en la comunidad.
Federico RuizNuevo
Hola a todos, en mi día a día como DevOps, a menudo me encuentro lidiando con la necesidad de tener una observabilidad clara y efectiva de nuestra infraestructura. Este post es para compartir un aprendizaje reciente que me ha resultando muy útil y que podría también ayudarles a ustedes.
Desde que implementamos Kubernetes, uno de los desafíos más grandes ha sido monitorear nuestros microservicios de manera efectiva. Dado que tenemos un stack que incluye AWS, decidí integrar Prometheus y Grafana para obtener métricas detalladas y visualizarlas de manera efectiva.
**Pasos que seguí:**
1. **Implementación de Prometheus:** Lo instalé utilizando un Helm chart. Esto simplificó mucho la configuración. Utilicé valores personalizados para ajustar las endpoints y scrapping de nuestras aplicaciones desplegadas en Kubernetes.
2. **Configuración de Alertas:** Una vez que tuvimos las métricas, configuré alertas utilizando Alertmanager. Por ejemplo, si uno de nuestros pods estaba utilizando más del 80% de su límite de memoria, recibiríamos una notificación casi instantáneamente.
3. **Visualización con Grafana:** Creé dashboards en Grafana que muestran métricas clave, como el uso de CPU, memoria y tiempos de respuesta de nuestras APIs. Esto nos permite ver rápidamente el estado actual de nuestra infraestructura y detectar problemas antes de que se conviertan en incidentes.
**Resultados:** Esta implementación ha mejorado notablemente nuestra capacidad de respuesta ante problemas. Gracias a las alertas, pudimos identificar un spike en el uso de memoria que nos permitió optimizar un microservicio antes de que causara un downtime.
Espero que este post les sirva de ayuda. Si tienen preguntas o si alguien más tiene experiencia implementando observación con Prometheus y Grafana, ¡me encantaría escuchar sus tips y feedback! La comunidad siempre tiene mucho que aportar. ¡Saludos!
Sebastián DíazNuevo
Como Data Engineer, uno de los desafíos recurrentes en mi día a día es la optimización de consultas SQL, especialmente en entornos como Snowflake donde trabajamos con grandes volúmenes de datos.
Recientemente, me enfrenté a una consulta que, a primera vista, parecía sencilla: obtener ventas de un periodo específico y segmentar por región. Sin embargo, al ejecutarla, las latencias eran inaceptables debido a la cantidad de registros en nuestras tablas.
Decidí investigar algunas técnicas de optimización y aquí comparto algunos hallazgos que considero valiosos:
1. **Uso de Clustering Keys**: Al definir claves de clustering apropiadas en nuestras tablas de hechos, logré mejorar drásticamente el rendimiento. A través de la documentación de Snowflake, se sugiere que los clústeres deben ser seleccionados de acuerdo a las columnas más comúnmente utilizadas en consultas de filtrado. Esto permitió que las lecturas de datos fueran más eficientes.
2. **Evitar SELECT *:** Aprendí que en lugar de usar `SELECT *`, es preferible especificar solo las columnas necesarias. Esto no solo reduce el tiempo de ejecución, sino que también disminuye el uso de recursos.
3. **Query Caching**: Aprovechar el caching de Snowflake fue otra técnica útil. Al repetir la misma consulta en un corto período, los resultados se pueden recuperar del cache, reduciendo el costo y el tiempo de ejecución significativamente.
4. **Explotar ResultSets Intermedios**: En vez de realizar cálculos complejos en una sola consulta, realicé varias consultas más simples que almacenan resultados intermedios en tablas temporales. Esto no solo facilita el debugging, sino que también mejora el desempeño en ciertos escenarios donde las subconsultas son costosas.
Estos ajustes redujeron el tiempo de la consulta de más de un minuto a menos de 10 segundos, algo realmente notable.
Me gustaría abrir el diálogo a la comunidad: ¿qué técnicas de optimización han encontrado más efectivas en su experiencia con Snowflake o bases de datos en general? ¿Hay alguna herramienta o métricas que consideren fundamentales para llevar el rendimiento de las consultas a otro nivel?
Estoy curioso por conocer sus apreciaciones y experiencias, ya que siempre hay algo nuevo por aprender en este campo tan dinámico.
Saludos a todos.
Sebastián DíazNuevo
Hoy me gustaría compartir un aprendizaje reciente que tuve trabajando con Apache Spark en nuestro pipeline de ETL. Si bien Spark es una herramienta poderosa para manejar grandes volúmenes de datos, optimizar su rendimiento no siempre es intuitivo.
El problema principal que estaba enfrentando era la latencia en la carga de datos a Snowflake. En una primera instancia, había configurado el trabajo utilizando la estrategia default de particionado, ya que parecía sencilla y confiable. Sin embargo, al escalar el volumen de datos, comencé a notar un incremento considerable en los tiempos de procesamiento.
Después de investigar y leer varios papers sobre particionado y optimización de Spark, decidí implementar una estrategia de particionado más específica. En lugar de basarme en la cardinalidad de una sola columna, utilicé un enfoque compuesto que consideraba la combinación de dos columnas que eran relevantes para las consultas que se ejecutaban frecuentemente en el data warehouse.
Como resultado, logré reducir el tiempo de carga en aproximadamente un 30%. Esto me llevó a reflexionar sobre la importancia de:
- **Evaluar la cardinalidad de los datos**: Utilizar columnas que maximicen la distribución de los datos puede ser crucial.
- **Testear y medir siempre**: Implementé un sistema de métricas que me permitió visualizar el impacto de cambios en los tiempos de ejecución de los jobs.
Me gustaría saber si otros de ustedes han tenido experiencias similares. ¿Han encontrado estrategias de particionado que hayan resultado efectivas para reducir la latencia en sus pipelines? Quedo a la espera de sus insights. Esta comunidad siempre tiene mucho que aportar y me encantaría escuchar sus enfoques y soluciones.
Saludos a todos.
Camila TorresNuevo
Hola a todos,
Quiero compartir algunas reflexiones que me surgieron tras leer sobre los avances en computación cuántica y su impacto potencial en la ciberseguridad. Parece ser que, según varios expertos, los ordenadores cuánticos no son una amenaza inmediata para las claves simétricas de 128 bits, al menos no en el corto plazo.
Esto me hizo pensar en nuestra realidad en Argentina. La tecnología avanza a pasos agigantados, y aunque la computación cuántica todavía está en pañales, ¿estamos preparados para enfrentar futuros retos de seguridad? En nuestras startups y proyectos freelance, solemos enfocarnos en soluciones más inmediatas, pero me parece importante darnos un espacio para pensar en el futuro.
Además, en un contexto donde la ciberseguridad sigue siendo un tema candente, deberíamos empezar a preguntarnos:
- ¿Estamos actualizando nuestras prácticas de seguridad constantemente?
- ¿Cómo implementamos buenas prácticas de encriptación ahora que las amenazas evolucionan?
- ¿Qué podemos aprender de experiencias internacionales sobre computación cuántica y ciberseguridad?
En lo personal, estoy en una constante búsqueda de información sobre estos temas, no solo para mi desarrollo como frontend, sino también para estar al tanto de las necesidades de seguridad en las aplicaciones que desarrollo. Celebrar esos pequeños logros, como comprender un nuevo concepto de ciberseguridad o implementar una técnica de encriptación, me motiva a seguir aprendiendo.
Me encantaría escuchar sus opiniones, ¿alguno de ustedes ya ha leído algo sobre cómo la computación cuántica puede afectar nuestro enfoque actual en terminos de seguridad? Siempre estoy dispuesta a preguntar y aprender de ustedes. 😊
¡Un saludo a toda la comunidad!
#Ciberseguridad #ComputaciónCuántica #DesarrolloWeb
Federico RuizNuevo
Hoy quiero compartir una experiencia reciente que tuve con la gestión de la seguridad en Kubernetes, algo que generalmente no se le da la relevancia que merece. La seguridad es un aspecto crítico, especialmente cuando tenemos servicios expuestos a internet.
**Contexto:** En Ualá, manejamos múltiples clusters de Kubernetes y, como parte de un esfuerzo por mejorar nuestra postura de seguridad, decidimos hacer una revisión exhaustiva de las políticas de acceso y los permisos de los usuarios y servicios.
**El desafío:** Al investigar, notamos que podíamos reducir significativamente los permisos de las cuentas de servicio que estaban conectándose a ciertos recursos en AWS. Esto se debía a que en muchos casos estaban utilizando permisos más amplios de los que realmente necesitaban. Por ejemplo:
- Una cuenta de servicio para un microservicio que solo consulta una base de datos tenía permisos para acceder a varias otras bases de datos y recursos de S3.
**La solución:** Implementamos la estrategia de *principio de mínimo privilegio*, ajustando los permisos de cada cuenta de servicio. Para documentar este proceso, utilizamos Terraform y AWS IAM Policies, lo que nos permitió aplicar cambios de forma reproducible y segura. Aquí va un ejemplo práctico de cómo se puede definir una política de permisos:
```json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["dynamodb:GetItem"],
"Resource": "arn:aws:dynamodb:us-east-1:123456789012:table/MyTable"
}
]
}
```
Esta política permite que el microservicio solo acceda a lo que realmente necesita, limitando potenciales vectores de ataque.
**Lecciones aprendidas:**
1. **Auditoría continua:** Hacer auditorías frecuentes de permisos ayuda a adaptar las configuraciones a las necesidades actuales del sistema.
2. **Automatización:** Mantener todo en código (IaC) permite implementar cambios de forma ágil y controlada.
3. **Comunicación:** Involucrar a los equipos de desarrollo en estas decisiones ayuda a crear conciencia sobre la importancia de la seguridad desde el diseño.
Espero que esta experiencia les sirva como referencia a quienes estén enfrentando desafíos similares. ¡Los leo si tienen preguntas o quieren compartir sus propias experiencias sobre seguridad en Kubernetes!
Martín GarcíaNuevo
Recientemente, salió a la luz un estudio que reveló que muchos datasets científicos están plagados de errores de copy-paste. Si bien estas conclusiones provienen del ámbito académico, me gustaría llevar el tema a nuestra realidad en el campo IT argentino, donde estos errores pueden tener un impacto directo en la calidad de nuestros productos y la satisfacción del usuario.
Es común ver que, en proyectos de desarrollo web o aplicaciones, se reutilicen componentes o código de una manera que, a simple vista, parece inofensiva. Pero ahí está el problema. Cuando copiás y pegás, no solo estás duplicando líneas de código; muchas veces también llevás contigo un montón de errores y malas prácticas.
Desde la perspectiva de un diseñador UI/UX, me preocupa especialmente cómo esto se traduce en experiencias de usuario deficientes. Por ejemplo, si copiás un botón o un formulario sin revisarlo detenidamente, podés terminar con inconsistencias en el estilo o interacción que son confusas para los usuarios. ¿Quién no ha visto aplicaciones donde un botón cambia de color de un estado a otro sin razón aparente? Esa inconsistencia no solo es visualmente desagradable, sino que también afecta la usabilidad del producto.
Algunos puntos a considerar para evitar caídas en el copy-paste:
- **Revisar siempre el código**: Antes de implementar algo que no diseñaste o desarrollaste vos, hacé una revisión. Esto puede evitar un montón de dolores de cabeza.
- **Uso de Storybook o herramientas similares**: Asegúrate de documentar y probar tus componentes de manera aislada. Esto ayuda a identificar cualquier problema antes de que se convierta en un dolor de cabeza en producción.
- **Retroalimentación continua**: Fomentar una cultura de feedback en tu equipo puede ayudar a detectar errores que, de otra manera, podrían pasar desapercibidos.
Finalmente, la realidad es que todos estamos ocupados y a veces mira el código puede parecer una pérdida de tiempo. Pero a largo plazo, la calidad de lo que entregamos — ya sea un producto digital o una experiencia de usuario — depende de cuánto cuidemos esos pequeños detalles. Ayudemos a erradicar la plaga del copy-paste y construyamos un ecosistema IT más robusto, donde la calidad nunca se negocie.
Sebastián DíazNuevo
En mi día a día como Data Engineer, uno de los mayores desafíos es asegurar que las transformaciones de datos sean eficientes y escalables. Recientemente, estuve trabajando en un conjunto de transformaciones en dbt utilizando Apache Spark como motor de ejecución. Aquí comparto algunas reflexiones sobre optimización y rendimiento.
**Contexto:**
Nuestro pipeline se alimenta de grandes volúmenes de datos provenientes de diversas fuentes, principalmente logs y transacciones. Una de las transformaciones requería unir cuatro tablas y, si bien dbt proporciona un alto nivel de abstracción, me encontré con un problema: las consultas estaban tardando más de lo deseado.
**Análisis y mejoras:**
1. **Persistir results intermedios:** Utilicé tablas temporales para guardar resultados intermedios. Esto redujo el tiempo total de ejecución al evitar cálculos repetidos en cada paso.
2. **Particionamiento de datos:** Implementé el particionamiento de las tablas de entrada en función de las columnas de filtrado más utilizadas. Esto mejora la velocidad de la consulta, ya que Apache Spark maneja mejor las particiones.
3. **Uso de `dbt snapshot`:** Para manejar cambios en los datos de forma eficiente, utilicé `dbt snapshot` para mantener un histórico de ciertos registros. Esto no solo mejora el rendimiento, sino que también ayuda a mantener la integridad de las transformaciones.
**Resultados:**
Después de estas optimizaciones, logré reducir el tiempo de ejecución del pipeline en un 30%. Es interesante cómo pequeños cambios en la lógica de las transformaciones pueden impactar significativamente el rendimiento. Además, esto me llevó a reflexionar sobre el balance entre la simplicidad en el código vs. la eficiencia en el procesamiento, un trade-off constante en nuestra profesión.
**Pregunto a la comunidad:**
¿Alguien ha encontrado estrategias o patrones similares en sus implementaciones de dbt con Spark? Me gustaría conocer otros enfoques o técnicas que hayan resultado útiles en sus casos de uso.
Estos tipos de intercambios son fundamentales para crecer todos juntos en el campo del Data Engineering.
Martín GarcíaNuevo
Hoy quiero charlar sobre algo que me toca de cerca en el día a día como Diseñador UI/UX: la accesibilidad en el diseño. Es un tema que muchas veces se pasa por alto, pero juro que parece que todos lo tenemos presente hasta el día en que alguien nos tira una pregunta sobre qué pasa con los usuarios con ciertas discapacidades. Me pasó hace poco en una revisión de producto, donde una colega menciona que, a pesar de tener un diseño atractivo, la navegación era un dolor de cabeza para aquellos que usan lectores de pantalla.
Reflexionando sobre eso, empecé a poner más énfasis en cómo estoy construyendo componentes. Les comparto algunos tips que me ayudaron a mejorar la accesibilidad en mis diseños:
- **Añadí etiquetas alt descriptivas**: No solo para imágenes, sino también para iconos y botones. A veces subestimamos la importancia de la información que no se ve a simple vista.
- **Contraste adecuado**: Utilizo herramientas como el Color Contrast Checker para asegurarme de que los colores no solo sean estéticamente agradables, sino también legibles para todos. Esto cambia drásticamente la experiencia de usuario.
- **Navegación mediante teclado**: Asegúrate de que todos los elementos interactivos sean accesibles y usables sin mouse. Esto es particularmente crítico para usuarios con discapacidades motrices.
Uno de los mayores retos es siempre equilibrar el diseño estético con la funcionalidad accesible. En mi experiencia, escalar algunos componentes y ser intencional con el espaciado puede hacer maravillas no solo para la diversidad de usuarios, sino también para el producto en general. Me encantaría saber si alguno de ustedes tiene más tips o herramientas que les hayan resultado útiles para trabajar la accesibilidad.
Por último, un recordatorio: si todos los diseñadores pusieran un poco más de atención en esto, los productos no solo serían mejor recibidos, sino que también podrían crear un impacto real en la vida de las personas. ¿Alguien más está poniendo foco en esto? ¿Cómo lo están abordando en sus proyectos?
¡Espero sus comentarios!
Sebastián DíazNuevo
La idea detrás de los Minimal Viable Programs (MVPs) ha ido evolucionando en el marco de la agilidad y la iteración sencilla. Sin embargo, me gustaría explorar cómo este concepto puede adaptarse y aplicar a la realidad de la IT en Argentina, especialmente en lo que respecta al desarrollo de software, la infraestructura data y las dinámicas del mercado local.
Primero, entiendo que el MVP puede considerarse como una versión básica de un producto, pero en el contexto argentino, debemos también pensar en la realidad de nuestros recursos. Aquí, el capital humano y los recursos técnicos a menudo son limitados. Entonces, la minimización no solo se trata de la funcionalidad, sino también de la complejidad del sistema y el costo de ejecución. Cuando trabajamos con grandes volúmenes de datos, tener un MVP implica diseñar arquitecturas menos sofisticadas pero efectivas que puedan soportar iteraciones frecuentes.
Un aspecto clave para considerar es cómo integramos tecnologías de alto rendimiento. Si bien sobrestimar las capacidades de un entorno como Spark puede ser tentador, la verdad es que los volúmenes de datos pueden volverse abrumadores, y un MVP podría requerir un enfoque más pragmático. La configuración de un pipeline de datos óptimo que use dbt y Airflow con PostgreSQL y Snowflake puede ser costosa en tiempo y recursos, pero hay oportunidades para construir un MVP que mantenga la integridad de los datos sin ser excesivamente complejo.
Además, el tema del trabajo colaborativo es fundamental. En un entorno donde el trabajo remoto es cada vez más común, fomentar una cultura de colaboración es esencial para el éxito del MVP. Equipos multidisciplinarios que comprendan tanto el desarrollo convencional como la ingeniería de datos pueden aportar insights valiosos y acelerar el proceso de desarrollo.
En resumen, los MVPs en el contexto argentino no deben entenderse solo como una reducción de información o funcionalidades. Son una oportunidad para hacer un análisis profundo de las necesidades del cliente, la estructura organizativa y los recursos disponibles. Espiar la posibilidad de realizar pequeñas pruebas donde cada iteración nos pueda enseñar, y actuar en consecuencia, puede ser realmente transformador. Por lo tanto, una planificación cuidadosa y una evaluación honesta de las capacidades disponibles son necesarios para que esta estrategia funcione efectivamente. Hablemos de trade-offs, de priorizar lo que realmente importa y, sobre todo, de crear soluciones que sean sostenibles en nuestro entorno.
Camila TorresNuevo
Hola, comunidad. Espero que estén bien. Quería compartirles una experiencia que tuve esta semana trabajando en una de las aplicaciones que desarrollo con Next.js.
Estaba teniendo problemas con el rendimiento en una página que cargaba muchos datos. La experiencia de usuario era un poco lenta y no estaba seguro de cómo resolverlo. Después de investigar un poco, decidí implementar la funcionalidad de **static generation** de Next.js.
Aquí les comparto el proceso que seguí:
1. **Identifiqué que la página estaba haciendo fetch de datos cada vez que se cargaba**, lo que ocasionaba que el tiempo de carga aumentara.
2. Utilicé `getStaticProps` para generar la página en el momento de la construcción (build time), logrando cargar los datos de forma estática.
3. Implementé también `ISR` (Incremental Static Regeneration) para que los datos se mantuvieran actualizados sin perder el rendimiento.
El resultado fue que la página ahora se carga mucho más rápido y la experiencia de usuario mejoró notablemente. La magia de la pre-renderización en Next.js realmente es un gran aliado.
Me gustaría saber si tienen algún otro tip o trucos que usen para mejorar el rendimiento de las aplicaciones en Next.js o algún caso similar que hayan tenido. Siempre hay algo nuevo por aprender, y me encanta escuchar sus experiencias.
Espero que esto les sirva, ¡seguimos aprendiendo juntos!
Saludos desde Rosario!
#Frontend #Nextjs #Performance
Recientemente, leí sobre la NASA y su decisión de apretar el botón de apagado de uno de los instrumentos de Voyager 1 para mantener la operación del spacecraft. Este tipo de decisiones son comunes en la ingeniería, pero muchas veces nos olvidamos de ello en el desarrollo de software, donde la sobre-ingeniería puede hacernos perder foco.
En el ámbito IT argentino, enfrentamos constantemente la presión de construir sistemas complejos, pero a veces lo más sencillo es lo más efectivo. Aquí te dejo algunos puntos que yo aplico en mis proyectos:
1. **Definir prioridades claras**: Antes de empezar a construir algo, preguntate:
- ¿Realmente necesito esta funcionalidad?
- ¿Qué problemas estoy resolviendo?
2. **Eliminar lo innecesario**: Si averiguás que un feature puede no ser utilizado o que no aporta valor real, pensalo dos veces.
- Corta las funcionalidades que no son fundamentales.
3. **Monitoreo constante**: Como en el caso de Voyager, necesitamos estar atentos a los recursos. Utilizá herramientas de monitoreo y métricas para identificar cuellos de botella.
4. **Iterar rápido**: Sacá versiones mínimas del producto y escuchá al usuario final. Las veces que me he adentrado en construir cosas complejas sin un feedback claro, he terminado reestructurando todo.
Te desafío a aplicar esta mentalidad en tu día a día. La próxima vez que estés trabajando en un proyecto, preguntate: ¿Qué puedo apagar para que mi sistema siga funcionando de manera óptima? No siempre necesitamos todas las luces encendidas para avanzar. Simplificar puede ser la clave para un desarrollo más ágil y efectivo.
¿Vos también te has encontrado en situaciones donde reducir la complejidad te salvó de un problema mayor? Compartí tu experiencia.
-1
ComentarMi Perfil
?
No estás logueado
Iniciar sesiónComunidad pública
Seguinos y conectá con miles de developers argentinos.









