Multiples vulnerabilidades de jQuery en RDoc

09/09/2019
Artículo original

Hay multiples vulnerabilidades tipo Cross-Site Scripting (XSS) en el jQuery incluido con RDoc que es empaquetado en Ruby. A todos los usuarios de Ruby se les recomienda actualizar Ruby a la versión más reciente que incluye la versión reparada de RDoc.

Detalles

Se han reportado las siguientes vulnerabilidades.

Se recomienda de manera especial a todos los usuarios de Ruby actualizar la instalación de Ruby o emplear tan pronto sea posible una de las soluciones alternas descritas más adelante. También debe regenerar la documentación RDoc existente para mitigar completamente las vulnerabilidades.

Versiones afectadas

  • Series de Ruby 2.3: todas
  • Series de Ruby 2.4: 2.4.6 y anteriores
  • Series de Ruby 2.5: 2.5.5 y anteriores
  • Series de Ruby 2.6: 2.6.3 y anteriores
  • lo anterior a la contribución en master f308ab2131ee675000926540cbb8c13c91dc3be5

Acciones requeridas

RDoc es una herramienta para generación de documentación estática. Reparar la herramienta misma no es suficiente para mitigar estas vulnerabilidades.

Así que, documentación RDoc generada con versiones previas deben ser regeneradas con un RDoc reciente.

Soluciones alternas

En principio debe actualizar su instalación de Ruby a la versión más reciente. RDoc 6.1.2 o posteriores incluye solución a las vulnerabilidades, así que actualice RDoc a la versión más reciente si no puede actualizar Ruby mismo.

Note que como se mencionó antes, debe volver a generar la documentación RDoc.

gem install rdoc -f

Actualización: La versión inicial de esta publicación, mencionaba parcialmente rdoc-6.1.1.gem, que también era vulnerable. Asegurese de instalara rdoc-6.1.2 o posterior.

Respecto a la versión de desarrollo, actualiza al HEAD más reciente de la rama master.

Creditos

Agradecimientos a Chris Seaton por reportar el problema.

Historia

  • Publicado originalmente el 2019-08-28 09:00:00 UTC
  • Versión RDoc arreglada el 2019-08-28 11:50:00 UTC
  • Mejoras menores al idioma el 2019-08-28 12:30:00 UTC

Publicado por aycabta el 2019-08-28
Traducción de vtamara

Kotlin for Beginners

31/08/2019
Artículo original


Koltin
es un lenguaje dependiente de la Máquina Virtual Java (JVM); empresas como Google han adoptado este lenguaje porque promete ofrecer compatibilidad e interoperabilidad con proyectos hechos con le lenguaje Java. Kotlin es muy similar a otros lenguajes de programación como Scala y Go (e incluso Typescript). Al igual que Java posee tipos clase (Byte, Short, Int, Float, Double, Boolean, Char). Además podemos importar librerías de Java sin ningún problema. Para declarar una variable modificable usamos var, para declarar una variable no modificable usamos val (similar a Scala).

Actualmente es muy popular para el desarrollo de aplicaciones móviles en Android.

Usando SDKMAN! podemos instalarlo.

$ sdk install kotlin

Mostramos la versión instalada.

$ kotlinc -version

leer más

Ejemplo de DataTables con Server Side – Más Rápido y Eficiente

31/08/2019
Artículo original

Espero y este post sea de tu agrado, no olvides compartirlo en su redes sociales y sobre todo.. Gracias por seguirnos!

Hoy veremos un ejemplo básico de DataTables con Server Side que nos hará mostrar grandes cantidades de datos directo desde base de datos de forma eficiente y veloz. Seguramente en más de un proyecto web habrás tenido la necesidad de mostrar datos en una tabla, podremos hacerlo con una tabla normal hecha por nosotros que posiblemente lucirá bastante fea y nos tomará bastante tiempo crearla o mediante DataTables. Para comenzar dejame decirte que si sigues utilizando tablas sencillas para tus proyectos debes de actualizarte con urgencia. Existen muchas opciones para crear tablas mucho más presentables y con funcionalidades de otro

El post Ejemplo de DataTables con Server Side – Más Rápido y Eficiente aparece en el Blog de Jonathan Melgoza

Cómo gestionar las teclas rápidas en Visual Studio Code: Guía visual definitiva

28/08/2019
Artículo original

Visual Studio Code se ha convertido en poco tiempo en uno de los editores de código más utilizado del mundo (incluso puede que el que más), sobre todo entre los desarrolladores Web, aunque permite programar con casi cualquier lenguaje o plataforma. Tiene muchas virtudes, pero uno de los factores de su éxito es también, sin duda, que es muy personalizable. Es fácil adaptarlo a los gustos personales en casi todos sus aspectos.

Y si hay algo que adoramos los desarrolladores son las teclas rápidas. Raro es el que usa el ratón para todo y lo más habitual es preferir las teclas rápidas porque, como su propio nombre indica, ahorran mucho tiempo. Hoy vamos a ver cómo personalizar las teclas rápidas que utilizamos que, aunque es fácil, tiene algún que otro truquito.

Para acceder a la personalización de las teclas rápidas hay que acudir a este menú:

Acceso al menú Archivo>Preferencias>Teclas Rápidas

o pulsar, por defecto, CTRL+K y CTRL+S una tras otra.

Esto nos abre una ventana en la que podemos ver todas las teclas rápidas asignadas actualmente:

Listado de teclas rápidas de VSCode

El cuadro de texto que tenemos arriba nos sirve para filtrar la gigantesca lista de posibilidades. Podemos buscar palabras clave para localizar acciones y saber qué teclas rápidas les corresponden:

o bien poner combinaciones de teclas concretas para saber con qué hacen. En ese sentido nos viene muy bien un botón de los que tenemos a la derecha del cuadro de texto. En ese lugar tenemos tres botones que nos sirven respectivamente para grabar teclas, ver el orden de precedencia de las que tengamos visualizadas, o borrar el cuadro de texto:

Las tres teclas mencionadas

Al primero de ellos no se le presta mucha atención pero es de lo más interesante ya que te permite grabar las teclas que pulses y colocarlas en el cuadro de texto, con lo que puedes averiguar para qué sirven exactamente y por lo tanto saber también si ya están siendo utilizadas o no:

Por ejemplo, en la animación anterior pulso la combinación CTRL+L, CTRL+U y averiguo que ya está siendo utilizada, en concreto por una extensión para trabajar con Markdown que tengo instalada, para convertir una lista ordenada en una no ordenada.

Así, si queremos cambiar la tecla rápida asociada a una acción podemos ver antes si la que queremos está siendo ya utilizada o no.

¿Y cómo se cambia la tecla asociada a una acción? Pues utilizando el pequeño lápiz que aparece a la izquierda cada vez que ponemos el cursor encima de una de las acciones:

También podemos usar, cómo no, una tecla rápida para ello: CTRL+K, CTRL+K (dos veces CTRL+K, vamos).

Por ejemplo, supongamos que quiero cambiar la tecla rápida asociada a la extensión que nos permite conocer el grado de adopción de una característica CSS o HTML con el servicio CanIUse. Pues pulsamos el lapicito y se pone a capturar teclas que se muestran en un diálogo flotante:

Fíjate en cómo, al pulsar las teclas deseadas ya te va avisando de si hay algún comando que las está utilizando actualmente. Cuando hayas pulsado las teclas que te interesan solo tienes que pulsar ENTER y quedarán asignadas, tal y como se ve en la animación anterior al final (de lo cual se deduce que ENTER no puede usarse como tecla rápida, lógicamente por otro lado).

Nota: solamente se pueden asignar como máximo dos combinaciones de teclas seguidas para una acción, como he hecho yo en este ejemplo. Cada una de ellas puede tener una letra y una combinación cualquiera de las teclas CTRL/CMD, MAYs, ALT y Win (tecla de Windows).

¿Y si nos arrepentimos y queremos dejar la tecla como estaba? Pues el menú contextual (botón derecho) de cada acción  nos brinda esta posibilidad usando la opción Reset Keybinding:

Resetear la tecla rápida

La diferencia entre esta opción y la anterior (Remove Keybinding o, en español, Eliminar tecla rápida) es que esta última la elimina dejando el comando sin tecla rápida alguna, mientras que la anterior deja la tecla rápida que haya por defecto con el editor, que en el caso de que no sea ninguna sería el mismo efecto.

Como comenté antes, si colocamos en el cuadro de texto una combinación de teclas cualquiera nos filtra la lista para mostrar los comandos que la tienen asignada. Es aquí donde entran en juego dos cuestiones muy importantes: el contexto y la precedencia.

El contexto es en qué momento tendrá efecto la tecla rápida asociada a un comando. Por ejemplo, si se trata de un comando que sólo tiene sentido mientras estás manejando el editor de código, el contexto será cuando el editor tenga el foco (o sea, estés trabajando en él). Pero si quieres que sirva para, por ejemplo, abrir la barra lateral con los archivos, no puede restringirse a contexto alguno ya que debe actuar en todo momento. Ese contexto es lo que aparece en la columna When del listado de teclas:

Contexto señalado en una captura de lista de teclas rápidas

Como vemos puede tener condiciones bastante complejas.

Para cambiar este contexto para una tecla concreta tenemos que usar el menú contextual de ésta pulsando con el botón secundario del ratón, como vimos en una figura anterior. Una de las opciones es precisamente esta Change When Expression o también podemos pulsar CTRL+K, CTRL+E. La lista completa de contextos posibles la tienes en la documentación oficial de Visual Studio Code.

El otro factor que mencionaba es la precedencia. Esto nos indica, en caso de coincidencia de teclas rápidas, cuál es el comando que tiene preferencia para actuar y en qué orden lo hará si actúan varios. Por ejemplo, la tecla CTRL+F por defecto está presente en un montón de contextos:

Posibles comandos para la tecla CTRL+F

Si está bien definida no debería tener el mismo contexto con dos comandos diferentes, pero si personalizamos mucho las teclas seguro que tarde o temprano tendremos un conflicto con esto. Es aquí en donde entra en juego la precedencia.

Por ejemplo, consideremos la acción Auto-Fix que lo que hace es arreglar lo que se pueda arreglar de manera automática en la línea actual (por ejemplo, corregir un error de sintaxis, una advertencia del Linter, etc...). Por defecto tiene una combinación de teclas muy complicada (MAYs+ALT+.), así que la editamos y le ponemos la combinación de teclas CTRL+F, al igual que todas las acciones que vemos en la figura anterior, y que parece mucho más cómoda y lógica.

Ahora podríamos tener un conflicto. Para saberlo podemos pulsar el botón de ordenar por precedencia para ver la lista de este modo:

Teclas ordenadas por precedencia

Ahora nuestro autofix está abajo de todo. Eso quiere decir que tiene la mayor precedencia de todas a igual contexto ya que la evaluación de comandos para una tecla rápida se efectúa de abajo a arriba.

Aparentemente no debería haber problema, porque todos los When son diferentes. Pero sí que tenemos un conflicto ya que el comando de buscar (Find) no tiene contexto asignado, lo cual significa que está en todos los contextos: es una tecla global. Así que el resultado en este caso es que, como nuestro Autofix tiene mayor precedencia, cuando estemos en el contexto de este comando estaremos anulando al de búsqueda. O sea: nos hemos cargado la tecla de buscar cuando estamos editando código. Mal rollo. Conviene cambiarla inmediatamente por otra que no nos dé conflicto o que al menos elimine una funcionalidad que no nos interese o no utilicemos.

Compartir nuestras teclas rápidas, o editarlas manualmente o hacer un backup de preferencias

Si somos de los que le gusta ir sin red y queremos editar estas teclas rápidas son la ayuda que nos da su editor predeterminado, podemos hacerlo fácilmente. Además, esto nos facilitará el poder llevárnoslas a otros equipos o compartirlas con otras personas (por ejemplo, con la gente con la que trabajamos o colaboramos).

Si te fijas, en la parte de arriba del editor de teclas rápidas hay un botón con una hoja y una flecha:

Al pulsarlo se abre la versión JSON de las teclas rápidas asignadas para nuestro usuario (o sea, que son personales y no afectan a otros posibles usuarios de nuestra máquina que también utilicen VSCode):

Aspecto del archivo JSOn de teclas rápidas

Este archivo keybindings.json se encuentra en tu perfil de usuario, en la ruta que te marca el editor en la parte de arriba, por lo que puedes editarlo como quieras y por supuesto transportarlo a otro lado para hacer una copia de seguridad o pasárselo a alguien.

Pero a mi es que me gusta Vim...

...o Sublime Text, o Emacs, o Eclipse, o... Hay gente para todo.

Si ya tienes la costumbre de usar ciertas teclas rápidas y no quieres tener que definirlas de nuevo en Visual Studio Code para utilizarlas ni quieres acostumbrarte a unas nuevas, estás de enhorabuena porque el equipo de VSCode (y la comunidad) ya ha pensado en ello y existen lo que se llaman "Mapas de teclas" o KeyMaps. Se trata de conjuntos extensos de reglas que remapean todos los comandos para que sean idénticos a los de otro editor como los mencionados (y algunos más).

¿Cómo los consigues? Muy fácil: vas al menú Archivo·Preferencias·Keymaps que está justo debajo del de la primera imagen de este artículo, te abrirá el editor de extensiones con todos los keymaps disponibles:

Keymaps

De hecho los que nos muestra son los recomendados. Si le quitamos de delante la palabra @recommended: veremos que hay muchos más. Seguro que no son tan finos como los recomendados, pero nos puede venir muy bien en algún caso si nuestro editor favorito no está en la lista inicial.

Solo tienes que instalar el que te interese (no puedes instalar más de uno, claro) y listo: a partir de ese momento las teclas rápidas de tu editor favorito estarán listas para que las utilices como siempre te ha gustado.

La verdad es que son estos detalles los que hacen que VS Code le guste a tanta gente.

¡Espero que te haya resultado útil!

Cómo animar fácilmente el fondo degradado de un botón con CSS

28/08/2019
Artículo original

Las animaciones y transiciones de CSS3 son geniales, siempre que tenga sentido usarlas y que no se abuse de ellas como se hizo en la época en la que Flash reinaba en este terreno. Son fáciles de implementar (al menos las más básicas), vistosas y muy útiles a la hora de mejorar la experiencia visual y de interacción web.

Pero hay una pequeña limitación en las transiciones con los fondos que son degradados de color (o gradientes) y que vamos a aprender a resolver fácilmente.

Supongamos que tenemos un flamante hipervínculo ejerciendo de botón al que quiero poner de fondo el siguiente degradado:

Usando el siguiente código:

<a class="ejemplo1">Pruébame</a>
a.ejemplo1 { background: linear-gradient(180deg, #65bce8 0%, #306485 100%); }

Se verá así:

Ahora lo que quiero es que, al hacer :hover por encima de él, el degradado se convierta grácilmente en este degradado de colores anaranjados:

Lo que hacemos es intentar crear una transición de un degradado a otro:

a.ejemplo1 {
    background: linear-gradient(180deg, #65bce8 0%, #306485 100%);
    transition: all .3s;
}

a.ejemplo1:hover {
    background: linear-gradient(180deg, #fbde74 0%, #ff9900 100%);
    transition: all .3s;
}

Y esto es lo que ocurre:

Botón con transición brusca del fondo degradado

¡Ups! Parece que la transición entre ambos estados no es demasiado grácil que digamos. No es que quede mal ni que se vea especialmente horrible, pero no es lo que queremos, que es una transición más suave.

Y es que los fondos degradados son una de las pocas propiedades que no se pueden animar directamente con transiciones CSS.

Bien, pues si este es tu caso y ya habías arrojado la toalla, no desesperes, porque hay una alternativa aunque el resultado no será exactamente igual a lo que estábamos buscando, pero sí muy parecido.

Para ello vamos a tener que dar un pequeño rodeo. Lo que vamos a hacer es meter los dos degradados en uno solo y variar su posición al hacer :hover, y esto sí que lo podemos animar con transiciones.

Así que nuestro degradado será algo así:

Para facilitar los cálculos, y que así se vea mejor el ejemplo, le he dado a nuestro botón un alto fijo de 50px. Así que en reposo le daré al fondo un alto de 100px, así me aseguro de que solo se ve la parte azul del degradado.

a.ejemplo2 {
    background: linear-gradient(180deg, #65bce8 0%, #306485 49%, #fbde74 50%, #ff9900 100%);
    background-size: 1px 100px;
    transition: all .3s;
}

Cuando un usuario haga :hover, el background se desplazará hacia arriba -50px (la altura del botón) y finalmente solo se verá el degradado naranja.

a.ejemplo2:hover {
    background-position: 0 -50px;
    transition: all .3s;
}

Dado que en la práctica los navegadores tratan los gradientes como si de una imagen se tratara, pues nosotros haremos lo mismo. Es como usar un sprite de degradados, pero creado al vuelo con CSS. Sencillo pero eficaz:

Botón con transición suave del fondo degradado

No podemos hacer transiciones directas de fondos con gradientes CSS, pero lo que sí podemos hacer es desplazar y escalar los fondos. Como siempre en CSS, muchas veces lo que parece imposible se puede lograr dando un pequeño rodeo, y esta puede ser la clave de nuestra victoria a la hora de maquetar para la web.

Ahora bien, para ello necesitas unos mínimos conocimientos sólidos y desarrollar un olfato que sólo se logra con la práctica. Este curso de HTML y CSS junto con este otro de maquetación responsive te ayudarán a fijar tus conocimiento mucho mejor y más rápido que aprendiendo por tu cuenta.

Ah, ¡por cierto! en este enlace puedes descargarte el código con los dos botones de los ejemplos funcionando. Espero que este pequeño truco te haya resultado útil.

Introducción rápida a LINQ con C#: manejar información en memoria nunca fue tan sencillo

21/08/2019
Artículo original

Como programadores, es muy habitual tener que trabajar sobre colecciones de datos por un motivo u otro, seleccionar datos, agruparlos, sumarlos ...

Una manera muy socorrida de trabajar con este tipo de datos es recorrer la colección. De hecho, es la solución para la gran mayoría de los lenguajes y la que mejor rendimiento nos ofrece.

Suponiendo que tenemos una lista de enteros, si queremos sumarlos podríamos hacer algo así:

var valores = new List<int> {1,2,3,4,5,6,7,8,9};
var suma = 0;
foreach (var valor in valores)
{
    suma += valor;
}

O si por ejemplo, queremos buscar los números que sean pares:

var valores = new List<int> {1,2,3,4,5,6,7,8,9};
var pares = new List<int>();
foreach (var valor in valores)
{
    if (valor % 2 == 0)
    {
        pares.Add(valor);
    }
}

La lista de ejemplos es infinita, y siempre vamos a poder encontrar una solución iterando la colección, pero... ¿Es la mejor opción?

¿Qué es LINQ?

Dicho de manera sencilla, LINQ (Language Integrated Query) es un conjunto de extensiones integradas en el lenguaje C#, que nos permite trabajar de manera cómoda y rápida con colecciones de datos, como si de una base de datos se tratase. Es decir, podemos llevar a cabo inserciones, selecciones y borrados, así como operaciones sobre sus elementos.

Language-Integrated Query (LINQ) es el nombre de un conjunto de tecnologías basadas en la integración de capacidades de consulta directamente en el lenguaje C#

Fuente: MSDN

Todas estas operaciones las vamos a conseguir muy fácilmente gracias a los métodos de extensión para colecciones que nos ofrece el espacio de nombres "System.Linq" y a las expresiones lambda. Sin ir más lejos, los dos ejemplos anteriores se podrían hacer así:

var valores = new List<int> {1,2,3,4,5,6,7,8,9};
var suma = valores.Sum();
var pares = valores.Where(x => x % 2 == 0).ToList();

Como se puede comprobar, la lectura es mucho más clara, por lo que ganamos en mantenibilidad del código.

En el ejemplo anterior, vemos que LINQ puede devolvernos valores de operaciones, o devolvernos colecciones.

Seguramente te hayas fijado en el ToList() del segundo caso. Esto es porque LINQ siempre nos va a devolver un objeto de tipo IEnumerable<T>, el cual debemos iterar. Hasta que no lo iteremos, la consulta no se ha ejecutado todavía, y solo tenemos una expresión sobre una colección, por eso invocamos ToList() para forzar la ejecución de la consulta.

Sobre la ejecución diferida de consultas se puede hablar largo y tendido ya que es una materia en sí misma. Para más información puedes consultar este enlace.

Vamos a ver un resumen de algunas de sus herramientas más útiles.

Para los ejemplos, vamos a suponer una clase como esta:

public class Alumno
{
    public string Nombre { get; set; }

    public int Nota { get; set; }
}

Y partamos de la base de que tenemos una colección de alumnos como esta:

var alumnos = new List<Alumno>
{
    new Alumno {Nombre = "Pedro",Nota = 5},
    new Alumno {Nombre = "Jorge",Nota = 8},
    new Alumno {Nombre = "Andres",Nota = 3}
};

Ahora veamos algunas de las operaciones que podemos llevar a cabo con LINQ sobre esta:

Select

Nos va a permitir hacer una selección sobre la colección de datos, ya sea seleccionándolos todos, solo una parte o transformándolos:

var nombresAlumnos = alumnos.Select(x => x.Nombre).ToList();

Where

Nos permite seleccionar una colección a partir de otra con los objetos que cumplan las condiciones especificadas:

var alumnosAprobados = alumnos.Where(x => x.Nota >= 5).ToList();

First/Last

Esta extensión nos va a permitir obtener respectivamente el primer y el último objeto de la colección. Esto es especialmente útil si la colección está ordenada.

var primero = alumnos.First();
var ultimo = alumnos.Last();

OrderBy

Gracias a este método, vamos a poder ordenar la colección en base a un criterio de ordenación que le indicamos mediante una expresión lambda. Análogamente, también existe OrderByDescending, el cual va a ordenar la colección de manera inversa según el criterio:

var ordenadoMenorAMayor = alumnos.OrderBy(x => x.Nota).ToList();
var ordenadoMayorAMenos = alumnos.OrderByDescending(x => x.Nota).ToList();

Sum

Como hemos visto más arriba, nos va a permitir sumar la colección:

var sumaNotas = alumnos.Sum(x => x.Nota);

Max/Min

Gracias a esta extensión, vamos a poder obtener los valores máximo y mínimo de la colección:

var notaMaxima = alumnos.Max(x => x.Nota);
var notaMinima = alumnos.Min(x => x.Nota);

Average

Este método nos va a devolver la media aritmética de los valores (numéricos) de los elementos que le indiquemos de la colección:

var media = alumnos.Average(x => x.Nota);

All/Any

Con este último operador, vamos a poder comprobar si todos o alguno de los valores de la colección cumplen el criterio que le indiquemos:

var todosAprobados = alumnos.All(x => x.Nota >= 5);
var algunAprobado = alumnos.Any(x => x.Nota >= 5);

Sintaxis integrada

Aunque en los ejemplos anteriores hemos visto el uso directo de los métodos de extensión, otra de las grandes ventajas que tiene LINQ es que permite crear expresiones directamente en el código, de manera similar a si escribiésemos SQL directamente en C#. Por ejemplo:

var resultado = from alumno in alumnos
                where alumno.Nota >= 5
                orderby alumno.Nota
                select alumno;

nos devolverá la lista de alumnos que tienen una nota superior a o igual a 5, ordenados por nota ascendentemente.

¿No es algo casi mágico?

Ventajas y desventajas

Ahora que hemos visto un poco por dónde pisamos, es hora de que hablemos sobre las ventajas y desventajas que nos puede aportar utilizar LINQ en vez de iterar las colecciones.

La principal y única desventaja que tiene, es que es un poco más lenta que si utilizásemos bucles for o foreach para iterar la colección y hacer la operación. Por supuesto esto no es apreciable en prácticamente ninguna situación convencional, pero en entornos donde cada milisegundo cuenta, debes conocer que tiene un impacto.

Por otro lado, las ventajas que nos aporta LINQ son principalmente que el código es más legible, ya que utiliza una sintaxis muy declarativa de lo que está haciendo, y sobre todo, nos ofrece una manera unificada de acceder a datos, sean el tipo que sean, y tengan el origen que tengan. Por ejemplo, podemos utilizar LINQ para trabajar con bases de datos, con XML, con Excel, con objetos en memoria, ¡y hasta con Twitter!

Resumiendo

Pese a que en esta entrada solo hemos hecho una pequeña introducción con un resumen reducido de las extensiones más frecuentes que nos aporta LINQ (créeme que muy pequeño... te recomiendo mirar el espacio de nombres y ver todas sus opciones), es una herramienta muy potente. Tanto, que otros lenguajes la han implementado también.

Si bien es cierto que existe una merma de rendimiento respecto a iterar el bucle directamente, el rendimiento perdido en el 99,99% de los casos se compensa con el beneficio que aporta tener un código claro, legible y mantenible.

Real Dev: desafíos para desarrolladores que ponen a prueba tus habilidades en la vida real

19/08/2019
Artículo original

Real Dev: desafíos para desarrolladores que ponen a prueba tus habilidades en la vida real

Real Dev es una nueva e interesante plataforma creada para que los programadores pongan a prueba sus habilidades resolviendo desafíos, en estos tendrán que resolver problemas que se pueden presentar en diferentes escenarios de la vida real.

Sus creadores creen que a la hora de contratar desarrolladores es mucho más importante evaluar las habilidades prácticas a la hora de solucionar un problema real, que estar resolviendo acertijos con algoritmos.

La propuesta es utilizar la plataforma de Real Dev como un sitio en el que los desarrolladores pueden practicar y aprender. Sus retos han sido extraídos de proyectos y código que está actualmente en producción, el código se prueba automáticamente, y también tienen una tabla de liderato para quienes participen.

10 desafíos para poner a pruebas tus habilidades como programador

De momento han lanzado el sitio con 10 desafíos diferentes (aunque planean añadir más) en los que se muestran problemas técnicos reales que se presentan en múltiples escenarios, como por ejemplo a la hora de armar los endpoints de un servidor HTTP, o escribir un script que haga algo, o armar el frontend de una página web, etc.

En Real Dev puedes iniciar sesión con tu email o con tu cuenta de GitHub, tras ello tendrás acceso a la lista de desafíos, solo tienes que elegir uno, instalar el CLI de forma local, iniciar sesión y comenzar a escribir código.

Puedes enviar la solución a cualquier hora del día, cualquier día de la semana. Ellos te ofrecen una herramienta de línea de comandos para que envíes el código y ellos lo reproducen en la nube para darte feedback instantáneo. Puede seguir practicando y Real Dev juzgará tu código con varios casos de prueba.

Zoncolan: así es la herramienta de Facebook para encontrar bugs de seguridad capaz de analizar todo su código en media hora

19/08/2019
Artículo original

Zoncolan: así es la herramienta de Facebook para encontrar bugs de seguridad capaz de analizar todo su código en media hora

Cuando un proyecto informático tiene el tamaño de Facebook, se hace necesario contar con herramientas que agilicen, entre otras muchas cosas, el hallazgo de bugs en sus millones de líneas de códigos. Para ello, en cuanto a seguridad, la compañía presume de haber desarrollado Zoncolan, una herramienta de análisis estático que permite encontrar bugs en ramas individuales y otros que afectan a ramas que interactúan entre sí.

Lo que aporta frente a la revisión manual es, sobre todo, velocidad, pero también mucha ayuda automatizada que, además de notificar sobre bugs, también ofrece información en tiempo real sobre posibles problemas que pueden surgir si se introducen ciertos cambios en el código.

Una vez se hacen las propuestas de cambios, Zoncolan comienza a escanear todo el código, y avisará al programador que haya introducido las líneas o a ingenieros de seguridad. Según Pieter Hooimeijer, manager de ingeniería de seguridad en Facebook, el año pasado, Zoncolan localizó 1.500 problemas en el código.

Zoncolan puede sustituir a personas en la detección de problemas, pero las sigue necesitando para mejorar

Zoncolan

En la web que Facebook ha lanzado sobre Zoncolan, la compañía afirma que como cualquier sistema de este tipo (refiriéndose al análisis estático), Zoncolan no puede encontrar todos los problemas, pero sí **permite encontrar algunas clases de problemas (y prevenir futuros) que se pueden solucionar de una vez y retroactivamente.

El problema de Zoncolan, como todas las herramientas de su tipo, es que es muy eficaz para encontrar bugs, pero de momento no capaz aprender de forma autónoma a saber qué es un bug, sino que tienen que ser los ingenieros los que establezcan reglas que indiquen los factores que pueden ser problemáticos. Aunque en el futuro probablemente esto cambie, Zoncolan puede escanear todo el código en tan solo 30 minutos, por lo que lo que ayuda en su forma actual ya es de gran valor.

Facebook explica así cómo Zoncolan ayuda a escalar el trabajo y crear reglas:

  • Un ingeniero de seguridad puede verificar los hallazgos sin tener que pasar horas incalculables revisando código manualmente.
  • Podemos utilizar una regla codificada para evitar que en el futuro se repita el mismo problema. Zoncolan funciona con miles de cambios de código por día antes de que el código se envíe a producción, y nos alerta de los problemas. Nuestro repertorio de reglas ha crecido con el tiempo, y podemos agregarlo o perfeccionarlo según sea necesario.
  • Las reglas por sí mismas sirven como documentación de los problemas de las clases. Una vez disponible como regla de Zoncolan, es más fácil para los ingenieros de seguridad examinar los matices de la regla en sí y los problemas que hemos encontrado como resultado. Este proceso ayuda a educar a los ingenieros sobre lo que deben buscar en el futuro. También puede informar las decisiones para construir mejores bibliotecas y marcos de trabajo, para eliminar clases de problemas por completo.

La compañía afirma que Zoncolan utiliza una técnica llamada "interpretación abstracta" para seguir las entradas controladlas por el usuario en la base del código. Analizando el código, es capaz de construir estructuras representando por una parte las funciones del código, con un gráfico de control de flujo, y por otra cómo interactúan, en un gráfico de llamadas. Zoncolan crea después un resumen del comportamiento de cada función, y registra solo propiedades relevantes para flujos de información potencialmente peligrosos.

La ejecución abstracta sigue todas las rutas del control, y analiza las ramas del código (como un "if"), individualmente y luego uniendo los resultados, de forma que se evalúan todos los caminos posibles a la vez. Facebook afirma estar trabajando para hacer proporcionar las herramientas de Zoncolan como código abierto para que otras compañías y desarrolladores puedan utilizarlas en sus productos.

Vía | Wired

Paquetes en Java: qué son, para qué se utilizan, y cómo se usan (con vídeo)

14/08/2019
Artículo original

Imagen ornamental. Cajas con Java escrito en la tapa. Foto original de Leone Venter en Unsplash

Los paquetes son el mecanismo que usa Java para facilitar la modularidad del código. Un paquete puede contener una o más definiciones de interfaces y clases, distribuyéndose habitualmente como un archivo. Para utilizar los elementos de un paquete es necesario importar este en el módulo de código en curso, usando para ello la sentencia import.

La funcionalidad de una aplicación Java se implementa habitualmente en múltiples clases, entre las que suelen existir distintas relaciones. Las clases se agrupan en unidades de un nivel superior, los paquetes, que actúan como ámbitos de contención de tipos. Cada módulo de código establece, mediante la palabra clave package al inicio, a qué paquete pertenece. Como ya sabrás, con la cláusula import cualquier módulo de código puede hacer referencia a tipos definidos en otros paquetes.

Vamos a familiarizarnos con los procedimientos para construir paquetes, para referenciarlos desde otros puntos y también veremos la relación existente entre paquetes, clases y el sistema de archivos donde se almacena el proyecto.

Creación de paquetes

Un paquete Java se genera sencillamente incluyendo la palabra clave package al inicio de los módulos de código en los que se definen las clases que formarán parte del mismo. Trabajando en un proyecto con NetBeans, comprobaremos que en la ventana Projects los paquetes se representan con un icono específico y actúan como nodos contenedores, alojando los módulos .java con el código fuente. El menú contextual del proyecto nos ofrece la opción New>Java Package, que será el que usemos habitualmente para crear un nuevo paquete:

Creación de un nuevo paquete en Netbeans

Nota: cada vez que se crea un nuevo proyecto con NetBeans se propone la definición de un nuevo paquete, cuyo nombre sería el mismo del proyecto, donde se alojarían los módulos de código. En proyectos complejos, no obstante, puede ser necesaria la creación de paquetes adicionales.

Un paquete puede contener, además de definiciones de tipos como las clases e interfaces, otros paquetes, dando lugar a estructuras jerárquicas de contenedores. La denominación de los subpaquetes, paquetes contenidos en otros, se compondrán del identificador del contenedor seguido de un punto y el nombre del subpaquete. De existir niveles adicionales se agregarían los distintos identificadores separados por puntos, formando así el nombre completo del paquete.

El diagrama siguiente representa el contenido de un paquete llamado campusmvp, teóricamente correspondiente a un proyecto de aplicación de contabilidad. En ese paquete de primer nivel tenemos un subpaquete con utilidades, llamado campusmvp.util, no directamente vinculadas con la aplicación de contabilidad. El subpaquete campusmvp.conta contendría todos los elementos asociados a dicha aplicación, distribuidos a su vez en un tercer nivel de paquetes que contienen las clases correspondientes al modelo, la vista, etc., siguiendo al patrón arquitectónico MVC. Cada uno de los módulos de definición de clase, denominados Cuenta.java, Movimiento.java, Vista.java, etc., comenzarían con una cláusula package indicando el nombre completo del paquete al que pertenecen:

Estructura jerárquica de paquetes

Nota: todas las clases que pertenecen a un mismo paquete comparten un ámbito común, al que pertenecerán aquellos miembros que no especifiquen explícitamente otro tipo de visibilidad.

Importación de paquetes

Los paquetes Java son como cajas de herramientas, cada una de ellas con una colección distinta de instrumentos útiles para nuestro trabajo, a las que podemos necesitar acceder cada vez que abordamos el desarrollo de un nuevo proyecto. Es en este contexto donde recurriremos a la cláusula import, a fin de importar en el ámbito actual las definiciones de otro paquete y poder usarlas según el procedimiento habitual, creando objetos, accediendo a los servicios de las clases, etc.

La cláusula import puede utilizarse para importar un elemento concreto de un paquete, facilitando el nombre de este seguido de un punto y el identificador de dicho elemento. Por ejemplo, para importar la clase Math del paquete java.lang, pudiendo así acceder a la constante PI y las funciones matemáticas que aporta, bastaría con la siguiente línea:

import java.lang.Math;

Es habitual que al importar un paquete nos interesen muchas de las clases definidas en el mismo. En este caso podríamos importarlas individualmente, usando la sintaxis anterior, o bien podríamos recurrir a la siguiente alternativa. Esto nos permitiría usar la clase Math, así como la clase System, la clase Thread y muchas otras definidas en el paquete java.lang:

import java.lang.*;

En ocasiones, como ocurre con la clase Math, importamos una clase para acceder directamente a sus miembros estáticos, constantes y métodos, no para crear objetos a partir de ellas, lo que nos fuerza a utilizar constantemente la sintaxis Clase.miembro, por ejemplo Math.PI o Math.sin(). Si tras importar la clase Math intentamos referirnos a estos miembros simplemente por su nombre, como se hace en la mitad superior de la siguiente imagen, obtendremos un error. En estos casos podemos recurrir a la sintaxis import static paquete.clase.*, cuya finalidad es incluir en el ámbito actual los miembros estáticos de la clase indicada. Es lo que se hace en la mitad inferior de la siguiente imagen:

Importación de paquetes

Relación entre clases, paquetes y el sistema de archivos

En Java existe una estrecha relación entre las definiciones de paquetes y clases y el sistema de archivos local, en el que se almacenan los módulos conteniendo el código. Es un hecho que puede pasarnos totalmente inadvertido al trabajar con un IDE como el de NetBeans, ya que sus opciones se encargan de ocultar estos detalles. No obstante, es interesante que conozcamos dicha relación ya que esto nos permitirá, en caso de necesidad, trabajar directamente con el JDK.

Cada módulo de código de un proyecto Java únicamente puede contener una clase pública, cuyo nombre, respetando mayúsculas y minúsculas, debe coincidir con el del módulo. Es decir, existe una correspondencia directa entre los identificadores de clase y archivos en los que se alojan. Esto no afecta a las clases anidadas y otras clases no públicas que pudiesen definirse en el mismo módulo.

El nombre del paquete establece además el nombre de la carpeta donde se alojan los módulos de código contenidos en el paquete. Los nombres de paquete pueden ser compuestos, usándose el punto como separador de las diferentes porciones del identificador. Cada parte identificaría a un subdirectorio, según se muestra en el siguiente esquema:

Esquema sistema de archivos

Al trabajar desde la línea de comandos, usando directamente el JDK, hemos de tener en cuenta que tanto la compilación como la ejecución verificarán que se satisface la correspondencia entre el nombre de paquete y clase y la estructura de directorios y nombre de archivo. Si esta no se cumple en algún punto, como ocurre en la parte inferior de la siguiente imagen, se obtiene un error.

Relación entre paquete y sistema de archivos

Nota: la estructura de directorios de un paquete puede almacenarse completa, una vez se compila el proyecto, en un archivo JAR. Este contendría asimismo los archivos de clase de cada módulo de código.

A continuación puedes ver un vídeo práctico explicativo de todo lo anterior, que está extraído directamente del curso de programación con Java de campusMVP:

[youtube:x4BDc-VGeZY]

De Linux a Python: iníciate en el mundo del hacking ético con este curso gratuito de 15 horas para principiantes

12/08/2019
Artículo original

De Linux a Python: iníciate en el mundo del hacking ético con este curso gratuito de 15 horas para principiantes

En Genbeta siempre estamos buscando las mejores opciones que ofrece Internet para aprender algo nuevo y compartirlas con ustedes. Esta vez nos hemos encontrado con un interesante curso ofrecido por la plataforma de freeCodeCamp desde su canal de YouTube.

Se trata de un curso de 15 horas sobre penetration testing orientado a principiantes que se quieren iniciar en el mundo del hacking ético. En él aprenderás todas las habilidades prácticas para trabajar en ese campo.

Sin embargo, aunque está orientado a principiantes, el curso tiene bastante profundidad, te enseñarán a desarrollar un Active Directory en Windows, a hacerlo vulnerable, a hackearlo y a parchearlo.

Curso completo de hacking ético

El curso está dividido en 11 partes, los temas a tratar incluyen desde Linux, a Python, pasando por todo tipo de herramientas de escaneo y tácticas de explotación, hasta un final sobre cómo escribir reportes y consejos para tu carrera.

Para las tareas que se te darán durante el curso tienes disponible un repositorio en GitHub que además contiene el plan de estudios completo con todas las lecciones organizadas y bien descritas.

Sobra decir que todo el material está completamente en inglés. Este curso fue dictado inicialmente en Twitch por The Cyber Mentor que también tiene el material alojado en su web personal. Además, varios participantes del curso y otros miembros de sas comunidad tienen un canal en Discord donde comparten información y al que puedes acudir si tienes dudas.

Página Anterior Página Siguiente